amp 0.5.2 → 0.5.3

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

@@ -0,0 +1,192 @@
+module Amp
+  module Repositories
+    module Git
+      class StagingArea < Amp::Repositories::AbstractStagingArea
+        
+        attr_accessor :repo
+        attr_accessor :vcs_dir
+        
+        def initialize(repo)
+          @repo = repo
+          @vcs_dir = '.git'
+        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
+
+        ##
+        # 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

data/lib/amp/repository/git/repo_format/versioned_file.rb

@@ -0,0 +1,119 @@
+module Amp
+  module Git
+    
+    ##
+    # This class allows you to access a file at a given revision in the repo's
+    # history. You can compare them, sort them, access the changeset, and
+    # all sorts of stuff.
+    class VersionedFile < Amp::Repositories::AbstractVersionedFile
+      
+      attr_accessor :revision
+      attr_accessor :path
+      attr_accessor :repo
+      
+      def initialize(repo, path, opts={})
+        @repo = repo
+        @path = path
+        @revision = opts[:revision]
+      end
+      
+      ##
+      # The changeset to which this versioned file belongs.
+      # 
+      # @return [AbstractChangeset]
+      def changeset
+        @changeset ||= Changeset.new @repo, @revision
+      end
+      
+      ##
+      # The size of this file
+      # 
+      # @return [Integer]
+      def size
+        @size ||= data.size
+      end
+      
+      ##
+      # The contents of a file at the given revision
+      # 
+      # @return [String] the data at the current revision
+      def data
+        @data ||= `git show #{revision}:#{path} 2> /dev/null`
+      end
+      
+      ##
+      # The hash value for sticking this fucker in a hash.
+      # 
+      # @return [Integer]
+      def hash
+        "#{size}--#{path}--#{repo.root}--#{revision} 2> /dev/null".hash
+      end
+      
+      ##
+      # Has this file been renamed? If so, return some useful info
+      def renamed?
+        nil
+      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)
+        return data == item if item.is_a? String
+        
+        not (data      == item.data     &&
+             size      == item.size     &&
+             revision  == item.revision &&
+             repo.root == item.repo.root )
+      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)
+        !cmp(vfile)
+      end
+      
+      ##
+      # Gets the flags for this file ('x', 'l', or '')
+      # 
+      # @return [String] 'x', 'l', or ''
+      def flags
+        '' # because git doesn't track them
+      end
+      
+    end
+    
+    ##
+    # This is a VersionedFile, except it's in the working directory, so its data
+    # is stored on disk in the actual file. Other than that, it's basically the
+    # same in its interface!
+    class VersionedWorkingFile < VersionedFile
+      
+      ##
+      # Initializes a new working dir file - slightly different semantics here
+      def initialize(repo, path, opts={})
+        super(repo, path, opts)
+      end
+      
+      def size
+        File.stat(repo.join(path)).size
+      end
+      
+      def data
+        File.read repo.working_join(path)
+      end
+      
+      def changeset
+        WorkingDirectoryChangeset.new repo
+      end
+      
+    end
+  end
+end

data/lib/amp/repository/git/repositories/local_repository.rb

