amp 0.5.2 → 0.5.3

data/lib/amp/encoding/pure_ruby/ruby_mercurial_patch.rb

@@ -1,123 +0,0 @@
-
-module Amp
-  module Diffs
-    
-    ##
-    # This handles applying patches in mercurial. yay!!!!
-    module MercurialPatch
-      
-      ##
-      # This attempts to apply a series of patches in time proportional to
-      # the total size of the patches, rather than patches * len(text). This
-      # means rather than shuffling strings around, we shuffle around
-      # pointers to fragments with fragment lists.
-      #
-      # When the fragment lists get too long, we collapse them. To do this
-      # efficiently, we do all our operations inside a buffer created by
-      # mmap and simply use memmove. This avoids creating a bunch of large
-      # temporary string buffers.
-      #
-      # UPDATE 2AM BEFORE I GO BACK TO SCHOOL
-      # I FUCKING HATE PYTHON
-      def self.apply_patches(source, patches)
-        return source if patches.empty?
-        patch_lens = patches.map {|patch| patch.size}
-        pl = patch_lens.sum
-        bl = source.size + pl
-        tl = bl + bl + pl
-        b1, b2 = 0, bl
-        
-        return a if tl == 0 #empty patches. lame.
-        
-        output = StringIO.new "",(ruby_19? ? "r+:ASCII-8BIT" : "r+")
-        output.write source
-        
-        frags = [[source.size, b1]]
-        
-        pos = b2 + bl
-        output.seek pos
-        patches.each {|patch| output.write(patch)}
-        patch_lens.each do |plen|
-          if frags.size > 128
-            b2, b1 = b1, b2
-            frags = [self.collect(output,b1,frags)]
-          end
-          newarr = []
-          endpt = pos + plen
-          last = 0
-          while pos < endpt
-            output.seek pos
-            p1, p2, l = output.read(12).unpack("NNN")
-            self.pull(newarr, frags, p1 - last)
-            self.pull([], frags, p2 - p1)
-            newarr << [l, pos + 12]
-            pos += l + 12
-            last = p2
-          end
-          frags = newarr + frags
-        end
-  
-        t = self.collect output, b2, frags
-        output.seek t[1]
-        output.read t[0]
-      end
-      
-      
-      def self.patched_size(orig, delta)
-        outlen, last, bin = 0, 0, 0
-        binend = delta.size
-        data = 12 # size of the delta instruction values (3 longs)
-        while data <= binend
-          decode = delta[bin..(bin+11)]
-          start, endpt, length = decode.unpack("NNN")
-          break if start > endpt
-          
-          bin = data + length
-          data = bin + 12
-          outlen += start - last
-          last = endpt
-          outlen += length
-        end
-        
-        raise "patch cannot be decoded" if bin != binend
-        
-        outlen += orig - last
-        outlen
-      end
-      
-      def self.copy_block(io, destination, source, count)
-        io.seek(source)
-        buf = io.read(count)
-        io.seek(destination)
-        io.write(buf)
-      end
-      
-      ##
-      # 
-      def self.pull(dst, src, l)
-        until l == 0
-          f = src.shift
-          if f[0] > l
-            src.unshift [f[0] - l, f[1] + l]
-            dst << [l, f[1]]
-            return
-          end
-          dst << f
-          l -= f[0]
-        end
-      end
-      
-      ##
-      # Takes the fragments we've accumulated and applies them all to the IO.
-      def self.collect(io, buf, list)
-        start = buf
-        list.each do |l, p|
-          self.copy_block(io, buf, p, l)
-          buf += l
-        end
-        [buf - start, start]
-      end
-      
-    end
-  end
-end

data/lib/amp/merges/merge_state.rb

