square-circle-triangle-grit 1.1.2

data/lib/grit/repo.rb

@@ -0,0 +1,562 @@
+module Grit
+
+  class RemoteError < StandardError
+  end
+
+  class RemoteNonexistentError < StandardError
+  end
+
+  class BranchNonexistentError < StandardError
+  end
+
+  class RemoteBranchExistsError < StandardError
+  end
+
+  class RemoteUninitializedError < StandardError
+  end
+
+  class Repo
+    DAEMON_EXPORT_FILE = 'git-daemon-export-ok'
+
+    # The path of the git repo as a String
+    attr_accessor :path
+    attr_accessor :working_dir
+    attr_reader :bare
+
+    # The git command line interface object
+    attr_accessor :git
+
+    # Create a new Repo instance
+    #   +path+ is the path to either the root git directory or the bare git repo
+    #   +options+ :is_bare force to load a bare repo
+    #
+    # Examples
+    #   g = Repo.new("/Users/tom/dev/grit")
+    #   g = Repo.new("/Users/tom/public/grit.git")
+    #
+    # Returns Grit::Repo
+    def initialize(path, options = {})
+      epath = File.expand_path(path)
+
+      if File.exist?(File.join(epath, '.git'))
+        self.working_dir = epath
+        self.path = File.join(epath, '.git')
+        @bare = false
+      elsif File.exist?(epath) && (epath =~ /\.git$/ || options[:is_bare])
+        self.path = epath
+        @bare = true
+      elsif File.exist?(epath)
+        raise InvalidGitRepositoryError.new(epath)
+      else
+        raise NoSuchPathError.new(epath)
+      end
+
+      self.git = Git.new(self.path, self.working_dir)
+    end
+
+    def self.init(path, options = {})
+      epath = File.expand_path(path)
+
+      if epath =~ /\.git$/ || options[:is_bare]
+        path = epath
+        working_dir = nil
+      else
+        path = File.join(epath, '.git')
+        working_dir = epath
+      end
+
+      git = Git.new(path, working_dir)
+
+      git.init
+
+      Repo.new(path)
+    end
+
+    def self.clone(remote_repo, path, options = {})
+      epath = File.expand_path(path)
+
+      if epath =~ /\.git$/ || options[:is_bare]
+        git_options = { :bare => true }
+      else
+        git_options = {}
+      end
+
+      git = Git.new(nil)
+      git.clone(git_options, remote_repo, epath)
+
+      Repo.new(path)
+    end
+
+    # The project's description. Taken verbatim from GIT_REPO/description
+    #
+    # Returns String
+    def description
+      File.open(File.join(self.path, 'description')).read.chomp
+    end
+
+    def blame(file, commit = nil)
+      Blame.new(self, file, commit)
+    end
+
+
+    # An array of Head objects representing the branch heads in
+    # this repo
+    #
+    # Returns Grit::Head[] (baked)
+    def heads
+      Head.find_all(self)
+    end
+
+    alias_method :branches, :heads
+
+    def get_head(head_name)
+      heads.find { |h| h.name == head_name }
+    end
+
+    def is_head?(head_name)
+      get_head(head_name)
+    end
+
+    # Object reprsenting the current repo head.
+    #
+    # Returns Grit::Head (baked)
+    def head
+      Head.current(self)
+    end
+
+
+    # Commits current index
+    #
+    # Returns true/false if commit worked
+    def commit_index(message)
+      self.git.commit({}, '-m', message)
+    end
+
+    # Commits all tracked and modified files
+    #
+    # Returns true/false if commit worked
+    def commit_all(message)
+      self.git.commit({}, '-a', '-m', message)
+    end
+
+    # Adds files to the index
+    def add(*files)
+      self.git.add({}, *files.flatten)
+    end
+
+    # Remove files from the index
+    def rm(*files)
+      self.git.rm({}, *files.flatten)
+    end
+
+    alias :remove :rm
+
+    def rm_r(*files)
+      self.git.rm({}, '-r', *files.flatten)
+    end
+
+    alias :remove_recursively :rm_r
+
+    def mv(source, destination)
+      self.git.mv({}, source, destination)
+    end
+
+    alias :move :mv
+    
+    def checkout_path_commit(commit, path)
+      self.git.checkout({}, commit, '--', path)
+    end
+    
+    def revert(commit)
+      self.git.revert({}, commit)
+    end
+
+
+    def blame_tree(commit, path = nil)
+      commit_array = self.git.blame_tree(commit, path)
+
+      final_array = {}
+      commit_array.each do |file, sha|
+        final_array[file] = commit(sha)
+      end
+      final_array
+    end
+
+    def status
+      Status.new(self)
+    end
+
+
+    # An array of Tag objects that are available in this repo
+    #
+    # Returns Grit::Tag[] (baked)
+    def tags
+      Tag.find_all(self)
+    end
+
+    # An array of Remote objects representing the remote branches in
+    # this repo
+    #
+    # Returns Grit::Remote[] (baked)
+    def remotes
+      Remote.find_all(self)
+    end
+
+    # An array of Ref objects representing the refs in
+    # this repo
+    #
+    # Returns Grit::Ref[] (baked)
+    def refs
+      [ Head.find_all(self), Tag.find_all(self), Remote.find_all(self) ].flatten
+    end
+
+    def commit_stats(start = 'master', max_count = 10, skip = 0)
+      options = {:max_count => max_count,
+                 :skip => skip}
+
+      CommitStats.find_all(self, start, options)
+    end
+
+    # An array of Commit objects representing the history of a given ref/commit
+    #   +start+ is the branch/commit name (default 'master')
+    #   +max_count+ is the maximum number of commits to return (default 10, use +false+ for all)
+    #   +skip+ is the number of commits to skip (default 0)
+    #
+    # Returns Grit::Commit[] (baked)
+    def commits(start = 'master', max_count = 10, skip = 0)
+      options = {:max_count => max_count,
+                 :skip => skip}
+
+      Commit.find_all(self, start, options)
+    end
+
+    # The Commits objects that are reachable via +to+ but not via +from+
+    # Commits are returned in chronological order.
+    #   +from+ is the branch/commit name of the younger item
+    #   +to+ is the branch/commit name of the older item
+    #
+    # Returns Grit::Commit[] (baked)
+    def commits_between(from, to)
+      result = Commit.find_all(self, "#{from}..#{to}").reverse
+      remote_error
+      result
+    end
+
+    # The Commits objects that are newer than the specified date.
+    # Commits are returned in chronological order.
+    #   +start+ is the branch/commit name (default 'master')
+    #   +since+ is a string represeting a date/time
+    #   +extra_options+ is a hash of extra options
+    #
+    # Returns Grit::Commit[] (baked)
+    def commits_since(start = 'master', since = '1970-01-01', extra_options = {})
+      options = {:since => since}.merge(extra_options)
+
+      Commit.find_all(self, start, options)
+    end
+
+    # The number of commits reachable by the given branch/commit
+    #   +start+ is the branch/commit name (default 'master')
+    #
+    # Returns Integer
+    def commit_count(start = 'master')
+      Commit.count(self, start)
+    end
+
+    # The Commit object for the specified id
+    #   +id+ is the SHA1 identifier of the commit
+    #
+    # Returns Grit::Commit (baked)
+    def commit(id)
+      options = {:max_count => 1}
+
+      Commit.find_all(self, id, options).first
+    end
+
+    # Returns a list of commits that is in +other_repo+ but not in self
+    #
+    # Returns Grit::Commit[]
+    def commit_deltas_from(other_repo, ref = "master", other_ref = "master")
+      # TODO: we should be able to figure out the branch point, rather than
+      # rev-list'ing the whole thing
+      repo_refs       = self.git.rev_list({}, ref).strip.split("\n")
+      other_repo_refs = other_repo.git.rev_list({}, other_ref).strip.split("\n")
+
+      (other_repo_refs - repo_refs).map do |ref|
+        Commit.find_all(other_repo, ref, {:max_count => 1}).first
+      end
+    end
+
+    # The Tree object for the given treeish reference
+    #   +treeish+ is the reference (default 'master')
+    #   +paths+ is an optional Array of directory paths to restrict the tree (deafult [])
+    #
+    # Examples
+    #   repo.tree('master', ['lib/'])
+    #
+    # Returns Grit::Tree (baked)
+    def tree(treeish = 'master', paths = [])
+      Tree.construct(self, treeish, paths)
+    end
+
+    # The Blob object for the given id
+    #   +id+ is the SHA1 id of the blob
+    #
+    # Returns Grit::Blob (unbaked)
+    def blob(id)
+      Blob.create(self, :id => id)
+    end
+
+    # The commit log for a treeish
+    #
+    # Returns Grit::Commit[]
+    def log(commit = 'master', path = nil, options = {})
+      default_options = {:pretty => "raw"}
+      actual_options  = default_options.merge(options)
+      arg = path ? [commit, '--', path] : [commit]
+      commits = self.git.log(actual_options, *arg)
+      Commit.list_from_string(self, commits)
+    end
+
+    # The diff from commit +a+ to commit +b+, optionally restricted to the given file(s)
+    #   +a+ is the base commit
+    #   +b+ is the other commit
+    #   +paths+ is an optional list of file paths on which to restrict the diff
+    def diff(a, b, *paths)
+      self.git.diff({}, a, b, '--', *paths)
+    end
+
+    # The commit diff for the given commit
+    #   +commit+ is the commit name/id
+    #
+    # Returns Grit::Diff[]
+    def commit_diff(commit)
+      Commit.diff(self, commit)
+    end
+
+    # Initialize a bare git repository at the given path
+    #   +path+ is the full path to the repo (traditionally ends with /<name>.git)
+    #   +options+ is any additional options to the git init command
+    #
+    # Examples
+    #   Grit::Repo.init_bare('/var/git/myrepo.git')
+    #
+    # Returns Grit::Repo (the newly created repo)
+    def self.init_bare(path, git_options = {}, repo_options = {})
+      git = Git.new(path)
+      git.init(git_options)
+      self.new(path, repo_options)
+    end
+
+    # Fork a bare git repository from this repo
+    #   +path+ is the full path of the new repo (traditionally ends with /<name>.git)
+    #   +options+ is any additional options to the git clone command (:bare and :shared are true by default)
+    #
+    # Returns Grit::Repo (the newly forked repo)
+    def fork_bare(path, options = {})
+      default_options = {:bare => true, :shared => true}
+      real_options = default_options.merge(options)
+      self.git.clone(real_options, self.path, path)
+      Repo.new(path)
+    end
+
+    # Archive the given treeish
+    #   +treeish+ is the treeish name/id (default 'master')
+    #   +prefix+ is the optional prefix
+    #
+    # Examples
+    #   repo.archive_tar
+    #   # => <String containing tar archive>
+    #
+    #   repo.archive_tar('a87ff14')
+    #   # => <String containing tar archive for commit a87ff14>
+    #
+    #   repo.archive_tar('master', 'myproject/')
+    #   # => <String containing tar archive and prefixed with 'myproject/'>
+    #
+    # Returns String (containing tar archive)
+    def archive_tar(treeish = 'master', prefix = nil)
+      options = {}
+      options[:prefix] = prefix if prefix
+      self.git.archive(options, treeish)
+    end
+
+    # Archive and gzip the given treeish
+    #   +treeish+ is the treeish name/id (default 'master')
+    #   +prefix+ is the optional prefix
+    #
+    # Examples
+    #   repo.archive_tar_gz
+    #   # => <String containing tar.gz archive>
+    #
+    #   repo.archive_tar_gz('a87ff14')
+    #   # => <String containing tar.gz archive for commit a87ff14>
+    #
+    #   repo.archive_tar_gz('master', 'myproject/')
+    #   # => <String containing tar.gz archive and prefixed with 'myproject/'>
+    #
+    # Returns String (containing tar.gz archive)
+    def archive_tar_gz(treeish = 'master', prefix = nil)
+      options = {}
+      options[:prefix] = prefix if prefix
+      self.git.archive(options, treeish, "| gzip")
+    end
+
+    # Write an archive directly to a file
+    #   +treeish+ is the treeish name/id (default 'master')
+    #   +prefix+ is the optional prefix (default nil)
+    #   +filename+ is the name of the file (default 'archive.tar.gz')
+    #   +format+ is the optional format (default nil)
+    #   +pipe+ is the command to run the output through (default 'gzip')
+    #
+    # Returns nothing
+    def archive_to_file(treeish = 'master', prefix = nil, filename = 'archive.tar.gz', format = nil, pipe = "gzip")
+      options = {}
+      options[:prefix] = prefix if prefix
+      options[:format] = format if format
+      self.git.archive(options, treeish, "| #{pipe} > #{filename}")
+    end
+
+    # Enable git-daemon serving of this repository by writing the
+    # git-daemon-export-ok file to its git directory
+    #
+    # Returns nothing
+    def enable_daemon_serve
+      FileUtils.touch(File.join(self.path, DAEMON_EXPORT_FILE))
+    end
+
+    # Disable git-daemon serving of this repository by ensuring there is no
+    # git-daemon-export-ok file in its git directory
+    #
+    # Returns nothing
+    def disable_daemon_serve
+      FileUtils.rm_f(File.join(self.path, DAEMON_EXPORT_FILE))
+    end
+
+    def gc_auto
+      self.git.gc({:auto => true})
+    end
+
+    # The list of alternates for this repo
+    #
+    # Returns Array[String] (pathnames of alternates)
+    def alternates
+      alternates_path = File.join(self.path, *%w{objects info alternates})
+
+      if File.exist?(alternates_path)
+        File.read(alternates_path).strip.split("\n")
+      else
+        []
+      end
+    end
+
+    # Sets the alternates
+    #   +alts+ is the Array of String paths representing the alternates
+    #
+    # Returns nothing
+    def alternates=(alts)
+      alts.each do |alt|
+        unless File.exist?(alt)
+          raise "Could not set alternates. Alternate path #{alt} must exist"
+        end
+      end
+
+      if alts.empty?
+        File.open(File.join(self.path, *%w{objects info alternates}), 'w') do |f|
+          f.write ''
+        end
+      else
+        File.open(File.join(self.path, *%w{objects info alternates}), 'w') do |f|
+          f.write alts.join("\n")
+        end
+      end
+    end
+
+    def config
+      @config ||= Config.new(self)
+    end
+
+    def index
+      Index.new(self)
+    end
+
+    def update_ref(head, commit_sha)
+      return nil if !commit_sha || (commit_sha.size != 40)
+
+      ref_heads = File.join(self.path, 'refs', 'heads')
+      FileUtils.mkdir_p(ref_heads)
+      File.open(File.join(ref_heads, head), 'w') do |f|
+        f.write(commit_sha)
+      end
+      commit_sha
+
+    end
+
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Repo "#{@path}">}
+    end
+
+    def push(repository = nil, refspec = nil)
+      self.git.push({}, repository, refspec)
+      remote_error_or_response
+    end
+
+    def pull(repository = nil, refspec = nil)
+      # git-pull seems to ignore the --work-tree setting and only works if you're actually in the directory
+      # fatal: .../git-core/git-pull cannot be used without a working tree.
+      in_working_dir do
+        self.git.pull({}, repository, refspec)
+        remote_error_or_response
+      end
+    end
+
+    def add_remote(name = nil, url = nil)
+      self.git.remote({}, 'add', name, url)
+      remote_error_or_response
+    end
+
+    def last_error
+      !self.git.last_error.blank? ? self.git.last_error : nil
+    end
+
+    def last_response
+      !self.git.last_response.blank? ? self.git.last_response : nil
+    end
+
+    private
+
+      def in_working_dir(&block)
+        cwt = self.git.work_tree
+
+        Dir.chdir(cwt) do
+          self.git.work_tree = nil
+            yield
+          self.git.work_tree = cwt
+        end
+      end
+
+      def remote_error
+        if last_error =~ /fatal: '.*': unable to chdir or not a git archive/
+          raise RemoteNonexistentError, last_error
+        elsif last_error =~ /ssh: Could not resolve hostname .*: nodename nor servname provided, or not known/
+          raise RemoteNonexistentError, last_error
+        elsif last_error =~ /fatal: Couldn't find remote ref .*/
+          raise BranchNonexistentError, last_error
+        elsif last_error =~ /error: src refspec .* does not match any./
+          raise BranchNonexistentError, last_error
+        elsif last_error =~ /unknown revision or path not in the working tree/
+          raise RemoteUninitializedError, last_error
+        elsif last_error =~ /(error|fatal)/
+          raise RemoteError, last_error
+        end
+      end
+
+      def remote_error_or_response
+        remote_error
+        last_response
+      end
+
+  end # Repo
+
+end # Grit

