git 1.19.1 → 4.4.5

data/lib/git/object.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
+require 'git/author'
+require 'git/diff'
+require 'git/errors'
+require 'git/log'
+
 module Git
-  
-  class GitTagNameDoesNotExist< StandardError 
-  end
-  
   # represents a git object
   class Object
-    
+    # A base class for all Git objects
     class AbstractObject
       attr_accessor :objectish, :type, :mode
 
       attr_writer :size
-      
+
       def initialize(base, objectish)
         @base = base
         @objectish = objectish.to_s
@@ -21,140 +24,133 @@ module Git
       end
 
       def sha
-        @sha ||= @base.lib.revparse(@objectish)
+        @sha ||= @base.lib.rev_parse(@objectish)
       end
-      
+
       def size
-        @size ||= @base.lib.object_size(@objectish)
+        @size ||= @base.lib.cat_file_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
       # read a large file in chunks.
       #
       # Use this for large files so that they are not held in memory.
-      def contents(&block)
+      def contents(&)
         if block_given?
-          @base.lib.object_contents(@objectish, &block)
+          @base.lib.cat_file_contents(@objectish, &)
         else
-          @contents ||= @base.lib.object_contents(@objectish)
+          @contents ||= @base.lib.cat_file_contents(@objectish)
         end
       end
-      
+
       def contents_array
-        self.contents.split("\n")
+        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)
+        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
-     
+      def tree? = false
+
+      def blob? = false
+
+      def commit? = false
+
+      def tag? = false
     end
-  
-    
+
+    # A Git blob object
     class Blob < AbstractObject
-      
       def initialize(base, sha, mode = nil)
         super(base, sha)
         @mode = mode
       end
-      
+
       def blob?
         true
       end
-
     end
-  
+
+    # A Git tree object
     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
-      
+      alias files blobs
+
       def trees
         @trees ||= check_tree[:trees]
       end
-      alias_method :subtrees, :trees
-      alias_method :subdirectories, :trees
-       
+      alias subtrees trees
+      alias 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]) 
-          end
-          
-          data['blob'].each do |key, blob| 
-            @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode]) 
-          end
-
-          {
-            :trees => @trees,
-            :blobs => @blobs
-          }
+      # 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])
+        end
+
+        data['blob'].each do |key, blob|
+          @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode])
         end
-      
+
+        { trees: @trees, blobs: @blobs }
+      end
     end
-  
+
+    # A Git commit object
     class Commit < AbstractObject
-      
       def initialize(base, sha, init = nil)
         super(base, sha)
         @tree = nil
@@ -162,111 +158,143 @@ module Git
         @author = nil
         @committer = nil
         @message = nil
-        if init
-          set_commit(init)
-        end
+        return unless init
+
+        from_data(init)
       end
-      
+
       def message
         check_commit
         @message
       end
-      
+
       def name
-        @base.lib.namerev(sha)
+        @base.lib.name_rev(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
+      alias date committer_date
 
       def diff_parent
         diff(parent)
       end
-      
-      def set_commit(data)
+
+      def set_commit(data) # rubocop:disable Naming/AccessorMethodName
+        Git::Deprecation.warn(
+          'Git::Object::Commit#set_commit is deprecated and will be removed in a future version. ' \
+          'Use #from_data instead.'
+        )
+        from_data(data)
+      end
+
+      def from_data(data)
         @sha ||= data['sha']
         @committer = Git::Author.new(data['committer'])
         @author = Git::Author.new(data['author'])
         @tree = Git::Object::Tree.new(@base, data['tree'])
-        @parents = data['parent'].map{ |sha| Git::Object::Commit.new(@base, sha) }
+        @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
-      
+
+      # see if this object has been initialized and do so if not
+      def check_commit
+        return if @tree
+
+        data = @base.lib.cat_file_commit(@objectish)
+        from_data(data)
+      end
     end
-  
+
+    # A Git tag object
+    #
+    # This class represents a tag in Git, which can be either annotated or lightweight.
+    #
+    # Annotated tags contain additional metadata such as the tagger's name, email, and
+    # the date when the tag was created, along with a message.
+    #
+    # TODO: Annotated tags are not objects
+    #
     class Tag < AbstractObject
       attr_accessor :name
-      
-      def initialize(base, sha, name)
+
+      # @overload initialize(base, name)
+      #   @param base [Git::Base] The Git base object
+      #   @param name [String] The name of the tag
+      #
+      # @overload initialize(base, sha, name)
+      #   @param base [Git::Base] The Git base object
+      #   @param sha [String] The SHA of the tag object
+      #   @param name [String] The name of the tag
+      #
+      def initialize(base, sha, name = nil)
+        if name.nil?
+          name = sha
+          sha = base.lib.tag_sha(name)
+          raise Git::UnexpectedResultError, "Tag '#{name}' does not exist." if sha == ''
+        end
+
         super(base, sha)
+
         @name = name
         @annotated = nil
         @loaded = false
       end
 
       def annotated?
-        @annotated ||= (@base.lib.object_type(self.name) == 'tag')
+        @annotated = @annotated.nil? ? (@base.lib.cat_file_type(name) == 'tag') : @annotated
       end
 
       def message
-        check_tag()
-        return @message
+        check_tag
+        @message
       end
-      
+
       def tag?
         true
       end
 
       def tagger
-        check_tag()
-        return @tagger
+        check_tag
+        @tagger
       end
 
       private
@@ -274,39 +302,37 @@ module Git
       def check_tag
         return if @loaded
 
-        if !self.annotated? 
-          @message = @tagger = nil
-        else
-          tdata = @base.lib.tag_data(@name)
+        if annotated?
+          tdata = @base.lib.cat_file_tag(@name)
           @message = tdata['message'].chomp
           @tagger = Git::Author.new(tdata['tagger'])
+        else
+          @message = @tagger = nil
         end
 
         @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)
