minad-git 1.1.1 → 1.1.2

data/lib/git/base.rb

@@ -4,13 +4,13 @@ module Git
 
     # opens a bare Git Repository - no working directory options
     def self.bare(git_dir, opts = {})
-      self.new({:repository => git_dir}.merge(opts))
+      new({:repository => git_dir}.merge(opts))
     end
 
     # opens a new Git Project from a working directory
     # you can specify non-standard git_dir and index file in the options
     def self.open(working_dir, opts={})
-      self.new({:working_directory => working_dir}.merge(opts))
+      new({:working_directory => working_dir}.merge(opts))
     end
 
     # initializes a git repository
@@ -30,7 +30,7 @@ module Git
       # run git_init there
       Git::Lib.new(opts).init
 
-      self.new(opts)
+      new(opts)
     end
 
     # clones a git repository locally
@@ -48,7 +48,7 @@ module Git
     #
     def self.clone(repository, name, opts = {})
       # run git-clone
-      self.new(Git::Lib.new.clone(repository, name, opts))
+      new(Git::Lib.new.clone(repository, name, opts))
     end
 
     def initialize(options = {})
@@ -187,19 +187,19 @@ module Git
 
     # returns +true+ if the branch exists locally
     def is_local_branch?(branch)
-      branch_names = self.branches.local.map {|b| b.name}
+      branch_names = branches.local.map {|b| b.name}
       branch_names.include?(branch)
     end
 
     # returns +true+ if the branch exists remotely
     def is_remote_branch?(branch)
-      branch_names = self.branches.local.map {|b| b.name}
+      branch_names = branches.local.map {|b| b.name}
       branch_names.include?(branch)
     end
 
     # returns +true+ if the branch exists
     def is_branch?(branch)
-      branch_names = self.branches.map {|b| b.name}
+      branch_names = branches.map {|b| b.name}
       branch_names.include?(branch)
     end
 
@@ -235,7 +235,7 @@ module Git
     #     end
     #   end
     def grep(string, path_limiter = nil, opts = {})
-      self.object('HEAD').grep(string, path_limiter, opts)
+      object('HEAD').grep(string, path_limiter, opts)
     end
 
     # returns a Git::Diff object
@@ -245,23 +245,23 @@ module Git
 
     # adds files from the working directory to the git repository
     def add(path = '.')
-      self.lib.add(path)
+      lib.add(path)
     end
 
     # removes file(s) from the git repository
     def remove(path = '.', opts = {})
-      self.lib.remove(path, opts)
+      lib.remove(path, opts)
     end
 
     # resets the working directory to the provided commitish
     def reset(commitish = nil, opts = {})
-      self.lib.reset(commitish, opts)
+      lib.reset(commitish, opts)
     end
 
     # resets the working directory to the commitish with '--hard'
     def reset_hard(commitish = nil, opts = {})
       opts = {:hard => true}.merge(opts)
-      self.lib.reset(commitish, opts)
+      lib.reset(commitish, opts)
     end
 
     # commits all pending changes in the index file to the git repository
@@ -271,7 +271,7 @@ module Git
     #   :allow_empty
     #   :author
     def commit(message, opts = {})
-      self.lib.commit(message, opts)
+      lib.commit(message, opts)
     end
 
     # commits all pending changes in the index file to the git repository,
@@ -279,23 +279,23 @@ module Git
     # calling @git.add() on them.
     def commit_all(message, opts = {})
       opts = {:add_all => true}.merge(opts)
-      self.lib.commit(message, opts)
+      lib.commit(message, opts)
     end
 
     # checks out a branch as the new git working directory
     def checkout(branch = 'master', opts = {})
-      self.lib.checkout(branch, opts)
+      lib.checkout(branch, opts)
     end
 
     # checks out an old version of a file
     def checkout_file(version, file)
-      self.lib.checkout_file(version,file)
+      lib.checkout_file(version,file)
     end
 
     # fetches changes from a remote branch - this does not modify the working directory,
     # it just gets the changes from the remote if there are any
     def fetch(remote = 'origin')
-      self.lib.fetch(remote)
+      lib.fetch(remote)
     end
 
     # pushes changes to a remote repository - easiest if this is a cloned repository,
@@ -304,19 +304,19 @@ module Git
     #  @git.config('remote.remote-name.push', 'refs/heads/master:refs/heads/master')
     #
     def push(remote = 'origin', branch = 'master', tags = false)
-      self.lib.push(remote, branch, tags)
+      lib.push(remote, branch, tags)
     end
 
     # merges one or more branches into the current working branch
     #
     # you can specify more than one branch to merge by passing an array of branches
     def merge(branch, message = 'merge')