@@ -1,164 +0,0 @@
-module Amp
-  module Merges
-    
-    ##
-    # = MergeState
-    # MergeState handles the merge/ directory in the repository, in order
-    # to keep track of how well the current merge is progressing. There is
-    # a file called merge/state that lists all the files that need merging
-    # and a little info about whether it has beeen merged or not.
-    #
-    # You can add a file to the mergestate, iterate over all of them, quickly
-    # look up to see if a file is still dirty, and so on.
-    class MergeState
-      include Enumerable
-      
-      ##
-      # Initializes a new mergestate with the given repo, and reads in all the
-      # information from merge/state.
-      #
-      # @param repo the repository being inspected
-      def initialize(repo)
-        @repo = repo
-        read!
-      end
-      
-      ##
-      # Resets the merge status, by clearing all merge information and files
-      # 
-      # @param node the node we're working with? seems kinda useless
-      def reset(node = nil)
-        @state = {}
-        @local = node if node
-        FileUtils.rm_rf @repo.join("merge")
-      end
-      alias_method :reset!, :reset
-      
-      ##
-      # Returns whether the file is part of a merge or not
-      # 
-      # @return [Boolean] if the dirty file in our state and not nil?
-      def include?(dirty_file)
-        not @state[dirty_file].nil?
-      end
-      
-      ##
-      # Accesses the the given file's merge status - can be "u" for unmerged,
-      # or other stuff we haven't figured out yet.
-      #
-      # @param [String] dirty_file the path to the file for merging.
-      # @return [String] the status as a letter - so far "u" means unmerged or "r"
-      #   for resolved.
-      def [](dirty_file)
-        @state[dirty_file] ? @state[dirty_file][0, 1] : ""
-      end
-      
-      ##
-      # Adds a file to the mergestate, which creates a separate file
-      # in the merge directory with all the information. I don't know
-      # what these parameters are for yet.
-      def add(fcl, fco, fca, fd, flags)
-        hash = Digest::SHA1.new.update(fcl.path).hexdigest
-        @repo.open("merge/#{hash}", "w") do |file|
-          file.write fcl.data
-        end
-        @state[fd] = ["u", hash, fcl.path, fca.path, fca.file_node.hexlify,
-                      fco.path, flags]
-        save
-      end
-      
-      ##
-      # Iterates over all the files that are involved in the current
-      # merging transaction.
-      #
-      # @yield each file, sorted by filename, that needs merging.
-      # @yieldparam file the filename that needs (or has been) merged.
-      # @yieldparam state all the information about the current merge with
-      #   this file.
-      def each
-        @state.keys.sort.each do |key|
-          yield(key, @state[key])
-        end
-      end
-      
-      ##
-      # Marks the given file with a given state, which is 1 letter. "u" means
-      # unmerged, "r" means resolved.
-      #
-      # @param [String] dirty_file the file path for marking
-      # @param [String] state the state - "u" for unmerged, "r" for resolved.
-      def mark(dirty_file, state)
-        @state[dirty_file][0] = state
-        save
-      end
-      
-      ##
-      # Resolves the given file for a merge between 2 changesets.
-      #
-      # @param dirty_file the path to the file for merging
-      # @param working_changeset the current changeset that is the destination
-      #   of the merge
-      # @param other_changeset the newer changeset, which we're merging to
-      def resolve(dirty_file, working_changeset, other_changeset)
-        return 0 if self[dirty_file] == "r"
-        state, hash, lfile, afile, anode, ofile, flags = @state[dirty_file]
-        r = true
-        @repo.open("merge/#{hash}") do |file|
-          @repo.working_write(dirty_file, file.read, flags)
-          working_file  = working_changeset[dirty_file]
-          other_file    = other_changeset[ofile]
-          ancestor_file = @repo.versioned_file(afile, :file_id => anode)
-          r = UI.file_merge(@repo, @local, lfile, working_file, other_file, ancestor_file)
-        end
-        
-        mark(dirty_file, "r") if r.nil? || r == false
-        return r
-      end
-      
-      ##
-      # Public access to writing the file.
-      def save
-        write!
-      end
-      alias_method :save!, :save
-      
-      private
-      
-      ##
-      # Reads in the merge state and sets up all our instance variables.
-      #
-      def read!
-        @state = {}
-        ignore_missing_files do
-          local_node = nil
-          @repo.open("merge/state") do |file|
-            get_node = true
-            file.each_line do |line|
-              if get_node
-                local_node = line.chomp
-                get_node = false
-              else
-                parts = line.chomp.split("\0")
-                @state[parts[0]] = parts[1..-1]
-              end
-            end
-            @local = local_node.unhexlify
-          end
-        end
-      end
-      
-      ##
-      # Saves the merge state to disk.
-      #
-      def write!
-        @repo.open("merge/state","w") do |file|
-          file.write @local.hexlify + "\n"
-          @state.each do |key, val|
-            file.write "#{([key] + val).join("\0")}\n"
-          end
-        end
-      end
-      
-    end
-  end
-end

