ruby-git-fw-new 1.3.3

data/lib/git/remote.rb

@@ -0,0 +1,36 @@
+module Git
+  class Remote < Path
+    
+    attr_accessor :name, :url, :fetch_opts
+    
+    def initialize(base, name)
+      @base = base
+      config = @base.lib.config_remote(name)
+      @name = name
+      @url = config['url']
+      @fetch_opts = config['fetch']
+    end
+    
+    def fetch(opts={})
+      @base.fetch(@name, opts)
+    end
+    
+    # merge this remote locally
+    def merge(branch = 'master')
+      @base.merge("#{@name}/#{branch}")
+    end
+    
+    def branch(branch = 'master')
+      Git::Branch.new(@base, "#{@name}/#{branch}")
+    end
+    
+    def remove
+      @base.lib.remote_remove(@name)     
+    end
+    
+    def to_s
+      @name
+    end
+    
+  end
+end

data/lib/git/repository.rb

@@ -0,0 +1,6 @@
+module Git
+
+  class Repository < Path
+  end
+
+end

data/lib/git/stash.rb

@@ -0,0 +1,27 @@
+module Git
+  class Stash
+    
+    def initialize(base, message, existing=false)
+      @base = base
+      @message = message
+      save unless existing
+    end
+    
+    def save
+      @saved = @base.lib.stash_save(@message)
+    end
+    
+    def saved?
+      @saved
+    end
+    
+    def message
+      @message
+    end
+    
+    def to_s
+      message
+    end
+    
+  end
+end

data/lib/git/stashes.rb

@@ -0,0 +1,44 @@
+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))
+      end
+    end
+    
+    def save(message)
+      s = Git::Stash.new(@base, message)
+      @stashes.unshift(s) if s.saved?
+    end
+    
+    def apply(index=nil)
+      @base.lib.stash_apply(index)
+    end
+    
+    def clear
+      @base.lib.stash_clear
+      @stashes = []
+    end
+
+    def size
+      @stashes.size
+    end
+    
+    def each(&block)
+      @stashes.each(&block)
+    end
+    
+    def [](index)
+      @stashes[index.to_i]
+    end
+    
+  end
+end

data/lib/git/status.rb

@@ -0,0 +1,117 @@
+module Git
+  
+  class Status
+    include Enumerable
+    
+    def initialize(base)
+      @base = base
+      construct_status
+    end
+    
+    def changed
+      @files.select { |k, f| f.type == 'M' }
+    end
+    
+    def added
+      @files.select { |k, f| f.type == 'A' }
+    end
+
+    def deleted
+      @files.select { |k, f| f.type == 'D' }
+    end
+    
+    def untracked
+      @files.select { |k, f| f.untracked }
+    end
+    
+    def pretty
+      out = ''
+      self.each do |file|
+        out << pretty_file(file)
+      end
+      out << "\n"
+      out
+    end
+
+    def pretty_file(file)
+      <<FILE
+#{file.path}
+\tsha(r) #{file.sha_repo.to_s} #{file.mode_repo.to_s}
+\tsha(i) #{file.sha_index.to_s} #{file.mode_index.to_s}
+\ttype   #{file.type.to_s}
+\tstage  #{file.stage.to_s}
+\tuntrac #{file.untracked.to_s}
+FILE
+    end
+    
+    # enumerable method
+    
+    def [](file)
+      @files[file]
+    end
+    
+    def each(&block)
+      @files.values.each(&block)
+    end
+    
+    class StatusFile
+      attr_accessor :path, :type, :stage, :untracked
+      attr_accessor :mode_index, :mode_repo
+      attr_accessor :sha_index, :sha_repo
+
+      def initialize(base, hash)
+        @base = base
+        @path = hash[:path]
+        @type = hash[:type]
+        @stage = hash[:stage]
+        @mode_index = hash[:mode_index]
+        @mode_repo = hash[:mode_repo]
+        @sha_index = hash[:sha_index]
+        @sha_repo = hash[:sha_repo]
+        @untracked = hash[:untracked]
+      end
+      
+      def blob(type = :index)
+        if type == :repo
+          @base.object(@sha_repo)
+        else
+          @base.object(@sha_index) rescue @base.object(@sha_repo)
+        end
+      end
+      
+      
+    end
+    
+    private
+    
+      def construct_status
+        @files = @base.lib.ls_files
+        ignore = @base.lib.ignored_files
+        
+        # find untracked in working dir
+        Dir.chdir(@base.dir.path) do
+          Dir.glob('**/*', File::FNM_DOTMATCH) do |file|
+            next if @files[file] || File.directory?(file) || ignore.include?(file) || file =~ /^.git\/.+/
+
+            @files[file] = {:path => file, :untracked => true}
+          end
+        end
+        
+        # find modified in tree
+        @base.lib.diff_files.each do |path, data|
+          @files[path] ? @files[path].merge!(data) : @files[path] = data
+        end
+        
+        # find added but not committed - new files
+        @base.lib.diff_index('HEAD').each do |path, data|
+          @files[path] ? @files[path].merge!(data) : @files[path] = data
+        end
+        
+        @files.each do |k, file_hash|
+          @files[k] = StatusFile.new(@base, file_hash)
+        end
+      end
+      
+  end
+  
+end