-      self.lib.merge(branch, message)
+      lib.merge(branch, message)
     end
 
     # iterates over the files which are unmerged
     def each_conflict(&block) # :yields: file, your_version, their_version
-      self.lib.conflicts(&block)
+      lib.conflicts(&block)
     end
 
     # fetches a branch from a remote and merges it into the current working branch
@@ -327,7 +327,7 @@ module Git
 
     # returns an array of Git:Remote objects
     def remotes
-      self.lib.remotes.map { |r| Git::Remote.new(self, r) }
+      lib.remotes.map { |r| Git::Remote.new(self, r) }
     end
 
     # adds a new remote to this repository
@@ -339,13 +339,13 @@ module Git
     #
     def add_remote(name, url, opts = {})
       url = url.repo.path if url.is_a?(Git::Base)
-      self.lib.remote_add(name, url, opts)
+      lib.remote_add(name, url, opts)
       Git::Remote.new(self, name)
     end
 
     # returns an array of all Git::Tag objects for this repository
     def tags
-      self.lib.tags.map { |r| tag(r) }
+      lib.tags.map { |r| tag(r) }
     end
 
     # returns a Git::Tag object
@@ -355,32 +355,32 @@ module Git
 
     # creates a new git tag (Git::Tag)
     def add_tag(tag_name)
-      self.lib.tag(tag_name)
+      lib.tag(tag_name)
       tag(tag_name)
     end
 
     # creates an archive file of the given tree-ish
     def archive(treeish, file = nil, opts = {})
-      self.object(treeish).archive(file, opts)
+      object(treeish).archive(file, opts)
     end
 
     # repacks the repository
     def repack
-      self.lib.repack
+      lib.repack
     end
 
     def gc
-      self.lib.gc
+      lib.gc
     end
 
     def apply(file)
       if File.exists?(file)
-        self.lib.apply(file)
+        lib.apply(file)
       end
     end
 
     def apply_mail(file)
-      self.lib.apply_mail(file) if File.exists?(file)
+      lib.apply_mail(file) if File.exists?(file)
     end
 
     ## LOWER LEVEL INDEX OPERATIONS ##
@@ -388,9 +388,9 @@ module Git
     def with_index(new_index) # :yields: new_index
       old_index = @index
       set_index(new_index, false)
-      return_value = yield @index
+      result = yield @index
       set_index(old_index)
-      return_value
+      result
     end
 
     def with_temp_index &blk
@@ -401,19 +401,19 @@ module Git
     end
 
     def checkout_index(opts = {})
-      self.lib.checkout_index(opts)
+      lib.checkout_index(opts)
     end
 
     def read_tree(treeish, opts = {})
-      self.lib.read_tree(treeish, opts)
+      lib.read_tree(treeish, opts)
     end
 
     def write_tree
-      self.lib.write_tree
+      lib.write_tree
     end
 
     def commit_tree(tree = nil, opts = {})
-      Git::Object::Commit.new(self, self.lib.commit_tree(tree, opts))
+      Git::Object::Commit.new(self, lib.commit_tree(tree, opts))
     end
 
     def write_and_commit_tree(opts = {})
@@ -427,18 +427,18 @@ module Git
 
 
     def ls_files
-      self.lib.ls_files
+      lib.ls_files
     end
 
     def with_working(work_dir) # :yields: the working directory
-      return_value = false
+      result = false
       old_working = @working_directory
       set_working(work_dir)
       Dir.chdir work_dir do
-        return_value = yield @working_directory
+        result = yield @working_directory
       end
       set_working(old_working)
-      return_value
+      result
     end
 
     def with_temp_working &blk
@@ -457,20 +457,20 @@ module Git
     #   @git.revparse('v2.4:/doc/index.html')
     #
     def revparse(objectish)
-      self.lib.revparse(objectish)
+      lib.revparse(objectish)
     end
 
     def ls_tree(objectish)
-      self.lib.ls_tree(objectish)
+      lib.ls_tree(objectish)
     end
 
     def cat_file(objectish)
-      self.lib.object_contents(objectish)
+      lib.object_contents(objectish)
     end
 
     # returns the name of the branch the working directory is currently on
     def current_branch
-      self.lib.branch_current
+      lib.branch_current
     end
 
 

data/lib/git/diff.rb

@@ -18,7 +18,7 @@ module Git
 
     def path(path)
       @path = path
-      return self
+      self
     end
 
     def size

data/lib/git/lib.rb

