phrase_replacer.py

Go to the documentation of this file.

#!/usr/bin/python
 
class phrase_replacer:
  """ A simple replacement tool that honors some C/C++ syntax when replacing.
 
      This will take a particular phrase given by the user and find it in a set of
      documents.  That phrase will be replaced when it appears completely, and is not
      in a C or C++ style comment (// or /* ... */).  It also must be clear of any
      other alphanumeric pollution, and only be surrounded by white space or operation
      characters.
  """
  
  def __init__(self, argv):
    """ Initializes the class with a set of arguments to work with.
 
        The arguments need to be in the form described by print_instructions().
    """    
    self.argumentsarguments = argv
    # we have three states for the processing: consuming normal code (not within a comment),
    # consuming a single line comment, and consuming a multi-line comment.
    self.EATING_NORMAL_TEXTEATING_NORMAL_TEXT = 0
    self.EATING_ONELINE_COMMENTEATING_ONELINE_COMMENT = 1
    self.EATING_MULTILINE_COMMENTEATING_MULTILINE_COMMENT = 2
 
  def print_instructions(self):
    """ Shows the instructions for using this class. """
    print("""
This script will replace all occurrences of a phrase you specify in a set of files.  The
replacement process will be careful about C and C++ syntax and will not replace occurrences
within comments or which are not "complete" phrases (due to other alpha-numeric characters
that abut the phrase).  The arguments to the script are:
 
  {0}: PhraseToReplace  ReplacementPhrase  File1  [File2 ...]
 
For example, if the phrase to replace is Goop, it will be replaced in these contexts:
  Goop[32]
  molo-Goop
  *Goop
but it will not be found in these contexts:
  // doop de Goop
  rGoop
  Goop23
""".format(self.argumentsarguments[0]))
 
  def validate_and_consume_command_line(self):
    """ Performs command line argument handling. """
    arg_count = len(self.argumentsarguments)
#    for i in range(1, arg_count):
#      print("i is {0}, arg is {1}".format(i, self.arguments[i]))
    # we need more than 2 arguments, since there needs to be at least one file also.
    if arg_count < 4:
      return False
    self.phrase_to_replacephrase_to_replace = self.argumentsarguments[1]
    self.replacement_bitreplacement_bit = self.argumentsarguments[2]
    print("got phrase to replace: \'{0}\' and replacement: \'{1}\'".format(self.phrase_to_replacephrase_to_replace, self.replacement_bitreplacement_bit))
    self.filesfiles = self.argumentsarguments[3:]
    return True
 
  def read_file_data(self, filename):
    """ loads the file into our memory buffer for processing. """
    try:
      our_file = open(filename, "rb")
      try:
        file_buffer = our_file.read()
      except IOError:
        print("There was an error reading the file {0}".format(filename))
        return False
      finally:
        our_file.close()              
    except IOError:
      print("There was an error opening the file {0}".format(filename))
      return False
    self.file_linesfile_lines = file_buffer.splitlines()
    return True
 
  def write_file_data(self, filename):
    """ takes the processed buffer and sends it back out to the filename. """
#    output_filename = filename + ".new"  # safe testing version.
    output_filename = filename
    try:
      our_file = open(output_filename, "wb")
      try:
        file_buffer = our_file.write(self.processed_bufferprocessed_buffer)
      except IOError:
        print("There was an error writing the file {0}".format(output_filename))
        return False
      finally:
        our_file.close()              
    except IOError:
      print("There was an error opening the file {0}".format(output_filename))
      return False
    return True
 
  def is_alphanumeric(self, check_char):
    """ given a character, this returns true if it's between a-z, A-Z or 0-9. """
    if (check_char[0] == "_"):
      return True
    if ( (check_char[0] <= "z") and (check_char[0] >= "a")):
      return True
    if ( (check_char[0] <= "Z") and (check_char[0] >= "A")):
      return True
    if ( (check_char[0] <= "9") and (check_char[0] >= "0")):
      return True
    return False
 
  def replace_within_string(self, fix_string):
    """ given a string to fix, this replaces all appropriate locations of the phrase. """
    indy = 0
