amp-core 0.1.0

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

@@ -0,0 +1,293 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    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
+        include Enumerable
+        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 opts [Boolean] :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 opts [String, Integer] :node_1 (".") an identifier for the starting
+        #   revision
+        # @option opts [String, Integer] :node_2 (nil) an identifier for the ending
+        #   revision. Defaults to the working directory.
+        # @option opts [Proc] :match (proc { true }) a proc that will match
+        #   a file, so we know if we're interested in it.
+        # @option opts [Boolean] :ignored (false) do we want to see files we're
+        #   ignoring?
+        # @option opts [Boolean] :clean (false) do we want to see files that are
+        #   totally unchanged?
+        # @option opts [Boolean] :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 opts [Boolean] :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
+end

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

@@ -0,0 +1,248 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+module Amp
+  module Core
+    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.
+        #
+        # @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
+end