smeagol 0.6.0 → 0.6.1

data/vendor/grit/lib/grit/diff.rb

@@ -0,0 +1,79 @@
+module Grit
+
+  class Diff
+    attr_reader :a_path, :b_path
+    attr_reader :a_blob, :b_blob
+    attr_reader :a_mode, :b_mode
+    attr_reader :new_file, :deleted_file, :renamed_file
+    attr_reader :similarity_index
+    attr_accessor :diff
+
+    def initialize(repo, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff, renamed_file = false, similarity_index = 0)
+      @repo   = repo
+      @a_path = a_path
+      @b_path = b_path
+      @a_blob = a_blob =~ /^0{40}$/ ? nil : Blob.create(repo, :id => a_blob)
+      @b_blob = b_blob =~ /^0{40}$/ ? nil : Blob.create(repo, :id => b_blob)
+      @a_mode = a_mode
+      @b_mode = b_mode
+      @new_file         = new_file     || @a_blob.nil?
+      @deleted_file     = deleted_file || @b_blob.nil?
+      @renamed_file     = renamed_file
+      @similarity_index = similarity_index.to_i
+      @diff             = diff
+    end
+
+    def self.list_from_string(repo, text)
+      lines = text.split("\n")
+
+      diffs = []
+
+      while !lines.empty?
+        m, a_path, b_path = *lines.shift.match(%r{^diff --git a/(.+?) b/(.+)$})
+
+        if lines.first =~ /^old mode/
+          m, a_mode = *lines.shift.match(/^old mode (\d+)/)
+          m, b_mode = *lines.shift.match(/^new mode (\d+)/)
+        end
+
+        if lines.empty? || lines.first =~ /^diff --git/
+          diffs << Diff.new(repo, a_path, b_path, nil, nil, a_mode, b_mode, false, false, nil)
+          next
+        end
+
+        sim_index    = 0
+        new_file     = false
+        deleted_file = false
+        renamed_file = false
+
+        if lines.first =~ /^new file/
+          m, b_mode = lines.shift.match(/^new file mode (.+)$/)
+          a_mode    = nil
+          new_file  = true
+        elsif lines.first =~ /^deleted file/
+          m, a_mode    = lines.shift.match(/^deleted file mode (.+)$/)
+          b_mode       = nil
+          deleted_file = true
+        elsif lines.first =~ /^similarity index (\d+)\%/
+          sim_index    = $1.to_i
+          renamed_file = true
+          2.times { lines.shift } # shift away the 2 `rename from/to ...` lines
+        end
+
+        m, a_blob, b_blob, b_mode = *lines.shift.match(%r{^index ([0-9A-Fa-f]+)\.\.([0-9A-Fa-f]+) ?(.+)?$})
+        b_mode.strip! if b_mode
+
+        diff_lines = []
+        while lines.first && lines.first !~ /^diff/
+          diff_lines << lines.shift
+        end
+        diff = diff_lines.join("\n")
+
+        diffs << Diff.new(repo, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff, renamed_file, sim_index)
+      end
+
+      diffs
+    end
+  end # Diff
+
+end # Grit

data/vendor/grit/lib/grit/errors.rb

@@ -0,0 +1,10 @@
+module Grit
+  class InvalidGitRepositoryError < StandardError
+  end
+
+  class NoSuchPathError < StandardError
+  end
+
+  class InvalidObjectType < StandardError
+  end
+end

data/vendor/grit/lib/grit/git-ruby.rb

