amp-git 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+.hg*
+*.gemspec

data/Gemfile

@@ -0,0 +1,15 @@
+# This is an install-only file - it's not used by the application
+source "http://rubygems.org"
+source "http://gems.github.com"
+
+gem 'amp-front', '>= 0.1.0'
+gem 'amp-core', '>= 0.1.0'
+
+group :development do
+  gem 'jeweler'
+  gem 'rspec', '< 2.0.0'
+  gem 'yard'
+  gem 'cucumber'
+  gem 'devver-construct', :require => 'construct'
+  gem 'minitest'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michael Edgar
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= amp-git
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Michael Edgar. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'amp-git'
+    gem.summary = %Q{The git plugin for Amp.}
+    gem.description = %Q{This gem provides git support to Amp. It is bundled with Amp itself.}
+    gem.email = 'michael.j.edgar@dartmouth.edu'
+    gem.homepage = 'http://github.com/michaeledgar/amp-git'
+    gem.authors = ['Michael Edgar']
+    gem.add_dependency 'amp-front', '>= 0.1.0'
+    gem.add_dependency 'amp-core', '>= 0.1.0'
+    gem.add_development_dependency 'rspec', '>= 1.2.9'
+    gem.add_development_dependency 'yard', '>= 0'
+    gem.add_development_dependency 'cucumber', '>= 0'
+    gem.add_development_dependency 'minitest', '>= 1.7'
+    gem.add_development_dependency 'devver-construct', '>= 1.1.0'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/test*.rb']
+  t.verbose = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort 'Cucumber is not available. In order to run features, you must: sudo gem install cucumber'
+  end
+end
+
+task :default => [:spec, :test]
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort 'YARD is not available. In order to run yardoc, you must: sudo gem install yard'
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/features/amp-git.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'amp-git'
+
+require 'spec/expectations'

data/lib/amp-git/encoding/binary_delta.rb

