hallettj-cloudrcs 0.0.1

data/lib/cloud_rcs/patch_types/addfile.rb

@@ -0,0 +1,74 @@
+module CloudRCS
+
+  # A primitive patch type that represents a new or an undeleted file.
+  class Addfile < PrimitivePatch
+    validates_presence_of :path
+
+    def after_initialize
+      verify_path_prefix
+    end
+
+    def to_s
+      "addfile #{self.class.escape_path(path)}"
+    end
+
+    def inverse
+      Rmfile.new(:path => path)
+    end
+
+    def commute(patch)
+      if patch.is_a? Addfile and patch.path == self.path
+        raise CommuteException(true, "Conflict: cannot create two files with the same path.")
+      elsif patch.is_a? Rmfile and patch.path == self.path
+        raise CommuteException(true, "Conflict: commuting addfile with rmfile in this case would cause file to be removed before it is created.")
+      elsif patch.is_a? Move and patch.original_path == self.path
+        raise CommuteException(true, "Conflict: commuting addfile with move in this case would cause file to be moved before it is created.")
+      else
+        patch1 = patch.clone
+        patch2 = self.clone
+      end
+      return patch1, patch2
+    end
+
+    def apply_to(file)
+      return file unless file.nil?
+      if patch.respond_to? :owner
+        new_file = self.class.file_class.new(:owner => patch.owner,
+                                             :contents => "",
+                                             :content_type => "text/plain")
+      else
+        new_file = self.class.file_class.new(:contents => "",
+                                             :content_type => "text/plain")
+      end
+      new_file.path = path
+      return new_file
+    end
+
+    class << self
+
+      # Addfile has a low priority so that it will appear before patches
+      # that are likely to depend on it - such as Hunk patches.
+      def priority
+        10
+      end
+
+      def generate(orig_file, changed_file)
+        if orig_file.nil? and not changed_file.nil?
+          return Addfile.new(:path => changed_file.path, :contents => changed_file.content_type)
+        end
+      end
+
+      def parse(contents)
+        unless contents =~ /^addfile\s+(\S+)\s*$/
+          raise "Failed to parse addfile patch: #{contents}"
+        end
+        Addfile.new(:path => unescape_path($1))
+      end
+
+    end
+
+  end
+
+  PATCH_TYPES << Addfile
+
+end

data/lib/cloud_rcs/patch_types/binary.rb

