smeagol 0.6.0 → 0.6.1

data/vendor/grit/lib/grit/ruby1.9.rb

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

data/vendor/grit/lib/grit/status.rb

@@ -0,0 +1,153 @@
+module Grit
+
+  class Status
+    include Enumerable
+
+    attr_reader :files
+
+    @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/vendor/grit/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/vendor/grit/lib/grit/tag.rb

@@ -0,0 +1,102 @@
+module Grit
+
+  class Tag < Ref
+    extend Lazy
+
+    lazy_reader :message
+    lazy_reader :tagger
+    lazy_reader :tag_date
+
+    def self.find_all(repo, options = {})
+      refs = repo.git.refs(options, prefix)
+      refs.split("\n").map do |ref|
+        name, id = *ref.split(' ')
+        sha = repo.git.commit_from_sha(id)
+        raise "Unknown object type." if sha == ''
+        commit = Commit.create(repo, :id => sha)
+        new(name, commit)
+      end
+    end
+
+    # Writes a new tag object from a hash
+    #  +repo+ is a Grit repo
+    #  +hash+ is the hash of tag values
+    #
+    # Returns a hash with +sha+ and +size+ of the created object
+    def self.create_tag_object(repo, hash, default_actor = nil)
+      tagger = hash[:tagger]
+      if !tagger
+        tagger = default_actor ? default_actor : Actor.new("none", "none@none")
+        tagger_date = Time.now
+      else
+        tagger_date = tagger[:date] ? Time.parse(tagger[:date]) : Time.now
+        tagger = Actor.new(tagger[:name], tagger[:email])
+      end
+      data = []
+      data << "object #{hash[:object]}"
+      data << "type #{hash[:type]}"
+      data << "tag #{hash[:tag]}"
+      data << "tagger #{tagger.output(tagger_date)}"
+      data << ""
+      data << hash[:message]
+      data = data.join("\n")
+      sha = repo.git.put_raw_object(data, 'tag')
+      { :sha => sha, :size => data.size }
+    end
+
+    # Parses the results from `cat-file -p`
+    #
+    # data - String tag object data.  Example:
+    #          object 7bcc0ee821cdd133d8a53e8e7173a334fef448aa
+    #          type commit
+    #          tag v0.7.0
+    #          tagger USER <EMAIL> DATE
+    #          
+    #          v0.7.0
+    #
+    # Returns parsed Hash.  Example: 
+    #   {:message => "...", :tagger => "bob", :tag_date => ...}
+    def self.parse_tag_data(data)
+      return unless data =~ /^object/
+      parsed = {}
+      lines  = data.split("\n")
+      parsed[:object] = lines.shift.sub(/^object /, '')
+      parsed[:type] = lines.shift.sub(/^type /, '')
+      parsed[:tag] = lines.shift.sub(/^tag /, '')
+      author_line = lines.shift
+      parsed[:tagger], parsed[:tag_date] = Commit.actor(author_line)
+      if !parsed[:tagger] || !parsed[:tagger].name
+        parsed[:tag_date] ||= Time.utc(1970)
+        parsed[:tagger]     = Actor.from_string(author_line.sub(/^tagger /, ''))
+      end
+      lines.shift # blank line
+      parsed[:message] = []
+      while lines.first && lines.first !~ /-----BEGIN PGP SIGNATURE-----/
+        parsed[:message] << lines.shift
+      end
+      parsed[:message] = parsed[:message] * "\n"
+      parsed[:pgp] = []
+      while lines.first
+        parsed[:pgp] << lines.shift
+      end
+      parsed[:pgp] = parsed[:pgp] * "\n"
+      parsed
+    end
+
+    def lazy_source
+      data         = commit.repo.git.cat_ref({:p => true}, name)
+      @message     = commit.short_message
+      @tagger      = commit.author
+      @tag_date    = commit.authored_date
+      return self if data.empty?
+
+      if parsed = self.class.parse_tag_data(data)
+        @message  = parsed[:message]
+        @tagger   = parsed[:tagger]
+        @tag_date = parsed[:tag_date]
+      end
+      self
+    end
+  end
+
+end

data/vendor/grit/lib/grit/tree.rb

@@ -0,0 +1,125 @@
+module Grit
+
+  class Tree
+    extend Lazy
+
+    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({:raise => true}, 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(/ |\t/, 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 Grit::InvalidObjectType, 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