titanous-git 1.1.0

data/lib/git/log.rb

@@ -0,0 +1,120 @@
+module Git
+  
+  # object that holds the last X commits on given branch
+  class Log
+    include Enumerable
+    
+    @base = nil
+    @commits = nil
+    
+    @object = nil
+    @path = nil
+    @count = nil
+    @since = nil
+    @skip = nil
+    @until = nil
+    @between = nil
+    
+    @dirty_flag = nil
+    
+    def initialize(base, count = 30)
+      dirty_log
+      @base = base
+      @count = count
+    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 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,275 @@
+module Git
+  
+  class GitTagNameDoesNotExist< StandardError 
+  end
+  
+  # represents a git object
+  class Object
+    
+    class AbstractObject
+      attr_accessor :objectish, :size, :type, :mode
+    
+      @base = nil
+      @contents = nil
+      @size = nil
+      @sha = nil
+      
+      def initialize(base, objectish)
+        @base = base
+        @objectish = objectish.to_s
+      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
+      
+      @tree = nil
+      @parents = nil
+      @author = nil
+      @committer = nil
+      @message = nil
+      
+      def initialize(base, sha, init = nil)
+        super(base, sha)
+        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/:   Blob   
+        when /commit/: Commit
+        when /tree/:   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,42 @@
+module Git
+  class Remote < Path
+    
+    attr_accessor :name, :url, :fetch_opts
+    
+    @base = nil
+    
+    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