#    print("got to replace within string")
    while (indy < len(fix_string)):
      # locate next occurrence of replacement text, if any.
      indy = fix_string.find(self.phrase_to_replacephrase_to_replace, indy)
#      print("find indy={0}".format(indy))
      if (indy > -1):
#        print("found occurrence of replacement string")
        # we found an occurrence, but we have to validate it's separated enough.
        char_before = "?"  # simple default that won't fail our check.
        char_after = "?"
        if (indy > 0):
          char_before = fix_string[indy-1]
        if (indy + len(self.phrase_to_replacephrase_to_replace) < len(fix_string) - 1):
          char_after = fix_string[indy+len(self.phrase_to_replacephrase_to_replace)]
#        print("char before {0}, char after {1}".format(char_before, char_after))
        if (not self.is_alphanumericis_alphanumeric(char_before) and not self.is_alphanumericis_alphanumeric(char_after)):
          # this looks like a good candidate for replacement.
          fix_string = "{0}{1}{2}".format(fix_string[0:indy], self.replacement_bitreplacement_bit, fix_string[indy+len(self.phrase_to_replacephrase_to_replace):])
#          print("changed string to: {0}".format(fix_string))
      else:
        break
      indy += 1  # no matches means we have to keep skipping forward.
    return fix_string  # give back processed form.
 
  def emit_normal_accumulator(self):
    """ handle emission of a chunk of normal code (without comments). """
    # process the text to perform the replacement...
    self.normal_accumulatornormal_accumulator = self.replace_within_stringreplace_within_string(self.normal_accumulatornormal_accumulator)
    # then send the text into our main buffer; we're done looking at it.
    self.processed_bufferprocessed_buffer += self.normal_accumulatornormal_accumulator
    self.normal_accumulatornormal_accumulator = ""
 
  def emit_comment_accumulator(self):
    """ emits the piled up text for comments found in the code. """
    self.processed_bufferprocessed_buffer += self.comment_accumulatorcomment_accumulator
    self.comment_accumulatorcomment_accumulator = ""
 
  def process_file_data(self):
    """ iterates through the stored version of the file and replaces the phrase. """
    self.statestate = self.EATING_NORMAL_TEXTEATING_NORMAL_TEXT;
    # clear out any previously processed text.
    self.processed_bufferprocessed_buffer = ""   # reset our new version of the file contents.
    self.normal_accumulatornormal_accumulator = ""
    self.comment_accumulatorcomment_accumulator = ""
    # iterate through the file's lines.
    while (len(self.file_linesfile_lines) > 0):
      # get the next line out of the input.
      next_line = self.file_linesfile_lines[0]
      # drop that line from the remaining items.
      self.file_linesfile_lines = self.file_linesfile_lines[1:]
#      print("next line: {0}".format(next_line))
      # decide if we need a state transition.
      indy = 0
      if ((len(next_line) > 0) and (self.statestate == self.EATING_NORMAL_TEXTEATING_NORMAL_TEXT) and ('/' in next_line)):
        # loop to catch cases where multiple slashes are in line and one IS a comment.
        while (indy < len(next_line)):
          # locate next slash, if any.
          indy = next_line.find('/', indy)
          if (indy < 0):
            break
          if ((len(next_line) > indy + 1) and (next_line[indy + 1] == '/')):
            # switch states and handle any pent-up text.
            self.normal_accumulatornormal_accumulator += next_line[0:indy]  # get last tidbit before comment start.
            next_line = next_line[indy:]  # keep only the stuff starting at slash.
            self.statestate = self.EATING_ONELINE_COMMENTEATING_ONELINE_COMMENT
