p-mongo-git 1.8.1

data/lib/git/base/factory.rb

@@ -0,0 +1,101 @@
+module Git
+
+  class Base
+
+    module Factory
+
+      # @return [Git::Branch] an object for branch_name
+      def branch(branch_name = 'master')
+        Git::Branch.new(self, branch_name)
+      end
+
+      # @return [Git::Branches] a collection of all the branches in the repository.
+      #   Each branch is represented as a {Git::Branch}.
+      def branches
+        Git::Branches.new(self)
+      end
+
+      # returns a Git::Worktree object for dir, commitish
+      def worktree(dir, commitish = nil)
+        Git::Worktree.new(self, dir, commitish)
+      end
+
+      # returns a Git::worktrees object of all the Git::Worktrees
+      # objects for this repo
+      def worktrees
+        Git::Worktrees.new(self)
+      end
+
+      # @return [Git::Object::Commit] a commit object
+      def commit_tree(tree = nil, opts = {})
+        Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
+      end
+
+      # @return [Git::Diff] a Git::Diff object
+      def diff(objectish = 'HEAD', obj2 = nil, **opts)
+        Git::Diff.new(self, objectish, obj2, **opts)
+      end
+
+      # @return [Git::Object] a Git object
+      def gblob(objectish)
+        Git::Object.new(self, objectish, 'blob')
+      end
+
+      # @return [Git::Object] a Git object
+      def gcommit(objectish)
+        Git::Object.new(self, objectish, 'commit')
+      end
+
+      # @return [Git::Object] a Git object
+      def gtree(objectish)
+        Git::Object.new(self, objectish, 'tree')
+      end
+
+      # @return [Git::Log] a log with the specified number of commits
+      def log(count = 30)
+        Git::Log.new(self, count)
+      end
+
+      # returns a Git::Object of the appropriate type
+      # you can also call @git.gtree('tree'), but that's
+      # just for readability.  If you call @git.gtree('HEAD') it will
+      # still return a Git::Object::Commit object.
+      #
+      # object calls a factory method that will run a rev-parse
+      # on the objectish and determine the type of the object and return
+      # an appropriate object for that type
+      #
+      # @return [Git::Object] an instance of the appropriate type of Git::Object
+      def object(objectish)
+        Git::Object.new(self, objectish)
+      end
+
+      # @return [Git::Remote] a remote of the specified name
+      def remote(remote_name = 'origin')
+        Git::Remote.new(self, remote_name)
+      end
+
+      # @return [Git::Status] a status object
+      def status
+        Git::Status.new(self)
+      end
+
+      # @return [Git::Object::Tag] a tag object
+      def tag(tag_name)
+        Git::Object.new(self, tag_name, 'tag', true)
+      end
+
+      # Find as good common ancestors as possible for a merge
+      # example: g.merge_base('master', 'some_branch', 'some_sha', octopus: true)
+      #
+      # @return [Array<Git::Object::Commit>] a collection of common ancestors
+      def merge_base(*args)
+        shas = self.lib.merge_base(*args)
+        shas.map { |sha| gcommit(sha) }
+      end
+
+    end
+
+  end
+
+end

data/lib/git/branch.rb