@@ -45,16 +45,14 @@ module Git
       @path = opts[:path] || '.'
       clone_dir = opts[:path] ? File.join(@path, name) : name
 
-      arr_opts = []
-      arr_opts << "--bare" if opts[:bare]
-      arr_opts << "-o" << opts[:remote] if opts[:remote]
-      arr_opts << "--depth" << opts[:depth].to_i if opts[:depth] && opts[:depth].to_i > 0
+      args = []
+      args << "--bare" if opts[:bare]
+      args << "-o" << opts[:remote] if opts[:remote]
+      args << "--depth" << opts[:depth].to_i if opts[:depth] && opts[:depth].to_i > 0
 
-      arr_opts << '--'
-      arr_opts << repository
-      arr_opts << clone_dir
+      args << '--' << repository << clone_dir
 
-      command('clone', arr_opts)
+      command('clone', args)
 
       opts[:bare] ? {:repository => clone_dir} : {:working_directory => clone_dir}
     end
@@ -64,32 +62,32 @@ module Git
 
 
     def log_commits(opts = {})
-      arr_opts = ['--pretty=oneline']
-      arr_opts << "-#{opts[:count]}" if opts[:count]
-      arr_opts << "--since=#{opts[:since]}" if opts[:since].is_a? String
-      arr_opts << "--until=#{opts[:until]}" if opts[:until].is_a? String
-      arr_opts << "--grep=#{opts[:grep]}" if opts[:grep].is_a? String
-      arr_opts << "--author=#{opts[:author]}" if opts[:author].is_a? String
-      arr_opts << "#{opts[:between][0].to_s}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
-      arr_opts << opts[:object] if opts[:object].is_a? String
-      arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+      args = ['--pretty=oneline']
+      args << "-#{opts[:count]}" if opts[:count]
+      args << "--since=#{opts[:since]}" if opts[:since].is_a? String
+      args << "--until=#{opts[:until]}" if opts[:until].is_a? String
+      args << "--grep=#{opts[:grep]}" if opts[:grep].is_a? String
+      args << "--author=#{opts[:author]}" if opts[:author].is_a? String
+      args << "#{opts[:between][0].to_s}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
+      args << opts[:object] if opts[:object].is_a? String
+      args << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
 
-      command_lines('log', arr_opts, true).map { |l| l.split.first }
+      command_lines('log', args, true).map { |l| l.split.first }
     end
 
     def full_log_commits(opts = {})
-      arr_opts = ['--pretty=raw']
-      arr_opts << "-#{opts[:count]}" if opts[:count]
-      arr_opts << "--skip=#{opts[:skip]}" if opts[:skip]
-      arr_opts << "--since=#{opts[:since]}" if opts[:since].is_a? String
-      arr_opts << "--until=#{opts[:until]}" if opts[:until].is_a? String
-      arr_opts << "--grep=#{opts[:grep]}" if opts[:grep].is_a? String
-      arr_opts << "--author=#{opts[:author]}" if opts[:author].is_a? String
-      arr_opts << "#{opts[:between][0].to_s}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
-      arr_opts << opts[:object] if opts[:object].is_a? String
-      arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
-
-      full_log = command_lines('log', arr_opts, true)
+      args = ['--pretty=raw']
+      args << "-#{opts[:count]}" if opts[:count]
+      args << "--skip=#{opts[:skip]}" if opts[:skip]
+      args << "--since=#{opts[:since]}" if opts[:since].is_a? String
+      args << "--until=#{opts[:until]}" if opts[:until].is_a? String
+      args << "--grep=#{opts[:grep]}" if opts[:grep].is_a? String
+      args << "--author=#{opts[:author]}" if opts[:author].is_a? String
+      args << "#{opts[:between][0].to_s}..#{opts[:between][1].to_s}" if (opts[:between] && opts[:between].size == 2)
+      args << opts[:object] if opts[:object].is_a? String
+      args << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+
+      full_log = command_lines('log', args, true)
       process_commit_data(full_log)
     end
 
@@ -298,11 +296,15 @@ module Git
       command_lines('ls-files', '--stage').each do |line|
         (info, file) = line.split("\t")
         (mode, sha, stage) = info.split
+        file = eval(file) if file =~ /^\".*\"$/ # This takes care of quoted strings returned from git
         hsh[file] = {:path => file, :mode_index => mode, :sha_index => sha, :stage => stage}
       end
       hsh
     end
 
+    def ignored_files
+      command_lines('ls-files', ['--others', '-i', '--exclude-standard'])
+    end
 
     def config_remote(name)
       hsh = {}
