blackwinter-git 1.2.5

data/lib/git/log.rb

@@ -0,0 +1,121 @@
+module Git
+  
+  # object that holds the last X commits on given branch
+  class Log
+    include Enumerable
+    
+    def initialize(base, count = 30)
+      dirty_log
+      @base = base
+      @count = count
+ 
+      @commits = nil
+      @author = nil
+      @grep = nil
+      @object = nil
+      @path = nil
+      @since = nil
+      @skip = nil
+      @until = nil
+      @between = nil
+    end
+
+    def object(objectish)
+      dirty_log
+      @object = objectish
+      return self
+    end
+
+    def author(regex)
+      dirty_log
+      @author = regex
+      return self
+    end
+        
+    def grep(regex)
+      dirty_log
+      @grep = regex
+      return self
+    end
+    
+    def path(path)
+      dirty_log
+      @path = path
+      return self
+    end
+    
+    def skip(num)
+      dirty_log
+      @skip = num
+      return self
+    end
+    
+    def since(date)
+      dirty_log
+      @since = date
+      return self
+    end
+    
+    def until(date)
+      dirty_log
+      @until = date
+      return self
+    end
+    
+    def between(sha1, sha2 = nil)
+      dirty_log
+      @between = [sha1, sha2]
+      return self
+    end
+    
+    def to_s
+      self.map { |c| c.to_s }.join("\n")
+    end
+    
+
+    # forces git log to run
+    
+    def size
+      check_log
+      @commits.size rescue nil
+    end
+
+    def empty?
+      size.zero? rescue true
+    end
+    
+    def each(&block)
+      check_log
+      @commits.each(&block)
+    end
+    
+    def first
+      check_log
+      @commits.first rescue nil
+    end
+    
+    private 
+    
+      def dirty_log
+        @dirty_flag = true
+      end
+      
+      def check_log
+        if @dirty_flag
+          run_log
+          @dirty_flag = false
+        end
+      end
+      
+      # actually run the 'git log' command
+      def run_log      
+        log = @base.lib.full_log_commits(:count => @count, :object => @object, 
+                                    :path_limiter => @path, :since => @since, 
+                                    :author => @author, :grep => @grep, :skip => @skip,
+                                    :until => @until, :between => @between)
+        @commits = log.map { |c| Git::Object::Commit.new(@base, c['sha'], c) }
+      end
+      
+  end
+  
+end

data/lib/git/object.rb

@@ -0,0 +1,273 @@
+module Git
+  
+  class GitTagNameDoesNotExist< StandardError 
+  end
+  
+  # represents a git object
+  class Object
+    
+    class AbstractObject
+      attr_accessor :objectish, :size, :type, :mode
+      
+      def initialize(base, objectish)
+        @base = base
+        @objectish = objectish.to_s
+        @contents = nil
+        @trees = nil
+        @size = nil
+        @sha = nil
+      end
+
+      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
+      # read a large file in chunks.
+      #
+      # Use this for large files so that they are not held in memory.
+      def contents(&block)
+        if block_given?
+          @base.lib.object_contents(@objectish, &block)
+        else
+          @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
+      
+      @trees = nil
+      @blobs = nil
+      
+      def initialize(base, sha, mode = nil)
+        super(base, sha)
+        @mode = mode
+      end
+            
+      def children
+        blobs.merge(subtrees)
+      end
+      
+      def blobs
+        check_tree
+        @blobs
+      end
+      alias_method :files, :blobs
+      
+      def 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
+          unless @trees
+            @trees = {}
+            @blobs = {}
+            data = @base.lib.ls_tree(@objectish)
+            data['tree'].each { |k, d| @trees[k] = Git::Object::Tree.new(@base, d[:sha], d[:mode]) }
+            data['blob'].each { |k, d| @blobs[k] = Git::Object::Blob.new(@base, d[:sha], d[:mode]) }
+          end
+        end
+      
+    end
+  
+    class Commit < AbstractObject
+      
+      def initialize(base, sha, init = nil)
+        super(base, sha)
+        @tree = nil
+        @parents = nil
+        @author = nil
+        @committer = nil
+        @message = nil
+        if init
+          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        
+      end
+      
+      # git author
+      def author     
+        check_commit
+        @author
+      end
+      
+      def author_date
+        author.date
+      end
+      
+      # git author
+      def committer
+        check_commit
+        @committer
+      end
+      
+      def committer_date 
+        committer.date
+      end
+      alias_method :date, :committer_date
+
+      def diff_parent
+        diff(parent)
+      end
+      
+      def set_commit(data)
+        if data['sha']
+          @sha = data['sha']
+        end
+        @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) }
+        @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
+          unless @tree
+            data = @base.lib.commit_data(@objectish)
+            set_commit(data)
+          end
+        end
+      
+    end
+  
+    class Tag < AbstractObject
+      attr_accessor :name
+      
+      def initialize(base, sha, name)
+        super(base, sha)
+        @name = name
+      end
+
+      def tag?
+        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)
+      klass =
+        case type
+        when /blob/   then Blob   
+        when /commit/ then Commit
+        when /tree/   then Tree
+        end
+      klass.new(base, objectish)
+    end
+    
+  end
+end

data/lib/git/path.rb

@@ -0,0 +1,27 @@
+module Git
+  class Path
+    
+    attr_accessor :path
+    
+    def initialize(path, check_path = true)
+      if !check_path || File.exists?(path)
+        @path = File.expand_path(path)
+      else
+        raise ArgumentError, "path does not exist", File.expand_path(path)
+      end
+    end
+    
+    def readable?
+      File.readable?(@path)
+    end
+
+    def writable?
+      File.writable?(@path)
+    end
+    
+    def to_s
+      @path
+    end
+    
+  end
+end

data/lib/git/remote.rb

@@ -0,0 +1,40 @@
+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 remove
+      @base.remote_remove(@name)
+    end
+    
+    def fetch
+      @base.fetch(@name)
+    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,4 @@
+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,110 @@
+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 << 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(&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('**/*') do |file|
+            @files[file] = {:path => file, :untracked => true} unless @files[file] || File.directory?(file) || ignore.include?(file)
+          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/working_directory.rb

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