@@ -0,0 +1,232 @@
+module CloudRCS
+
+  class Binary < PrimitivePatch
+    serialize :contents, Array
+
+    validates_presence_of :path, :contents, :position
+    validates_numericality_of :position, :only_integer => true, :greater_than_or_equal_to => 0
+
+    def apply_to(file)
+      return file unless file.path == path
+
+      hex_contents = Binary.binary_to_hex(file.contents)
+
+      # Check that the patch matches the file contents
+      unless hex_contents[position...position+lengthold] == removed
+        raise ApplyException.new(true), "Portion of binary patch marked for removal does not match existing contents in file. Existing contents at position #{position}: '#{hex_contents[position...position+lengthold]}' ; marked for removal: '#{removed}'"
+      end
+
+      # Then, remove stuff
+      unless removed.blank?
+        hex_contents[position...position+lengthold] = ""
+      end
+
+      # Finally, add stuff
+      unless added.blank?
+        hex_contents.insert(position, added)
+      end
+
+      file.contents = Binary.hex_to_binary(hex_contents)
+      return file
+    end
+
+    def inverse
+      Binary.new(:path => path,
+                 :position => position,
+                 :contents => [added, removed],
+                 :inverted => true)
+    end
+
+    def commute(patch)
+      if patch.is_a? Binary and patch.path == self.path
+
+        # self is applied first and precedes patch in the file
+        if self.position + self.lengthnew < patch.position
+          patch1 = Binary.new(:path => patch.path,
+                            :position => (patch.position - self.lengthnew + self.lengthold),
+                            :contents => patch.contents)
+          patch2 = Binary.new(:path => self.path, 
+                              :position => self.position, 
+                              :contents => self.contents)
+          
+        # self is applied first, but is preceded by patch in the file          
+        elsif patch.position + patch.lengthold < self.position
+          patch1 = Binary.new(:path => patch.path, 
+                              :position => patch.position, 
+                              :contents => patch.contents)
+          patch2 = Binary.new(:path => self.path, 
+                            :position => (self.position + patch.lengthnew - patch.lengthold),
+                            :contents => self.contents)
+          
+        # patch precedes self in file, but bumps up against it
+        elsif patch.position + patch.lengthnew == self.position and
+            self.lengthold != 0 and patch.lengthold != 0 and 
+            self.lengthnew != 0 and patch.lengthnew != 0
+          patch1 = Binary.new(:path => patch.path, 
+                              :position => patch.position, 
+                              :contents => patch.contents)
+          patch2 = Binary.new(:path => self.path, 
+                              :position => (self.position - patch.lengthnew + patch.lengthold), 
+                              :contents => self.contents)
+          
+        # self precedes patch in file, but bumps up against it
+        elsif self.position + self.lengthold == patch.position and
+            self.lengthold != 0 and patch.lengthold != 0 and 
+            self.lengthnew != 0 and patch.lengthnew != 0
+          patch1 = Binary.new(:path => patch.path,
+                              :position => patch.position,
+                              :contents => patch.contents)
+          patch2 = Binary.new(:path => self.path, 
+                              :position => (self.position + patch.lengthnew - patch.lengthold), 
+                              :contents => self.contents)
+          
+        # Patches overlap. This is a conflict scenario
+        else
+          raise CommuteException.new(true), "Conflict: binary patches overlap."
+        end
+        
+      elsif patch.is_a? Rmfile and patch.path == self.path
+        raise CommuteException.new(true), "Conflict: cannot modify a file after it is removed."
+
+      elsif patch.is_a? Move and self.path == patch.original_path
+        patch1 = patch.clone
+        patch2 = self.clone
+        patch2.path = patch.new_path
+        
+      # Commutation is trivial
+      else
+        patch1, patch2 = patch, self
+      end
+      
+      return patch1, patch2
+    end
+
+    def to_s
+      header = "binary #{self.class.escape_path(path)} #{position}"
+      old = removed.scan(/.{1,78}/).collect { |c| '-' + c }.join("\n")
+      new = added.scan(/.{1,78}/).collect { |c| '+' + c }.join("\n")
+      return [header, old, new].delete_if { |e| e.blank? }.join("\n")
+    end
+
+    def removed
+      contents.first
+    end
+
+    def added
+      contents.last
+    end
+
+    def lengthold
+      removed.length
+    end
+    
+    def lengthnew
+      added.length
+    end
+
+    class << self
+
+      # Use a low priority so that the binary patch generating method
+      # will be called before the hunk patch generating method
+      def priority
+        20
+      end
+
+      def generate(orig_file, changed_file)
+        return if orig_file.nil? and changed_file.nil?
+        return unless (orig_file and orig_file.contents.is_binary_data?) or 
+          (changed_file and changed_file.contents.is_binary_data?)
+
+        # Convert binary data to hexadecimal for storage in a text
+        # file
+        orig_hex = orig_file ? binary_to_hex(orig_file.contents).scan(/.{2}/) : []
+        changed_hex = changed_file ? binary_to_hex(changed_file.contents).scan(/.{2}/) : []
+
+        file_path = orig_file ? orig_file.path : changed_file.path
+
+        diffs = Diff::LCS.diff(orig_hex, changed_hex)
+        chunks = []
+        offset = 0
+        diffs.each do |d|
+
+          # We need to recalculate positions for removals - just as in
+          # hunk generation.
+          unless chunks.empty?
+            offset += chunks.last.lengthnew - chunks.last.lengthold
+          end
+          d.collect! do |l|
+            if l.action == '-'
+              Diff::LCS::Change.new(l.action, l.position + (offset / 2), l.element)
+            else
+              l
+            end
+          end
+
+          position = d.first.position * 2
+
+          removed = d.find_all { |l| l.action == '-' }.collect { |l| l.element }.join
+          added = d.find_all { |l| l.action == '+' }.collect { |l| l.element }.join
+          
+          unless removed.blank? and added.blank?
+            chunks << Binary.new(:contents => [removed, added],
+                                 :position => position,
+                                 :path => file_path)
+          end
+          
+        end
+        
+        return chunks
+      end
+      
+      def parse(contents)
+        unless contents =~ /^binary\s+(\S+)\s+(\d+)\s+(.*)$/m
+          raise ParseException.new(true), "Failed to parse binary patch: \"#{contents}\""
+        end
+        file_path = unescape_path($1)
+        starting_position = $2.to_i
+        contents = $3
+
+        removed, added = [], []
+        removed_offset = 0
+        added_offset = 0
+        contents.split("\n").each do |line|
+          if line =~ /^-([\S]*)\s*$/
+            removed << $1
+            removed_offset += 1
+          elsif line =~ /^\+([\S]*)\s*$/
+            added << $1
+            added_offset += 1
+          else
+            raise "Failed to parse a line in binary patch: \"#{line}\""
+          end
+        end
+
+        removed = removed.join
+        added = added.join
+
+        return Binary.new(:path => file_path, 
+                          :position => starting_position, 
+                          :contents => [removed, added])
+      end
+      
+      # We want to store the contents of a binary file encoded as a
+      # hexidecimal value. These two methods allow for translating
+      # between binary and hexidecimal.
+      #
+      # Code borrowed from:
+      # http://4thmouse.com/index.php/2008/02/18/converting-hex-to-binary-in-4-languages/
+      def hex_to_binary(hex)
+        hex.to_a.pack("H*")
+      end
+      
+      def binary_to_hex(bin)
+        bin.unpack("H*").first
+      end
+      
+    end
+
+  end
+  
+  PATCH_TYPES << Binary
+
+end

