git 1.19.1 → 2.1.1

data/lib/git/log.rb

@@ -1,15 +1,76 @@
 module Git
 
-  # object that holds the last X commits on given branch
+  # Return the last n commits that match the specified criteria
+  #
+  # @example The last (default number) of commits
+  #   git = Git.open('.')
+  #   Git::Log.new(git) #=> Enumerable of the last 30 commits
+  #
+  # @example The last n commits
+  #   Git::Log.new(git).max_commits(50) #=> Enumerable of last 50 commits
+  #
+  # @example All commits returned by `git log`
+  #   Git::Log.new(git).max_count(:all) #=> Enumerable of all commits
+  #
+  # @example All commits that match complex criteria
+  #   Git::Log.new(git)
+  #     .max_count(:all)
+  #     .object('README.md')
+  #     .since('10 years ago')
+  #     .between('v1.0.7', 'HEAD')
+  #
+  # @api public
+  #
   class Log
     include Enumerable
 
-    def initialize(base, count = 30)
+    # Create a new Git::Log object
+    #
+    # @example
+    #   git = Git.open('.')
+    #   Git::Log.new(git)
+    #
+    # @param base [Git::Base] the git repository object
+    # @param max_count [Integer, Symbol, nil] the number of commits to return, or
+    #   `:all` or `nil` to return all
+    #
+    #   Passing max_count to {#initialize} is equivalent to calling {#max_count} on the object.
+    #
+    def initialize(base, max_count = 30)
       dirty_log
       @base = base
-      @count = count
+      max_count(max_count)
+    end
+
+    # The maximum number of commits to return
+    #
+    # @example All commits returned by `git log`
+    #   git = Git.open('.')
+    #   Git::Log.new(git).max_count(:all)
+    #
+    # @param num_or_all [Integer, Symbol, nil] the number of commits to return, or
+    #   `:all` or `nil` to return all
+    #
+    # @return [self]
+    #
+    def max_count(num_or_all)
+      dirty_log
+      @max_count = (num_or_all == :all) ? nil : num_or_all
+      self
     end
 
+    # Adds the --all flag to the git log command
+    #
+    # This asks for the logs of all refs (basically all commits reachable by HEAD,
+    # branches, and tags). This does not control the maximum number of commits
+    # returned. To control how many commits are returned, call {#max_count}.
+    #
+    # @example Return the last 50 commits reachable by all refs
+    #   git = Git.open('.')
+    #   Git::Log.new(git).max_count(50).all
+    #
+    # @return [self]
+    #
     def all
       dirty_log
       @all = true
@@ -119,7 +180,7 @@ module Git
       # actually run the 'git log' command
       def run_log
         log = @base.lib.full_log_commits(
-          count: @count, all: @all, object: @object, path_limiter: @path, since: @since,
+          count: @max_count, all: @all, object: @object, path_limiter: @path, since: @since,
           author: @author, grep: @grep, skip: @skip, until: @until, between: @between,
           cherry: @cherry
         )

data/lib/git/object.rb

@@ -1,16 +1,18 @@
+require 'git/author'
+require 'git/diff'
+require 'git/errors'
+require 'git/log'
+
 module Git
-  
-  class GitTagNameDoesNotExist< StandardError 
-  end
-  
+
   # represents a git object
   class Object
-    
+
     class AbstractObject
       attr_accessor :objectish, :type, :mode
 
       attr_writer :size
-      
+
       def initialize(base, objectish)
         @base = base
         @objectish = objectish.to_s
@@ -23,11 +25,11 @@ module Git
       def sha
         @sha ||= @base.lib.revparse(@objectish)
       end
-      
+
       def size
         @size ||= @base.lib.object_size(@objectish)
       end
-      
+
       # Get the object's contents.
       # If no block is given, the contents are cached in memory and returned as a string.
       # If a block is given, it yields an IO object (via IO::popen) which could be used to
@@ -41,108 +43,108 @@ module Git
           @contents ||= @base.lib.object_contents(@objectish)
         end
       end
-      
+
       def contents_array
         self.contents.split("\n")
       end
-      
+
       def to_s
         @objectish
       end
-      
+
       def grep(string, path_limiter = nil, opts = {})
         opts = {:object => sha, :path_limiter => path_limiter}.merge(opts)
         @base.lib.grep(string, opts)
       end
-      
+
       def diff(objectish)
         Git::Diff.new(@base, @objectish, objectish)
       end