@@ -0,0 +1,262 @@
+require 'grit/git-ruby/repository'
+
+module Grit
+
+  # the functions in this module intercept the calls to git binary
+  # made by the grit objects and attempts to run them in pure ruby
+  # if it will be faster, or if the git binary is not available (!!TODO!!)
+  module GitRuby
+
+    attr_accessor :ruby_git_repo, :git_file_index
+
+    def init(options, *args)
+      if options.size == 0
+        Grit::GitRuby::Repository.init(@git_dir)
+      else
+        method_missing('init', options, *args)
+      end
+    end
+
+    def cat_file(options, sha)
+      if options[:t]
+        file_type(sha)
+      elsif options[:s]
+        file_size(sha)
+      elsif options[:p]
+        try_run { ruby_git.cat_file(sha) }
+      end
+    rescue Grit::GitRuby::Repository::NoSuchShaFound
+      ''
+    end
+
+    def cat_ref(options, ref)
+      sha = rev_parse({}, ref)
+      cat_file(options, sha)
+    end
+
+    # lib/grit/tree.rb:16:      output = repo.git.ls_tree({}, treeish, *paths)
+    def ls_tree(options, treeish, *paths)
+      sha = rev_parse({}, treeish)
+      ruby_git.ls_tree(sha, paths.flatten, options.delete(:r))
+    rescue Grit::GitRuby::Repository::NoSuchShaFound
+      ''
+    end
+
+    # git diff --full-index 'ec037431382e83c3e95d4f2b3d145afbac8ea55d' 'f1ec1aea10986159456846b8a05615b87828d6c6'
+    def diff(options, sha1, sha2 = nil)
+      try_run { ruby_git.diff(sha1, sha2, options) }
+    end
+
+    def rev_list(options, *refs)
+      refs = ['master'] if refs.empty?
+      options.delete(:skip) if options[:skip].to_i == 0
+      allowed_options = [:max_count, :since, :until, :pretty]  # this is all I can do right now
+      if ((options.keys - allowed_options).size > 0) || refs.size > 1
+        method_missing('rev-list', options, *refs)
+      elsif (options.size == 0)
+        # pure rev-list
+        ref = refs.first
+        begin
+          file_index.commits_from(rev_parse({}, ref)).join("\n") + "\n"
+        rescue
+          method_missing('rev-list', options, *refs)
+        end
+      else
+        ref = refs.first
+        aref = rev_parse({:verify => true}, ref)
+        if aref.is_a? Array
+          method_missing('rev-list', options, *refs)
+        else
+          try_run { ruby_git.rev_list(aref, options) }
+        end
+      end
+    end
+
+    def rev_parse(options, string)
+      raise RuntimeError, "invalid string: #{string.inspect}" unless string.is_a?(String)
+
+      # Split ranges, but don't split when specifying a ref:path.
+      # Don't split HEAD:some/path/in/repo..txt
+      # Do split sha1..sha2
+      if string !~ /:/ && string =~ /\.\./
+        (sha1, sha2) = string.split('..')
+        return [rev_parse({}, sha1), rev_parse({}, sha2)]
+      end
+
+      if /^[0-9a-f]{40}$/.match(string)  # passing in a sha - just no-op it
+        return string.chomp
+      end
+
+      head = File.join(@git_dir, 'refs', 'heads', string)
+      return File.read(head).chomp if File.file?(head)
+
+      head = File.join(@git_dir, 'refs', 'remotes', string)
+      return File.read(head).chomp if File.file?(head)
+
+      head = File.join(@git_dir, 'refs', 'tags', string)
+      return File.read(head).chomp if File.file?(head)
+
+      ## check packed-refs file, too
+      packref = File.join(@git_dir, 'packed-refs')
+      if File.file?(packref)
+        File.readlines(packref).each do |line|
+          if m = /^(\w{40}) refs\/.+?\/(.*?)$/.match(line)
+            next if !Regexp.new(Regexp.escape(string) + '$').match(m[3])
+            return m[1].chomp
+          end
+        end
+      end
+
+      ## !! more - partials and such !!
+
+      # revert to calling git - grr
+      return method_missing('rev-parse', options, string).chomp
+    end
+
+    def refs(options, prefix)
+      refs = []
+      already = {}
+      Dir.chdir(@git_dir) do
+        files = Dir.glob(prefix + '/**/*')
+        files.each do |ref|
+          next if !File.file?(ref)
+          id = File.read(ref).chomp
+          name = ref.sub("#{prefix}/", '')
+          if !already[name]
+            refs << "#{name} #{id}"
+            already[name] = true
+          end
+        end
+
+        if File.file?('packed-refs')
+          File.readlines('packed-refs').each do |line|
+            if m = /^(\w{40}) (.*?)$/.match(line)
+              next if !Regexp.new('^' + prefix).match(m[2])
+              name = m[2].sub("#{prefix}/", '')
+              if !already[name]
+                refs << "#{name} #{m[1]}"
+                already[name] = true
+              end
+            end
+          end
+        end
+      end
+
+      refs.join("\n")
+    end
+
+    def tags(options, prefix)
+      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}/", '')
+
+          if !already[name]
+            refs << "#{name} #{id}"
+            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]
+
+              id =
+              if next_line && next_line[0] == ?^
+                next_line[1..-1].chomp
+              else
+                m[1]
+              end
+
+              if !already[name]
+                refs << "#{name} #{id}"
+                already[name] = true
+              end
+            end
+          end
+        end
+      end
+
+      refs.join("\n")
+    end
+
+    def file_size(ref)
+      try_run { ruby_git.cat_file_size(ref).to_s }
+    end
+
+    def file_type(ref)
+      try_run { ruby_git.cat_file_type(ref).to_s }
+    end
+
+    def ruby_git
+      @ruby_git_repo ||= Repository.new(@git_dir)
+    end
+
+    private
+
+      def try_run
+        ret = ''
+        Timeout.timeout(self.class.git_timeout) do
+          ret = yield
+        end
+        @bytes_read += ret.size
+
+        #if @bytes_read > 5242880 # 5.megabytes
+        #  bytes = @bytes_read
+        #  @bytes_read = 0
+        #  raise Grit::Git::GitTimeout.new(command, bytes)
+        #end
+
+        ret
+      rescue Timeout::Error => e
+        bytes = @bytes_read
+        @bytes_read = 0
+        raise Grit::Git::GitTimeout.new(command, bytes)
+      end
+
+      def looking_for(commit, path = nil)
+        tree_sha = ruby_git.get_subtree(rev_parse({}, commit), path)
+
+        looking_for = []
+        ruby_git.get_object_by_sha1(tree_sha).entry.each do |e|
+          if path && !(path == '' || path == '.' || path == './')
+            file = File.join(path, e.name)
+          else
+            file = e.name
+          end
+          file += '/' if e.type == :directory
+          looking_for << file
+        end
+        looking_for
+      end
+
+      def clean_paths(commit_array)
+        new_commits = {}
+        commit_array.each do |file, sha|
+          file = file.chop if file[file.size - 1 , 1] == '/'
+          new_commits[file] = sha
+        end
+        new_commits
+      end
+
+    # TODO
+    # git grep -n 'foo' 'master'
+    # git log --pretty='raw' --max-count='1' 'master' -- 'LICENSE'
+    # git log --pretty='raw' --max-count='1' 'master' -- 'test'
+
+  end
+end

