amp-git 0.1.0

data/lib/amp-git/repo_format/packfile_index.rb

@@ -0,0 +1,196 @@
+##################################################################
+#                  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                   #
+#                                                                #
+##################################################################
+
+# This was written by reading the Git Book. No source code was
+# examined to produce this code. It is the original work of its
+# creators, Michael Edgar and Ari Brown.
+#
+# http://book.git-scm.com/7_the_packfile.html
+# http://git.rsbx.net/Documents/Git_Data_Formats.txt
+# http://repo.or.cz/w/git.git?a=blob;f=Documentation/technical/pack-format.txt;h=1803e64e465fa4f8f0fe520fc0fd95d0c9def5bd;hb=HEAD
+
+module Amp
+  module Core
+    module Repositories    
+      module Git
+        class PackFileIndexLookupError < StandardError; end
+        ##
+        # = PackFile
+        #
+        # Git uses it's "gc" command to pack loose objects into PackFiles.
+        # This is one file, preferably with an index (though not requiring one),
+        # which stores a number of objects in a very simple raw form.
+        #
+        # This class handles the index file, which is used for fast lookups of
+        # entries in packfiles. They use fanouts to make searching very simple.
+        #
+        # The fanout values are interesting - they are the number of entries with a first sha1
+        # byte less than or equal to the byte provided. So if the only sha1s you can
+        # find in a given packfile are 00112233.... and 020304.... then the first few
+        # fanouts are:
+        # fanout[0] = 1
+        # fanout[1] = 1
+        # fanout[2] = 2
+        # ....
+        # fanout[254] = 2
+        class PackFileIndex
+          
+          class << self
+            ##
+            # Initializes the index file by reading from an input source.  Does not
+            # automatically read in any actual data, but instead finds the necessary
+            # values to make searching by SHA1 quick.
+            #
+            # @param [IO, #read] fp an input stream at the beginning of the index
+            def parse(fp)
+              fourcc = fp.read(4)
+              if fourcc == "\xfftOc"
+                version = fp.read(4).unpack("N").first
+                PackFileIndexV2.new(fp) if version == 2
+              else
+                fp.seek(-4, IO::SEEK_CUR)
+                PackFileIndexV1.new(fp)
+              end
+            end
+          end
+          
+          FANOUT_TABLE_SIZE = 4 * 256
+
+          # Common PackFileIndex methods
+          attr_reader :size
+          attr_reader :fanout
+
+          # Common initialization code
+          # @param [IO, #read] fp input stream to read the file from
+          def initialize(fp)
+            @fp = fp
+            @fanout = @fp.read(FANOUT_TABLE_SIZE).unpack("N256")
+            @size = @fanout[255]
+          end
+          
+          ##
+          # uses fanout logic to determine the indices in which the desired
+          # hash might be found. This range can be searched to find the hash.
+          def search_range_for_hash(hash)
+            byte = Support::StringUtils.ord(hash[0,1])
+            min = byte > 0 ? (fanout[byte - 1]) : 0
+            max = fanout[byte]
+            min...max
+          end
+        end
+        
+        ##
+        # This class is for the older version of index files. They are
+        # structured as simply a fanout table and a list of [offset][sha1] entries.
+        # There's a checksum at the bottom for verification.
+        #
+        # Initialization only reads in the fanout table, and the file is left open.
+        class PackFileIndexV1 < PackFileIndex
+          ENTRY_TABLE_START = 256 * 4
+          ENTRY_TABLE_ENTRY_SIZE = 20 + 4
+          ENTRY_TABLE_FORMAT = "Na20"
+          
+          ##
+          # Looks up the offset in a packfile of a given hash. nil is returned if
+          # the sha1 isn't found.
+          #
+          # @param [String] hsh a binary, sha-1 hash of the desired object
+          # @return [Fixnum, nil] the offset into the corresponding packfile at which you
+          #  can find the object
+          def offset_for_hash(hsh)
+            range = search_range_for_hash hsh
+            @fp.seek(FANOUT_TABLE_START + range.begin * ENTRY_TABLE_ENTRY_SIZE, IO::SEEK_SET)
+            # linear search for now.
+            # TODO: binary search!
+            range.each do |_|
+              offset, sha1 = @fp.read(ENTRY_TABLE_ENTRY_SIZE).unpack(ENTRY_TABLE_FORMAT)
+              return offset if sha1 == hsh
+            end
+            raise PackFileIndexLookupError.new("Couldn't find the hash #{hsh.inspect} in the packfile index.")
+          end
+        end
+        
+        ##
+        # This class is for the older version of index files. They are
+        # structured as simply a fanout table and a list of [offset][sha1] entries.
+        # There's a checksum at the bottom for verification.
+        #
+        # Initialization only reads in the fanout table, and the file is left open.
+        class PackFileIndexV2 < PackFileIndex
+          ENTRY_TABLE_START = 256 * 4 + 8
+          SHA1_FORMAT = "a20"
+          SHA1_SIZE = 20
+          
+          def sha1_table_offset
+            ENTRY_TABLE_START
+          end
+          
+          def crc_table_offset
+            ENTRY_TABLE_START + size * SHA1_SIZE
+          end
+          
+          def offset_table_offset
+            crc_table_offset + size * 4
+          end
+          
+          def big_offset_table_offset
+            offset_table_offset + size * 4
+          end
+          
+          ##
+          # Looks up the offset in a packfile of a given hash. nil is returned if
+          # the sha1 isn't found.
+          #
+          # @param [String] hsh a binary, sha-1 hash of the desired object
+          # @return [Fixnum, nil] the offset into the corresponding packfile at which you
+          #  can find the object
+          def offset_for_hash(hsh)
+            range = search_range_for_hash hsh
+            @fp.seek(sha1_table_offset + range.begin * SHA1_SIZE, IO::SEEK_SET)
+            # linear search for now.
+            # TODO: binary search!
+            range.each do |idx|
+              sha1 = @fp.read(SHA1_SIZE).unpack(SHA1_FORMAT).first # sha1s are 20 bytes
+              return offset_for_index(idx) if sha1 == hsh
+            end
+            raise PackFileIndexLookupError.new("Couldn't find the hash #{hsh.inspect} in the packfile index.")
+          end
+          
+          ##
+          # Looks up the offset of an object given its index in the file. This index
+          # is assumed to have been determined by matching the sha1 of the object to
+          # a sha1 in the SHA1 table of the index.
+          #
+          # This requires a little more advanced logic because there is an offset table,
+          # and a 64-bit offset table. The normal offset table only supports 31-bit offsets,
+          # if the high bit is set, then the 31-bit value is actually an index into the big
+          # offset table.
+          #
+          # @param [Integer] idx the index into the offset table
+          # @return [Integer] the offset in the packfile where you can find the object with
+          #   the given index into the index
+          def offset_for_index(idx)
+            @fp.seek(offset_table_offset + 4 * idx, IO::SEEK_SET)
+            offset = @fp.read(4).unpack("N").first
+            if offset & 0x80000000 != 0
+              @fp.seek(big_offset_table_offset + 8 * (offset & 0x7fffffff))
+              offset = Support::EncodingUtils.network_to_host_64(@fp.read(8).unpack("Q").first)
+            end
+            offset
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amp-git/repo_format/raw_object.rb