-      
+
       def log(count = 30)
         Git::Log.new(@base, count).object(@objectish)
       end
-      
+
       # creates an archive of this object (tree)
       def archive(file = nil, opts = {})
         @base.lib.archive(@objectish, file, opts)
       end
-      
+
       def tree?; false; end
-      
+
       def blob?; false; end
-      
+
       def commit?; false; end
 
       def tag?; false; end
-     
+
     end
-  
-    
+
+
     class Blob < AbstractObject
-      
+
       def initialize(base, sha, mode = nil)
         super(base, sha)
         @mode = mode
       end
-      
+
       def blob?
         true
       end
 
     end
-  
+
     class Tree < AbstractObject
-      
+
       def initialize(base, sha, mode = nil)
         super(base, sha)
         @mode = mode
         @trees = nil
         @blobs = nil
       end
-            
+
       def children
         blobs.merge(subtrees)
       end
-      
+
       def blobs
         @blobs ||= check_tree[:blobs]
       end
       alias_method :files, :blobs
-      
+
       def trees
         @trees ||= check_tree[:trees]
       end
       alias_method :subtrees, :trees
       alias_method :subdirectories, :trees
-       
+
       def full_tree
         @base.lib.full_tree(@objectish)
       end
-                  
+
       def depth
         @base.lib.tree_depth(@objectish)
       end
-      
+
       def tree?
         true
       end
-       
+
       private
 
         # actually run the git command
         def check_tree
           @trees = {}
           @blobs = {}
-          
+
           data = @base.lib.ls_tree(@objectish)
 
-          data['tree'].each do |key, tree| 
-            @trees[key] = Git::Object::Tree.new(@base, tree[:sha], tree[:mode]) 
+          data['tree'].each do |key, tree|
+            @trees[key] = Git::Object::Tree.new(@base, tree[:sha], tree[:mode])
           end
-          
-          data['blob'].each do |key, blob| 
-            @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode]) 
+
+          data['blob'].each do |key, blob|
+            @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode])
           end
 
           {
@@ -150,11 +152,11 @@ module Git
             :blobs => @blobs
           }
         end
-      
+
     end
-  
+
     class Commit < AbstractObject
-      
+
       def initialize(base, sha, init = nil)
         super(base, sha)
         @tree = nil
@@ -166,48 +168,48 @@ module Git
           set_commit(init)
         end
       end
-      
+
       def message
         check_commit
         @message
       end
-      
+
       def name
         @base.lib.namerev(sha)
       end
-      
+
       def gtree
         check_commit
         Tree.new(@base, @tree)
       end
-      
+
       def parent
         parents.first
       end
-      
+
       # array of all parent commits
       def parents
         check_commit
-        @parents        
+        @parents
       end
-      
+
       # git author
-      def author     
+      def author
         check_commit
         @author
       end
-      
+
       def author_date
         author.date
       end
-      
+
       # git author
       def committer
         check_commit
         @committer
       end
-      
-      def committer_date 
+
+      def committer_date
         committer.date
       end
       alias_method :date, :committer_date
@@ -215,7 +217,7 @@ module Git
       def diff_parent
         diff(parent)
       end
-      
+
       def set_commit(data)
         @sha ||= data['sha']
         @committer = Git::Author.new(data['committer'])
@@ -224,26 +226,26 @@ module Git
         @parents = data['parent'].map{ |sha| Git::Object::Commit.new(@base, sha) }
         @message = data['message'].chomp
       end
-      
+
       def commit?
         true
       end
 
       private
-  
+
         # see if this object has been initialized and do so if not
         def check_commit
           return if @tree
-          
+
           data = @base.lib.commit_data(@objectish)
           set_commit(data)
         end
-      
+
     end
-  
+
     class Tag < AbstractObject
       attr_accessor :name
-      
+
       def initialize(base, sha, name)
         super(base, sha)
         @name = name
@@ -259,7 +261,7 @@ module Git
         check_tag()
         return @message
       end
-      
+
       def tag?
         true
       end
@@ -274,7 +276,7 @@ module Git
       def check_tag
         return if @loaded
 
-        if !self.annotated? 
+        if !self.annotated?
           @message = @tagger = nil
         else
           tdata = @base.lib.tag_data(@name)
@@ -284,29 +286,29 @@ module Git
 
         @loaded = true
       end
-        
+
     end