data/vendor/grit/lib/grit/git-ruby/commit_db.rb

@@ -0,0 +1,52 @@
+begin
+  require 'sequel'
+
+  module Grit
+
+    class CommitDb
+
+      SCHEMA_VERSION = 1
+
+      attr_accessor :db, :git
+
+      def initialize(git_obj, index_location = nil)
+        @git = git_obj
+        db_file = File.join(index_location || @git.git_dir, 'commit_db')
+        if !File.exists?(db_file)
+          @db = Sequel.open "sqlite:///#{db_file}"
+          setup_tables
+        else
+          @db = Sequel.open "sqlite:///#{db_file}"
+        end
+      end
+
+      def rev_list(branch, options)
+      end
+
+      def update_db(branch = nil)
+        # find all refs/heads, for each
+        # add branch if not there
+        # go though all commits in branch
+          # add new commit_branches a
+          # and commit_nodes for each new one
+          # stop if reach commit that already has branch and node links
+      end
+
+      def setup_tables
+        @db << "create table meta (meta_key text, meta_value text)"
+        @db[:meta] << {:meta_key => 'schema', :meta_value => SCHEMA_VERSION}
+
+        @db << "create table commits (id integer, sha text, author_date integer)"
+        @db << "create table nodes (id integer, path text, type text)"
+        @db << "create table branches (id integer, ref text, commit_id integer)"
+
+        @db << "create table commit_branches (commit_id integer, branch_id integer)"
+        @db << "create table commit_nodes (commit_id integer, node_id integer, node_sha string)"
+      end
+
+    end
+  end
+
+rescue LoadError
+  # no commit db
+end

data/vendor/grit/lib/grit/git-ruby/git_object.rb