data/lib/amp/merges/merge_ui.rb

@@ -1,322 +0,0 @@
-require 'tempfile'
-
-module Amp
-  module Merges
-    
-    ##
-    # This module handles figuring out how to merge files using the user's
-    # preferences. It is mixed into the UI class. The UI class must implement
-    # the "config" method.
-    module MergeUI
-      
-      ##
-      # Performs a 3-way merge in the working directory from vf_local to vf_other,
-      # using the common ancestor vf_ancestor.
-      #
-      # @todo change 1s and 0s to bools
-      # @todo consistent return type
-      #
-      # @param [Repository] repo the repository in which we are merging files
-      # @param [String] parent_node the node_id of the parent node before the merge
-      # @param [String] original_fn the original local filename before the merge
-      # @param [WorkingVersionedFile] vf_local the current, working-directory versioned file
-      # @param [VersionedFile] vf_other the file's changeset to which we are migrating
-      # @param [VersionedFile] vf_ancestor the common ancestor between vf_local and vf_other
-      # @return [Boolean] true if there were conflicts during the merge
-      def file_merge(repo, parent_node, original_fn, vf_local, vf_other, vf_ancestor)
-        is_binary = proc {|ctx| ctx.data.binary? rescue false}
-        
-        return nil if !(vf_other.cmp vf_local.data)
-        
-        path = vf_local.path
-        binary = is_binary[vf_local] || is_binary[vf_other] || is_binary[vf_ancestor]
-        symlink = (vf_local.flags + vf_other.flags).include? "l"
-        
-        tool, tool_path = pick_tool(repo, path, binary, symlink)
-        UI.status("Picked tool #{tool} for #{path} (binary #{binary} symlink #{symlink})")
-        
-        unless tool
-          tool = "internal:local"
-          if UI.ask("no tool found to merge #{path}\n"+
-                    "keep (l)ocal or take (o)ther?") != "l"
-            tool = "internal:other"
-          end
-        end
-        
-        case tool
-        when "internal:local"
-          return 0
-        when "internal:other"
-          repo.working_write(path, vf_other.data, vf_other.flags)
-          return 0
-        when "internal:fail"
-          return 1
-        end
-        
-        a = repo.working_join(path)
-        b_file = save_versioned_file_temp("base", vf_ancestor)
-        c_file = save_versioned_file_temp("other", vf_other)
-        b, c = b_file.path, c_file.path
-        
-        out = ""
-        back = a + ".orig" + File.extname(a)
-        File.copy(a, back)
-        
-        if original_fn != vf_other.path
-          UI.status("merging #{original_fn} and #{vf_other.path} to #{path}")
-        else
-          UI.status("merging #{path}")
-        end
-        
-        if tool_setting(tool, "premerge", !(binary || symlink))
-          ret = ThreeWayMerger.three_way_merge(a, b, c, :quiet => true)
-          unless ret
-            UI.debug("premerge successful")
-            File.unlink(back)
-            File.safe_unlink(b)
-            File.safe_unlink(c)
-            return false
-          end
-          File.copy(back, a) # restore frmo backup and try again
-        end
-        
-        environment = {"HG_FILE" => path,
-                       "HG_MY_NODE" => parent_node.hexlify[0..11],
-                       "HG_OTHER_NODE" => vf_other.changeset.to_s,
-                       "HG_MY_ISLINK" => vf_local.flags.include?("l"),
-                       "HG_OTHER_ISLINK" => vf_other.flags.include?("l"),
-                       "HG_BASE_ISLINK" => vf_ancestor.flags.include?("l")}
-        if tool == "internal:merge"
-          ret = ThreeWayMerger.three_way_merge(a, b, c, :label => ['local', 'other'])
-        else
-          args = tool_setting_string(tool, "args", "$local $base $other")
-          if args.include?("$output")
-            out, a = a, back # read input from backup, write to original
-          end
-          replace = {"local" => a, "base" => b, "other" => c, "output" => out}
-          args.gsub!(/\$(local|base|other|output)/) { replace[$1]}
-          # shelling out
-          ret = Amp::Support::system(tool_path+" "+args, :chdir => repo.root, :environ => environment)
-        end
-        ret = (ret == true ? 1 : (ret == false ? 0 : ret))
-        if ret == 0 && tool_setting(tool, "checkconflicts")
-          if vf_local.data =~ /^(<<<<<<< .*|=======|>>>>>>> .*)$/
-            ret = 1
-          end
-        end
-        
-        if ret == 0 && tool_setting(tool, "checkchanged")
-          if File.stat(repo.working_join(path)) === File.stat(back)
-            if UI::yes_or_no "output file #{path} appears unchanged\nwas merge successful?"
-              r = 1
-            end
-          end
-        end
-        
-        fix_end_of_lines(repo.working_join(path), back) if tool_setting(tool, "fixeol")
-        
-        if ret == 1
-          UI::warn "merging #{path} failed!"
-        else
-          File.unlink back
-        end
-        File.unlink b
-        File.unlink c
-        
-        !ret.zero? # return
-      end
-      
-      private
-      
-      def save_versioned_file_temp(prefix, versioned_file)
-        prefix = "#{File.basename versioned_file.path}~#{prefix}"
-        
-        tempfile = Tempfile.new prefix
-        path = tempfile.path
-        tempfile.write versioned_file.data
-        tempfile.close false # DON'T unlink it
-        
-        tempfile
-      end
-      
-      ##
-      # Converts the end-of-line characters in a file to match the original file.
-      # Thus, if we merge from our copy to a new one, and there foreign
-      # end-of-line characters got merged in, we want to nuke them and put in our own!
-      #
-      # @param [String] new_file the path to the newly merged file
-      # @param [String] original_file the path to the original file
-      def fix_end_of_lines(new_file, original_file)
-        new_eol = guess_end_of_line(File.read(original_file))
-        if new_eol
-          data = File.read(new_file)
-          old_eol = guess_end_of_line(data)
-          if old_eol
-            new_data = data.gsub(old_eol, new_eol)
-            
-            File.open(file, "w") {|f| f.write new_data } if new_data != data
-          end
-        end
-      end
-      
-      
-      ##
-      # Guesses the end-of-line character for a file in a very lazy fashion.
-      #
-      # @param [String] data the file data to guess from
-      # @return [String, nil] the guessed end-of-line character(s).
-      def guess_end_of_line(data)
-        return nil if data.include?("\0")       # binary
-        return "\r\n" if data.include?("\r\n")  # windows
-        return "\r"   if data.include?("\r")    # old mac
-        return "\n"   if data.include?("\n")    # *nix
-        return nil                              # wtf?
-      end
-      
-      ##
-      # Picks a merge tool based on the user's settings in hgrc files and environment
-      # variables. Returns a hash specifying both the name and path of the
-      # merge tool's executable.
-      #
-      # @todo merge-patterns, line 56 of filemerge.py
-      # @param [Repository] repo the repository we are performing a merge upon
-      # @param [String] path the path to the file we're merging
-      # @param [Boolean] binary is the file a binary file?
-      # @param [Boolean] symlink is the file a symlink?
-      # @return [Hash] keyed as follows:
-      #   :name => the name of the chosen tool
-      #   :path => the path to the tool (if an executable is to be used)
-      def pick_tool(repo, path, binary, symlink)
-        hgmerge = ENV["HGMERGE"]
-				return [hgmerge, hgmerge] if hgmerge
-        
-        # @todo: add merge-patterns support
-        
-        # scan the merge-tools section
-        tools = {}
-        config["merge-tools"].each do |k, v|
-          t = k.split(".").first
-          unless tools[t]
-            tools[t] = tool_setting_string(t, "priority", "0").to_i
-          end
-        end
-        
-        # go through the list of tools and sort by priority
-        tool_names = tools.keys
-        tools = tools.map {|tool, prio| [-prio, tool]}.sort
-        # check the [ui] section for a "merge" setting
-        uimerge = config["ui","merge"]
-        if uimerge
-          unless tool_names.include?(uimerge)
-            return [uimerge, uimerge]
-          end
-          tools.unshift([nil, uimerge]) # highest priority
-        end
-        
-        # add the "hgmerge" binary
-        tools << [nil, "hgmerge"] # the old default, if found
-        # check everything in our list, and if we actually find one that works,
-        # return it
-        tools.each do |priority, tool|
-          if check_tool(tool, nil, symlink, binary)
-            tool_path = find_tool(tool)
-            return [tool, "\"#{tool_path}\""]
-          end
-        end
-        # last but not least, do a simple_merge.
-        return (!symlink && !binary) ? "internal:merge" : [nil, nil]
-      end
-      
-      ##
-      # Quick access to the merge-tools section of the configuration files.
-      # A merge tool will set it up with data like this:
-      #     [merge-tools]
-      #     awesometool.executable = /usr/bin/awesometool
-      #     awesometool.regkey = HKEY_USELESS_INFO
-      # and so on. This method abstracts away the scheme for encoding this information
-      # gets string values from the configuration.
-      #
-      # @param [String] tool the name of the tool to look up data for
-      # @param [String] part the specific information about the tool to look up
-      # @param [String] default the default value, if the configuration setting
-      #   can't be found
-      # @return [String] the setting for the given merge tool we're looking up, as
-      #   as a string.
-      def tool_setting_string(tool, part, default="")
-        config["merge-tools", "#{tool}.#{part}", String, default]
-      end
-      
-      ##
-      # Quick access to the merge-tools section of the configuration files.
-      # Returns boolean values.
-      #
-      # @see check_tool_string
-      # @param [String] tool the name of the tool to look up data for
-      # @param [String] part the specific information about the tool to look up
-      # @param [Boolean] default the default value, if the configuration setting
-      #   can't be found
-      # @return [Boolean] the setting for the given merge tool we're looking up, as
-      #   as a string.
-      def tool_setting(tool, part, default=false)
-        config["merge-tools", "#{tool}.#{part}", Boolean, default]
-      end
-      
-      ##
-      # Given the name of a merge tool, attempt to locate an executable file
-      # for the tool.
-      #
-      # @param [String] tool the name of the merge tool to locate
-      # @return [String] the path to the executable for the merge tool, or nil
-      #   if the tool cannot be found
-      def find_tool(tool)
-        if ["internal:fail", "internal:local", "internal:other"].include?(tool)
-          return tool
-        end
-        # windows stuff
-        k = tool_setting_string(tool, "regkey")
-        if k && k.any?
-          p = File.amp_lookup_reg(k, tool_setting_string(tool, "regname"))
-          if p && p.any?
-            p = File.amp_find_executable(p + check_tool_string(tool, "regappend"))
-            if p
-              return p
-            end
-          end
-        end
-        # normal *nix lookup
-        return File.amp_find_executable(tool_setting_string(tool, "executable", tool))
-      end
-      
-      ##
-      # Checks to see if a given tool is available given the necessary settings.
-      # 
-      # @todo add GUI check
-      # @param [String] tool the name of the tool we want to check
-      # @param [String] pat the pattern we matched to get here. Could be nil.
-      # @param [Boolean] symlink are we merging across a symlink here?
-      # @param [Boolean] binary are we merging a binary file? you crazy?!
-      # @return [Boolean] is the given tool available?
-      def check_tool(tool, pat, symlink, binary)
-        tool_msg = tool
-        tool_msg += " specified for " + pat if pat
-        
-        if !(find_tool tool)
-          if pat
-            warn("couldn't find merge tool #{tool}")
-          else
-            note("couldn't find merge tool #{tool}")
-          end
-        elsif symlink && !(tool_setting(tool, "symlink"))
-          warn("tool #{tool} can't handle symlinks")
-        elsif binary  && !(tool_setting(tool, "binary"))
-          warn("tool #{tool} can't handle binary files")
-        elsif false # TODO: add GUI check
-        else
-          return true
-        end
-        return false # we're here if any of the previous checks created a warning
-      end
-      
-    end
-  end
-end