@@ -0,0 +1,164 @@
+module Amp
+  module Repositories    
+    module Git
+      
+      class LocalRepository < Amp::Repositories::AbstractLocalRepository
+        
+        attr_accessor :root
+        attr_accessor :config
+        attr_accessor :file_opener
+        attr_accessor :git_opener
+        attr_accessor :staging_area
+        
+        def initialize(path="", create=false, config=nil)
+          super(path, create, config)
+          
+          @config = config
+          
+          @file_opener = Amp::Opener.new @root # This will open relative to the repo root
+          @file_opener.default = :open_file    # these two are the same, pretty much
+          @git_opener  = Amp::Opener.new @root # this will open relative to root/.git
+          @git_opener.default  = :open_git     # just with different defaults
+          
+          @staging_area = Amp::Repositories::Git::StagingArea.new self
+          
+          if create
+            init
+          end
+        end
+        
+        def init(config=@config)
+          super(config)
+          
+          `cd #{@root} && git init 2> /dev/null`
+          true
+        end
+        
+        def commit(opts={})
+          add_all_files
+          string = "git commit #{opts[:user] ? "--author #{opts[:user].inspect}" : "" }" +
+                   " #{opts[:empty_ok] ? "--allow-empty" : "" }" +
+                   " #{opts[:message] ? "-m #{opts[:message].inspect}" : "" } 2> /dev/null"
+          string.strip!
+          
+          system string
+        end
+        
+        def add_all_files
+          staging_area.add status[:modified]
+        end
+        
+        def forget(*files)
+          staging_area.forget *files
+        end
+        
+        def [](rev)
+          case rev
+          when String
+            Amp::Git::Changeset.new self, rev
+          when nil
+            Amp::Git::WorkingDirectoryChangeset.new self
+          when 'tip', :tip
+            Amp::Git::Changeset.new self, parents[0]
+          when Integer
+            revs = `git log --pretty=oneline 2> /dev/null`.split("\n")
+            short_name = revs[revs.size - 1 - rev].split(' ').first
+            Amp::Git::Changeset.new self, short_name
+          end
+        end
+        
+        def size
+          `git log --pretty=oneline 2> /dev/null`.split("\n").size
+        end
+        
+        ##
+        # Write +text+ to +filename+, where +filename+
+        # is local to the root.
+        #
+        # @param [String] filename The file as relative to the root
+        # @param [String] text The text to write to said file
+        def working_write(filename, text)
+          file_opener.open filename, 'w' do |f|
+            f.write text
+          end
+        end
+        
+        ##
+        # Determines if a file has been modified from :node1 to :node2.
+        # 
+        # @return [Boolean] has it been modified
+        def file_modified?(file, opts={})
+          file_status(file, opts) == :included
+        end
+        
+        ##
+        # Returns a Symbol.
+        # Possible results:
+        # :added (subset of :included)
+        # :removed
+        # :untracked
+        # :included (aka :modified)
+        # :normal
+        # 
+        # If you call localrepo#status from this method... well...
+        # I DARE YOU!
+        def file_status(filename, opts={})
+          parse_status! opts
+          inverted = @status.inject({}) do |h, (k, v)|
+            v.each {|v_| h[v_] = k }
+            h
+          end
+          
+          # Now convert it so it uses the same jargon
+          # we REALLY need to get the dirstate and localrepo on
+          # the same page here.
+          case inverted[filename]
+          when :modified
+            :included
+          when :added
+            :added
+          when :removed
+            :removed
+          when :unknown
+            :untracked
+          else
+            :normal
+          end
+            
+        end
+        
+        def parse_status!(opts={})
+          return if @parsed
+          
+          data    = `git status #{opts[:node1]}..#{opts[:node2]}  2> /dev/null`.split("\n")
+          @status = data.inject({}) do |h, line| # yeah i know stfu
+            case line
+            when /^#\s+(\w+):\s(.+)$/
+              h[$1.to_sym] = $2; h
+            when /^#\s+([^ ]+)$/
+              h[:unknown] = $1; h
+            else
+              h
+            end
+          end
+          @parsed = true
+        end
+        
+        def parents
+          first = `git log -1 HEAD 2> /dev/null`
+          dad   = first[/^commit (.+)$/, 1]
+          dad   = dad ? dad[0..6] : nil
+          mom   = nil
+          
+          if first =~ /Merge: (.+)\.\.\. (.+)\.\.\.$/ # Merge: 1c002dd... 35cfb2b...
+            dad = $1 # just have them both use the short name, nbd
+            mom = $2
+          end
+          
+          [dad, mom]
+        end
+        
+      end
+    end
+  end
+end