@@ -0,0 +1,56 @@
+##################################################################
+#                  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                   #
+#                                                                #
+##################################################################
+
+# This was written by reading the Git Book. No source code was
+# examined to produce this code. It is the original work of its
+# creators, Michael Edgar and Ari Brown.
+#
+# http://book.git-scm.com/7_how_git_stores_objects.html
+
+module Amp
+  module Core
+    module Repositories    
+      module Git
+        ##
+        # = LooseObject
+        #
+        # A single loose object (tree, tag, commit, etc.) in the Git system.
+        # Its type and content will be determined after we read the file.
+        #
+        # It is uniquely identified by a SHA1 hash.
+        class RawObject
+          attr_reader :type, :content, :hash_id
+          AUTHOR_MATCH = /([^<]*) <(.*)> (\d+) ([-+]?\d+)/
+          class << self
+            
+            
+            def for_hash(hsh, git_opener)
+              # no way to handle packed objects yet
+              LooseObject.lookup(hsh, git_opener)
+            end
+            
+            def construct(hsh, opener, type, content)
+              # type, content should both be set now
+              type_lookup = {'tree' => TreeObject, 'commit' => CommitObject, 'tag' => TagObject}
+              object_klass = type_lookup[type] || LooseObject
+              result = object_klass.new(hsh, opener, content)
+              result.type = type if object_klass == LooseObject
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amp-git/repo_format/staging_area.rb

