boof-grit 1.1.2

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

data/lib/grit/submodule.rb

@@ -0,0 +1,88 @@
+module Grit
+  
+  class Submodule
+    attr_reader :id
+    attr_reader :mode
+    attr_reader :name
+    
+    # Create a Submodule containing just the specified attributes
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Submodule (unbaked)
+    def self.create(repo, atts)
+      self.allocate.create_initialize(repo, atts)
+    end
+    
+    # Initializer for Submodule.create
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Submodule
+    def create_initialize(repo, atts)
+      @repo = repo
+      atts.each do |k, v|
+        instance_variable_set("@#{k}".to_sym, v)
+      end
+      self
+    end
+    
+    # The url of this submodule
+    #   +ref+ is the committish that should be used to look up the url
+    #
+    # Returns String
+    def url(ref)
+      config = self.class.config(@repo, ref)
+      
+      lookup = config.keys.inject({}) do |acc, key|
+        id = config[key]['id']
+        acc[id] = config[key]['url']
+        acc
+      end
+      
+      lookup[@id]
+    end
+    
+    # The configuration information for the given +repo+
+    #   +repo+ is the Repo
+    #   +ref+ is the committish (defaults to 'master')
+    #
+    # Returns a Hash of { <path:String> => { 'url' => <url:String>, 'id' => <id:String> } }
+    # Returns {} if no .gitmodules file was found
+    def self.config(repo, ref = "master")
+      commit = repo.commit(ref)
+      blob = commit.tree/'.gitmodules'
+      return {} unless blob
+      
+      lines = blob.data.gsub(/\r\n?/, "\n" ).split("\n")
+      
+      config = {}
+      current = nil
+      
+      lines.each do |line|
+        if line =~ /^\[submodule "(.+)"\]$/
+          current = $1
+          config[current] = {}
+          config[current]['id'] = (commit.tree/current).id
+        elsif line =~ /^\t(\w+) = (.+)$/
+          config[current][$1] = $2
+          config[current]['id'] = (commit.tree/$2).id if $1 == 'path'
+        else
+          # ignore
+        end
+      end
+      
+      config
+    end
+    
+    def basename
+      File.basename(name)
+    end    
+    
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Submodule "#{@id}">}
+    end
+  end # Submodule
+  
+end # Grit

data/lib/grit/tag.rb

@@ -0,0 +1,66 @@
+module Grit
+
+  class Tag < Ref
+    def self.find_all(repo, options = {})
+      refs = []
+      already = {}
+
+      Dir.chdir(repo.path) do
+        files = Dir.glob(prefix + '/**/*')
+
+        files.each do |ref|
+          next if !File.file?(ref)
+
+          id = File.read(ref).chomp
+          name = ref.sub("#{prefix}/", '')
+          commit = commit_from_sha(repo, id)
+
+          if !already[name]
+            refs << self.new(name, commit)
+            already[name] = true
+          end
+        end
+
+        if File.file?('packed-refs')
+          lines = File.readlines('packed-refs')
+          lines.each_with_index do |line, i|
+            if m = /^(\w{40}) (.*?)$/.match(line)
+              next if !Regexp.new('^' + prefix).match(m[2])
+              name = m[2].sub("#{prefix}/", '')
+
+              # Annotated tags in packed-refs include a reference
+              # to the commit object on the following line.
+              next_line = lines[i+1]
+              if next_line && next_line[0] == ?^
+                commit = Commit.create(repo, :id => next_line[1..-1].chomp)
+              else
+                commit = commit_from_sha(repo, m[1])
+              end
+
+              if !already[name]
+                refs << self.new(name, commit)
+                already[name] = true
+              end
+            end
+          end
+        end
+      end
+
+      refs
+    end
+
+    def self.commit_from_sha(repo, id)
+      git_ruby_repo = GitRuby::Repository.new(repo.path)
+      object = git_ruby_repo.get_object_by_sha1(id)
+
+      if object.type == :commit
+        Commit.create(repo, :id => id)
+      elsif object.type == :tag
+        Commit.create(repo, :id => object.object)
+      else
+        raise "Unknown object type."
+      end
+    end
+  end
+
+end

data/lib/grit/tree.rb

