git_store 0.3.1

data/.gitignore

@@ -0,0 +1,5 @@
+*~
+doc/*
+pkg/*
+test/repo
+html/*

data/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/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/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/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/lib/git_store/blob.rb

@@ -0,0 +1,32 @@
+class GitStore
+
+  # This class stores the raw string data of a blob, but also the
+  # deserialized data object.
+  class Blob
+
+    attr_accessor :store, :id, :data, :mode, :object
+
+    # Initialize a Blob
+    def initialize(store, id = nil, data = nil)
+      @store = store
+      @id = id || store.id_for('blob', data)
+      @data = data
+      @mode = "100644"
+    end
+
+    def ==(other)
+      Blob === other and id == other.id
+    end
+
+    def dump
+      @data
+    end
+
+    # Write the data to the git object store
+    def write
+      @id = store.put(self)
+    end
+
+  end
+
+end

data/lib/git_store/commit.rb

@@ -0,0 +1,65 @@
+class GitStore
+
+  class Commit
+    attr_accessor :store, :id, :tree, :parent, :author, :committer, :message
+
+    def initialize(store, id = nil, data = nil)
+      @store = store
+      @id = id
+      @parent = []
+
+      parse(data) if data
+    end
+
+    def ==(other)
+      Commit === 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 'parent'
+          @parent << value
+
+        when 'author'
+          @author = User.parse(value)
+
+        when 'committer'
+          @committer = User.parse(value)
+
+        when 'tree'
+          @tree = store.get(value)
+        end
+      end
+
+      self
+    end
+
+    def diff(commit, path = nil)
+      commit = commit.id if Commit === commit
+      Diff.exec(store, "git diff --full-index #{commit} #{id} -- '#{path}'")
+    end
+
+    def diffs(path = nil)
+      diff(parent.first, path)
+    end
+
+    def write
+      @id = store.put(self)
+    end
+
+    def dump
+      [ "tree #{ tree.id }",
+        parent.map { |parent| "parent #{parent}" },
+        "author #{ author.dump }",
+        "committer #{ committer.dump }",
+        '',
+        message ].flatten.join("\n")
+    end
+
+  end
+
+end

data/lib/git_store/diff.rb

@@ -0,0 +1,76 @@
+class GitStore
+
+  # adapted from Grit
+  class Diff
+    attr_reader :store
+    attr_reader :a_path, :b_path
+    attr_reader :a_blob, :b_blob
+    attr_reader :a_mode, :b_mode
+    attr_reader :new_file, :deleted_file
+    attr_reader :diff
+
+    def initialize(store, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff)
+      @store = store
+      @a_path = a_path
+      @b_path = b_path
+      @a_blob = a_blob =~ /^0{40}$/ ? nil : store.get(a_blob)
+      @b_blob = b_blob =~ /^0{40}$/ ? nil : store.get(b_blob)
+      @a_mode = a_mode
+      @b_mode = b_mode
+      @new_file = new_file
+      @deleted_file = deleted_file
+      @diff = diff
+    end
+
+    def self.exec(store, cmd)
+      list(store, IO.popen(cmd) { |io| io.read })
+    end
+
+    def self.list(store, 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(store, a_path, b_path, nil, nil, a_mode, b_mode, false, false, nil)
+          next
+        end
+
+        new_file = false
+        deleted_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
+        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(store, a_path, b_path, a_blob, b_blob, a_mode, b_mode, new_file, deleted_file, diff)
+      end
+
+      diffs
+    end
+  end
+
+end

data/lib/git_store/handlers.rb

@@ -0,0 +1,36 @@
+
+# This fix ensures sorted yaml maps.
+class Hash
+	def to_yaml( opts = {} )
+		YAML::quick_emit( object_id, opts ) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        sort_by { |k, v| k.to_s }.each do |k, v|
+          map.add( k, v )
+        end
+      end
+    end
+	end
+end
+
+class GitStore
+
+  class DefaultHandler
+    def read(data)
+      data
+    end
+
+    def write(data)
+      data.to_s
+    end
+  end
+
+  class YAMLHandler
+    def read(data)
+      YAML.load(data)
+    end
+
+    def write(data)
+      data.to_yaml
+    end
+  end
+end