-        end
-        return Git::Object::Tag.new(base, sha, objectish)
-      end
-      
-      type ||= base.lib.object_type(objectish)
+    def self.new(base, objectish, type = nil, is_tag = false) # rubocop:disable Style/OptionalBooleanParameter
+      return new_tag(base, objectish) if is_tag
+
+      type ||= base.lib.cat_file_type(objectish)
+      # TODO: why not handle tag case here too?
       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
-    
+
+    private_class_method def self.new_tag(base, objectish)
+      Git::Deprecation.warn('Git::Object.new with is_tag argument is deprecated. Use Git::Object::Tag.new instead.')
+      Git::Object::Tag.new(base, objectish)
+    end
   end
 end

data/lib/git/path.rb

@@ -1,19 +1,28 @@
+# frozen_string_literal: true
+
 module Git
- 
- class Path
-    
-    attr_accessor :path
-    
-    def initialize(path, check_path=true)
+  # A base class that represents and validates a filesystem path
+  #
+  # Use for tracking things relevant to a Git repository, such as the working
+  # directory or index file.
+  #
+  class Path
+    def path
+      Git::Deprecation.warn(
+        'The .path accessor is deprecated and will be removed in v5.0. ' \
+        'Use .to_s instead.'
+      )
+      @path
+    end
+
+    def initialize(path, must_exist: true)
       path = File.expand_path(path)
-      
-      if check_path && !File.exist?(path)
-        raise ArgumentError, 'path does not exist', [path]
-      end
-      
+
+      raise ArgumentError, 'path does not exist', [path] if must_exist && !File.exist?(path)
+
       @path = path
     end
-    
+
     def readable?
       File.readable?(@path)
     end
@@ -21,11 +30,9 @@ module Git
     def writable?
       File.writable?(@path)
     end
-    
+
     def to_s
       @path
     end
-    
- end
-
+  end
 end

data/lib/git/remote.rb

@@ -1,6 +1,8 @@
-module Git
-  class Remote < Path
+# frozen_string_literal: true
 
+module Git
+  # A remote in a Git repository
+  class Remote
     attr_accessor :name, :url, :fetch_opts
 
     def initialize(base, name)
@@ -11,7 +13,7 @@ module Git
       @fetch_opts = config['fetch']
     end
 
-    def fetch(opts={})
+    def fetch(opts = {})
       @base.fetch(@name, opts)
     end
 
@@ -33,6 +35,5 @@ module Git
     def to_s
       @name
     end
-
   end
 end

data/lib/git/repository.rb

@@ -1,6 +1,6 @@
-module Git
+# frozen_string_literal: true
 
+module Git
   class Repository < Path
   end
-
 end

data/lib/git/stash.rb

@@ -1,27 +1,26 @@
+# frozen_string_literal: true
+
 module Git
+  # A stash in a Git repository
   class Stash
-    
-    def initialize(base, message, existing=false)
+    def initialize(base, message, save: false)
       @base = base
       @message = message
-      save unless existing
+      self.save unless save
     end
-    
+
     def save
       @saved = @base.lib.stash_save(@message)
     end
-    
+
     def saved?
       @saved
     end
-    
-    def message
-      @message
-    end
-    
+
+    attr_reader :message
+
     def to_s
       message
     end
-    
   end
-end
+end

data/lib/git/stashes.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module Git
-  
   # object that holds all the available stashes
   class Stashes
     include Enumerable
-    
+
     def initialize(base)
       @stashes = []
-      
+
       @base = base
-            
-      @base.lib.stashes_all.each do |id, message|
-        @stashes.unshift(Git::Stash.new(@base, message, true))
+
+      @base.lib.stashes_all.each do |indexed_message|
+        _index, message = indexed_message
+        @stashes.unshift(Git::Stash.new(@base, message, save: true))
       end
     end
 
@@ -24,16 +26,16 @@ module Git
     def all
       @base.lib.stashes_all
     end
-    
+
     def save(message)
       s = Git::Stash.new(@base, message)
       @stashes.unshift(s) if s.saved?
     end
-    
-    def apply(index=nil)
+
+    def apply(index = nil)
       @base.lib.stash_apply(index)
     end
-    
+
     def clear
       @base.lib.stash_clear
       @stashes = []
@@ -42,14 +44,13 @@ module Git
     def size
       @stashes.size
     end
-    
-    def each(&block)
-      @stashes.each(&block)
+
+    def each(&)
+      @stashes.each(&)
     end
-    
+
     def [](index)
       @stashes[index.to_i]
     end
-    
   end
 end