amp-core 0.1.0

data/lib/amp-core/repository/abstract/abstract_staging_area.rb

@@ -0,0 +1,202 @@
+##################################################################
+#                  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
+      class AbstractStagingArea
+        include CommonStagingAreaMethods
+      
+        ##
+        # Marks a file to be added to the repository upon the next commit.
+        # 
+        # @param [[String]] filenames a list of files to add in the next commit
+        # @return [Boolean] true for success, false for failure
+        def add(*filenames)
+          raise NotImplementedError.new("add() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Marks a file to be removed from the repository upon the next commit. Last argument
+        # can be a hash, which can take an :unlink key, specifying whether the files should actually
+        # be removed or not.
+        # 
+        # @param [[String]] filenames a list of files to remove in the next commit
+        # @return [Boolean] true for success, false for failure
+        def remove(*filenames)
+          raise NotImplementedError.new("remove() must be implemented by subclasses of AbstractStagingArea.")
+        end
+        
+        ##
+        # Set +file+ as normal and clean. Un-removes any files marked as removed, and
+        # un-adds any files marked as added.
+        # 
+        # @param  [Array<String>] files the name of the files to mark as normal
+        # @return [Boolean] success marker
+        def normal(*files)
+          raise NotImplementedError.new("normal() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Mark the files as untracked.
+        # 
+        # @param  [Array<String>] files the name of the files to mark as untracked
+        # @return [Boolean] success marker
+        def forget(*files)
+          raise NotImplementedError.new("forget() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Marks a file to be copied from the +from+ location to the +to+ location
+        # in the next commit, while retaining history.
+        # 
+        # @param [String] from the source of the file copy
+        # @param [String] to the destination of the file copy
+        # @return [Boolean] true for success, false for failure
+        def copy(from, to)
+          raise NotImplementedError.new("copy() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Marks a file to be moved from the +from+ location to the +to+ location
+        # in the next commit, while retaining history.
+        # 
+        # @param [String] from the source of the file move
+        # @param [String] to the destination of the file move
+        # @return [Boolean] true for success, false for failure
+        def move(from, to)
+          raise NotImplementedError.new("move() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Marks a modified file to be included in the next commit.
+        # If your VCS does this implicitly, this should be defined as a no-op.
+        # 
+        # @param [[String]] filenames a list of files to include for committing
+        # @return [Boolean] true for success, false for failure
+        def include(*filenames)
+          raise NotImplementedError.new("include() must be implemented by subclasses of AbstractStagingArea.")
+        end
+        alias_method :stage, :include
+      
+        ##
+        # Mark a modified file to not be included in the next commit.
+        # If your VCS does not include this idea because staging a file is implicit, this should
+        # be defined as a no-op.
+        # 
+        # @param [[String]] filenames a list of files to remove from the staging area for committing
+        # @return [Boolean] true for success, false for failure
+        def exclude(*filenames)
+          raise NotImplementedError.new("exclude() must be implemented by subclasses of AbstractStagingArea.")
+        end
+        alias_method :unstage, :exclude
+      
+        ##
+        # Returns a Symbol.
+        # Possible results:
+        # :added (subset of :included)
+        # :removed
+        # :untracked
+        # :included
+        # :normal
+        #
+        def file_status(filename)
+          raise NotImplementedError.new("file_status() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # The directory used by the VCS to store magical information (.hg, .git, etc.).
+        #
+        # @api
+        # @return [String] relative to root
+        def vcs_dir
+          raise NotImplementedError.new("vcs_dir() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Saves the staging area's state.  Any added files, removed files, "normalized" files
+        # will have that status saved here.
+        def save
+          raise NotImplementedError.new("save() must be implemented by subclasses of AbstractStagingArea")
+        end
+      
+        ##
+        # Returns all files tracked by the repository *for the working directory* - not
+        # to be confused with the most recent changeset.
+        #
+        # @api
+        # @return [Array<String>] all files tracked by the repository at this moment in
+        #   time, including just-added files (for example) that haven't been committed yet.
+        def all_files
+          raise NotImplementedError.new("all_files() must be implemented by subclasses of AbstractStagingArea.")
+        end
+      
+        ##
+        # Returns whether the given directory is being ignored. Optional method - defaults to
+        # +false+ at all times.
+        #
+        # @api-optional
+        # @param [String] directory the directory to check against ignoring rules
+        # @return [Boolean] are we ignoring this directory?
+        def ignoring_directory?(directory)
+          false
+        end
+      
+        ##
+        # Returns whether the given file is being ignored. Optional method - defaults to
+        # +false+ at all times.
+        #
+        # @api-optional
+        # @param [String] file the file to check against ignoring rules
+        # @return [Boolean] are we ignoring this file?
+        def ignoring_file?(file)
+          false
+        end
+      
+        ##
+        # Does a detailed look at a file, to see if it is clean, modified, or needs to have its
+        # content checked precisely.
+        #
+        # Supplements the built-in #status command so that its output will be cleaner.
+        #
+        # Defaults to report files as normal - it cannot check if a file has been modified
+        # without this method being overridden.
+        #
+        # @api-optional
+        #
+        # @param [String] file the filename to look up
+        # @param [File::Stats] st the current results of File.lstat(file)
+        # @return [Symbol] a symbol representing the current file's status
+        def file_precise_status(file, st)
+          return :lookup
+        end
+      
+        ##
+        # Calculates the difference (in bytes) between a file and its last tracked state.
+        #
+        # Defaults to zero - in other words, it deactivates the delta feature.
+        #
+        # @api-optional
+        # @param [String] file the filename to look up
+        # @param [File::Stats] st the current results of File.lstat(file)
+        # @return [Fixnum] the number of bytes difference between the file and
+        #  its last tracked state.
+        def calculate_delta(file, st)
+          0
+        end
+      
+      end
+    end
+  end
+end

data/lib/amp-core/repository/abstract/abstract_versioned_file.rb

@@ -0,0 +1,116 @@
+##################################################################
+#                  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
+      class AbstractVersionedFile
+        include CommonVersionedFileMethods
+      
+        ##
+        # The changeset to which this versioned file belongs.
+        # 
+        # @return [AbstractChangeset]
+        def changeset
+          raise NotImplementedError.new("changeset() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # The repo to which this {VersionedFile} belongs
+        # 
+        # @return [AbstractLocalRepository]
+        def repo
+          raise NotImplementedError.new("repo() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+        alias_method :repository, :repo
+      
+        ##
+        # The path to this file
+        # 
+        # @return [String]
+        def path
+          raise NotImplementedError.new("path() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # The revision of the file. This can be vague, so let me explain:
+        # This is the revision of the repo from which this VersionedFile is.
+        # If this is unclear, please submit a patch fixing it.
+        # 
+        # @return [Integer]
+        def revision
+          raise NotImplementedError.new("revision() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # The size of this file
+        # 
+        # @return [Integer]
+        def size
+          raise NotImplementedError.new("size() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # The contents of a file at the given revision
+        # 
+        # @return [String] the data at the current revision
+        def data
+          raise NotImplementedError.new("data() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # The hash value for sticking this fucker in a hash.
+        # 
+        # @return [Integer]
+        def hash
+          raise NotImplementedError.new("hash() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # Has this file been renamed? If so, return some useful info
+        def renamed?
+          raise NotImplementedError.new("renamed() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # Compares to either a bit of text or another versioned file.
+        # Returns true if different, false for the same.
+        # (much like <=> == 0 for the same)
+        # 
+        # @param [AbstractVersionedFile, String] item what we're being compared to
+        # @return [Boolean] true if different, false if same.
+        def cmp(item)
+          raise NotImplementedError.new("cmp() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # Are two versioned files the same? This means same path and revision indexes.
+        # 
+        # @param [AbstractVersionedFile] vfile what we're being compared to
+        # @return [Boolean]
+        def ==(vfile)
+          raise NotImplementedError.new("==() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      
+        ##
+        # Gets the flags for this file ('x', 'l', or '')
+        # 
+        # @return [String] 'x', 'l', or ''
+        def flags
+          raise NotImplementedError.new("flags() must be implemented by subclasses of AbstractVersionedFile.")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+##################################################################
+#                  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
+    
+      ##
+      # = 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]
+              other.unified_diff_with self[k]
+            end
+            s
+          end
+        end
+      
+        ##
+        # Gets the number of lines added and removed in this changeset.
+        #
+        # @return [Hash{Symbol => Integer}] a hash returning line-changed
+        #   statistics. Keys are :added, :deleted
+        def changed_lines_statistics
+          result = {:added => 0, :removed => 0}
+          changed_files.each do |_, diffproc|
+            diff = diffproc.call
+            diff.split("\n").each do |line|
+              if line.start_with?("+") && !line.start_with?("+++")
+                result[:added] += 1
+              elsif line.start_with?("-") && !line.start_with?("---")
+                result[:removed] += 1
+              end
+            end
+          end
+          result
+        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
+      
+        ##
+        # Gets the list of parents useful for printing in a template - no
+        # point in saying that revision 127's only parent is 126, for example.
+        #
+        # @return [Array<Changeset>] a list of changesets that are the parent of
+        #   this node and happen to be worth noting to the user.
+        def useful_parents
+          ret_parents = self.parents
+          if ret_parents[1].nil?
+            if ret_parents[0].revision >= self.revision - 1
+              ret_parents = []
+            else
+              ret_parents = [ret_parents[0]]
+            end
+          end
+          ret_parents
+        end
+      
+        ##
+        # Renders the changeset with a given template. Takes a few different options
+        # to control output.
+        #
+        # @param [Hash] opts ({}) the options to control rendering to text
+        # @option opts [Boolean] :no_output (false) Don't actually return any output
+        # @option opts [String] :"template-raw" a bare string to render as a template.
+        #   Nice option for letting users drop a teensy bit of template code into their
+        #   commands.
+        # @option opts [String, Template] :template ("default-log") The name of the
+        #   template to use (if a String is provided), or the actual template to use
+        #   (if a Template object is provided).
+        # @return [String] the changeset pumped through the template.
+        def to_templated_s(opts={})
+          locals = {:change_node => node,
+                    :revision    => self.revision,
+                    :username    => self.user,
+                    :date        => self.easy_date,
+                    :files       => self.altered_files,
+                    :description => self.description,
+                    :branch      => self.branch,
+                    :cs_tags     => self.tags,
+        
+                    :added       => opts[:added]   || [],
+                    :removed     => opts[:removed] || [],
+                    :updated     => opts[:updated] || [],
+                    :config      => opts,
+
+                    :parents     => useful_parents.map {|p| [p.revision, p.node.short_hex] }
+                  }
+        
+          return "" if opts[:no_output]
+        
+          template_for_options(opts).render(locals, binding)
+        end
+      
+        ##
+        # Returns template to handle templating based on the options provided.
+        #
+        # @param [Hash] options a list of options to configure template usage
+        # @return [Template] a template to use to print the changeset to a
+        #   nice string.
+        def template_for_options(opts = {})
+          type = opts[:template_type] || 'log'
+          if opts[:"template-raw"]
+            Support::RawERbTemplate.new(opts[:"template-raw"])
+          elsif opts[:template].is_a?(Support::Template)
+            opts[:template]
+          else
+            template = opts[:template]
+            template = "default-#{type}" if template.nil? || template.to_s == "default"
+            Support::Template['mercurial', template]
+          end
+        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
+end