data/lib/git/version.rb

@@ -0,0 +1,7 @@
+module Git
+
+  # The current gem version
+  # @return [String] the current gem version.
+  VERSION='1.3.0'
+
+end

data/lib/git/working_directory.rb

@@ -0,0 +1,4 @@
+module Git
+  class WorkingDirectory < Git::Path
+  end
+end

data/lib/ruby-git-fw-new.rb

@@ -0,0 +1,166 @@
+# Add the directory containing this file to the start of the load path if it
+# isn't there already.
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'git/author'
+require 'git/base'
+require 'git/branch'
+require 'git/branches'
+require 'git/config'
+require 'git/diff'
+require 'git/index'
+require 'git/lib'
+require 'git/log'
+require 'git/object'
+require 'git/path'
+require 'git/remote'
+require 'git/repository'
+require 'git/status'
+require 'git/stash'
+require 'git/stashes'
+require 'git/working_directory'
+
+lib = Git::Lib.new(nil, nil)
+unless lib.meets_required_version?
+  $stderr.puts "[WARNING] The git gem requires git #{lib.required_command_version.join('.')} or later, but only found #{lib.current_command_version.join('.')}. You should probably upgrade."
+end
+
+# Git/Ruby Library
+#
+# This provides bindings for working with git in complex
+# interactions, including branching and merging, object
+# inspection and manipulation, history, patch generation
+# and more.  You should be able to do most fundamental git
+# operations with this library.
+#
+# This module provides the basic functions to open a git 
+# reference to work with. You can open a working directory,
+# open a bare repository, initialize a new repo or clone an
+# existing remote repository.
+#
+# Author::    Scott Chacon (mailto:schacon@gmail.com)
+# License::   MIT License
+module Git
+  
+  #g.config('user.name', 'Scott Chacon') # sets value
+  #g.config('user.email', 'email@email.com')  # sets value
+  #g.config('user.name')  # returns 'Scott Chacon'
+  #g.config # returns whole config hash
+  def config(name = nil, value = nil)
+    lib = Git::Lib.new
+    if(name && value)
+      # set value
+      lib.config_set(name, value)
+    elsif (name)
+      # return value
+      lib.config_get(name)
+    else
+      # return hash
+      lib.config_list
+    end
+  end
+
+  def self.configure
+    yield Base.config
+  end
+
+  def self.config
+    return Base.config
+  end
+
+  def global_config(name = nil, value = nil)
+    self.class.global_config(name, value)
+  end
+
+  # open a bare repository
+  #
+  # this takes the path to a bare git repo
+  # it expects not to be able to use a working directory
+  # so you can't checkout stuff, commit things, etc.
+  # but you can do most read operations
+  def self.bare(git_dir, options = {})
+    Base.bare(git_dir, options)
+  end
+    
+  # clones a remote repository
+  #
+  # options
+  #   :bare => true (does a bare clone)
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  #
+  # example
+  #  Git.clone('git://repo.or.cz/rubygit.git', 'clone.git', :bare => true)
+  #
+  def self.clone(repository, name, options = {})
+    Base.clone(repository, name, options)
+  end
+
+  # Export the current HEAD (or a branch, if <tt>options[:branch]</tt>
+  # is specified) into the +name+ directory, then remove all traces of git from the
+  # directory.
+  #
+  # See +clone+ for options.  Does not obey the <tt>:remote</tt> option,
+  # since the .git info will be deleted anyway; always uses the default
+  # remote, 'origin.'
+  def self.export(repository, name, options = {})
+    options.delete(:remote)
+    repo = clone(repository, name, {:depth => 1}.merge(options))
+    repo.checkout("origin/#{options[:branch]}") if options[:branch]
+    Dir.chdir(repo.dir.to_s) { FileUtils.rm_r '.git' }
+  end
+  
+  # Same as g.config, but forces it to be at the global level
+  #
+  #g.config('user.name', 'Scott Chacon') # sets value
+  #g.config('user.email', 'email@email.com')  # sets value
+  #g.config('user.name')  # returns 'Scott Chacon'
+  #g.config # returns whole config hash
+  def self.global_config(name = nil, value = nil)
+    lib = Git::Lib.new(nil, nil)
+    if(name && value)
+      # set value
+      lib.global_config_set(name, value)
+    elsif (name)
+      # return value
+      lib.global_config_get(name)
+    else
+      # return hash
+      lib.global_config_list
+    end
+  end
+
+  # initialize a new git repository, defaults to the current working directory
+  #
+  # options
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  def self.init(working_dir = '.', options = {})
+    Base.init(working_dir, options)
+  end
+    
+  # returns a Hash containing information about the references 
+  # of the target repository
+  #
+  # @param [String|NilClass] location the target repository location or nil for '.'
+  # @return [{String=>Hash}] the available references of the target repo.
+  def self.ls_remote(location=nil)
+    Git::Lib.new.ls_remote(location)
+  end
+
+  # open an existing git working directory
+  # 
+  # this will most likely be the most common way to create
+  # a git reference, referring to a working directory.
+  # if not provided in the options, the library will assume
+  # your git_dir and index are in the default place (.git/, .git/index)
+  #
+  # options
+  #   :repository => '/path/to/alt_git_dir'
+  #   :index => '/path/to/alt_index_file'
+  def self.open(working_dir, options = {})
+    Base.open(working_dir, options)
+  end
+    
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: ruby-git-fw-new
+version: !ruby/object:Gem::Version
+  version: 1.3.3
+platform: ruby
+authors:
+- Scott Chacon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: 
+email: schacon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG
+- LICENSE
+- README.md
+- VERSION
+- lib/git/author.rb
+- lib/git/base.rb
+- lib/git/base/factory.rb
+- lib/git/branch.rb
+- lib/git/branches.rb
+- lib/git/config.rb
+- lib/git/diff.rb
+- lib/git/index.rb
+- lib/git/lib.rb
+- lib/git/log.rb
+- lib/git/object.rb
+- lib/git/path.rb
+- lib/git/remote.rb
+- lib/git/repository.rb
+- lib/git/stash.rb
+- lib/git/stashes.rb
+- lib/git/status.rb
+- lib/git/version.rb
+- lib/git/working_directory.rb
+- lib/ruby-git-fw-new.rb
+homepage: http://github.com/schacon/ruby-git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- git 1.6.0.0, or greater
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Ruby/Git is a Ruby library that can be used to create, read and manipulate
+  Git repositories by wrapping system calls to the git binary.
+test_files: []
+has_rdoc: