jit 0.0.0 → 1.0.0

data/lib/config/stack.rb

@@ -0,0 +1,42 @@
+require "pathname"
+require_relative "../config"
+
+class Config
+  class Stack
+
+    GLOBAL_CONFIG = File.expand_path("~/.gitconfig")
+    SYSTEM_CONFIG = "/etc/gitconfig"
+
+    def initialize(git_path)
+      @configs = {
+        :local  => Config.new(git_path.join("config")),
+        :global => Config.new(Pathname.new(GLOBAL_CONFIG)),
+        :system => Config.new(Pathname.new(SYSTEM_CONFIG))
+      }
+    end
+
+    def file(name)
+      if @configs.has_key?(name)
+        @configs[name]
+      else
+        Config.new(Pathname.new(name))
+      end
+    end
+
+    def open
+      @configs.each_value(&:open)
+    end
+
+    def get(key)
+      get_all(key).last
+    end
+
+    def get_all(key)
+      [:system, :global, :local].flat_map do |name|
+        @configs[name].open
+        @configs[name].get_all(key)
+      end
+    end
+
+  end
+end

data/lib/database.rb

@@ -0,0 +1,112 @@
+require "digest/sha1"
+require "forwardable"
+require "pathname"
+require "strscan"
+
+require_relative "./database/author"
+require_relative "./database/blob"
+require_relative "./database/commit"
+require_relative "./database/entry"
+require_relative "./database/tree"
+require_relative "./database/tree_diff"
+
+require_relative "./database/backends"
+
+class Database
+  TYPES = {
+    "blob"   => Blob,
+    "tree"   => Tree,
+    "commit" => Commit
+  }
+
+  Raw = Struct.new(:type, :size, :data)
+
+  extend Forwardable
+  def_delegators :@backend, :has?, :load_info, :load_raw,
+                            :prefix_match, :pack_path
+
+  def initialize(pathname)
+    @objects = {}
+    @backend = Backends.new(pathname)
+  end
+
+  def store(object)
+    content    = serialize_object(object)
+    object.oid = hash_content(content)
+
+    @backend.write_object(object.oid, content)
+  end
+
+  def hash_object(object)
+    hash_content(serialize_object(object))
+  end
+
+  def load(oid)
+    @objects[oid] ||= read_object(oid)
+  end
+
+  def load_tree_entry(oid, pathname)
+    commit = load(oid)
+    root   = Database::Entry.new(commit.tree, Tree::TREE_MODE)
+
+    return root unless pathname
+
+    pathname.each_filename.reduce(root) do |entry, name|
+      entry ? load(entry.oid).entries[name] : nil
+    end
+  end
+
+  def load_tree_list(oid, pathname = nil)
+    return {} unless oid
+
+    entry = load_tree_entry(oid, pathname)
+    list  = {}
+
+    build_list(list, entry, pathname || Pathname.new(""))
+    list
+  end
+
+  def build_list(list, entry, prefix)
+    return unless entry
+    return list[prefix.to_s] = entry unless entry.tree?
+
+    load(entry.oid).each_entry do |name, item|
+      build_list(list, item, prefix.join(name))
+    end
+  end
+
+  def tree_entry(oid)
+    Entry.new(oid, Tree::TREE_MODE)
+  end
+
+  def short_oid(oid)
+    oid[0..6]
+  end
+
+  def tree_diff(a, b, prune = [])
+    diff = TreeDiff.new(self, prune)
+    diff.compare_oids(a, b)
+    diff.changes
+  end
+
+  private
+
+  def serialize_object(object)
+    string = object.to_s.force_encoding(Encoding::ASCII_8BIT)
+    "#{ object.type } #{ string.bytesize }\0#{ string }"
+  end
+
+  def hash_content(string)
+    Digest::SHA1.hexdigest(string)
+  end
+
+  def read_object(oid)
+    raw     = load_raw(oid)
+    scanner = StringScanner.new(raw.data)
+
+    object = TYPES[raw.type].parse(scanner)
+    object.oid = oid
+
+    object
+  end
+end

data/lib/database/author.rb

@@ -0,0 +1,27 @@
+require "time"
+
+class Database
+  TIME_FORMAT = "%s %z"
+
+  Author = Struct.new(:name, :email, :time) do
+    def self.parse(string)
+      name, email, time = string.split(/<|>/).map(&:strip)
+      time = Time.strptime(time, TIME_FORMAT)
+
+      Author.new(name, email, time)
+    end
+
+    def short_date
+      time.strftime("%Y-%m-%d")
+    end
+
+    def readable_time
+      time.strftime("%a %b %-d %H:%M:%S %Y %z")
+    end
+
+    def to_s
+      timestamp = time.strftime(TIME_FORMAT)
+      "#{ name } <#{ email }> #{ timestamp }"
+    end
+  end
+end

data/lib/database/backends.rb

@@ -0,0 +1,57 @@
+require "forwardable"
+
+require_relative "./loose"
+require_relative "./packed"
+
+class Database
+  class Backends
+
+    extend Forwardable
+    def_delegators :@loose, :write_object
+
+    def initialize(pathname)
+      @pathname = pathname
+      @loose    = Loose.new(pathname)
+      @stores   = [@loose] + packed
+    end
+
+    def pack_path
+      @pathname.join("pack")
+    end
+
+    def has?(oid)
+      @stores.any? { |store| store.has?(oid) }
+    end
+
+    def load_info(oid)
+      @stores.reduce(nil) { |info, store| info || store.load_info(oid) }
+    end
+
+    def load_raw(oid)
+      @stores.reduce(nil) { |raw, store| raw || store.load_raw(oid) }
+    end
+
+    def prefix_match(name)
+      oids = @stores.reduce([]) do |list, store|
+        list + store.prefix_match(name)
+      end
+
+      oids.uniq
+    end
+
+    private
+
+    def packed
+      packs = Dir.entries(pack_path).grep(/\.pack$/)
+              .map { |name| pack_path.join(name) }
+              .sort_by { |path| File.mtime(path) }
+              .reverse
+
+      packs.map { |path| Packed.new(path) }
+
+    rescue Errno::ENOENT
+      []
+    end
+
+  end
+end

data/lib/database/blob.rb

@@ -0,0 +1,24 @@
+class Database
+  class Blob
+
+    attr_accessor :oid
+    attr_reader :data
+
+    def self.parse(scanner)
+      Blob.new(scanner.rest)
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def type
+      "blob"
+    end
+
+    def to_s
+      @data
+    end
+
+  end
+end

data/lib/database/commit.rb

@@ -0,0 +1,70 @@
+require_relative "./author"
+
+class Database
+  class Commit
+
+    attr_accessor :oid
+    attr_reader :parents, :tree, :author, :committer, :message
+
+    def self.parse(scanner)
+      headers = Hash.new { |hash, key| hash[key] = [] }
+
+      loop do
+        line = scanner.scan_until(/\n/).strip
+        break if line == ""
+
+        key, value = line.split(/ +/, 2)
+        headers[key].push(value)
+      end
+
+      Commit.new(
+        headers["parent"],
+        headers["tree"].first,
+        Author.parse(headers["author"].first),
+        Author.parse(headers["committer"].first),
+        scanner.rest)
+    end
+
+    def initialize(parents, tree, author, committer, message)
+      @parents   = parents
+      @tree      = tree
+      @author    = author
+      @committer = committer
+      @message   = message
+    end
+
+    def merge?
+      @parents.size > 1
+    end
+
+    def parent
+      @parents.first
+    end
+
+    def date
+      @committer.time
+    end
+
+    def title_line
+      @message.lines.first
+    end
+
+    def type
+      "commit"
+    end
+
+    def to_s
+      lines = []
+
+      lines.push("tree #{ @tree }")
+      lines.concat(@parents.map { |oid| "parent #{ oid }" })
+      lines.push("author #{ @author }")
+      lines.push("committer #{ @committer }")
+      lines.push("")
+      lines.push(@message)
+
+      lines.join("\n")
+    end
+
+  end
+end