-    
+
     # if we're calling this, we don't know what type it is yet
     # so this is our little factory method
     def self.new(base, objectish, type = nil, is_tag = false)
       if is_tag
         sha = base.lib.tag_sha(objectish)
         if sha == ''
-          raise Git::GitTagNameDoesNotExist.new(objectish)
+          raise Git::UnexpectedResultError.new("Tag '#{objectish}' does not exist.")
         end
         return Git::Object::Tag.new(base, sha, objectish)
       end
-      
+
       type ||= base.lib.object_type(objectish)
       klass =
         case type
-        when /blob/   then Blob   
+        when /blob/   then Blob
         when /commit/ then Commit
         when /tree/   then Tree
         end
       klass.new(base, objectish)
     end
-    
+
   end
 end

data/lib/git/status.rb

@@ -1,6 +1,12 @@
 module Git
+  # The status class gets the status of a git repository
   #
-  # A class for git status
+  # This identifies which files have been modified, added, or deleted from the
+  # worktree. Untracked files are also identified.
+  #
+  # The Status object is an Enumerable that contains StatusFile objects.
+  #
+  # @api public
   #
   class Status
     include Enumerable
@@ -16,7 +22,7 @@ module Git
     #
     # @return [Enumerable]
     def changed
-      @files.select { |_k, f| f.type == 'M' }
+      @_changed ||= @files.select { |_k, f| f.type == 'M' }
     end
 
     #
@@ -28,20 +34,19 @@ module Git
     #     changed?('lib/git.rb')
     # @return [Boolean]
     def changed?(file)
-      changed.member?(file)
+      case_aware_include?(:changed, :lc_changed, file)
     end
 
-    #
     # Returns an Enumerable containing files that have been added.
     # File path starts at git base directory
     #
     # @return [Enumerable]
     def added
-      @files.select { |_k, f| f.type == 'A' }
+      @_added ||= @files.select { |_k, f| f.type == 'A' }
     end
 
-    #
     # Determines whether the given file has been added to the repository
+    #
     # File path starts at git base directory
     #
     # @param file [String] The name of the file.
@@ -49,7 +54,7 @@ module Git
     #     added?('lib/git.rb')
     # @return [Boolean]
     def added?(file)
-      added.member?(file)
+      case_aware_include?(:added, :lc_added, file)
     end
 
     #
@@ -58,7 +63,7 @@ module Git
     #
     # @return [Enumerable]
     def deleted
-      @files.select { |_k, f| f.type == 'D' }
+      @_deleted ||= @files.select { |_k, f| f.type == 'D' }
     end
 
     #
@@ -70,7 +75,7 @@ module Git
     #     deleted?('lib/git.rb')
     # @return [Boolean]
     def deleted?(file)
-      deleted.member?(file)
+      case_aware_include?(:deleted, :lc_deleted, file)
     end
 
     #
@@ -79,7 +84,7 @@ module Git
     #
     # @return [Enumerable]
     def untracked
-      @files.select { |_k, f| f.untracked }
+      @_untracked ||= @files.select { |_k, f| f.untracked }
     end
 
     #
@@ -91,7 +96,7 @@ module Git
     #     untracked?('lib/git.rb')
     # @return [Boolean]
     def untracked?(file)
-      untracked.member?(file)
+      case_aware_include?(:untracked, :lc_untracked, file)
     end
 
     def pretty
@@ -126,9 +131,63 @@ module Git
 
     # subclass that does heavy lifting
     class StatusFile
-      attr_accessor :path, :type, :stage, :untracked
-      attr_accessor :mode_index, :mode_repo
-      attr_accessor :sha_index, :sha_repo
+      # @!attribute [r] path
+      #   The path of the file relative to the project root directory
+      #   @return [String]
+      attr_accessor :path
+
+      # @!attribute [r] type
+      #   The type of change
+      #
+      #   * 'M': modified
+      #   * 'A': added
+      #   * 'D': deleted
+      #   * nil: ???
+      #
+      #   @return [String]
+      attr_accessor :type
+
+      # @!attribute [r] mode_index
+      #   The mode of the file in the index
+      #   @return [String]
+      #   @example 100644
+      #
+      attr_accessor :mode_index
+
+      # @!attribute [r] mode_repo
+      #   The mode of the file in the repo
+      #   @return [String]
+      #   @example 100644
+      #
+      attr_accessor :mode_repo
+
+      # @!attribute [r] sha_index
+      #   The sha of the file in the index
+      #   @return [String]
+      #   @example 123456
+      #
+      attr_accessor :sha_index
+
+      # @!attribute [r] sha_repo
+      #   The sha of the file in the repo
+      #   @return [String]
+      #   @example 123456
+      attr_accessor :sha_repo
+
+      # @!attribute [r] untracked
+      #   Whether the file is untracked
+      #   @return [Boolean]
+      attr_accessor :untracked
+
+      # @!attribute [r] stage
+      #   The stage of the file
+      #
+      #   * '0': the unmerged state
+      #   * '1': the common ancestor (or original) version
+      #   * '2': "our version" from the current branch head
+      #   * '3': "their version" from the other branch head
+      #   @return [String]
+      attr_accessor :stage
 
       def initialize(base, hash)
         @base = base