data/lib/cloud_rcs/patch_types/hunk.rb

@@ -0,0 +1,263 @@
+module CloudRCS
+
+  # Hunk is one type of primitive patch. It represents a deletion or
+  # an insertion, or a combination of both, in a text file.
+  #
+  # A Hunk is constructed using the path of a file, the first line
+  # modifications to the file, and a set of diffs, each of which
+  # represents a line added to or deleted from the file.
+
+  class Hunk < PrimitivePatch
+    serialize :contents, Array
+
+    validates_presence_of :path, :contents, :position
+    validates_numericality_of :position, :only_integer => true, :greater_than_or_equal_to => 1
+
+    def validate
+      # Make sure diffs only contain the actions '+' and '-'
+      if contents.respond_to? :each
+        contents.each do |d|
+          unless ['+','-'].include? d.action
+            errors.add(:contents, "contains an unknown action.")
+          end
+        end
+      end
+    end
+
+    #   def after_initialize
+    #     verify_path_prefix
+    #     starting_line ||= contents.first.position
+    #   end
+    
+    def to_s
+      "hunk #{self.class.escape_path(path)} #{position}\n" + contents.collect do |d|
+        "#{d.action}#{d.element}"
+      end.join("\n")
+    end
+
+    # The inverse of a Hunk simply swaps adds and deletes.
+    def inverse
+      new_removals = added_lines.collect do |d|
+        Diff::LCS::Change.new('-', d.position, d.element)
+      end
+      new_adds = removed_lines.collect do |d|
+        Diff::LCS::Change.new('+', d.position, d.element)
+      end
+      Hunk.new(:path => path, :position => position, :contents => (new_removals + new_adds))
+    end
+
+    # Given another patch, generates two new patches that have the
+    # same effect as the original two, but with the order of the
+    # analogous patches reversed. The message receiver is the first
+    # patch, and the argument is the second; so after commuting the
+    # analog of this patch will be second.
+    def commute(patch)
+      if patch.is_a? Hunk and patch.path == self.path
+
+        # self is applied first and precedes patch in the file
+        if self.position + self.lengthnew < patch.position
+          patch1 = Hunk.new(:path => patch.path,
+                            :position => (patch.position - self.lengthnew + self.lengthold),
+                            :contents => patch.contents)
+          patch2 = Hunk.new(:path => self.path, :position => self.position, :contents => self.contents)
+          
+        # self is applied first, but is preceded by patch in the file          
+        elsif patch.position + patch.lengthold < self.position
+          patch1 = Hunk.new(:path => patch.path, :position => patch.position, :contents => patch.contents)
+          patch2 = Hunk.new(:path => self.path, 
+                            :position => (self.position + patch.lengthnew - patch.lengthold),
+                            :contents => self.contents)
+          
+        # patch precedes self in file, but bumps up against it
+        elsif patch.position + patch.lengthnew == self.position and
+            self.lengthold != 0 and patch.lengthold != 0 and 
+            self.lengthnew != 0 and patch.lengthnew != 0
+          patch1 = Hunk.new(:path => patch.path, :position => patch.position, :contents => patch.contents)
+          patch2 = Hunk.new(:path => self.path, 
+                            :position => (self.position - patch.lengthnew + patch.lengthold), 
+                            :contents => self.contents)
+          
+        # self precedes patch in file, but bumps up against it
+        elsif self.position + self.lengthold == patch.position and
+            self.lengthold != 0 and patch.lengthold != 0 and 
+            self.lengthnew != 0 and patch.lengthnew != 0
+          patch1 = Hunk.new(:path => patch.path, :position => patch.position, :contents => patch.contents)
+          patch2 = Hunk.new(:path => self.path, 
+                            :position => (self.position + patch.lengthnew - patch.lengthold), 
+                            :contents => self.contents)
+          
+        # Patches overlap. This is a conflict scenario
+        else
+          raise CommuteException.new(true, "Conflict: hunk patches overlap.")
+        end
+        
+      elsif patch.is_a? Rmfile and patch.path == self.path
+        raise CommuteException.new(true, "Conflict: cannot modify a file after it is removed.")
+
+      elsif patch.is_a? Move and self.path == patch.original_path
+        patch1 = patch.clone
+        patch2 = self.clone
+        patch2.path = patch.new_path
+        
+      # Commutation is trivial
+      else
+        patch1, patch2 = patch, self
+      end
+      
+      return patch1, patch2
+    end
+
+    def apply_to(file)
+      return file unless file.path == path
+
+      # Passing a negative number as the second argument of split
+      # preserves trailing newline characters at the end of the file
+      # when the lines are re-joined.
+      lines = file.contents.split("\n",-1)
+
+      # First, remove lines
+      removed_lines.each do |d|
+        if lines[position-1] == d.element.sub(/(\s+)\$\s*$/) { $1 }
+          lines.delete_at(position-1)
+        else
+          raise ApplyException.new(true), "Line in hunk marked for removal does not match contents of existing line in file\nfile contents: #{position} -'#{lines[position-1]}'\nline to be removed: #{d.position} -'#{d.element}'"
+        end
+      end
+
+      # Next, add lines
+      added_lines.each_with_index do |d,i|
+        lines.insert(position - 1 + i, d.element.sub(/(\s+)\$\s*$/) { $1 })
+      end
+
+      file.contents = lines.join("\n")
+      return file
+    end
+
+    # Returns the number of lines added by the hunk patch
+    def lengthnew
+      added_lines.length
+    end
+
+    # Returns the number of lines removed by the hunk patch
+    def lengthold
+      removed_lines.length
+    end
+
+    def removed_lines
+      contents.find_all { |d| d.action == '-' }   # .sort { |a,b| a.position <=> b.position }
+    end
+
+    def added_lines
+      contents.find_all { |d| d.action == '+' }   # .sort { |a,b| a.position <=> b.position }
+    end
+
+    class << self
+
+      # Given a list of files, determine whether this patch type
+      # describes the changes between the files and generate patches
+      # accordingly.
+      #
+      # In this case we use the Diff::LCS algorithm to generate Change
+      # objects representing each changed line between two files. The
+      # changesets are automatically nested into a two dimensional
+      # Array, where each row represents a changed portion of the file
+      # that is separated from the other rows by an unchanged portion
+      # of the file. So we split that dimension of the Array into
+      # separate Hunk patches and return the resulting list.
+      def generate(orig_file, changed_file)
+        return if orig_file.nil? and changed_file.nil?
+        return if (orig_file and orig_file.contents.is_binary_data?) or 
+          (changed_file and changed_file.contents.is_binary_data?)
+
+        # If the original or the changed file is nil, the hunk should
+        # contain the entirety of the other file. This is so that a
+        # record is kept of a file that is deleted; and so that the
+        # contents of a file is added to it after it is created.
+        orig_lines = orig_file ? orig_file.contents.split("\n",-1) : []
+        changed_lines = changed_file ? changed_file.contents.split("\n",-1) : []
+
+        # Insert end-of-line tokens to preserve white space at the end
+        # of lines. This is part of the darcs patch format.
+        orig_lines.each { |l| l += "$" if l =~ /\s+$/ }
+        changed_lines.each { |l| l += "$" if l =~ /\s+$/ }
+
+        file_path = orig_file ? orig_file.path : changed_file.path
+
+        diffs = Diff::LCS.diff(orig_lines, changed_lines)
+        hunks = []
+        offset = 0
+        diffs.each do |d|
+          
+          # Diff::LCS assumes that removed lines from all hunks will be
+          # removed from file before new lines are added. Unfortunately,
+          # in this implementation we remove and add lines from each
+          # hunk in order. So the position values for removed lines will
+          # be off in all but the first hunk. So we need to adjust those
+          # position values before we create the hunk patch.
+          unless hunks.empty?
+            offset += hunks.last.lengthnew - hunks.last.lengthold
+          end
+          d.collect! do |l|
+            if l.action == '-'
+              Diff::LCS::Change.new(l.action, l.position + offset, l.element)
+            else
+              l
+            end
+          end
+
+          # The darcs patch format counts lines starting from 1; whereas
+          # Diff::LCS counts lines starting from 0. So we add 1 to the
+          # position of the first changed line to get the
+          # darcs-compatible starting line number for the Hunk patch.
+          position = d.first.position + 1
+          
+          hunks << Hunk.new(:path => file_path, :position => position, :contents => d)
+        end
+        return hunks
+      end
+
+      # Parse hunk info from a file and convert into a Hunk object.
+      def parse(contents)
+        unless contents =~ /^hunk\s+(\S+)\s+(\d+)\s+(.*)$/m
+          raise ParseException.new(true), "Failed to parse hunk patch: \"#{contents}\""
+        end
+        file_path = unescape_path($1)
+        starting_position = $2.to_i
+        contents = $3
+
+        last_action = nil
+        line_offset = 0
+
+        diffs = []
+        add_line_offset = 0
+        del_line_offset = 0
+        contents.split("\n").each do |line|
+          # These regular expressions ensure that each line ends with a
+          # non-whitespace character, or is empty. A dollar sign is
+          # added during patch generation to the end of lines that end
+          # in whitespace; so parsing this way will not cut off
+          # whitespace that is supposed to be added to any patched file.
+          #
+          # If the line is empty, $1 will be nil. So it is important to
+          # pass $1.to_s instead of just $1 to change nil to "".
+          if line =~ /^\+(.*[\S\$])?\s*$/
+            diffs << Diff::LCS::Change.new('+', starting_position + add_line_offset, $1.to_s)
+            add_line_offset += 1
+          elsif line =~ /^-(.*[\S\$])?\s*$/
+            diffs << Diff::LCS::Change.new('-', starting_position + del_line_offset, $1.to_s)
+            del_line_offset += 1
+          else
+            raise "Failed to parse a line in hunk: \"#{line}\""
+          end
+        end
+
+        return Hunk.new(:path => file_path, :position => starting_position, :contents => diffs)
+      end
+
+    end
+    
+  end
+
+  PATCH_TYPES << Hunk
+
+end