data/lib/database/entry.rb

@@ -0,0 +1,7 @@
+class Database
+  Entry = Struct.new(:oid, :mode) do
+    def tree?
+      mode == Tree::TREE_MODE
+    end
+  end
+end

data/lib/database/loose.rb

@@ -0,0 +1,70 @@
+require "strscan"
+require "zlib"
+
+require_relative "../temp_file"
+
+class Database
+  class Loose
+
+    def initialize(pathname)
+      @pathname = pathname
+    end
+
+    def has?(oid)
+      File.file?(object_path(oid))
+    end
+
+    def load_info(oid)
+      type, size, _ = read_object_header(oid, 128)
+      Raw.new(type, size)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def load_raw(oid)
+      type, size, scanner = read_object_header(oid)
+      Raw.new(type, size, scanner.rest)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def prefix_match(name)
+      dirname = object_path(name).dirname
+
+      oids = Dir.entries(dirname).map do |filename|
+        "#{ dirname.basename }#{ filename }"
+      end
+
+      oids.select { |oid| oid.start_with?(name) }
+    rescue Errno::ENOENT
+      []
+    end
+
+    def write_object(oid, content)
+      path = object_path(oid)
+      return if File.exist?(path)
+
+      file = TempFile.new(path.dirname, "tmp_obj")
+      file.write(Zlib::Deflate.deflate(content, Zlib::BEST_SPEED))
+      file.move(path.basename)
+    end
+
+    private
+
+    def object_path(oid)
+      @pathname.join(oid[0..1], oid[2..-1])
+    end
+
+    def read_object_header(oid, read_bytes = nil)
+      path    = object_path(oid)
+      data    = Zlib::Inflate.new.inflate(File.read(path, read_bytes))
+      scanner = StringScanner.new(data)
+
+      type = scanner.scan_until(/ /).strip
+      size = scanner.scan_until(/\0/)[0..-2].to_i
+
+      [type, size, scanner]
+    end
+
+  end
+end

data/lib/database/packed.rb

@@ -0,0 +1,75 @@
+require "forwardable"
+
+require_relative "../pack/expander"
+require_relative "../pack/index"
+require_relative "../pack/reader"
+
+class Database
+  class Packed
+
+    extend Forwardable
+    def_delegators :@index, :prefix_match
+
+    def initialize(pathname)
+      @pack_file = File.open(pathname, File::RDONLY)
+      @reader    = Pack::Reader.new(@pack_file)
+
+      @index_file = File.open(pathname.sub_ext(".idx"), File::RDONLY)
+      @index      = Pack::Index.new(@index_file)
+    end
+
+    def has?(oid)
+      @index.oid_offset(oid) != nil
+    end
+
+    def load_info(oid)
+      offset = @index.oid_offset(oid)
+      offset ? load_info_at(offset) : nil
+    end
+
+    def load_raw(oid)
+      offset = @index.oid_offset(oid)
+      offset ? load_raw_at(offset) : nil
+    end
+
+    private
+
+    def load_info_at(offset)
+      @pack_file.seek(offset)
+      record = @reader.read_info
+
+      case record
+      when Pack::Record
+        Raw.new(record.type, record.data)
+      when Pack::OfsDelta
+        base = load_info_at(offset - record.base_ofs)
+        Raw.new(base.type, record.delta_data)
+      when Pack::RefDelta
+        base = load_info(record.base_oid)
+        Raw.new(base.type, record.delta_data)
+      end
+    end
+
+    def load_raw_at(offset)
+      @pack_file.seek(offset)
+      record = @reader.read_record
+
+      case record
+      when Pack::Record
+        record
+      when Pack::OfsDelta
+        base = load_raw_at(offset - record.base_ofs)
+        expand_delta(base, record)
+      when Pack::RefDelta
+        base = load_raw(record.base_oid)
+        expand_delta(base, record)
+      end
+    end
+
+    def expand_delta(base, record)
+      data = Pack::Expander.expand(base.data, record.delta_data)
+      Pack::Record.new(base.type, data)
+    end
+
+  end
+end