@@ -0,0 +1,215 @@
+##################################################################
+#                  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
+      module Git
+        class StagingArea < Amp::Core::Repositories::AbstractStagingArea
+          
+          attr_accessor :repo
+          
+          def initialize(repo)
+            @repo = repo
+          end
+          
+          ##
+          # 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)
+            `git add #{filenames.join ' '} 2> /dev/null`
+            true
+          end
+
+          ##
+          # The directory used by the VCS to store magical information (.hg, .git, etc.).
+          #
+          # @api
+          # @return [String] relative to root
+          def vcs_dir
+            '.hg'
+          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, Array<String>] filenames a list of files to remove in the next commit
+          # @return [Boolean] true for success, false for failure
+          def remove(*filenames)
+            `git rm #{filenames.join ' '} 2> /dev/null`
+            true
+          end
+
+          ##
+          # Set +file+ as normal and clean. Un-removes any files marked as removed, and
+          # un-adds any files marked as added.
+          # 
+          # @param  [String, Array<String>] files the name of the files to mark as normal
+          # @return [Boolean] success marker
+          def normal(*files)
+            # Do nothing...
+            true
+          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)
+            `git rm --cached #{files.join ' '} 2> /dev/null`
+            true
+          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)
+            `git cp #{from} #{to} 2> /dev/null`
+            true
+          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)
+            `git mv #{from} #{to} 2> /dev/null`
+            true
+          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, Array<String>] filenames a list of files to include for committing
+          # @return [Boolean] true for success, false for failure
+          def include(*filenames)
+            add filenames
+          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)
+            `git rm --cached #{filenames.join ' '} 2> /dev/null`
+            true
+          end
+          alias_method :unstage, :exclude
+
+          ##
+          # Returns a Symbol.
+          # 
+          # If you call localrepo#status from this method... well...
+          # I DARE YOU!
+          def file_status(filename)
+            parse!
+            inverted = @status.inject({}) do |h, (k, v)|
+              v.each {|v_| h[v_] = k }
+              h
+            end
+            
+            # lame hack, i know
+            case val = inverted[filename]
+            when :modified
+              :normal
+            else
+              val
+            end
+          end
+          
+          # modified, lookup, or clean
+          # in this case, since we're shelling out,
+          # only modified or clean
+          def file_precise_status(filename, st)
+            parse!
+            inverted = @status.inject({}) do |h, (k, v)|
+              v.each {|v_| h[v_] = k }
+              h
+            end
+            
+            # bleh this code sucks
+            if inverted[filename] == :modified
+              :modified
+            else
+              :clean
+            end
+          end
+          
+          ##
+          # Calculates the difference (in bytes) between a file and its last tracked state.
+          #
+          # Supplements the built-in #status method so that its output will include deltas.
+          #
+          # @apioptional
+          # @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
+          
+          def parse!
+            return if @parsed
+            
+            @status = {}
+            data    = `git status 2> /dev/null`.split("\n")
+            data.inject @status do |h, line|
+              case line
+              when /^#\s+(\w+):\s(.+)$/
+                h[$1.to_sym] = $2.strip
+              when /^#\s+new file:\s(.+)$/
+                h[:added] = $1.strip
+              when /^#\s+([^ ]+)$/
+                h[:untracked] = $1.strip
+              else
+                h
+              end
+            end
+            
+            @parsed = true
+          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
+            Amp::Git::WorkingDirectoryChangeset.new(@repo).all_files
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amp-git/repo_format/tag_object.rb

