gitki 0.1.0

data/vendor/git_store/lib/git_store/tag.rb

@@ -0,0 +1,40 @@
+class GitStore
+
+  class Tag
+    attr_accessor :store, :id, :object, :type, :tagger, :message
+
+    def initialize(store, id = nil, data = nil)
+      @store = store
+      @id = id
+
+      parse(data) if data
+    end
+
+    def ==(other)
+      Tag === other and id == other.id
+    end        
+
+    def parse(data)
+      headers, @message = data.split(/\n\n/, 2)
+
+      headers.split(/\n/).each do |header|
+        key, value = header.split(/ /, 2)
+        case key
+        when 'type'
+          @type = value
+
+        when 'object'
+          @object = store.get(value)
+
+        when 'tagger'
+          @tagger = User.parse(value)
+
+        end
+      end
+
+      self
+    end
+
+  end
+
+end

data/vendor/git_store/lib/git_store/tree.rb

@@ -0,0 +1,183 @@
+class GitStore
+
+  class Tree
+    include Enumerable
+
+    attr_reader :store, :table
+    attr_accessor :id, :data, :mode
+
+    # Initialize a tree
+    def initialize(store, id = nil, data = nil)
+      @store = store
+      @id = id
+      @table = {}
+      @mode = "040000"
+      parse(data) if data
+    end
+
+    def ==(other)
+      Tree === other and id == other.id
+    end
+
+    # Has this tree been modified?
+    def modified?
+      @modified or @table.values.any? { |entry| Tree === entry and entry.modified? }
+    end
+
+    # Find or create a subtree with specified name.
+    def tree(name)
+      get(name) or put(name, Tree.new(store))
+    end
+
+    # Read the contents of a raw git object.
+    def parse(data)
+      @table.clear
+
+      while data.size > 0
+        mode, data = data.split(" ", 2)
+        name, data = data.split("\0", 2)
+        id = data.slice!(0, 20).unpack("H*").first
+        
+        @table[name] = store.get(id)
+      end
+    end
+
+    def dump
+      @table.map { |k, v| "#{ v.mode } #{ k }\0#{ [v.write].pack("H*") }" }.join
+    end
+    
+    # Write this tree back to the git repository.
+    #
+    # Returns the object id of the tree.
+    def write
+      return id if not modified?      
+      @modified = false
+      @id = store.put(self)
+    end
+
+    # Read entry with specified name.
+    def get(name)
+      entry = @table[name]
+      
+      case entry
+      when Blob
+        entry.object ||= handler_for(name).read(entry.data)
+          
+      when Tree
+        entry
+      end
+    end
+
+    def handler_for(name)
+      store.handler_for(name)
+    end    
+
+    # Write entry with specified name.
+    def put(name, value)
+      @modified = true
+      
+      if value.is_a?(Tree)
+        @table[name] = value
+      else
+        @table[name] = Blob.new(store, nil, handler_for(name).write(value))
+      end
+     
+      value
+    end
+
+    # Remove entry with specified name.
+    def remove(name)
+      @modified = true
+      @table.delete(name.to_s)
+    end
+
+    # Does this key exist in the table?
+    def has_key?(name)
+      @table.has_key?(name.to_s)
+    end
+
+    def normalize_path(path)
+      (path[0, 1] == '/' ? path[1..-1] : path).split('/')
+    end    
+
+    # Read a value on specified path.
+    def [](path)
+      normalize_path(path).inject(self) do |tree, key|
+        tree.get(key) or return nil
+      end
+    end
+
+    # Write a value on specified path.
+    def []=(path, value)
+      list = normalize_path(path)
+      tree = list[0..-2].to_a.inject(self) { |tree, name| tree.tree(name) }
+      tree.put(list.last, value)
+    end
+
+    # Delete a value on specified path.
+    def delete(path)
+      list = normalize_path(path)
+      
+      tree = list[0..-2].to_a.inject(self) do |tree, key|
+        tree.get(key) or return
+      end
+      
+      tree.remove(list.last)
+    end
+
+    # Iterate over all objects found in this subtree.
+    def each(path = [], &block)
+      @table.sort.each do |name, entry|
+        child_path = path + [name]
+        case entry
+        when Blob
+          entry.object ||= handler_for(name).read(entry.data)
+          yield child_path.join("/"), entry.object
+          
+        when Tree
+          entry.each(child_path, &block)
+        end
+      end
+    end
+
+    def each_blob(path = [], &block)
+      @table.sort.each do |name, entry|
+        child_path = path + [name]
+
+        case entry
+        when Blob
+          yield child_path.join("/"), entry
+          
+        when Tree
+          entry.each_blob(child_path, &block)
+        end
+      end
+    end
+
+    def paths
+      map { |path, data| path }
+    end
+
+    def values
+      map { |path, data| data }
+    end
+
+    # Convert this tree into a hash object.
+    def to_hash
+      @table.inject({}) do |hash, (name, entry)|
+        if entry.is_a?(Tree) 
+          hash[name] = entry.to_hash
+        else
+          hash[name] = entry.object ||= handler_for(name).read(entry.data)
+        end
+        hash
+      end
+    end
+
+    def inspect
+      "#<GitStore::Tree #{id} #{mode} #{to_hash.inspect}>"
+    end
+    
+  end
+
+end