@@ -0,0 +1,126 @@
+require 'git/path'
+
+module Git
+
+  class Branch < Path
+    
+    attr_accessor :full, :remote, :name
+    
+    def initialize(base, name)
+      @full = name
+      @base = base
+      @gcommit = nil
+      @stashes = nil
+      @remote, @name = parse_name(name)
+    end
+    
+    def gcommit
+      @gcommit ||= @base.gcommit(@full)
+      @gcommit
+    end
+    
+    def stashes
+      @stashes ||= Git::Stashes.new(@base)
+    end
+    
+    def checkout
+      check_if_create
+      @base.checkout(@full)
+    end
+    
+    def archive(file, opts = {})
+      @base.lib.archive(@full, file, opts)
+    end
+    
+    # g.branch('new_branch').in_branch do
+    #   # create new file
+    #   # do other stuff
+    #   return true # auto commits and switches back
+    # end
+    def in_branch(message = 'in branch work')
+      old_current = @base.lib.branch_current
+      checkout
+      if yield
+        @base.commit_all(message)
+      else
+        @base.reset_hard
+      end
+      @base.checkout(old_current)
+    end
+    
+    def create
+      check_if_create
+    end
+    
+    def delete
+      @base.lib.branch_delete(@name)
+    end
+    
+    def current
+      determine_current
+    end
+    
+    def contains?(commit)
+      !@base.lib.branch_contains(commit, self.name).empty?
+    end
+    
+    def merge(branch = nil, message = nil)
+      if branch
+        in_branch do 
+          @base.merge(branch, message)
+          false
+        end
+        # merge a branch into this one
+      else
+        # merge this branch into the current one
+        @base.merge(@name)
+      end
+    end
+    
+    def update_ref(commit)
+      @base.lib.update_ref(@full, commit)
+    end
+    
+    def to_a
+      [@full]
+    end
+    
+    def to_s
+      @full
+    end
+    
+    private 
+
+      def check_if_create
+        @base.lib.branch_new(@name) rescue nil
+      end
+      
+      def determine_current
+        @base.lib.branch_current == @name
+      end
+    
+      # Given a full branch name return an Array containing the remote and branch names.
+      #
+      # Removes 'remotes' from the beggining of the name (if present).
+      # Takes the second part (splittign by '/') as the remote name.
+      # Takes the rest as the repo name (can also hold one or more '/').
+      #
+      # Example:
+      #   parse_name('master') #=> [nil, 'master']
+      #   parse_name('origin/master') #=> ['origin', 'master']
+      #   parse_name('remotes/origin/master') #=> ['origin', 'master']
+      #   parse_name('origin/master/v2') #=> ['origin', 'master/v2'] 
+      #
+      # param [String] name branch full name.
+      # return [<Git::Remote,NilClass,String>] an Array containing the remote and branch names. 
+      def parse_name(name)
+        if name.match(/^(?:remotes)?\/([^\/]+)\/(.+)/)
+          return [Git::Remote.new(@base, $1), $2]
+        end
+
+        return [nil, name]
+      end
+    
+  end
+  
+end

data/lib/git/branches.rb

@@ -0,0 +1,71 @@
+module Git
+  
+  # object that holds all the available branches
+  class Branches
+
+    include Enumerable
+    
+    def initialize(base)
+      @branches = {}
+      
+      @base = base
+            
+      @base.lib.branches_all.each do |b|
+        @branches[b[0]] = Git::Branch.new(@base, b[0])
+      end
+    end
+
+    def local
+      self.select { |b| !b.remote }
+    end
+    
+    def remote
+      self.select { |b| b.remote }
+    end
+    
+    # array like methods
+
+    def size
+      @branches.size
+    end    
+    
+    def each(&block)
+      @branches.values.each(&block)
+    end
+    
+    # Returns the target branch
+    #
+    # Example:
+    #   Given (git branch -a):
+    #    master
+    #    remotes/working/master
+    #
+    #   g.branches['master'].full #=> 'master'
+    #   g.branches['working/master'].full => 'remotes/working/master'
+    #   g.branches['remotes/working/master'].full => 'remotes/working/master'
+    #
+    # @param [#to_s] branch_name the target branch name.
+    # @return [Git::Branch] the target branch.
+    def [](branch_name)
+      @branches.values.inject(@branches) do |branches, branch|
+        branches[branch.full] ||= branch
+
+        # This is how Git (version 1.7.9.5) works. 
+        # Lets you ignore the 'remotes' if its at the beginning of the branch full name (even if is not a real remote branch). 
+        branches[branch.full.sub('remotes/', '')] ||= branch if branch.full =~ /^remotes\/.+/
+        
+        branches
+      end[branch_name.to_s]
+    end
+    
+    def to_s
+      out = ''
+      @branches.each do |k, b|
+        out << (b.current ? '* ' : '  ') << b.to_s << "\n"
+      end
+      out
+    end
+    
+  end
+
+end

data/lib/git/config.rb

@@ -0,0 +1,22 @@
+module Git
+
+  class Config
+
+    attr_writer :binary_path, :git_ssh
+
+    def initialize
+      @binary_path = nil
+      @git_ssh = nil
+    end
+
+    def binary_path
+      @binary_path || ENV['GIT_PATH'] && File.join(ENV['GIT_PATH'], 'git') || 'git'
+    end
+
+    def git_ssh
+      @git_ssh || ENV['GIT_SSH']
+    end
+
+  end
+
+end

