gitki 0.1.0

data/vendor/git_store/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2008 Matthias Georgi <http://www.matthias-georgi.de>
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/git_store/README.md

@@ -0,0 +1,147 @@
+Git Store - using Git as versioned data store in Ruby
+=====================================================
+
+GitStore implements a versioned data store based on the revision
+management system [Git][1]. You can store object hierarchies as nested
+hashes, which will be mapped on the directory structure of a git
+repository. Basically GitStore checks out the repository into a
+in-memory representation, which can be modified and finally committed.
+
+GitStore supports transactions, so that updates to the store either
+fail or succeed completely.
+
+### Installation
+
+GitStore can be installed as gem easily:
+
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install georgi-git_store
+
+### Usage Example
+
+First thing you should do, is to initialize a new git repository.
+
+    $ mkdir test
+    $ cd test
+    $ git init
+
+Now you can instantiate a GitStore instance and store some data. The
+data will be serialized depending on the file extension. So for YAML
+storage you can use the 'yml' extension:
+
+    store = GitStore.new('/path/to/repo')
+
+    store['users/matthias.yml'] = User.new('Matthias')
+    store['pages/home.yml'] = Page.new('matthias', 'Home')
+
+    store.commit 'Added user and page'
+
+### Transactions
+
+GitStore manages concurrent access by a file locking scheme. So only
+one process can start a transaction at one time. This is implemented
+by locking the `refs/head/<branch>.lock` file, which is also
+respected by the git binary.
+
+If you access the repository from different processes or threads, you
+should write to the store using transactions. If something goes wrong
+inside a transaction, all changes will be rolled back to the original
+state.
+
+    store = GitStore.new('/path/to/repo')
+
+    store.transaction do
+      # If an exception happens here, the transaction will be aborted.
+      store['pages/home.yml'] = Page.new('matthias', 'Home')
+    end
+
+
+A transaction without a block looks like this:
+
+    store.start_transaction
+ 
+    store['pages/home.yml'] = Page.new('matthias', 'Home')
+
+    store.rollback # This will restore the original state
+
+
+### Data Storage
+
+When you call the `commit` method, your data is written back straight
+into the git repository. No intermediate file representation. So if
+you want to have a look at your data, you can use a git browser like
+[git-gui][6] or checkout the files:
+
+    $ git checkout
+
+
+### Iteration
+
+Iterating over the data objects is quite easy. Furthermore you can
+iterate over trees and subtrees, so you can partition your data in a
+meaningful way. For example you may separate the config files and the
+pages of a wiki:
+
+    store['pages/home.yml'] = Page.new('matthias', 'Home')
+    store['pages/about.yml'] = Page.new('matthias', 'About')
+    store['config/wiki.yml'] = { 'name' => 'My Personal Wiki' }
+
+    # Enumerate all objects
+    store.each { |obj| ... } 
+
+    # Enumerate only pages
+    store['pages'].each { |page| ... }
+
+
+### Serialization
+
+Serialization is dependent on the filename extension. You can add more
+handlers if you like, the interface is like this:
+
+    class YAMLHandler
+      def read(data)
+        YAML.load(data)
+      end
+   
+      def write(data)
+        data.to_yaml
+      end    
+    end
+
+Shinmun uses its own handler for files with `md` extension:
+
+    class PostHandler
+      def read(data)
+        Post.new(:src => data)
+      end
+   
+      def write(post)
+        post.dump
+      end    
+    end
+
+    store = GitStore.new('.')
+    store.handler['md'] = PostHandler.new
+
+
+### GitStore on GitHub
+
+Download or fork the project on its [Github page][5]
+
+### Mailing List
+
+Please join the [GitStore Google Group][3] for further discussion.
+
+### Related Work
+
+John Wiegley already has done [something similar for Python][4].
+
+
+
+[1]: http://git.or.cz/
+[2]: http://github.com/mojombo/grit
+[3]: http://groups.google.com/group/gitstore
+[4]: http://www.newartisans.com/blog_files/git.versioned.data.store.php
+[5]: http://github.com/georgi/git_store
+[6]: http://www.kernel.org/pub/software/scm/git/docs/git-gui.html
+[7]: http://www.matthias-georgi.de/shinmun

