amp 0.5.2 → 0.5.3

data/lib/amp/repository/abstract/common_methods/changeset.rb

@@ -0,0 +1,75 @@
+module Amp
+  module Repositories
+    
+    ##
+    # = CommonVersionedFileMethods
+    #
+    # These methods are common to all repositories, and this module is mixed into
+    # the AbstractLocalRepository class. This guarantees that all repositories will
+    # have these methods.
+    #
+    # No methods should be placed into this module unless it relies on methods in the
+    # general API for repositories.
+    module CommonChangesetMethods
+      
+      ##
+      # A hash of the files that have been changed and their most recent diffs.
+      # The diffs are lazily made upon access. To just get the files, use #altered_files
+      # or #changed_files.keys
+      # Checks whether this changeset included a given file or not.
+      # 
+      # @return [Hash<String => String>] a hash of {filename => the diff}
+      def changed_files
+        h = {}
+        class << h
+          def [](*args)
+            super(*args).call # we expect a proc
+          end
+        end
+        
+        altered_files.inject(h) do |s, k|
+          s[k] = proc do
+            other = parents.first[k]
+            self[k].unified_diff other
+          end
+        end
+      end
+      
+      ##
+      # Is +file+ being tracked at this point in time?
+      # 
+      # @param [String] file the file to lookup
+      # @return [Boolean] whether the file is in this changeset's manifest
+      def include?(file)
+        all_files.include? file
+      end
+      
+      ##
+      # recursively walk
+      # 
+      # @param [Amp::Matcher] match this is a custom object that knows files
+      #   magically. Not your grampa's proc!
+      def walk(match)
+        # just make it so the keys are there
+        results = []
+        
+        hash = Hash.with_keys match.files
+        hash.delete '.'
+        
+        each do |file|
+          hash.each {|f, val| (hash.delete file and break) if f == file }
+          
+          results << file if match.call file # yield file if match.call file
+        end
+        
+        hash.keys.sort.each do |file|
+          if match.bad file, "No such file in revision #{revision}" and match[file]
+            results << file # yield file
+          end
+        end
+        results
+      end
+      
+    end
+  end
+end

data/lib/amp/repository/abstract/common_methods/local_repo.rb

