gitmodel 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.DS_Store
+.bundle
+.gitmodel-data
+coverage
+pkg
+rdoc

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2@gitmodel

data/Gemfile

@@ -0,0 +1,5 @@
+# Edit this Gemfile to bundle your application's dependencies.
+source :rubygems
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    gitmodel (0.0.0)
+      activemodel (>= 3.0.1)
+      activesupport (>= 3.0.1)
+      grit (>= 2.3.0)
+      lockfile (>= 1.4.3)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.4.0)
+    activemodel (3.0.1)
+      activesupport (= 3.0.1)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activesupport (3.0.1)
+    autotest (4.4.1)
+    autotest-fsevent (0.2.3)
+      sys-uname
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    grit (2.3.0)
+      diff-lcs (~> 1.1)
+      mime-types (~> 1.15)
+    i18n (0.4.1)
+    lockfile (1.4.3)
+    mime-types (1.16)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+    sys-uname (0.8.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ZenTest (>= 4.4.0)
+  activemodel (>= 3.0.1)
+  activesupport (>= 3.0.1)
+  autotest (>= 4.4.1)
+  autotest-fsevent (>= 0.2.3)
+  gitmodel!
+  grit (>= 2.3.0)
+  lockfile (>= 1.4.3)
+  rspec (>= 2.0.1)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Paul Dowman
+
+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 OR COPYRIGHT HOLDERS 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,143 @@
+GitModel: distributed, versioned NoSQL for Ruby
+---------------------------------------------------
+
+_http://github.com/pauldowman/gitmodel_
+
+GitModel is an
+[ActiveModel](http://yehudakatz.com/2010/01/10/activemodel-make-any-ruby-object-feel-like-activerecord/)-compliant
+persistence framework for Ruby that uses [Git](http://git-scm.com/) for
+versioning and remote syncing.
+
+GitModel persists Ruby objects using Git as a data storage engine. It's an
+ActiveModel implementation so it works stand-alone or in Rails 3 as a drop-in
+replacement for ActiveRecord or DataMapper. 
+
+Because the database is a Git repository it can be synced across multiple
+machines, manipulated with standard Git client tools, can be branched and
+merged, and of course keeps the history of all changes.
+
+
+Status
+------
+
+_It is nowhere near production ready but I'm working on it. Please feel free to
+contribute tests and/or code to help!_
+
+
+Why it's awesome
+----------------
+
+* Schema-less NoSQL data store
+* Each record is a normal Ruby object, attributes are any Ruby type or large
+  chunks of binary data
+* Never lose data, history is kept forever and can be restored simply using
+  standard Git tools
+* Branch and merge your production data 
+  * GitModel can actually work with different branches
+  * Branch or tag snapshots of your data
+  * Experiment on production data using branches, for example to test a
+    migration
+* Distributed (synced using standard Git push/pull)
+* Transactions
+* Metadata for all database changes (Git commit messages, date & time, etc.)
+* In order to be easily human-editable, the database is simply files and
+  directores stored in a Git repository.  GitModel uses the Git repo directly
+  (rather than Git's checked-out "working copy") but you can do a "git
+  checkout" to view and manipulate the database contents, and then "git commit"
+* Test-driven development and excellent test coverage
+* Clean and easy-to-use API
+
+
+Usage
+-----
+
+    GitModel.db_root = '/tmp/gitmodel-data'
+    GitModel.create_db!
+
+    class Post
+      include GitModel::Persistable
+
+      attribute :title
+      attribute :body
+      attribute :categories, :default => []
+      attribute :allow_comments, :default => true
+
+      blob :image
+
+    end
+
+    p1 = Post.new(:id => 'lessons-learned', :title => 'Lessons learned', :body => '...')
+    p1.image = some_binary_data
+    p1.save!
+
+    p2 = Post.new(:id => 'hotdog-eating-contest', :title => 'I won!')
+    p2.body = 'This weekend I won a hotdog eating contest!'
+    p2.image = some_binary_data
+    p2.blobs['hotdogs.jpg'] = some_binary_data
+    p2.blobs['the-aftermath.jpg'] = some_binary_data
+    p2.save!
+
+    p3 = Post.create!(:id => 'running-with-scissors', :title => 'Running with scissors', :body => '...')
+
+    p4 = Post.find('running-with-scissors')
+
+
+    class Comment
+      include GitModel::Persistable
+      attribute :text
+    end
+
+    c1 = Comment.create!(:id => '2010-01-03-328', :text => '...')
+    c2 = Comment.create!(:id => '2010-05-29-742', :text => '...')
+
+
+Database file structure
+-----------------------
+
+The database is stored in a human-editable format. Simply do "git checkout -f"
+and you'll see directories and files.
+
+Each type of object is stored in a top-level directory (this is analogous to
+ActiveRecord tables), and each object is stored in a subdirectory which is
+named using the object's id (i.e. the primary key). Attributes that are Ruby
+types (strings, numbers, hashes, arrays, whatever) are stored in a file named
+attributes.json and binary attributes ("blobs") are stored in their own
+files.
+
+For example, the database for the example above would have a directory
+structure that looks like this:
+
+* db-root 
+  * comments 
+    * 2010-01-03-328
+      * _attributes.json_
+    * 2010-05-29-742
+      * _attributes.json_
+  * posts 
+    * hotdog-eating-contest
+      * _attributes.json_
+      * _hotdogs.jpg_
+      * _image_
+      * _the-aftermath.jpg_
+    * lessons-learned
+      * _attributes.json_
+      * _image_
+    * running-with-scissors
+      * _attributes.json_
+
+
+To Do
+-----
+
+* Querying
+  * Use AREL?
+* Finish some pending specs
+* Associations
+* API documentation
+* Rails integration
+  * rake tasks
+  * generators
+* Performance
+  * Haven't optimized for performance yet. 
+
+

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/gitmodel.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.name = 'gitmodel'
+  s.version = '0.0.1'
+  s.platform    = Gem::Platform::RUBY
+
+  s.authors = ["Paul Dowman"]
+  s.email = 'paul@pauldowman.com'
+  s.homepage = 'http://github.com/pauldowman/gitmodel'
+
+  s.summary = %q{An ActiveModel-compliant persistence framework for Ruby that uses Git for versioning and remote syncing.}
+  s.description = <<-DESC.strip.gsub(/\n\s+/, " ")
+    GitModel persists Ruby objects using Git as a data storage engine. It's an
+    ActiveModel implementation so it works stand-alone or in Rails 3 as a drop-in
+    replacement for ActiveRecord or DataMapper.  Because the database is a Git
+    repository it can be synced across multiple machines, manipulated with standard
+    Git client tools, can be branched and merged, and of course keeps the history
+    of all changes.
+  DESC
+
+  s.add_dependency 'activemodel', '>= 3.0.1'
+  s.add_dependency 'activesupport', '>= 3.0.1'
+  s.add_dependency 'grit', '>= 2.3.0'
+  s.add_dependency 'lockfile', '>= 1.4.3'
+
+  s.add_development_dependency 'ZenTest', '>= 4.4.0'
+  s.add_development_dependency 'autotest', '>= 4.4.1'
+  s.add_development_dependency 'autotest-fsevent', '>= 0.2.3' if RUBY_PLATFORM.downcase.include?("darwin") # OS X only
+  s.add_development_dependency 'rspec', '>= 2.0.1'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+end
+

data/lib/gitmodel/errors.rb

@@ -0,0 +1,25 @@
+module GitModel
+  
+  # Generic GitModel exception class.
+  class GitModelError < StandardError
+  end
+  
+  # Raised when GitModel cannot find record by given id or set of ids.
+  class RecordNotFound < GitModelError
+  end
+  
+  # Raised by GitModel::Persistable.save! and GitModel::Persistable.create! methods when record cannot be
+  # saved because record is invalid.
+  class RecordNotSaved < GitModelError
+  end
+  
+  class RecordExists < GitModelError
+  end
+  
+  class RecordDoesntExist < GitModelError
+  end
+   
+  class NullId < GitModelError
+  end
+
+end

data/lib/gitmodel/persistable.rb

@@ -0,0 +1,269 @@
+module GitModel
+  module Persistable
+
+    def self.included(base)
+      base.class_eval do
+         
+        extend ActiveModel::Callbacks
+        extend ActiveModel::Naming
+        include ActiveModel::Validations
+        include ActiveModel::Dirty
+        include ActiveModel::Observing
+        include ActiveModel::Translation
+
+        define_model_callbacks :initialize, :find, :touch, :only => :after
+        define_model_callbacks :save, :create, :update, :destroy
+      end
+
+      base.extend(ClassMethods)
+    end
+    
+  
+    def initialize(args = {})
+      _run_initialize_callbacks do
+        @new_record = true 
+        self.attributes = {}
+        self.blobs = {}
+        args.each do |k,v|
+          self.send("#{k}=".to_sym, v)
+        end
+      end
+    end
+
+    def to_model
+      self
+    end
+
+    def to_key
+      id ? [id] : nil
+    end
+
+    def to_param
+      id && id.to_s
+    end
+      
+    def id
+      @id
+    end
+  
+    def id=(string)
+      # TODO ensure is valid as a filename
+      @id = string
+    end
+
+    def attributes
+      @attributes
+    end
+  
+    def attributes=(new_attributes, guard_protected_attributes = true)
+      @attributes = HashWithIndifferentAccess.new
+      if new_attributes
+        new_attributes.each {|k,v| @attributes[k] = v}
+      end
+    end
+
+    def blobs
+      @blobs
+    end
+  
+    def blobs=(new_blobs)
+      @blobs = HashWithIndifferentAccess.new
+      if new_blobs
+        new_blobs.each {|k,v| @blobs[k] = v}
+      end
+    end
+
+    def new_record?
+      @new_record || false
+    end
+  
+    # Valid options are:
+    #   :transaction
+    #   OR:
+    #   :branch
+    #   :commit_message
+    # Returns false if validations failed, otherwise returns the SHA of the commit
+    def save(options = {})
+      raise GitModel::NullId unless self.id
+
+      if new_record?
+        raise GitModel::RecordExists if self.class.exists?(self.id)
+      else
+        raise GitModel::RecordDoesntExist unless self.class.exists?(self.id)
+      end
+
+      dir = File.join(self.class.db_subdir, self.id)
+
+      transaction = options.delete(:transaction) || GitModel::Transaction.new(options) 
+      result = transaction.execute do |t|
+        # Write the attributes to the attributes file
+        t.index.add(File.join(dir, 'attributes.json'), JSON.pretty_generate(attributes))
+
+        # Write the blob files
+        blobs.each do |name, data|
+          t.index.add(File.join(dir, name), data)
+        end
+      end
+
+      return result
+    end
+
+    # Same as #save but raises an exception on error
+    def save!(options = {})
+      save(options) || raise(GitModel::RecordNotSaved)
+    end
+
+    def delete(options = {})
+      freeze
+      self.class.delete(id, options)
+    end
+
+    def to_s
+      "#<#{self.class.name}:#{__id__} id=#{id}, attributes=#{attributes.inspect}, blobs.keys=#{blobs.keys.inspect}>"
+    end
+
+
+    private
+
+    def load(dir)
+      _run_find_callbacks do
+        # remove dangerous ".."
+        # todo find a better way to ensure path is safe
+        dir.gsub!(/\.\./, '')
+
+        raise GitModel::RecordNotFound if GitModel.current_tree.nil?
+
+        self.id = File.basename(dir)
+        @new_record = false
+        
+        # load the attributes
+        object = GitModel.current_tree / File.join(dir, 'attributes.json')
+        raise GitModel::RecordNotFound if object.nil?
+
+        self.attributes = JSON.parse(object.data, :max_nesting => false)
+
+        # load all other non-hidden files in the dir as blobs
+        blobs = (GitModel.current_tree / dir).blobs.reject{|b| b.name[0] == '.' || b.name == 'attributes.json'}
+        blobs.each do |b|
+          self.blobs[b.name] = b.data
+        end
+      end
+    end
+
+
+    module ClassMethods
+
+      def db_subdir
+        self.to_s.tableize
+      end
+
+      def attribute(name, options = {})
+        default = options[:default]
+        self.class_eval <<-EOF
+          def #{name}; attributes[:#{name}] || #{default.inspect}; end
+          def #{name}=(value); attributes[:#{name}] = value; end
+        EOF
+      end
+
+      def blob(name, options = {})
+        self.class_eval <<-EOF
+          def #{name}; blobs[:#{name}]; end
+          def #{name}=(value); blobs[:#{name}] = value; end
+        EOF
+      end
+
+      def find(id)
+        GitModel.logger.debug "Finding #{name} with id: #{id}"
+        o = new
+        dir = File.join(db_subdir, id)
+        o.send :load, dir
+        return o
+      end
+
+      def exists?(id)
+        GitModel.repo.commits.any? && !(GitModel.current_tree / File.join(db_subdir, id, 'attributes.json')).nil?
+      end
+
+      def find_all(conditions = {})
+        GitModel.logger.debug "Finding all #{name.pluralize} with conditions: #{conditions.inspect}"
+        results = []
+        dirs = (GitModel.current_tree / db_subdir).trees
+        dirs.each do |dir|
+          if dir.blobs.any?
+            o = new
+            o.send :load, File.join(db_subdir, dir.name)
+            results << o
+          end
+        end
+
+        return results
+      end
+
+      def create(args)
+        if args.is_a?(Array)
+          args.map{|arg| create(arg)}
+        else
+          o = self.new(args)
+          o.save
+        end
+        return o
+      end
+
+      def create!(args)
+        if args.is_a?(Array)
+          args.map{|arg| create!(arg)}
+        else
+          o = self.new(args)
+          o.save!
+        end
+        return o
+      end
+
+      def delete(id, options = {})
+        path = File.join(db_subdir, id)
+        transaction = options.delete(:transaction) || GitModel::Transaction.new(options) 
+        result = transaction.execute do |t|
+          delete_tree(path, t.index, options)
+        end
+      end
+
+      def delete_all(options = {})
+        transaction = options.delete(:transaction) || GitModel::Transaction.new(options) 
+        result = transaction.execute do |t|
+          delete_tree(db_subdir, t.index, options)
+        end
+      end
+
+
+      private
+
+      def delete_tree(path, index, options = {})
+        # This leaves a bunch of empty sub-trees, there must be a way to just
+        # replace the tree to be deleted with an empty tree that doesn't even
+        # reference the sub-trees.
+        current = index.tree
+        path.split('/').each do |dir|
+          current[dir] ||= {}
+          current = current[dir]
+        end
+
+        build_tree_hash(current, (index.current_tree / path))
+      end
+
+      # recusively build the hash representing the objects that grit will commit
+      def build_tree_hash(hash, tree)
+        tree.blobs.each do |b|
+          hash[b.name] = false
+        end
+        tree.trees.each do |t|
+          hash[t.name] = {}
+          build_tree_hash(hash[t.name], t)
+        end
+        return hash
+      end
+
+    end # module ClassMethods
+    
+  end # module Persistable
+end # module GitModel
+

data/lib/gitmodel/transaction.rb

@@ -0,0 +1,62 @@
+module GitModel
+  class Transaction
+
+    attr_accessor :index
+    attr_accessor :branch
+    attr_accessor :commit_message
+
+    def initialize(options = {})
+      self.branch = options[:branch] || GitModel.default_branch
+      self.commit_message = options[:commit_message]
+    end
+
+    def execute(&block)
+      if index 
+        # We're already in a transaction
+        yield self
+      else
+        # For now there's a big ugly lock here, this will be fixed!
+        # TODO move this lock around the commit only (need to make sure two
+        # processes aren't updating refs/heads/<branch> at the same time) and
+        # make concurrent transactions can work. This will require some merging
+        # magic!
+        lock do
+          # We're not in a transaction, start a new one
+          GitModel.logger.debug "Beginning transaction on #{branch}..."
+
+          # Save the current head so that concurrent transactions can work. We need
+          # to make sure the parent of this commit is the same SHA that this
+          # index's tree is based on.
+          parent = GitModel.last_commit(branch)
+
+          self.index = Grit::Index.new(GitModel.repo)
+          index.read_tree(parent.to_s)
+          
+          yield self
+
+          committer = Grit::Actor.new(GitModel.git_user_name, GitModel.git_user_email)
+          sha = index.commit(commit_message, parent ? [parent] : nil, committer, nil, branch)
+          # TODO return false and log if anything went wrong with the commit
+
+          GitModel.logger.debug "Finished transaction on #{branch}."
+
+          return sha
+        end
+      end
+    end
+
+    # Wait until we can get an exclusive lock on the branch, then execute the
+    # block.  We lock the branch by creating refs/heads/<branch>.lock, which
+    # the git commands also seem to respect
+    def lock(&block)
+      lockfile = Lockfile.new File.join(GitModel.repo.path, 'refs/heads', branch + '.lock')
+      begin
+        lockfile.lock
+        yield
+      ensure
+        lockfile.unlock
+      end
+    end
+
+  end
+end