data/vendor/git_store/lib/git_store/user.rb

@@ -0,0 +1,29 @@
+class GitStore
+
+  class User
+    attr_accessor :name, :email, :time
+
+    def initialize(name, email, time)
+      @name, @email, @time = name, email, time
+    end
+
+    def dump
+      "#{ name } <#{email}> #{ time.to_i } #{ time.strftime('%z') }"
+    end
+
+    def self.from_config
+      name = IO.popen("git config user.name")  { |io| io.gets.chomp }
+      email = IO.popen("git config user.email") { |io| io.gets.chomp }
+      
+      new name, email, Time.now
+    end
+
+    def self.parse(user)
+      if match = user.match(/(.*)<(.*)> (\d+) ([+-]\d+)/)
+        new match[1].strip, match[2].strip, Time.at(match[3].to_i + match[4].to_i * 3600)
+      end
+    end    
+    
+  end
+  
+end

data/vendor/git_store/test/bare_store_spec.rb

@@ -0,0 +1,33 @@
+require "#{File.dirname(__FILE__)}/../lib/git_store"
+require "#{File.dirname(__FILE__)}/helper"
+require 'pp'
+
+describe GitStore do
+
+  REPO = '/tmp/git_store_test.git'
+
+  attr_reader :store
+
+  before(:each) do
+    FileUtils.rm_rf REPO
+    Dir.mkdir REPO
+    Dir.chdir REPO
+
+    `git init --bare`
+    @store = GitStore.new(REPO, 'master', true)
+  end
+
+  it 'should fail to initialize without a valid git repository' do
+    lambda {
+      GitStore.new('/foo', 'master', true)
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'should save and load entries' do
+    store['a'] = 'Hello'
+    store.commit
+    store.load
+    
+    store['a'].should == 'Hello'
+  end
+end

data/vendor/git_store/test/benchmark.rb

@@ -0,0 +1,30 @@
+require 'git_store'
+require 'grit'
+require 'benchmark'
+require 'fileutils'
+
+REPO = '/tmp/git-store'
+
+FileUtils.rm_rf REPO
+FileUtils.mkpath REPO
+Dir.chdir REPO
+
+`git init`
+
+store = GitStore.new(REPO)
+
+Benchmark.bm 20 do |x|
+  x.report 'store 1000 objects' do
+    store.transaction { 'aaa'.upto('jjj') { |key| store[key] = rand.to_s } }
+  end
+  x.report 'commit one object' do
+    store.transaction { store['aa'] = rand.to_s }
+  end
+  x.report 'load 1000 objects' do
+    GitStore.new('.').values { |v| v }
+  end
+  x.report 'load 1000 with grit' do
+    Grit::Repo.new('.').tree.contents.each { |e| e.data }
+  end  
+end
+

data/vendor/git_store/test/commit_spec.rb

@@ -0,0 +1,81 @@
+require "#{File.dirname(__FILE__)}/../lib/git_store"
+require 'pp'
+
+describe GitStore::Commit do
+  
+  REPO = '/tmp/git_store_test'
+
+  attr_reader :store
+
+  before(:each) do
+    FileUtils.rm_rf REPO
+    Dir.mkdir REPO
+    Dir.chdir REPO
+    `git init`
+    @store = GitStore.new(REPO)
+  end
+
+  it "should dump in right format" do
+    user = GitStore::User.new("hanni", "hanni@email.de", Time.now)
+
+    commit = GitStore::Commit.new(nil)
+    commit.tree = @store.root.id
+    commit.author = user
+    commit.committer = user
+    commit.message = "This is a message"
+
+    commit.dump.should == "tree #{@store.root.id}
+author #{user.dump}
+committer #{user.dump}
+
+This is a message"
+  end
+
+  it "should be readable by git binary" do
+    time = Time.local(2009, 4, 20)
+    author = GitStore::User.new("hans", "hans@email.de", time)
+    
+    store['a'] = "Yay"
+    commit = store.commit("Commit Message", author, author)
+
+    IO.popen("git log") do |io|
+      io.gets.should == "commit #{commit.id}\n"
+      io.gets.should == "Author: hans <hans@email.de>\n"
+      io.gets.should == "Date:   Mon Apr 20 00:00:00 2009 #{Time.now.strftime('%z')}\n"
+      io.gets.should == "\n"
+      io.gets.should == "    Commit Message\n"
+    end
+  end
+
+  it "should diff 2 commits" do
+    store['x'] = 'a'
+    store['y'] = "
+First Line.
+Second Line.
+Last Line.
+"
+    a = store.commit
+
+    store.delete('x')
+    store['y'] = "
+First Line.
+Last Line.
+Another Line.
+"
+    store['z'] = 'c'
+
+    b = store.commit
+
+    diff = b.diff(a)
+
+    diff[0].a_path.should == 'x'
+    diff[0].deleted_file.should be_true
+
+    diff[1].a_path.should == 'y'
+    diff[1].diff.should == "--- a/y\n+++ b/y\n@@ -1,4 +1,4 @@\n \n First Line.\n-Second Line.\n Last Line.\n+Another Line."
+
+    diff[2].a_path.should == 'z'
+    diff[2].new_file.should be_true
+  end
+  
+end

data/vendor/git_store/test/git_store_spec.rb

@@ -0,0 +1,257 @@
+require "#{File.dirname(__FILE__)}/../lib/git_store"
+require "#{File.dirname(__FILE__)}/helper"
+require 'pp'
+
+describe GitStore do
+
+  REPO = '/tmp/git_store_test'
+
+  attr_reader :store
+
+  before(:each) do
+    FileUtils.rm_rf REPO
+    Dir.mkdir REPO
+    Dir.chdir REPO
+    
+    `git init`
+    @store = GitStore.new(REPO)
+  end
+  
+  def file(file, data)
+    FileUtils.mkpath(File.dirname(file))
+    open(file, 'w') { |io| io << data }
+    
+    `git add #{file}`
+    `git commit -m 'added #{file}'`
+    File.unlink(file)
+  end
+  
+  it 'should fail to initialize without a valid git repository' do
+    lambda {
+      GitStore.new('/')
+    }.should raise_error(ArgumentError)
+  end
+
+  it 'should find modified entries' do
+    store['a'] = 'Hello'
+
+    store.root.should be_modified
+
+    store.commit
+    
+    store.root.should_not be_modified
+
+    store['a'] = 'Bello'
+
+    store.root.should be_modified
+  end
+
+  it 'should load a repo' do
+    file 'a', 'Hello'
+    file 'b', 'World'
+    
+    store.load
+
+    store['a'].should == 'Hello'
+    store['b'].should == 'World'
+  end
+
+  it 'should load folders' do
+    file 'x/a', 'Hello'
+    file 'y/b', 'World'
+    
+    store.load
+    store['x'].should be_kind_of(GitStore::Tree)
+    store['y'].should be_kind_of(GitStore::Tree)
+
+    store['x']['a'].should == 'Hello'
+    store['y']['b'].should == 'World'
+  end
+
+  it 'should load yaml' do
+    file 'x/a.yml', '[1, 2, 3, 4]'
+
+    store.load
+    
+    store['x']['a.yml'].should == [1,2,3,4]    
+    store['x']['a.yml'] = [1,2,3,4,5]
+  end
+
+  it 'should save yaml' do
+    store['x/a.yml'] = [1,2,3,4,5]      
+    store['x/a.yml'].should == [1,2,3,4,5]
+  end
+
+  it 'should detect modification' do    
+    store.transaction do
+      store['x/a'] = 'a'
+    end
+    
+    store.load
+
+    store['x/a'].should == 'a'
+
+    store.transaction do
+      store['x/a'] = 'b'
+      store['x'].should be_modified
+      store.root.should be_modified
+    end
+
+    store.load
+
+    store['x/a'].should == 'b'
+  end
+
+  it 'should resolve paths' do
+    file 'x/a', 'Hello'
+    file 'y/b', 'World'
+    
+    store.load
+    
+    store['x/a'].should == 'Hello'
+    store['y/b'].should == 'World'
+
+    store['y/b'] = 'Now this'
+
+    store['y']['b'].should == 'Now this'        
+  end
+
+  it 'should create new trees' do
+    store['new/tree'] = 'This tree'
+    store['new/tree'].should == 'This tree'
+  end
+
+  it 'should delete entries' do
+    store['a'] = 'Hello'
+    store.delete('a')
+    
+    store['a'].should be_nil
+  end
+
+  it 'should have a head commit' do
+    file 'a', 'Hello'
+
+    store.load
+    store.head.should_not be_nil
+  end
+
+  it 'should detect changes' do
+    file 'a', 'Hello'
+
+    store.should be_changed
+  end
+
+  it 'should rollback a transaction' do
+    file 'a/b', 'Hello'
+    file 'c/d', 'World'
+
+    begin
+      store.transaction do
+        store['a/b'] = 'Changed'
+        store['x/a'] = 'Added'
+        raise
+      end
+    rescue
+    end
+
+    store['a/b'].should == 'Hello'
+    store['c/d'].should == 'World'
+    store['x/a'].should be_nil
+  end
+
+  it 'should commit a transaction' do
+    file 'a/b', 'Hello'
+    file 'c/d', 'World'
+
+    store.transaction do
+      store['a/b'] = 'Changed'
+      store['x/a'] = 'Added'
+    end
+
+    a = git_ls_tree(store['a'].id)
+    x = git_ls_tree(store['x'].id)
+
+    a.should == [["100644", "blob", "b653cf27cef08de46da49a11fa5016421e9e3b32", "b"]]
+    x.should == [["100644", "blob", "87d2b203800386b1cc8735a7d540a33e246357fa", "a"]]      
+
+    git_show(a[0][2]).should == 'Changed'
+    git_show(x[0][2]).should == 'Added'
+  end
+  
+  it "should save blobs" do
+    store['a'] = 'a'
+    store['b'] = 'b'
+    store['c'] = 'c'
+
+    store.commit
+
+    a = store.id_for('blob', 'a')
+    b = store.id_for('blob', 'b')
+    c = store.id_for('blob', 'c')
+
+    git_show(a).should == 'a'
+    git_show(b).should == 'b'
+    git_show(c).should == 'c'
+  end  
+
+  it 'should allow only one transaction' do
+    file 'a/b', 'Hello'
+
+    ready = false
+
+    store.transaction do
+      Thread.start do
+        store.transaction do
+          store['a/b'] = 'Changed by second thread'
+        end
+        ready = true
+      end
+      store['a/b'] = 'Changed'
+    end
+
+    sleep 0.01 until ready
+
+    store.load
+    
+    store['a/b'].should == 'Changed by second thread'
+  end
+  
+  it 'should find all objects' do
+    store.load
+    store['c'] = 'Hello'
+    store['d'] = 'World'
+    store.commit
+
+    store.to_a.should == [['c', 'Hello'], ['d', 'World']]
+  end
+
+  it "should load commits" do
+    store['a'] = 'a'
+    store.commit 'added a'
+
+    store['b'] = 'b'
+    store.commit 'added b'
+
+    store.commits[0].message.should == 'added b'
+    store.commits[1].message.should == 'added a'
+  end
+
+  it "should load tags" do
+    file 'a', 'init'
+    
+    `git tag -m 'message' 0.1`
+
+    store.load
+
+    user = GitStore::User.from_config
+    id = File.read('.git/refs/tags/0.1')
+    tag = store.get(id)
+
+    tag.type.should == 'commit'
+    tag.object.should == store.head
+    tag.tagger.name.should == user.name
+    tag.tagger.email.should == user.email
+    tag.message.should =~ /message/    
+  end
+  
+end