@@ -0,0 +1,277 @@
+module Amp
+  module Repositories
+    
+    ##
+    # = CommonLocalRepoMethods
+    #
+    # These methods are common to all repositories, and this module is mixed into
+    # the AbstractLocalRepository class. This guarantees that all repositories will
+    # have these methods.
+    #
+    # No methods should be placed into this module unless it relies on methods in the
+    # general API for repositories.
+    module CommonLocalRepoMethods
+      
+      attr_accessor :config
+      
+      ##
+      # Initializes a new directory to the given path, and with the current
+      # configuration.
+      # 
+      # @param [String] path a path to the Repository.
+      # @param [Boolean] create Should we create a new one? Usually for
+      #   the "amp init" command.
+      # @param [Amp::AmpConfig] config the configuration loaded from the user's
+      #   system. Will have some settings overwritten by the repo's hgrc.
+      def initialize(path="", create=false, config=nil)
+        @capabilities = {}
+        @root         = File.expand_path path.chomp("/")
+        @config       = config
+      end
+      
+      ##
+      # Initializes a new repository in the given directory. We recommend
+      # calling this at some point in your repository subclass as it will 
+      # do amp-specific initialization, though you will need to do all the
+      # hard stuff yourself.
+      def init(config=@config)
+        FileUtils.makedirs root
+        working_write "Ampfile", <<-EOF
+# Any ruby code here will be executed before Amp loads a repository and
+# dispatches a command.
+#
+# Example command:
+#
+# command "echo" do |c|
+#    c.opt :"no-newline", "Don't print a trailing newline character", :short => "-n"
+#    c.on_run do |opts, args|
+#        print args.join(" ")
+#        print "\\n" unless opts[:"no-newline"]
+#    end
+# end
+EOF
+        
+      end
+      
+      ##
+      # Joins the path to the repo's root (not .hg, the working dir root)
+      # 
+      # @param path the path we're joining
+      # @return [String] the path joined to the working directory's root
+      def working_join(path)
+        File.join(root, path)
+      end
+      
+      ##
+      # Call the hooks that run under +call+
+      # 
+      # @param [Symbol] call the location in the system where the hooks
+      #   are to be called
+      def run_hook(call, opts={:throw => false})
+        Hook.run_hook(call, opts)
+      end
+      
+      ##
+      # Adds a list of file paths to the repository for the next commit.
+      # 
+      # @param [String, Array<String>] paths the paths of the files we need to
+      #   add to the next commit
+      # @return [Array<String>] which files WEREN'T added
+      def add(*paths)
+        staging_area.add(*paths)
+      end
+      
+      ##
+      # Removes the file (or files) from the repository. Marks them as removed
+      # in the DirState, and if the :unlink option is provided, the files are
+      # deleted from the filesystem.
+      #
+      # @param list the list of files. Could also just be 1 file as a string.
+      #   should be paths.
+      # @param opts the options for this removal. Must be last argument or will mess
+      #   things up.
+      # @option [Boolean] opts :unlink (false) whether or not to delete the
+      #   files from the filesystem after marking them as removed from the
+      #   DirState.
+      # @return [Boolean] success?
+      def remove(*args)
+        staging_area.remove(*args)
+      end
+      
+      def relative_join(file, cur_dir=FileUtils.pwd)
+        @root_pathname ||= Pathname.new(root)
+        Pathname.new(File.expand_path(File.join(cur_dir, file))).relative_path_from(@root_pathname).to_s
+      end
+      
+      ##
+      # Walk recursively through the directory tree (or a changeset)
+      # finding all files matched by the match function
+      # 
+      # @param [String, Integer] node selects which changeset to walk
+      # @param [Amp::Match] match the matcher decides how to pick the files
+      # @param [Array<String>] an array of filenames
+      def walk(node=nil, match = Match.create({}) { true })
+        self[node].walk match # calls Changeset#walk
+      end
+      
+      ##
+      # Iterates over each changeset in the repository, from oldest to newest.
+      # 
+      # @yield each changeset in the repository is yielded to the caller, in order
+      #   from oldest to newest. (Actually, lowest revision # to highest revision #)
+      def each(&block)
+        0.upto(size - 1) { |i| yield self[i] }
+      end
+      
+      
+      ##
+      # This gives the status of the repository, comparing 2 node in
+      # its history. Now, with no parameters, it's going to compare the
+      # last revision with the working directory, which is the most common
+      # usage - that answers "what is the current status of the repository,
+      # compared to the last time a commit happened?". However, given any
+      # two revisions, it can compare them.
+      # 
+      # @example @repo.status # => {:unknown => ['code/smthng.rb'], :added => [], ...}
+      # @param [Hash] opts the options for this command. there's a bunch.
+      # @option [String, Integer] opts :node_1 (".") an identifier for the starting
+      #   revision
+      # @option [String, Integer] opts :node_2 (nil) an identifier for the ending
+      #   revision. Defaults to the working directory.
+      # @option [Proc] opts :match (proc { true }) a proc that will match
+      #   a file, so we know if we're interested in it.
+      # @option [Boolean] opts :ignored (false) do we want to see files we're
+      #   ignoring?
+      # @option [Boolean] opts :clean (false) do we want to see files that are
+      #   totally unchanged?
+      # @option [Boolean] opts :unknown (false) do we want to see files we've
+      #   never seen before (i.e. files the user forgot to add to the repo)?
+      # @option [Boolean] opts :delta (false) do we want to see the overall delta?
+      # @return [Hash<Symbol => Array<String>>] no, I'm not kidding. the keys are:
+      #   :modified, :added, :removed, :deleted, :unknown, :ignored, :clean, and :delta. The
+      #   keys are the type of change, and the values are arrays of filenames
+      #   (local to the root) that are under each key.
+      def status(opts={:node_1 => '.'})
+        run_hook :status
+        
+        opts[:delta] ||= true
+        node1, node2, match = opts[:node_1], opts[:node_2], opts[:match]
+        
+        match = Match.create({}) { true } unless match
+        
+        node1 = self[node1] unless node1.kind_of? Repositories::AbstractChangeset # get changeset objects
+        node2 = self[node2] unless node2.kind_of? Repositories::AbstractChangeset
+        
+        # are we working with working directories?
+        working = node2.working?
+        comparing_to_tip = working && node2.parents.include?(node1)
+        
+        status = Hash.new {|h, k| h[k] = k == :delta ? 0 : [] }
+        
+        if working
+          # get the dirstate's latest status
+          status.merge! staging_area.status(opts[:ignored], opts[:clean], opts[:unknown], match)
+          
+          # this case is run about 99% of the time
+          # do we need to do hashes on any files to see if they've changed?
+          if comparing_to_tip && status[:lookup].any?
+            clean, modified = fix_files(status[:lookup], node1, node2)
+            
+            status[:clean].concat clean
+            status[:modified].concat modified
+          end
+        end
+        # if we're working with old revisions...
+        unless comparing_to_tip
+          # get the older revision manifest            
+          node1_file_list = node1.all_files.dup
+          node2_file_list = node2.all_files.dup
+          if working
+            # remove any files we've marked as removed them from the '.' manifest
+            status[:removed].each {|file| node2_file_list.delete file }
+          end
+          
+          # Every file in the later revision (or working directory)
+          node2.all_files.each do |file|
+            # Does it exist in the old manifest? If so, it wasn't added.
+            if node1.include? file
+              # It's in the old manifest, so lets check if its been changed
+              # Else, it must be unchanged
+              if file_modified? file, :node1 => node1, :node2 => node2 # tests.any?
+                status[:modified] << file
+              elsif opts[:clean]
+                status[:clean]    << file
+              end
+              # Remove that file from the old manifest, since we've checked it
+              node1_file_list.delete file
+            else
+              # if it's not in the old manifest, it's been added
+              status[:added] << file
+            end
+          end
+          
+          # Anything left in the old manifest is a file we've removed since the
+          # first revision.
+          status[:removed] = node1_file_list
+        end
+        
+        # We're done!
+        status.delete :lookup # because nobody cares about it
+        delta = status.delete :delta
+        
+        status.each {|k, v| v.sort! } # sort dem fuckers
+        status[:delta] = delta if opts[:delta]
+        status.each {|k, _| status.delete k if opts[:only] && !opts[:only].include?(k) }
+        status
+      end
+      
+      ##
+      # Look up the files in +lookup+ to make sure
+      # they're either the same or not. Normally, we can
+      # just tell if two files are the same by looking at their sizes. But
+      # sometimes, we can't! That's where this method comes into play; it
+      # hashes the files to verify integrity.
+      # 
+      # @param [String] lookup files to look up
+      # @param node1
+      # @param node2
+      # @return [[String], [String]] clean files and modified files
+      def fix_files(lookup, node1, node2)
+        write_dirstate = false # this gets returned
+        modified = [] # and this
+        fixup    = [] # fixup are files that haven't changed so they're being
+                      # marked wrong in the dirstate. this gets returned
+        
+        lookup.each do |file|
+          # this checks to see if the file has been modified after doing
+          # hashes/flag checks
+          tests = [ node1.include?(file)                   ,
+                    node2.flags(file) == node1.flags(file) ,
+                    node1[file]      === node2[file]       ]
+          
+          unless tests.all?
+            modified << file
+          else
+            fixup << file # mark the file as clean
+          end
+        end
+        
+  
+        # mark every fixup'd file as clean in the dirstate
+        begin
+          lock_working do
+            staging_area.normal *fixup  
+            fixup.each do |file|
+              modified.delete file
+            end
+          end
+        rescue LockError
+        end
+        
+        # the fixups are actually clean
+        [fixup, modified]
+      end
+    end
+    
+  end
+end