@@ -0,0 +1,353 @@
+#
+# converted from the gitrb project
+#
+# authors:
+#    Matthias Lederhofer <matled@gmx.net>
+#    Simon 'corecode' Schubert <corecode@fs.ei.tum.de>
+#    Scott Chacon <schacon@gmail.com>
+#
+# provides native ruby access to git objects and pack files
+#
+
+# These classes translate the raw binary data kept in the sha encoded files
+# into parsed data that can then be used in another fashion
+require 'stringio'
+
+module Grit
+  module GitRuby
+
+  # class for author/committer/tagger lines
+  class UserInfo
+    attr_accessor :name, :email, :date, :offset
+
+    def initialize(str)
+      @email = ''
+      @date = Time.now
+      @offset = 0
+
+      m = /^(.*?) <(.*)> (\d+) ([+-])0*(\d+?)$/.match(str)
+      if !m
+        case str
+        when /<.+>/
+          m, @name, @email = *str.match(/(.*) <(.+?)>/)
+        else
+          @name = str
+        end
+      else
+        @name = m[1]
+        @email = m[2]
+        @date = Time.at(Integer(m[3]))
+        @offset = (m[4] == "-" ? -1 : 1)*Integer(m[5])
+      end
+    end
+
+    def to_s
+      "%s <%s> %s %+05d" % [@name, @email, @date.to_i, @offset]
+    end
+  end
+
+  # base class for all git objects (blob, tree, commit, tag)
+  class GitObject
+    attr_accessor :repository
+    attr_accessor :sha
+
+    def GitObject.from_raw(rawobject, repository = nil)
+      case rawobject.type
+      when :blob
+        return Blob.from_raw(rawobject, repository)
+      when :tree
+        return Tree.from_raw(rawobject, repository)
+      when :commit
+        return Commit.from_raw(rawobject, repository)
+      when :tag
+        return Tag.from_raw(rawobject, repository)
+      else
+        raise RuntimeError, "got invalid object-type"
+      end
+    end
+
+    def initialize
+      raise NotImplemented, "abstract class"
+    end
+
+    def type
+      raise NotImplemented, "abstract class"
+    end
+
+    def raw_content
+      raise NotImplemented, "abstract class"
+    end
+
+    def sha1
+      Digest::SHA1.hexdigest("%s %d\0" % \
+                             [self.type, self.raw_content.length] + \
+                             self.raw_content)
+    end
+  end
+
+  class Blob < GitObject
+    attr_accessor :content
+
+    def self.from_raw(rawobject, repository)
+      new(rawobject.content)
+    end
+
+    def initialize(content, repository=nil)
+      @content = content
+      @repository = repository
+    end
+
+    def type
+      :blob
+    end
+
+    def raw_content
+      @content
+    end
+  end
+
+  class DirectoryEntry
+    S_IFMT  = 00170000
+    S_IFLNK =  0120000
+    S_IFREG =  0100000
+    S_IFDIR =  0040000
+    S_IFGITLINK = 0160000
+    attr_accessor :mode, :name, :sha1
+    def initialize(mode, filename, sha1o)
+      @mode = 0
+      mode.each_byte do |i|
+        @mode = (@mode << 3) | (i-'0'.getord(0))
+      end
+      @name = filename
+      @sha1 = sha1o
+      if ![S_IFLNK, S_IFDIR, S_IFREG, S_IFGITLINK].include?(@mode & S_IFMT)
+        raise RuntimeError, "unknown type for directory entry"
+      end
+    end
+
+    def type
+      case @mode & S_IFMT
+      when S_IFGITLINK
+        @type = :submodule
+      when S_IFLNK
+        @type = :link
+      when S_IFDIR
+        @type = :directory
+      when S_IFREG
+        @type = :file
+      else
+        raise RuntimeError, "unknown type for directory entry"
+      end
+    end
+
+    def type=(type)
+      case @type
+      when :link
+        @mode = (@mode & ~S_IFMT) | S_IFLNK
+      when :directory
+        @mode = (@mode & ~S_IFMT) | S_IFDIR
+      when :file
+        @mode = (@mode & ~S_IFMT) | S_IFREG
+      when :submodule
+        @mode = (@mode & ~S_IFMT) | S_IFGITLINK
+      else
+        raise RuntimeError, "invalid type"
+      end
+    end
+
+    def format_type
+      case type
+      when :link
+        'link'
+      when :directory
+        'tree'
+      when :file
+        'blob'
+      when :submodule
+        'commit'
+      end
+    end
+
+    def format_mode
+      "%06o" % @mode
+    end
+
+    def raw
+      "%o %s\0%s" % [@mode, @name, [@sha1].pack("H*")]
+    end
+  end
+
+
+  def self.read_bytes_until(io, char)
+    string = ''
+    if RUBY_VERSION > '1.9'
+      while ((next_char = io.getc) != char) && !io.eof
+        string += next_char
+      end
+    else
+      while ((next_char = io.getc.chr) != char) && !io.eof
+        string += next_char
+      end
+    end
+    string
+  end
+
+
+  class Tree < GitObject
+    attr_accessor :entry
+
+    def self.from_raw(rawobject, repository=nil)
+      raw = StringIO.new(rawobject.content)
+
+      entries = []
+      while !raw.eof?
+        mode      = Grit::GitRuby.read_bytes_until(raw, ' ')
+        file_name = Grit::GitRuby.read_bytes_until(raw, "\0")
+        raw_sha   = raw.read(20)
+        sha = raw_sha.unpack("H*").first
+
+        entries << DirectoryEntry.new(mode, file_name, sha)
+      end
+      new(entries, repository)
+    end
+
+    def initialize(entries=[], repository = nil)
+      @entry = entries
+      @repository = repository
+    end
+
+    def type
+      :tree
+    end
+
+    def raw_content
+      # TODO: sort correctly
+      #@entry.sort { |a,b| a.name <=> b.name }.
+      @entry.collect { |e| [[e.format_mode, e.format_type, e.sha1].join(' '), e.name].join("\t") }.join("\n")
+    end
+
+    def actual_raw
+      #@entry.collect { |e| e.raw.join(' '), e.name].join("\t") }.join("\n")
+    end
+  end
+
+  class Commit < GitObject
+    attr_accessor :author, :committer, :tree, :parent, :message, :headers
+
+    def self.from_raw(rawobject, repository=nil)
+      parent = []
+      tree = author = committer = nil
+
+      headers, message = rawobject.content.split(/\n\n/, 2)
+      all_headers = headers.split(/\n/).map { |header| header.split(/ /, 2) }
+      all_headers.each do |key, value|
+        case key
+        when "tree"
+          tree = value
+        when "parent"
+          parent.push(value)
+        when "author"
+          author = UserInfo.new(value)
+        when "committer"
+          committer = UserInfo.new(value)
+        else
+          warn "unknown header '%s' in commit %s" % \
+            [key, rawobject.sha1.unpack("H*")[0]]
+        end
+      end
+      if not tree && author && committer
+        raise RuntimeError, "incomplete raw commit object"
+      end
+      new(tree, parent, author, committer, message, headers, repository)
+    end
+
+    def initialize(tree, parent, author, committer, message, headers, repository=nil)
+      @tree = tree
+      @author = author
+      @parent = parent
+      @committer = committer
+      @message = message
+      @headers = headers
+      @repository = repository
+    end
+
+    def type
+      :commit
+    end
+
+    def raw_content
+      "tree %s\n%sauthor %s\ncommitter %s\n\n" % [
+        @tree,
+        @parent.collect { |i| "parent %s\n" % i }.join,
+        @author, @committer] + @message
+    end
+
+    def raw_log(sha)
+      output = "commit #{sha}\n"
+      output += @headers + "\n\n"
+      output += @message.split("\n").map { |l| '    ' + l }.join("\n") + "\n\n"
+    end
+
+  end
+
+  class Tag < GitObject
+    attr_accessor :object, :tag, :tagger, :message, :object_type
+    attr_writer :type
+
+    def self.from_raw(rawobject, repository=nil)
+
+      headers, message = rawobject.content.split(/\n\n/, 2)
+      headers = headers.split(/\n/).map { |header| header.split(' ', 2) }
+
+      object = ''
+      type = ''
+      tag = ''
+      tagger = ''
+
+      headers.each do |key, value|
+        case key
+        when "object"
+          object = value
+        when "type"
+          if !["blob", "tree", "commit", "tag"].include?(value)
+            raise RuntimeError, "invalid type in tag"
+          end
+          type = value.to_sym
+        when "tag"
+          tag = value
+        when "tagger"
+          tagger = UserInfo.new(value)
+        else
+          warn "unknown header '%s' in tag" % \
+            [key, rawobject.sha1.unpack("H*")[0]]
+        end
+      end
+
+      if not object && type && tag && tagger
+        raise RuntimeError, "incomplete raw tag object"
+      end
+      new(object, type, tag, tagger, message, repository)
+    end
+
+    def initialize(object, type, tag, tagger, message, repository=nil)
+      @object = object
+      @type = type
+      @object_type = type
+      @tag = tag
+      @tagger = tagger
+      @repository = repository
+      @message = message
+    end
+
+    def raw_content
+      ("object %s\ntype %s\ntag %s\ntagger %s\n\n" % \
+        [@object, @type, @tag, @tagger]) + @message.to_s
+    end
+
+    def type
+      :tag
+    end
+  end
+
+  end
+end