@@ -0,0 +1,123 @@
+module Grit
+  
+  class Tree
+    lazy_reader :contents
+    attr_reader :id
+    attr_reader :mode
+    attr_reader :name
+    
+    # Construct the contents of the tree
+    #   +repo+ is the Repo
+    #   +treeish+ is the reference
+    #   +paths+ is an optional Array of directory paths to restrict the tree
+    #
+    # Returns Grit::Tree (baked)
+    def self.construct(repo, treeish, paths = [])
+      output = repo.git.ls_tree({}, treeish, *paths)
+      self.allocate.construct_initialize(repo, treeish, output)
+    end
+    
+    def construct_initialize(repo, id, text)
+      @repo = repo
+      @id = id
+      @contents = []
+      
+      text.split("\n").each do |line|
+        @contents << content_from_string(repo, line)
+      end
+      @contents.compact!
+
+      self
+    end
+    
+    def lazy_source
+      Tree.construct(@repo, @id, [])
+    end
+    
+    # Create an unbaked Tree containing just the specified attributes
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Tree (unbaked)
+    def self.create(repo, atts)
+      self.allocate.create_initialize(repo, atts)
+    end
+    
+    # Initializer for Tree.create
+    #   +repo+ is the Repo
+    #   +atts+ is a Hash of instance variable data
+    #
+    # Returns Grit::Tree (unbaked)
+    def create_initialize(repo, atts)
+      @repo = repo
+      
+      atts.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end
+      self
+    end
+    
+    # Parse a content item and create the appropriate object
+    #   +repo+ is the Repo
+    #   +text+ is the single line containing the items data in `git ls-tree` format
+    #
+    # Returns Grit::Blob or Grit::Tree
+    def content_from_string(repo, text)
+      mode, type, id, name = text.split(" ", 4)
+      case type
+        when "tree"
+          Tree.create(repo, :id => id, :mode => mode, :name => name)
+        when "blob"
+          Blob.create(repo, :id => id, :mode => mode, :name => name)
+        when "link"
+          Blob.create(repo, :id => id, :mode => mode, :name => name)
+        when "commit"
+          Submodule.create(repo, :id => id, :mode => mode, :name => name)
+        else
+          raise "Invalid type: #{type}"
+      end
+    end
+    
+    # Find the named object in this tree's contents
+    #
+    # Examples
+    #   Repo.new('/path/to/grit').tree/'lib'
+    #   # => #<Grit::Tree "6cc23ee138be09ff8c28b07162720018b244e95e">
+    #   Repo.new('/path/to/grit').tree/'README.txt'
+    #   # => #<Grit::Blob "8b1e02c0fb554eed2ce2ef737a68bb369d7527df">
+    #
+    # Returns Grit::Blob or Grit::Tree or nil if not found
+    def /(file)
+      if file =~ /\//
+        file.split("/").inject(self) { |acc, x| acc/x } rescue nil
+      else
+        self.contents.find { |c| c.name == file }
+      end
+    end
+    
+    def basename
+      File.basename(name)
+    end
+    
+    # Pretty object inspection
+    def inspect
+      %Q{#<Grit::Tree "#{@id}">}
+    end
+
+    # Find only Tree objects from contents
+    def trees
+      contents.select {|v| v.kind_of? Tree}
+    end
+
+    # Find only Blob objects from contents
+    def blobs
+      contents.select {|v| v.kind_of? Blob}
+    end
+
+    # Compares trees by name
+    def <=>(other)
+      name <=> other.name
+    end
+  end # Tree
+
+end # Grit

data/lib/open3_detach.rb

@@ -0,0 +1,46 @@
+module Open3
+  extend self
+
+  def popen3(*cmd)
+    pw = IO::pipe   # pipe[0] for read, pipe[1] for write
+    pr = IO::pipe
+    pe = IO::pipe
+
+    pid = fork{
+      # child
+      fork{
+        # grandchild
+        pw[1].close
+        STDIN.reopen(pw[0])
+        pw[0].close
+
+        pr[0].close
+        STDOUT.reopen(pr[1])
+        pr[1].close
+
+        pe[0].close
+        STDERR.reopen(pe[1])
+        pe[1].close
+
+        exec(*cmd)
+      }
+      exit!(0)
+    }
+
+    pw[0].close
+    pr[1].close
+    pe[1].close
+    Process.waitpid(pid)
+    pi = [pw[1], pr[0], pe[0]]
+    pw[1].sync = true
+    if defined? yield
+      begin
+        return yield(*pi)
+      ensure
+        Process.detach(pid) if pid
+        pi.each { |p| p.close unless p.closed? }
+      end
+    end
+    pi
+  end
+end