data/lib/git/diff.rb

@@ -0,0 +1,156 @@
+module Git
+
+  # object that holds the last X commits on given branch
+  class Diff
+    include Enumerable
+
+    def initialize(base, from = nil, to = nil, **opts)
+      @base = base
+      @from = from && from.to_s
+      @to = to && to.to_s
+      @opts = opts
+
+      @path = nil
+      @full_diff = nil
+      @full_diff_files = nil
+      @stats = nil
+    end
+    attr_reader :from, :to
+
+    def name_status
+      cache_name_status
+    end
+
+    def path(path)
+      @path = path
+      return self
+    end
+
+    def size
+      cache_stats
+      @stats[:total][:files]
+    end
+
+    def lines
+      cache_stats
+      @stats[:total][:lines]
+    end
+
+    def deletions
+      cache_stats
+      @stats[:total][:deletions]
+    end
+
+    def insertions
+      cache_stats
+      @stats[:total][:insertions]
+    end
+
+    def stats
+      cache_stats
+      @stats
+    end
+
+    # if file is provided and is writable, it will write the patch into the file
+    def patch(file = nil)
+      cache_full
+      @full_diff
+    end
+    alias_method :to_s, :patch
+
+    # enumerable methods
+
+    def [](key)
+      process_full
+      @full_diff_files.assoc(key)[1]
+    end
+
+    def each(&block) # :yields: each Git::DiffFile in turn
+      process_full
+      @full_diff_files.map { |file| file[1] }.each(&block)
+    end
+
+    class DiffFile
+      attr_accessor :patch, :path, :mode, :src, :dst, :type
+      @base = nil
+      NIL_BLOB_REGEXP = /\A0{4,40}\z/.freeze
+
+      def initialize(base, hash)
+        @base = base
+        @patch = hash[:patch]
+        @path = hash[:path]
+        @mode = hash[:mode]
+        @src = hash[:src]
+        @dst = hash[:dst]
+        @type = hash[:type]
+        @binary = hash[:binary]
+      end
+
+      def binary?
+        !!@binary
+      end
+
+      def blob(type = :dst)
+        if type == :src && !NIL_BLOB_REGEXP.match(@src)
+          @base.object(@src)
+        elsif !NIL_BLOB_REGEXP.match(@dst)
+          @base.object(@dst)
+        end
+      end
+    end
+
+    private
+
+      def cache_full
+        @full_diff ||= @base.lib.diff_full(@from, @to, {:path_limiter => @path}.update(**@opts))
+      end
+
+      def process_full
+        return if @full_diff_files
+        cache_full
+        @full_diff_files = process_full_diff
+      end
+
+      def cache_stats
+        @stats ||=  @base.lib.diff_stats(@from, @to, {:path_limiter => @path})
+      end
+
+      def cache_name_status
+        @name_status ||= @base.lib.diff_name_status(@from, @to, {:path => @path})
+      end
+
+      # break up @diff_full
+      def process_full_diff
+        defaults = {
+          :mode => '',
+          :src => '',
+          :dst => '',
+          :type => 'modified'
+        }
+        final = {}
+        current_file = nil
+        @full_diff.split("\n").each do |line|
+          if m = /^diff --git a\/(.*?) b\/(.*?)/.match(line)
+            current_file = m[1]
+            final[current_file] = defaults.merge({:patch => line, :path => current_file})
+          else
+            if m = /^index ([0-9a-f]{4,40})\.\.([0-9a-f]{4,40})( ......)*/.match(line)
+              final[current_file][:src] = m[1]
+              final[current_file][:dst] = m[2]
+              final[current_file][:mode] = m[3].strip if m[3]
+            end
+            if m = /^([[:alpha:]]*?) file mode (......)/.match(line)
+              final[current_file][:type] = m[1]
+              final[current_file][:mode] = m[2]
+            end
+            if m = /^Binary files /.match(line)
+              final[current_file][:binary] = true
+            end
+            final[current_file][:patch] << "\n" + line
+          end
+        end
+        final.map { |e| [e[0], DiffFile.new(@base, e[1])] }
+      end
+
+  end
+end