data/lib/grit/ruby1.9.rb

@@ -0,0 +1,7 @@
+class String 
+  if ((defined? RUBY_VERSION) && (RUBY_VERSION[0..2] == "1.9"))
+    def getord(offset); self[offset].ord; end
+  else
+    alias :getord :[]
+  end
+end

data/lib/grit/status.rb

@@ -0,0 +1,151 @@
+module Grit
+  
+  class Status
+    include Enumerable
+    
+    @base = nil
+    @files = nil
+    
+    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 << file.path
+        out << "\n\tsha(r) " + file.sha_repo.to_s + ' ' + file.mode_repo.to_s
+        out << "\n\tsha(i) " + file.sha_index.to_s + ' ' + file.mode_index.to_s
+        out << "\n\ttype   " + file.type.to_s
+        out << "\n\tstage  " + file.stage.to_s
+        out << "\n\tuntrac " + file.untracked.to_s
+        out << "\n"
+      end
+      out << "\n"
+      out
+    end
+    
+    # enumerable method
+    
+    def [](file)
+      @files[file]
+    end
+    
+    def each
+      @files.each do |k, file|
+        yield file
+      end
+    end
+    
+    class StatusFile
+      attr_accessor :path, :type, :stage, :untracked
+      attr_accessor :mode_index, :mode_repo
+      attr_accessor :sha_index, :sha_repo
+      
+      @base = nil
+      
+      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 = ls_files
+        
+        Dir.chdir(@base.working_dir) do 
+          # find untracked in working dir
+          Dir.glob('**/*') do |file|
+            if !@files[file]
+              @files[file] = {:path => file, :untracked => true} if !File.directory?(file)
+            end
+          end
+
+          # find modified in tree
+         diff_files.each do |path, data|
+            @files[path] ? @files[path].merge!(data) : @files[path] = data
+          end
+        
+          # find added but not committed - new files
+          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
+
+      # compares the index and the working directory
+      def diff_files
+        hsh = {}
+        @base.git.diff_files.split("\n").each do |line|
+          (info, file) = line.split("\t")
+          (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
+          hsh[file] = {:path => file, :mode_file => mode_src.to_s[1, 7], :mode_index => mode_dest, 
+                        :sha_file => sha_src, :sha_index => sha_dest, :type => type}
+        end
+        hsh
+      end
+
+      # compares the index and the repository
+      def diff_index(treeish)
+        hsh = {}
+        @base.git.diff_index({}, treeish).split("\n").each do |line|
+          (info, file) = line.split("\t")
+          (mode_src, mode_dest, sha_src, sha_dest, type) = info.split
+          hsh[file] = {:path => file, :mode_repo => mode_src.to_s[1, 7], :mode_index => mode_dest, 
+                        :sha_repo => sha_src, :sha_index => sha_dest, :type => type}
+        end
+        hsh
+      end
+
+      def ls_files
+        hsh = {}
+        lines = @base.git.ls_files({:stage => true})
+        lines.split("\n").each do |line|
+          (info, file) = line.split("\t")
+          (mode, sha, stage) = info.split
+          hsh[file] = {:path => file, :mode_index => mode, :sha_index => sha, :stage => stage}
+        end
+        hsh
+      end
+  end
+  
+end