lg_pod_plugin 1.0.8 → 1.0.10

data/lib/git/log.rb

@@ -1,135 +0,0 @@
-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
-      @cherry = 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 cherry
-      dirty_log
-      @cherry = true
-      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
-
-    def last
-      check_log
-      @commits.last rescue nil
-    end
-
-    def [](index)
-      check_log
-      @commits[index] 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, :cherry => @cherry)
-        @commits = log.map { |c| Git::Object::Commit.new(@base, c['sha'], c) }
-      end
-      
-  end
-  
-end

data/lib/git/object.rb

@@ -1,312 +0,0 @@
-module Git
-  
-  class GitTagNameDoesNotExist< StandardError 
-  end
-  
-  # represents a git object
-  class Object
-    
-    class AbstractObject
-      attr_accessor :objectish, :type, :mode
-
-      attr_writer :size
-      
-      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
-      
-      def initialize(base, sha, mode = nil)
-        super(base, sha)
-        @mode = mode
-        @trees = nil
-        @blobs = nil
-      end
-            
-      def children
-        blobs.merge(subtrees)
-      end
-      
-      def blobs
-        @blobs ||= check_tree[:blobs]
-      end
-      alias_method :files, :blobs
-      
-      def trees
-        @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
-          @trees = {}
-          @blobs = {}
-          
-          data = @base.lib.ls_tree(@objectish)
-
-          data['tree'].each do |key, tree| 
-            @trees[key] = Git::Object::Tree.new(@base, tree[:sha], tree[:mode]) 
-          end
-          
-          data['blob'].each do |key, blob| 
-            @blobs[key] = Git::Object::Blob.new(@base, blob[:sha], blob[:mode]) 
-          end
-
-          {
-            :trees => @trees,
-            :blobs => @blobs
-          }
-        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)
-        @sha ||= data['sha']
-        @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
-          return if @tree
-          
-          data = @base.lib.commit_data(@objectish)
-          set_commit(data)
-        end
-      
-    end
-  
-    class Tag < AbstractObject
-      attr_accessor :name
-      
-      def initialize(base, sha, name)
-        super(base, sha)
-        @name = name
-        @annotated = nil
-        @loaded = false
-      end
-
-      def annotated?
-        @annotated ||= (@base.lib.object_type(self.name) == 'tag')
-      end
-
-      def message
-        check_tag()
-        return @message
-      end
-      
-      def tag?
-        true
-      end
-
-      def tagger
-        check_tag()
-        return @tagger
-      end
-
-      private
-
-      def check_tag
-        return if @loaded
-
-        if !self.annotated? 
-          @message = @tagger = nil
-        else
-          tdata = @base.lib.tag_data(@name)
-          @message = tdata['message'].chomp
-          @tagger = Git::Author.new(tdata['tagger'])
-        end
-
-        @loaded = 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

@@ -1,31 +0,0 @@
-module Git
- 
- class Path
-    
-    attr_accessor :path
-    
-    def initialize(path, check_path=true)
-      path = File.expand_path(path)
-      
-      if check_path && !File.exist?(path)
-        raise ArgumentError, 'path does not exist', [path]
-      end
-      
-      @path = path
-    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

@@ -1,36 +0,0 @@
-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

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

data/lib/git/stash.rb

@@ -1,27 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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
-
-    #
-    # Returns an multi-dimensional Array of elements that have been stash saved.
-    # Array is based on position and name. See Example
-    #
-    # @example Returns Array of items that have been stashed
-    #     .all - [0, "testing-stash-all"]]
-    # @return [Array]
-    def all
-      @base.lib.stashes_all
-    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