data/lib/amp/repository/abstract/common_methods/staging_area.rb

@@ -0,0 +1,233 @@
+module Amp
+  module Repositories
+    
+    ##
+    # = CommonStagingAreaMethods
+    #
+    # These methods are common to all staging areas, and this module is mixed into
+    # the AbstractStagingArea class. This guarantees that all staging areas will
+    # have these methods.
+    #
+    # No methods should be placed into this module unless it relies on methods in the
+    # general API for staging areas.
+    module CommonStagingAreaMethods
+      
+      ##
+      # Returns whether or not the repository is tracking the given file.
+      #
+      # @api
+      # @param [String] filename the file to look up
+      # @return [Boolean] are we tracking the given file?
+      def tracking?(filename)
+        file_status(filename) != :untracked
+      end
+      
+      ##
+      # Helper method that filters out a list of explicit filenames that do not
+      # belong in the repository. It then stores the File stats of the files
+      # it keeps, and returns any explicitly named directories.
+      #
+      # @todo this is still tied to hg
+      # @param [Array<String>] files the files to examine
+      # @param [Amp::Match] match the matcher object
+      # @return [Array<Hash, Array<String>>] returns an array: [file_stats, directories]
+      def examine_named_files(files, match)
+        results, work = {vcs_dir => true}, [] # ignore the .hg
+        files.reject {|f| results[f] || f == ""}.sort.each do |file|
+          path  = File.join(repo.root, file)
+          
+          if File.exist?(path)
+            # we'll take it! but only if it's a directory, which means we have
+            # more work to do...
+            if File.directory?(path)
+              # add it to the list of dirs we have to search in
+              work << File.join(repo.root, file) unless ignoring_directory? file
+            elsif File.file?(path) || File.symlink?(path)
+              # ARGH WE FOUND ZE BOOTY
+              results[file] = File.lstat path
+            else
+              # user you are a fuckup in life please exit the world
+              UI::warn "#{file}: unsupported file type (type is #{File.ftype file})"
+              results[file] = nil if tracking? file
+            end
+          else
+            prefix = file + '/'
+            
+            unless all_files.find { |f, _| f == file || f.start_with?(prefix) }
+              bad_type[file]
+              results[file] = nil if (tracking?(file) || !ignoring_file?(file)) && match.call(file)
+            end
+          end
+        end
+        [results, work]
+      end
+      
+      ##
+      # Helper method that runs match's patterns on every non-ignored file in
+      # the repository's directory.
+      #
+      # @param [Hash] found_files the already found files (we don't want to search them
+      #   again)
+      # @param [Array<String>] dirs the directories to search
+      # @param [Amp::Match] match the matcher object that runs patterns against
+      #   filenames
+      # @return [Hash] the updated found_files hash
+      def find_with_patterns(found_files, dirs, match)
+        results = found_files
+        Find.find(*dirs) do |f|
+          tf = f[(repo.root.size+1)..-1]
+          Find.prune if results[tf]
+          
+          stats = File.lstat f
+          match_result = match.call tf
+          tracked = tracking? tf
+          
+          if File.directory? f
+            Find.prune if ignoring_file? tf
+            results[tf] = nil if tracked && match_result
+          elsif File.file?(f) || File.symlink?(f)
+            if match_result && (tracked || !ignoring_file?(tf))
+              results[tf] = stats
+            end
+          elsif tracked && match_result
+            results[tf] = nil
+          end
+        end
+        results
+      end
+      
+      ##
+      # Walk recursively through the directory tree, finding all
+      # files matched by the regexp in match.
+      # 
+      # Step 1: find all explicit files
+      # Step 2: visit subdirectories
+      # Step 3: report unseen items in the @files hash
+      # 
+      # @todo this is still tied to hg
+      # @param [Boolean] unknown
+      # @param [Boolean] ignored
+      # @return [Hash<String => [NilClass, File::Stat]>] nil for directories and
+      #   stuff, File::Stat for files and links
+      def walk(unknown, ignored, match = Amp::Match.new { true })
+        if ignored
+          @ignore_all = false
+        elsif not unknown
+          @ignore_all = true
+        end
+        
+        files = (match.files || []).uniq
+        
+        # why do we overwrite the entire array if it includes the current dir?
+        # we even kill posisbly good things
+        files = [''] if files.include?('.') # strange thing to do
+        
+        # Step 1: find all explicit files
+        results, found_directories = examine_named_files files, match
+        work = [repo.root] + found_directories
+        
+        # Run the patterns
+        results = find_with_patterns(results, work, match)
+        
+        # step 3: report unseen items in @files
+        visit = all_files.select {|f| !results[f] && match.call(f) }.sort
+        
+        visit.each do |file|
+          path = File.join(repo.root, file)
+          keep = File.exist?(path) && (File.file?(path) || File.symlink(path))
+          results[file] = keep ? File.lstat(path) : nil
+        end
+        
+        results.delete vcs_dir
+        @ignore_all = nil # reset this
+        results
+      end
+      
+      ##
+      # what's the current state of life, man!
+      # Splits up all the files into modified, clean,
+      # added, deleted, unknown, ignored, or lookup-needed.
+      # 
+      # @param [Boolean] ignored do we collect the ignore files?
+      # @param [Boolean] clean do we collect the clean files?
+      # @param [Boolean] unknown do we collect the unknown files?
+      # @param [Amp::Match] match the matcher
+      # @return [Hash<Symbol => Array<String>>] a hash of the filestatuses and their files
+      def status(ignored, clean, unknown, match = Match.new { true })
+        list_ignored, list_clean, list_unknown = ignored, clean, unknown
+        lookup, modified, added, unknown, ignored = [], [], [], [], []
+        moved, copied, removed, deleted, clean = [], [], [], [], []
+        delta = 0
+      
+        walk(list_unknown, list_ignored, match).each do |file, st|
+          next if file.nil?
+          
+          unless tracking?(file)
+            if list_ignored && ignoring_directory?(file)
+              ignored << file
+            elsif list_unknown
+              unknown << file unless ignoring_file?(file)
+            end
+          
+            next # on to the next one, don't do the rest
+          end
+        
+          # here's where we split up the files
+          state = file_status file
+          
+          delta += calculate_delta(file, st)
+          if !st && [:normal, :modified, :added].include?(state)
+            # add it to the deleted folder if it should be here but isn't
+            deleted << file
+          elsif state == :normal
+            case file_precise_status(file, st)
+            when :modified
+              modified << file
+            when :lookup
+              lookup << file
+            when :clean
+              clean << file if list_clean
+            end
+          
+          elsif state == :merged
+            modified << file
+          elsif state == :added
+            added << file
+          elsif state == :removed
+            removed << file
+          end
+        end
+        
+        # # This code creates the copied and moved arrays
+        # # 
+        # # ugh this should be optimized
+        # # as in, built into the code above ^^^^^
+        # dirstate.copy_map.each do |dst, src|
+        #   # assume that if +src+ is in +removed+ then +dst+ is in +added+
+        #   # we know that this part will be COPIES
+        #   if removed.include? src
+        #     removed.delete src
+        #     added.delete   dst
+        #     copied << [src, dst]
+        #   elsif added.include? dst # these are the MOVES
+        #     added.delete dst
+        #     moved << [src, dst]
+        #   end
+        # end
+      
+        r = { :modified => modified.sort , # those that have clearly been modified
+              :added    => added.sort    , # those that are marked for adding
+              :removed  => removed.sort  , # those that are marked for removal
+              :deleted  => deleted.sort  , # those that should be here but aren't
+              :unknown  => unknown.sort  , # those that aren't being tracked
+              :ignored  => ignored.sort  , # those that are being deliberately ignored
+              :clean    => clean.sort    , # those that haven't changed
+              :lookup   => lookup.sort   , # those that need to be content-checked to see if they've changed
+              #:copied   => copied.sort_by {|a| a[0] }, # those that have been copied
+              #:moved    => moved.sort_by  {|a| a[0] }, # those that have been moved
+              :delta    => delta           # how many bytes have been added or removed from files (not bytes that have been changed)
+            }
+      end
+    end
+  end
+end