@@ -0,0 +1,171 @@
+##################################################################
+#                  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://git.rsbx.net/Documents/Git_Data_Formats.txt
+
+module Amp
+  module Core
+    module Repositories
+      module Git
+        
+        ##
+        # All of git's specific encoding classes.
+        module Encoding
+          class DeltaError < StandardError; end
+          
+          ##
+          # Handles the binary delta format that are found in Git's packfiles.
+          # The format is detailed in the link above.
+          class BinaryDelta
+            attr_accessor :base_length, :result_length, :hunks
+            
+            ##
+            # Parses a git-format binary delta from a string.
+            #
+            # @param [String] delta the delta to parse
+            def initialize(delta)
+              fp = StringIO.new(delta)
+              @base_length = read_little_endian_base128(fp)
+              @result_length = read_little_endian_base128(fp)
+              @hunks = []
+              while !fp.eof?
+                @hunks << Hunk.parse(fp)
+              end
+            end
+            
+            ##
+            # Applies the binary delta to an original text. Returns the patched
+            # data.
+            #
+            # @param [String] original the text to patch with the delta
+            # @return the patched data
+            def apply(original)
+              if original.size != @base_length
+                raise DeltaError.new("Expected input data to be #{@base_length} bytes, but was #{original.size} bytes.")
+              end
+              output = StringIO.new
+              @hunks.each do |hunk|
+                hunk.apply(output, original)
+              end
+              if output.string.size != @result_length
+                raise DeltaError.new("Expected patched data to be #{@result_length} bytes, but was #{output.string.size} bytes.")
+              end
+              output.string
+            end
+            
+            private
+            
+            ##
+            # Reads a little endian, base-128 value from a stream.
+            # This is a variable-length integer, where bytes 0 to N-1 have an MSB
+            # of 1, and byte N has an MSB of 0.
+            #
+            # @param [IO, #read] fp the input stream to read the value from
+            # @return [Integer] the encoded integer
+            def read_little_endian_base128(fp)
+              result = shift = 0
+              begin
+                byte = Support::StringUtils.ord(fp.read(1))
+                result |= (byte & 0x7f) << shift
+                shift += 7
+              end while byte & 0x80 > 0
+              result
+            end
+            
+            ##
+            # @api private
+            class Hunk
+              ##
+              # Parses a hunk from the input stream. Each hunk is an action: either a
+              # a copy from an input stream, or an "insert" which inserts specified
+              # data.
+              def self.parse(fp)
+                opcode = Support::StringUtils.ord(fp.read(1))
+                if opcode & 0x80 == 0
+                  InsertHunk.new(opcode, fp)
+                else
+                  CopyHunk.new(opcode, fp)
+                end
+              end
+            end
+            
+            ##
+            # A Hunk that performs an insert operation.  One of two types of delta
+            # hunks in the git binary delta format.
+            class InsertHunk
+              ##
+              # Creates a new insert hunk.
+              #
+              # @param [Fixnum] opcode the opcode that identifies this hunk's properties.
+              # @param [IO, #read] fp the input stream we're reading this delta from
+              def initialize(opcode, fp)
+                @data = fp.read(opcode & 0x7f)
+              end
+              
+              ##
+              # Applies the Hunk with a given output buffer with an input string.
+              #
+              # @param [IO, #write] output the output buffer we're building up
+              # @param [String] input the original data. ignored for InsertHunk.
+              def apply(output, input)
+                output.write @data
+              end
+            end
+            
+            ##
+            # A Hunk that performs a copy operation.  One of two types of delta
+            # hunks in the git binary delta format.
+            class CopyHunk
+              ##
+              # Creates a new copy hunk.
+              #
+              # @param [Fixnum] opcode the opcode that identifies this hunk's properties.
+              # @param [IO, #read] fp the input stream we're reading this delta from
+              def initialize(opcode, fp)
+                @offset = @length = 0
+                shift = 0
+                0.upto(3) do
+                  @offset |= Support::StringUtils.ord(fp.read(1)) << shift if opcode & 0x01 > 0
+                  opcode >>= 1
+                  shift += 8
+                end
+                shift = 0
+                0.upto(2) do
+                  @length |= Support::StringUtils.ord(fp.read(1)) << shift if opcode & 0x01 > 0
+                  opcode >>= 1
+                  shift += 8
+                end
+                @length = 1 << 16 if @length == 0
+              end
+              
+              ##
+              # Applies the Hunk with a given output buffer with an input string.
+              #
+              # @param [IO, #write] output the output buffer we're building up
+              # @param [String] input the original data. Used for copies.
+              def apply(output, input)
+                output.write input[@offset...@offset + @length]
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,348 @@
+##################################################################
+#                  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                   #
+#                                                                #
+##################################################################
+
+require 'time'
+
+module Amp
+  module Git
+    
+    ##
+    # A Changeset is a simple way of accessing the repository within a certain
+    # revision. For example, if the user specifies revision # 36, or revision
+    # 3adf21, then we can look those up, and work within the repository at the
+    # moment of that revision.
+    class Changeset < Amp::Core::Repositories::AbstractChangeset
+      
+      attr_accessor :repo
+      attr_reader   :revision
+      alias_method :repository, :repo
+      
+      def initialize(repo, rev)
+        @repo       = repo
+        if short_name.kind_of?(Integer)
+          @revision = rev
+          @node_id = convert_rev_to_node(rev)
+        else
+          @revision = convert_node_to_rev(rev)
+          @node_id = rev
+        end
+      end
+      
+      def node; @node_id; end
+      
+      
+      ##
+      # Compares 2 changesets so we can sort them and whatnot
+      # 
+      # @param [Changeset] other a changeset we will compare against
+      # @return [Integer] -1, 0, or 1. Typical comparison.
+      def <=>(other)
+        date <=> other.date
+      end
+      
+      ##
+      # Iterates over every tracked file at this point in time.
+      # 
+      # @return [Changeset] self, because that's how #each works
+      def each(&b)
+        all_files.each( &b)
+        self
+      end
+      
+      ##
+      # the nodes that this node inherits from
+      # 
+      # @return [Array<Abstract Changeset>]
+      def parents
+        parse!
+        @parents
+      end
+
+      ##
+      # Retrieve +filename+
+      #
+      # @return [AbstractVersionedFile]
+      def get_file(filename)
+        VersionedFile.new @repo, file, :revision => node
+      end
+      alias_method :[], :get_file
+
+      ##
+      # When was the changeset made?
+      # 
+      # @return [Time]
+      def date
+        parse!
+        @date
+      end
+
+      ##
+      # The user who made the changeset
+      # 
+      # @return [String] the user who made the changeset
+      def user
+        parse!
+        @user
+      end
+      
+      ##
+      # Which branch this changeset belongs to
+      # 
+      # @return [String] the user who made the changeset
+      def branch
+        parse!
+        raise NotImplementedError.new("branch() must be implemented by subclasses of AbstractChangeset.")
+      end
+
+      ##
+      # @return [String]
+      def description
+        parse!
+        @description
+      end
+      
+      ##
+      # What files have been altered in this changeset?
+      # 
+      # @return [Array<String>]
+      def altered_files
+        parse!
+        @altered_files
+      end
+      
+      ##
+      # Returns a list of all files that are tracked at this current revision.
+      #
+      # @return [Array<String>] the files tracked at the given revision
+      def all_files
+        parse!
+        @all_files
+      end
+      
+      # Is this changeset a working changeset?
+      #
+      # @return [Boolean] is the changeset representing the working directory?
+      def working?
+        false
+      end
+      
+      private
+      
+      
+      ##
+      # Converts a semi-reliable revision # into a git changeset node.
+      def convert_rev_to_node(rev)
+        %x(git rev-list --reverse HEAD).split("\n")[rev - 1]
+      end
+      
+      ##
+      # Converts a git changeset node into a semi-reliable revision #
+      def convert_node_to_rev(node)
+        %x(git rev-list --reverse HEAD | grep -n #{node} | cut -d: -f1).to_i
+      end
+        
+      
+      # yeah, i know, you could combine these all into one for a clean sweep.
+      # but it's clearer this way
+      def parse!
+        return if @parsed
+        
+        # the parents
+        log_data = `git log -1 #{node}^ 2> /dev/null`
+        
+        # DETERMINING PARENTS
+        dad   = log_data[/^commit (.+)$/, 1]
+        dad   = dad ? dad[0..6] : nil
+        mom   = nil
+        
+        if log_data =~ /^Merge: (.+)\.\.\. (.+)\.\.\.$/ # Merge: 1c002dd... 35cfb2b...
+          dad = $1 # just have them both use the short name, nbd
+          mom = $2
+        end
+        
+        @parents = [dad, mom].compact.map {|r| Changeset.new repo, r }
+        
+        # the actual changeset
+        log_data = `git log -1 #{node}  2> /dev/null`
+        
+        # DETERMINING DATE
+        @date = Time.parse log_data[/^Date:\s+(.+)$/, 1]
+        
+        # DETERMINING USER
+        @user = log_data[/^Author:\s+(.+)$/, 1]
+        
+        # DETERMINING DESCRIPTION
+        @description = log_data.split("\n")[4..-1].map {|l| l.strip }.join "\n"
+        
+        # ALTERED FILES
+        @altered_files = `git log -1 #{node} --pretty=oneline --name-only  2> /dev/null`.split("\n")[1..-1]
+        
+        # ALL FILES
+        # @all_files is also sorted. Hooray!
+        @all_files = `git ls-tree -r #{node}`.split("\n").map do |line|
+          # 100644 blob cdbeb2a42b714a4db49293c87fec4e180d07d44f    .autotest
+          line[/^\d+ \w+ \w+\s+(.+)$/, 1]
+        end
+        
+        @parsed = true
+      end
+      
+    end
+    
+    class WorkingDirectoryChangeset < Amp::Repositories::AbstractChangeset
+      
+      attr_accessor :repo
+      alias_method :repository, :repo
+      
+      def initialize(repo, opts={:text => ''})
+        @repo = repo
+        @text = opts[:text]
+        @date = Time.parse opts[:date].to_s
+        @user = opts[:user]
+        @parents = opts[:parents].map {|p| Changeset.new(@repo, p) } if opts[:parents]
+        @status  = opts[:changes]
+      end
+      
+      ##
+      # the nodes that this node inherits from
+      # 
+      # @return [Array<Abstract Changeset>]
+      def parents
+        @parents || (parse! && @parents)
+      end
+      
+      def revision; nil; end
+
+      ##
+      # Retrieve +filename+
+      #
+      # @return [AbstractVersionedFile]
+      def get_file(filename)
+        VersionedWorkingFile.new @repo, filename
+      end
+      alias_method :[], :get_file
+
+      ##
+      # When was the changeset made?
+      # 
+      # @return [Time]
+      def date
+        Time.now
+      end
+
+      ##
+      # The user who made the changeset
+      # 
+      # @return [String] the user who made the changeset
+      def user
+        @user ||= @repo.config.username
+      end
+      
+      ##
+      # Which branch this changeset belongs to
+      # 
+      # @return [String] the user who made the changeset
+      def branch
+        @branch ||= `git branch  2> /dev/null`[/\*\s(.+)$/, 1]
+      end
+
+      ##
+      # @return [String]
+      def description
+        @text || ''
+      end
+      
+      def status
+        @status ||= @repo.status :unknown => true
+      end
+      
+      ##
+      # Iterates over every tracked file at this point in time.
+      # 
+      # @return [Changeset] self, because that's how #each works
+      def each(&b)
+        all_files.each( &b)
+        self
+      end
+      
+      ##
+      # Returns a list of all files that are tracked at this current revision.
+      #
+      # @return [Array<String>] the files tracked at the given revision
+      def all_files
+        @all_files ||= `git ls-files  2> /dev/null`.split("\n")
+      end
+      
+      # Is this changeset a working changeset?
+      #
+      # @return [Boolean] is the changeset representing the working directory?
+      def working?
+        true
+      end
+      
+      ##
+      # Recursively walk the directory tree, getting all files that +match+ says
+      # are good.
+      # 
+      # @param [Amp::Match] match how to select the files in the tree
+      # @param [Boolean] check_ignored (false) should we check for ignored files?
+      # @return [Array<String>] an array of filenames in the tree that match +match+
+      def walk(match, check_ignored = false)
+        tree = @repo.staging_area.walk true, check_ignored, match
+        tree.keys.sort
+      end
+      
+      # What files have been altered in this changeset?
+      def altered_files; `git show --name-only #{node} 2> /dev/null`.split("\n"); end
+      # What files have changed?
+      def modified; status[:modified]; end
+      # What files have we added?
+      def added; status[:added]; end
+      # What files have been removed?
+      def removed; status[:removed]; end
+      # What files have been deleted (but not officially)?
+      def deleted; status[:deleted]; end
+      # What files are hanging out, but untracked?
+      def unknown; status[:unknown]; end
+      # What files are pristine since the last revision?
+      def clean; status[:normal]; end
+      
+      # yeah, i know, you could combine these all into one for a clean sweep.
+      # but it's clearer this way
+      def parse!
+        return if @parsed
+        
+        log_data = `git log -1 HEAD  2> /dev/null`
+        
+        unless log_data.empty?
+          # DETERMINING PARENTS
+          commit = log_data[/^commit (.+)$/, 1]
+          dad    = commit ? commit[0..6] : nil
+          mom    = nil
+          
+          if log_data =~ /^Merge: (.+)\.\.\. (.+)\.\.\.$/ # Merge: 1c002dd... 35cfb2b...
+            dad = $1 # just have them both use the short name, nbd
+            mom = $2
+          end
+          
+          @parents = [dad, mom].compact.map {|p| Changeset.new @repo, p }
+        else
+          @parents = []
+        end
+        @parsed = true
+      end
+      
+    end
+  end
+end