@@ -357,41 +359,41 @@ module Git
     end
 
     def add(path = '.')
-      arr_opts = ['--']
+      args = ['--']
       if path.is_a?(Array)
-        arr_opts += path
+        args += path
       else
-        arr_opts << path
+        args << path
       end
-      command('add', arr_opts)
+      command('add', args)
     end
 
     def remove(path = '.', opts = {})
-      arr_opts = ['-f']  # overrides the up-to-date check by default
-      arr_opts << ['-r'] if opts[:recursive]
-      arr_opts << '--'
+      args = ['-f']  # overrides the up-to-date check by default
+      args << '-r' if opts[:recursive]
+      args << '--'
       if path.is_a?(Array)
-        arr_opts += path
+        args += path
       else
-        arr_opts << path
+        args << path
       end
 
-      command('rm', arr_opts)
+      command('rm', args)
     end
 
     def commit(message, opts = {})
-      arr_opts = ['-m', message]
-      arr_opts << '-a' if opts[:add_all]
-      arr_opts << '--allow-empty' if opts[:allow_empty]
-      arr_opts << "--author" << opts[:author] if opts[:author]
-      command('commit', arr_opts)
+      args = ['-m', message]
+      args << '-a' if opts[:add_all]
+      args << '--allow-empty' if opts[:allow_empty]
+      args << "--author" << opts[:author] if opts[:author]
+      command('commit', args)
     end
 
     def reset(commit, opts = {})
-      arr_opts = []
-      arr_opts << '--hard' if opts[:hard]
-      arr_opts << commit if commit
-      command('reset', arr_opts)
+      args = []
+      args << '--hard' if opts[:hard]
+      args << commit if commit
+      command('reset', args)
     end
 
     def revert(commit)
@@ -399,15 +401,15 @@ module Git
     end
 
     def apply(patch_file)
-      arr_opts = []
-      arr_opts << '--' << patch_file if patch_file
-      command('apply', arr_opts)
+      args = []
+      args << '--' << patch_file if patch_file
+      command('apply', args)
     end
 
     def apply_mail(patch_file)
-      arr_opts = []
-      arr_opts << '--' << patch_file if patch_file
-      command('am', arr_opts)
+      args = []
+      args << '--' << patch_file if patch_file
+      command('am', args)
     end
 
     def stashes_all
@@ -452,26 +454,23 @@ module Git
     end
 
     def checkout(branch, opts = {})
-      arr_opts = []
-      arr_opts << '-f' if opts[:force]
-      arr_opts << '-b' << opts[:new_branch] if opts[:new_branch]
-      arr_opts << branch
+      args = []
+      args << '-f' if opts[:force]
+      args << '-b' << opts[:new_branch] if opts[:new_branch]
+      args << branch
 
-      command('checkout', arr_opts)
+      command('checkout', args)
     end
 
     def checkout_file(version, file)
-      arr_opts = []
-      arr_opts << version
-      arr_opts << file
-      command('checkout', arr_opts)
+      command('checkout', [version, '--', file])
     end
 
     def merge(branch, message = nil)
-      arr_opts = []
-      arr_opts << '-m' << message if message
-      arr_opts += [branch]
-      command('merge', arr_opts)
+      args = []
+      args << '-m' << message if message
+      args += [branch]
+      command('merge', args)
     end
 
     def unmerged
@@ -494,13 +493,11 @@ module Git
     end
 
     def remote_add(name, url, opts = {})
-      arr_opts = ['add']
-      arr_opts << '-f' if opts[:with_fetch]
-      arr_opts << '--'
-      arr_opts << name
-      arr_opts << url
+      args = ['add']
+      args << '-f' if opts[:with_fetch]
+      args << '--' << name << url
 
-      command('remote', arr_opts)
+      command('remote', args)
     end
 
     # this is documented as such, but seems broken for some reason
@@ -548,10 +545,10 @@ module Git
 
     # reads a tree into the current index file
     def read_tree(treeish, opts = {})
-      arr_opts = []
-      arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
-      arr_opts += [treeish]
-      command('read-tree', arr_opts)
+      args = []
+      args << "--prefix=#{opts[:prefix]}" if opts[:prefix]
+      args += [treeish]
+      command('read-tree', args)
     end
 
     def write_tree
@@ -564,11 +561,10 @@ module Git
       t.write(opts[:message])
       t.close
 