#            print("state => oneline comment")
            self.emit_normal_accumulatoremit_normal_accumulator()
            break
          if ((len(next_line) > indy + 1) and (next_line[indy + 1] == '*')):
            # switch states and deal with accumulated text.
            self.normal_accumulatornormal_accumulator += next_line[0:indy]  # get last tidbit before comment start.
            next_line = next_line[indy:]  # keep only the stuff starting at slash.
            self.statestate = self.EATING_MULTILINE_COMMENTEATING_MULTILINE_COMMENT
#            print("state => multiline comment")
            self.emit_normal_accumulatoremit_normal_accumulator()
            break
          indy += 1  # no matches means we have to keep skipping forward.
 
      # now handle things appropriately for our current state.
      if (self.statestate == self.EATING_NORMAL_TEXTEATING_NORMAL_TEXT):
        # add the text to the normal accumulator.
#        print("would handle normal text")
        self.normal_accumulatornormal_accumulator += next_line + "\n"
      elif (self.statestate == self.EATING_ONELINE_COMMENTEATING_ONELINE_COMMENT):
        # save the text in comment accumulator.
#        print("would handle oneline comment")
        self.comment_accumulatorcomment_accumulator += next_line + "\n"
        self.emit_comment_accumulatoremit_comment_accumulator()
        self.statestate = self.EATING_NORMAL_TEXTEATING_NORMAL_TEXT
      elif (self.statestate == self.EATING_MULTILINE_COMMENTEATING_MULTILINE_COMMENT):
        # save the text in comment accumulator.
#        print("would handle multiline comment")
        self.comment_accumulatorcomment_accumulator += next_line + "\n"
        # check for whether the multi-line comment is completed on this line.
        if ("*/" in next_line):
#          print("found completion for multiline comment on line.")
          self.emit_comment_accumulatoremit_comment_accumulator()
          self.statestate = self.EATING_NORMAL_TEXTEATING_NORMAL_TEXT
    # verify we're not in the wrong state still.
    if (self.statestate == self.EATING_MULTILINE_COMMENTEATING_MULTILINE_COMMENT):
      print("file seems to have unclosed multi-line comment.")
    # last step is to spit out whatever was trailing in the accumulator.
    self.emit_normal_accumulatoremit_normal_accumulator()
    # if we got to here, we seem to have happily consumed the file.
    return True
 
  def replace_all_occurrences(self):
    """ Orchestrates the process of replacing the phrases. """
    # process our command line arguments to see what we need to do.
    try_command_line = self.validate_and_consume_command_linevalidate_and_consume_command_line()
    if (try_command_line != True):
      print("failed to process the command line...\n")
      self.print_instructionsprint_instructions()
      exit(1)
    # iterate through the list of files we were given and process them.
    for i in range(0, len(self.filesfiles)):
      print("file {0} is \'{1}\'".format(i, self.filesfiles[i]))
      worked = self.read_file_dataread_file_data(self.filesfiles[i])
      if (worked is False):
        print("skipping since file read failed on: {0}".format(self.filesfiles[i]))
        continue
#      print("{0} got file contents:\n{1}".format(self.files[i], self.file_lines))
      worked = self.process_file_dataprocess_file_data()
      if (worked is False):
        print("skipping, since processing failed on: {0}".format(self.filesfiles[i]))
        continue
      worked = self.write_file_datawrite_file_data(self.filesfiles[i])
      if (worked is False):
        print("writing file back failed on: {0}".format(self.filesfiles[i]))
    print("finished processing all files.")
  
 
if __name__ == "__main__":
    import sys
    slicer = phrase_replacer(sys.argv)
    slicer.replace_all_occurrences()
 
 
 
# parking lot of things to do in future:
 
#hmmm: actually sometimes one DOES want to replace within comments.  argh.
#      make ignoring inside comments an optional thing.  later.
 
# hmmm: one little issue here is if the text to be replaced happens to reside on
#       the same line after a multi-line comment.  we are okay with ignoring that
#       possibility for now since it seems brain-dead to write code that way.