@@ -0,0 +1,87 @@
+##################################################################
+#                  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                   #
+#                                                                #
+##################################################################
+
+# This was written by reading the Git Book. No source code was
+# examined to produce this code. It is the original work of its
+# creators, Michael Edgar and Ari Brown.
+#
+# http://book.git-scm.com/7_how_git_stores_objects.html
+
+module Amp
+  module Core
+    module Repositories
+      module Git
+        ##
+        # = TagObject
+        #
+        # This is a formal tag object in the commit system. Most tags actually don't
+        # involve one of these objects - they just create a ref (alias) to a commit
+        # object. This tag will also reference a (usually) commit object, but they
+        # can contain their own messages, including PGP signatures. And honestly,
+        # we just have to suck it up and support them.
+        class TagObject < RawObject
+          attr_reader :object_ref, :reffed_type, :tag, :tagger, :date, :message
+          
+          ##
+          # Initializes the TagObject. Needs a hash to identify it and
+          # an opener. The opener should point to the .git directory. Immediately
+          # parses the object.
+          #
+          # @param [String] hsh the hash to use to find the object
+          # @param [Support::RootedOpener] opener the opener to use to open the
+          #   object file
+          # @param [String] content if the content is known already, use
+          #   the provided content instead
+          def initialize(hsh, opener, content = nil)
+            if content
+              @hash_id, @opener = hsh, opener
+              @type = 'tag'
+              @content = content
+            else
+              super(hsh, opener)
+            end
+            parse!
+          end
+
+          private
+          
+          ##
+          # Parses the commit object into our attributes.
+          def parse!
+            lines = @content.split("\n")
+            last_idx = 0
+            lines.each_with_index do |line, idx|
+              case line
+              when /^object (.{40})/
+                @object_ref = Support::StringUtils.unhexlify($1)
+              when /^type (\S+)/
+                @reffed_type = $1
+              when /^tag\s+(.*)\s*$/
+                @tag = $1
+              when /^tagger #{AUTHOR_MATCH}/
+                @tagger = "#{$1} <#{$2}>"
+                @date = Time.at($3.to_i)
+              when ""
+                last_idx = idx + 1
+                break
+              end
+            end
+            @message = lines[last_idx..-1].join("\n")
+          end
+        
+        end
+      end
+    end
+  end
+end

data/lib/amp-git/repo_format/tree_object.rb

@@ -0,0 +1,98 @@
+##################################################################
+#                  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                   #
+#                                                                #
+##################################################################
+
+# This was written by reading the Git Book. No source code was
+# examined to produce this code. It is the original work of its
+# creators, Michael Edgar and Ari Brown.
+#
+# http://book.git-scm.com/7_how_git_stores_objects.html
+
+module Amp
+  module Core
+    module Repositories
+      module Git
+        ##
+        # = TreeObject
+        #
+        # This is a tree object representing a versioned directory. It has
+        # a list of 
+        class TreeObject < RawObject
+          TreeEntry = Struct.new(:name, :mode, :ref)
+          
+          ##
+          # Initializes the RawObject. Needs a hash to identify it and
+          # an opener. The opener should point to the .git directory.
+          #
+          # @param [String] hsh the hash to use to find the object
+          # @param [Support::RootedOpener] opener the opener to use to open the
+          #   object file
+          # @param [String] content if the content is known already, use
+          #   the provided content instead
+          def initialize(hsh, opener, content = nil)
+            if content
+              @hash_id, @opener = hsh, opener
+              @type = 'tree'
+              @content = content
+            else
+              super(hsh, opener)
+            end
+            parse!
+          end
+        
+          ##
+          # Returns a list of the names of the files/directories (blobs/trees) in the
+          # tree
+          #
+          # @return [Array<String>] a (possibly unsorted) list of file and
+          #   and directory names in this tree
+          def entry_names
+            @pairs.keys
+          end
+        
+          ##
+          # Returns the number of entries in the directory.
+          #
+          # @return [Fixnum] the number of entries in this directory
+          def size
+            @pairs.size
+          end
+          
+          ##
+          # Returns a TreeObject for the given filename in this level of
+          # the tree.
+          #
+          # @param [String] name the name of the file to look up
+          # @return [TreeEntry] the treeobject representing the file
+          def tree_lookup(name)
+            @pairs[name]
+          end
+        
+          private
+          
+          def parse!
+            require 'strscan'
+            @pairs = {}
+            scanner = StringScanner.new(@content)
+            until scanner.eos?
+              break unless scanner.scan(/(\d+) (\S+?)\x00(.{20})/m)
+              new_entry = TreeEntry.new(scanner[2], scanner[1].to_i(8), scanner[3])
+              @pairs[new_entry.name] = new_entry
+            end
+          end
+        
+        end
+      end
+    end
+  end
+end