-      arr_opts = []
-      arr_opts << tree
-      arr_opts << '-p' << opts[:parent] if opts[:parent]
-      arr_opts += [opts[:parents]].map { |p| ['-p', p] }.flatten if opts[:parents]
-      command('commit-tree', arr_opts, true, "< #{escape t.path}")
+      args = [tree]
+      args << '-p' << opts[:parent] if opts[:parent]
+      args += [opts[:parents]].map { |p| ['-p', p] }.flatten if opts[:parents]
+      command('commit-tree', args, true, "< #{escape t.path}")
     end
 
     def update_ref(branch, commit)
@@ -576,13 +572,13 @@ module Git
     end
 
     def checkout_index(opts = {})
-      arr_opts = []
-      arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
-      arr_opts << "--force" if opts[:force]
-      arr_opts << "--all" if opts[:all]
-      arr_opts << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
+      args = []
+      args << "--prefix=#{opts[:prefix]}" if opts[:prefix]
+      args << "--force" if opts[:force]
+      args << "--all" if opts[:all]
+      args << '--' << opts[:path_limiter] if opts[:path_limiter].is_a? String
 
-      command('checkout-index', arr_opts)
+      command('checkout-index', args)
     end
 
     # creates an archive file
@@ -602,13 +598,13 @@ module Git
 
       file ||= Tempfile.new('archive').path
 
-      arr_opts = []
-      arr_opts << "--format=#{opts[:format]}" if opts[:format]
-      arr_opts << "--prefix=#{opts[:prefix]}" if opts[:prefix]
-      arr_opts << "--remote=#{opts[:remote]}" if opts[:remote]
-      arr_opts << sha
-      arr_opts << '--' << opts[:path] if opts[:path]
-      command('archive', arr_opts, true, (opts[:add_gzip] ? '| gzip' : '') + " > #{escape file}")
+      args = []
+      args << "--format=#{opts[:format]}" if opts[:format]
+      args << "--prefix=#{opts[:prefix]}" if opts[:prefix]
+      args << "--remote=#{opts[:remote]}" if opts[:remote]
+      args << sha
+      args << '--' << opts[:path] if opts[:path]
+      command('archive', args, true, (opts[:add_gzip] ? '| gzip' : '') + " > #{escape file}")
       return file
     end
 
@@ -618,14 +614,14 @@ module Git
       command(cmd, opts, chdir).split("\n")
     end
 
-    def command(cmd, opts = [], chdir = true, redirect = '', &block)
+    def command(cmd, args = [], chdir = true, redirect = '', &block)
       ENV['GIT_DIR'] = @git_dir
       ENV['GIT_INDEX_FILE'] = @git_index_file
       ENV['GIT_WORK_TREE'] = @git_work_dir
       path = @git_work_dir || @git_dir || @path
 
-      opts = [opts].flatten.map {|s| escape(s) }.join(' ')
-      git_cmd = "git #{cmd} #{opts} #{redirect} 2>&1"
+      args = [args].flatten.map {|s| escape(s) }.join(' ')
+      git_cmd = "git #{cmd} #{args} #{redirect} 2>&1"
 
       out = nil
       if chdir && (Dir.getwd != path)

data/lib/git/log.rb

@@ -23,49 +23,49 @@ module Git
     def object(objectish)
       dirty_log
       @object = objectish
-      return self
+      self
     end
 
     def author(regex)
       dirty_log
       @author = regex
-      return self
+      self
     end
 
     def grep(regex)
       dirty_log
       @grep = regex
-      return self
+      self
     end
 
     def path(path)
       dirty_log
       @path = path
-      return self
+      self
     end
 
     def skip(num)
       dirty_log
       @skip = num
-      return self
+      self
     end
 
     def since(date)
       dirty_log
       @since = date
-      return self
+      self
     end
 
     def until(date)
       dirty_log
       @until = date
-      return self
+      self
     end
 
     def between(sha1, sha2 = nil)
       dirty_log
       @between = [sha1, sha2]
-      return self
+      self
     end
 
     def to_s

data/lib/git/status.rb

@@ -82,10 +82,12 @@ module Git
       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('**/*') do |file|
-            @files[file] = {:path => file, :untracked => true} unless @files[file] || File.directory?(file)
+            @files[file] = {:path => file, :untracked => true} unless @files[file] || File.directory?(file) || ignore.include?(file)
           end
         end
 

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: minad-git
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors: 
 - Scott Chacon
-autorequire: git
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-02-13 00:00:00 -08:00
+date: 2009-04-08 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -39,7 +39,7 @@ files:
 - lib/git.rb
 - README
 has_rdoc: true
-homepage: 
+homepage: http://github.com/schacon/ruby-git/tree/master
 post_install_message: 
 rdoc_options: []