@@ -158,10 +217,19 @@ module Git
     private
 
     def construct_status
+      # Lists all files in the index and the worktree
+      # git ls-files --stage
+      # { file => { path: file, mode_index: '100644', sha_index: 'dd4fc23', stage: '0' } }
       @files = @base.lib.ls_files
 
+      # Lists files in the worktree that are not in the index
+      # Add untracked files to @files
       fetch_untracked
+
+      # Lists files that are different between the index vs. the worktree
       fetch_modified
+
+      # Lists files that are different between the repo HEAD vs. the worktree
       fetch_added
 
       @files.each do |k, file_hash|
@@ -170,28 +238,68 @@ module Git
     end
 
     def fetch_untracked
-      ignore = @base.lib.ignored_files
-
-      root_dir = @base.dir.path
-      Dir.glob('**/*', File::FNM_DOTMATCH, base: root_dir) do |file|
-        next if @files[file] || File.directory?(File.join(root_dir, file)) ||
-                ignore.include?(file) || file =~ %r{^.git\/.+}
-
+      # git ls-files --others --exclude-standard, chdir: @git_work_dir)
+      # { file => { path: file, untracked: true } }
+      @base.lib.untracked_files.each do |file|
         @files[file] = { path: file, untracked: true }
       end
     end
 
     def fetch_modified
-      # find modified in tree
+      # Files changed between the index vs. the worktree
+      # git diff-files
+      # { file => { path: file, type: 'M', mode_index: '100644', mode_repo: '100644', sha_index: '0000000', :sha_repo: '52c6c4e' } }
       @base.lib.diff_files.each do |path, data|
         @files[path] ? @files[path].merge!(data) : @files[path] = data
       end
     end
 
     def fetch_added
-      # find added but not committed - new files
+      unless @base.lib.empty?
+      # Files changed between the repo HEAD vs. the worktree
+      # git diff-index HEAD
+      # { file => { path: file, type: 'M', mode_index: '100644', mode_repo: '100644', sha_index: '0000000', :sha_repo: '52c6c4e' } }
       @base.lib.diff_index('HEAD').each do |path, data|
-        @files[path] ? @files[path].merge!(data) : @files[path] = data
+          @files[path] ? @files[path].merge!(data) : @files[path] = data
+        end
+      end
+    end
+
+    # It's worth noting that (like git itself) this gem will not behave well if
+    # ignoreCase is set inconsistently with the file-system itself. For details:
+    # https://git-scm.com/docs/git-config#Documentation/git-config.txt-coreignoreCase
+    def ignore_case?
+      return @_ignore_case if defined?(@_ignore_case)
+      @_ignore_case = @base.config('core.ignoreCase') == 'true'
+    rescue Git::FailedError
+      @_ignore_case = false
+    end
+
+    def downcase_keys(hash)
+      hash.map { |k, v| [k.downcase, v] }.to_h
+    end
+
+    def lc_changed
+      @_lc_changed ||= changed.transform_keys(&:downcase)
+    end
+
+    def lc_added
+      @_lc_added ||= added.transform_keys(&:downcase)
+    end
+
+    def lc_deleted
+      @_lc_deleted ||= deleted.transform_keys(&:downcase)
+    end
+
+    def lc_untracked
+      @_lc_untracked ||= untracked.transform_keys(&:downcase)
+    end
+
+    def case_aware_include?(cased_hash, downcased_hash, file)
+      if ignore_case?
+        send(downcased_hash).include?(file.downcase)
+      else
+        send(cased_hash).include?(file)
       end
     end
   end

data/lib/git/version.rb

@@ -1,5 +1,5 @@
 module Git
   # The current gem version
   # @return [String] the current gem version.
-  VERSION='1.19.1'
+  VERSION='2.1.1'
 end