data/vendor/git_store/Rakefile

@@ -0,0 +1,35 @@
+require 'rake'
+require "rake/rdoctask"
+
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install the rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['-cfs']
+  t.spec_files = FileList['test/**/*_spec.rb']
+end
+
+desc "Print SpecDocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+  t.spec_opts = ["--format", "specdoc"]
+  t.spec_files = FileList['test/*_spec.rb']
+end
+
+desc "Generate the RDoc"
+Rake::RDocTask.new do |rdoc|
+  files = ["README.md", "LICENSE", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.md"
+  rdoc.title = "Git Store - using Git as versioned data store in Ruby"
+end
+
+desc "Run the rspec"
+task :default => :spec

data/vendor/git_store/TODO

@@ -0,0 +1,3 @@
+* File history
+* File diffs
+* Retrieving all paths of a repository.

data/vendor/git_store/git_store.gemspec

@@ -0,0 +1,40 @@
+Gem::Specification.new do |s|
+  s.name = 'git_store'
+  s.version = '0.3.1'
+  s.summary = 'a simple data store based on git'
+  s.author = 'Matthias Georgi'
+  s.email = 'matti.georgi@gmail.com'
+  s.homepage = 'http://ww.matthias-georgi.de/git_store'
+  s.description = <<END
+GitStore implements a versioned data store based on the revision
+management system Git. You can store object hierarchies as nested
+hashes, which will be mapped on the directory structure of a git
+repository. GitStore checks out the repository into a in-memory
+representation, which can be modified and finally committed.
+END
+  s.require_path = 'lib'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.md']  
+  s.files = %w{
+.gitignore
+LICENSE
+README.md
+Rakefile
+git_store.gemspec
+lib/git_store.rb
+lib/git_store/blob.rb
+lib/git_store/commit.rb
+lib/git_store/diff.rb
+lib/git_store/handlers.rb
+lib/git_store/pack.rb
+lib/git_store/tag.rb
+lib/git_store/tree.rb
+lib/git_store/user.rb
+test/bare_store_spec.rb
+test/benchmark.rb
+test/commit_spec.rb
+test/git_store_spec.rb
+test/tree_spec.rb
+}
+end
+

data/vendor/git_store/lib/git_store.rb

@@ -0,0 +1,373 @@
+require 'rubygems'
+require 'zlib'
+require 'digest/sha1'
+require 'yaml'
+require 'fileutils'
+
+require 'git_store/blob'
+require 'git_store/diff'
+require 'git_store/tree'
+require 'git_store/tag'
+require 'git_store/user'
+require 'git_store/pack'
+require 'git_store/commit'
+require 'git_store/handlers'
+
+# GitStore implements a versioned data store based on the revision
+# management system git. You can store object hierarchies as nested
+# hashes, which will be mapped on the directory structure of a git
+# repository.
+#
+# GitStore supports transactions, so that updates to the store either
+# fail or succeed completely.
+#
+# GitStore manages concurrent access by a file locking scheme. So only
+# one process can start a transaction at one time. This is implemented
+# by locking the `refs/head/<branch>.lock` file, which is also respected
+# by the git binary.
+#
+# A regular commit should be atomic by the nature of git, as the only
+# critical part is writing the 40 bytes SHA1 hash of the commit object
+# to the file `refs/head/<branch>`, which is done atomically by the
+# operating system.
+#
+# So reading a repository should be always consistent in a git
+# repository. The head of a branch points to a commit object, which in
+# turn points to a tree object, which itself is a snapshot of the
+# GitStore at commit time. All involved objects are keyed by their
+# SHA1 value, so there is no chance for another process to write to
+# the same files.
+#
+class GitStore
+  include Enumerable
+
+  TYPE_CLASS = {
+    'tree' => Tree,
+    'blob' => Blob,
+    'commit' => Commit,
+    'tag' => Tag
+  }     
+
+  CLASS_TYPE = {
+    Tree => 'tree',
+    Blob => 'blob',
+    Commit => 'commit',
+    Tag => 'tag'
+  }     
+
+  attr_reader :path, :index, :root, :branch, :lock_file, :head, :packs, :handler, :bare, :objects
+
+  # Initialize a store.
+  def initialize(path, branch = 'master', bare = false)
+    if bare && !File.exists?("#{path}") or 
+        !bare && !File.exists?("#{path}/.git")
+      raise ArgumentError, "first argument must be a valid Git repository: `#{path}'"
+    end
+    
+    @bare    = bare
+    @path    = path.chomp('/')
+    @branch  = branch
+    @root    = Tree.new(self)
+    @packs   = {}
+    @objects = {}
+    
+    init_handler
+    
+    load_packs("#{git_path}/objects/pack")
+    load
+  end
+
+  def init_handler
+    @handler = {
+      'yml' => YAMLHandler.new
+    }    
+    @handler.default = DefaultHandler.new
+  end
+
+  # The path to the current head file.
+  def head_path
+    "#{git_path}/refs/heads/#{branch}"
+  end
+
+  # The path to the object file for given id.
+  def object_path(id)
+    "#{git_path}/objects/#{ id[0...2] }/#{ id[2..39] }"
+  end
+
+  def git_path
+    if bare
+      "#{path}"
+    else
+      "#{path}/.git"
+    end
+  end
+
+  # Read the id of the head commit.
+  #
+  # Returns the object id of the last commit.
+  def read_head_id
+    File.read(head_path).strip if File.exists?(head_path)
+  end
+
+  def handler_for(path)
+    handler[ path.split('.').last ]
+  end
+
+  # Read an object for the specified path.
+  def [](path)
+    root[path] 
+  end
+
+  # Write an object to the specified path.
+  def []=(path, data)
+    root[path] = data
+  end
+
+  # Iterate over all key-values pairs found in this store.
+  def each(&block)
+    root.each(&block)
+  end
+
+  def paths
+    root.paths
+  end
+
+  def values
+    root.values
+  end
+
+  def delete(path)
+    root.delete(path)
+  end
+
+  def tree(name)
+    root.tree(name)
+  end
+
+  # Returns the store as a hash tree.
+  def to_hash
+    root.to_hash
+  end
+
+  # Inspect the store.
+  def inspect
+    "#<GitStore #{path} #{branch}>"
+  end
+
+  # Has our store been changed on disk?
+  def changed?
+    head.nil? or head.id != read_head_id
+  end
+
+  # Load the current head version from repository. 
+  def load(from_disk = false)
+    if id = read_head_id
+      @head = get(id)
+      @root = @head.tree
+    end
+    
+    load_from_disk if from_disk
+  end
+  
+  def load_from_disk
+    root.each_blob do |path, blob|
+      file = "#{self.path}/#{path}"      
+      if File.file?(file)
+        blob.data = File.read(file)
+      end
+    end
+  end
+
+  # Reload the store, if it has been changed on disk.
+  def refresh!
+    load if changed?
+  end
+
+  # Is there any transaction going on?
+  def in_transaction?
+    Thread.current['git_store_lock']
+  end
+
+  # All changes made inside a transaction are atomic. If some
+  # exception occurs the transaction will be rolled back.
+  #
+  # Example:
+  #   store.transaction { store['a'] = 'b' }
+  #
+  def transaction(message = "")
+    start_transaction
+    result = yield
+    commit message
+    
+    result
+  rescue
+    rollback
+    raise
+  ensure
+    finish_transaction
+  end
+
+  # Start a transaction.
+  #
+  # Tries to get lock on lock file, reload the this store if
+  # has changed in the repository.
+  def start_transaction
+    file = open("#{head_path}.lock", "w")
+    file.flock(File::LOCK_EX)
+    
+    Thread.current['git_store_lock'] = file
+    
+    load if changed?
+  end
+
+  # Restore the state of the store.
+  #
+  # Any changes made to the store are discarded.
+  def rollback
+    objects.clear
+    load
+    finish_transaction
+  end
+  
+  # Finish the transaction.
+  #
+  # Release the lock file.
+  def finish_transaction
+    Thread.current['git_store_lock'].close rescue nil
+    Thread.current['git_store_lock'] = nil
+    
+    File.unlink("#{head_path}.lock") rescue nil    
+  end
+
+  # Write the commit object to disk and set the head of the current branch.
+  #
+  # Returns the id of the commit object
+  def commit(message = '', author = User.from_config, committer = author)
+    root.write
+    
+    commit = Commit.new(self)
+    commit.tree = root
+    commit.parent << head.id if head
+    commit.author = author
+    commit.committer = committer
+    commit.message = message
+    commit.write
+
+    open(head_path, "wb") do |file|
+      file.write(commit.id)
+    end
+
+    @head = commit
+  end
+
+  def commits(limit = 10, start = head)
+    entries = []
+    current = start
+    
+    while current and entries.size < limit
+      entries << current
+      current = get(current.parent.first)
+    end
+
+    entries
+  end
+
+  def get(id)
+    return nil if id.nil?
+
+    return objects[id] if objects.has_key?(id)
+    
+    type, content = get_object(id)
+
+    klass = TYPE_CLASS[type] or raise NotImplementedError, "type not supported: #{type}"
+    
+    objects[id] = klass.new(self, id, content)
+  end
+
+  def put(object)
+    type = CLASS_TYPE[object.class] or raise NotImplementedError, "class not supported: #{object.class}"
+    
+    id = put_object(type, object.dump)
+
+    objects[id] = object
+
+    id
+  end
+
+  # Returns the hash value of an object string.
+  def sha(str)
+    Digest::SHA1.hexdigest(str)[0, 40]
+  end
+
+  def id_for(type, content)
+    sha "#{type} #{content.length}\0#{content}"
+  end
+
+  # Read the raw object with the given id from the repository.
+  #
+  # Returns a pair of content and type of the object
+  def get_object(id)
+    path = object_path(id)
+    
+    if File.exists?(path)
+      buf = open(path, "rb") { |f| f.read }
+
+      raise "not a loose object: #{id}" if not legacy_loose_object?(buf)
+      
+      header, content = Zlib::Inflate.inflate(buf).split(/\0/, 2)
+      type, size = header.split(/ /, 2)
+      
+      raise "bad object: #{id}" if content.length != size.to_i
+    else
+      content, type = get_object_from_pack(id)
+    end
+    
+    return type, content
+  end
+  
+  # Write a raw object to the repository.
+  #
+  # Returns the object id.
+  def put_object(type, content)
+    data = "#{type} #{content.length}\0#{content}"    
+    id = sha(data)
+    path = object_path(id)
+    
+    unless File.exists?(path)
+      FileUtils.mkpath(File.dirname(path))
+      open(path, 'wb') do |f|
+        f.write Zlib::Deflate.deflate(data)
+      end
+    end
+
+    id
+  end
+
+  def legacy_loose_object?(buf)
+    word = (buf[0] << 8) + buf[1]
+    
+    buf[0] == 0x78 && word % 31 == 0
+  end  
+
+  def get_object_from_pack(id)
+    pack, offset = @packs[id]
+    
+    pack.parse_object(offset) if pack
+  end      
+
+  def load_packs(path)
+    if File.directory?(path)
+      Dir.open(path) do |dir|        
+        entries = dir.select { |entry| entry =~ /\.pack$/i }
+        entries.each do |entry|
+          pack = PackStorage.new(File.join(path, entry))
+          pack.each_entry do |id, offset|
+            id = id.unpack("H*").first
+            @packs[id] = [pack, offset]
+          end
+        end
+      end
+    end
+  end
+
+end