gitmodel 0.0.4 → 0.0.5

data/.rvmrc

@@ -1 +1,3 @@
 rvm use ruby-1.9.2@gitmodel
+echo "starting memcached..."
+memcached &

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    gitmodel (0.0.4)
+    gitmodel (0.0.5)
       activemodel (>= 3.0.1)
       activesupport (>= 3.0.1)
       grit (>= 2.3.0)
       lockfile (>= 1.4.3)
+      memcache-client (>= 1.8.5)
       yajl-ruby (>= 0.8.2)
 
 GEM
@@ -26,6 +27,7 @@ GEM
       mime-types (~> 1.15)
     i18n (0.5.0)
     lockfile (1.4.3)
+    memcache-client (1.8.5)
     mime-types (1.16)
     rspec (2.6.0)
       rspec-core (~> 2.6.0)

data/README.md

@@ -151,6 +151,25 @@ structure that looks like this:
             * _attributes.json_
 
 
+Performance
+-----------
+
+GitModel supports memcached for query results. This is off by default, but can be configured like this:
+
+    GitModel.memcache_servers(['server_1', 'server_2', ...])
+    GitModel.memcache_namespace('optional_namespace')
+
+The namespace is optional, and usually not necessary because GitModel will prepend the last segment of GitModel.db_root anyway.
+
+A Git SHA is also prepended to every key, so that outdated versions will not be retrieved from the cache. This is the SHA of the latest commit so unfortunately this is only useful when there are not frequent commits because every commit invalidates the cache. (This is obviously not ideal and I'm sure it can be improved upon.)
+
+There is still a lot of work to be done to make it faster. First, some analysis is required, but some guesses about things that would help are:
+
+    * Use [Rugged](https://github.com/libgit2/rugged) instead of Grit
+    * Remove the transaction lock (see transaction.rb line 19)
+    * Ability to iterate over result set without eager loading of all instances
+
+
 Contributing
 ------------
 
@@ -179,10 +198,6 @@ To do
     * Generators
     * Rake tasks
 * Performance
-    * Haven't optimized for performance yet. 
-    * Use [Rugged](https://github.com/libgit2/rugged) instead of Grit
-    * Remove the transaction lock (see transaction.rb line 19)
-    * Ability to iterate over result set without eager loading of all instances
 * Persistable.find/find_all/etc could be based on staged files so that queries reflect uncommitted changes
 * Better query support
     * Associations

data/gitmodel.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'gitmodel'
-  s.version = '0.0.4'
+  s.version = '0.0.5'
   s.platform    = Gem::Platform::RUBY
 
   s.authors = ["Paul Dowman"]
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'activesupport', '>= 3.0.1'
   s.add_dependency 'grit', '>= 2.3.0'
   s.add_dependency 'lockfile', '>= 1.4.3'
+  s.add_dependency 'memcache-client', '>= 1.8.5'
   s.add_dependency 'yajl-ruby', '>= 0.8.2'
 
   s.add_development_dependency 'ZenTest', '>= 4.4.0'

data/lib/gitmodel.rb

@@ -1,12 +1,15 @@
+# coding: UTF-8
+
 require 'rubygems'
 require 'bundler/setup'
 
 require 'active_model'
 require 'active_support/all' # TODO we don't really want all here, clean this up
 require 'grit'
-require 'yajl'
 require 'lockfile'
+require 'memcache'
 require 'pp'
+require 'yajl'
 
 $:.unshift(File.dirname(__FILE__))
 require 'gitmodel/errors'
@@ -32,6 +35,9 @@ module GitModel
   mattr_accessor :git_user_name
   mattr_accessor :git_user_email
 
+  mattr_accessor :memcache_servers
+  mattr_accessor :memcache_namespace
+
   def self.repo
     @@repo = Grit::Repo.new(GitModel.db_root)
   end
@@ -56,28 +62,64 @@ module GitModel
     create_db!
   end
 
-  def self.last_commit(branch = nil)
-    branch ||= default_branch
-    # PERFORMANCE Cache this somewhere and update it on commit?
-    # (Need separate instance per branch)
-
-    return nil unless repo.commits(branch).any?
-
-    # We should be able to use just repo.commits(branch).first here but
-    # this is a workaround for this bug: 
-    # http://github.com/mojombo/grit/issues/issue/38
-    GitModel.repo.commits("#{branch}^..#{branch}").first || GitModel.repo.commits(branch).first
+  def self.last_commit(branch)
+    cache(branch, 'last-commit') do
+      unless repo.commits(branch).any?
+        nil
+      else
+        # We should be able to use just repo.commits(branch).first here but
+        # this is a workaround for this bug: 
+        # http://github.com/mojombo/grit/issues/issue/38
+        GitModel.repo.commits("#{branch}^..#{branch}").first || GitModel.repo.commits(branch).first
+      end
+    end
   end
 
-  def self.current_tree(branch = nil)
+  def self.current_tree(branch)
     c = last_commit(branch)
     c ? c.tree : nil
   end
 
-  def self.index!
-    dirs = (GitModel.current_tree).trees
+  def self.index!(branch)
+    dirs = (GitModel.current_tree(branch)).trees
     dirs.each do |dir|
-      dir.name.classify.constantize.index!
+      dir.name.classify.constantize.index!(branch)
     end
   end
+
+  # If we're using memcached (i.e. the memcache_servers setting is not nil) and
+  # the key exists in memcached, it's value will be returned and the block will
+  # not be run.  If key does not exist in memcached, block will be executed,
+  # it's value stored in memcached under key, and value will be returned.
+  #
+  # There's no need to sweep the cache because the SHA of the latest Git commit
+  # is appended to the key, so any database change invalidates all cached
+  # objects.
+  def self.cache(branch, key, &block)
+    key = "#{key}-#{head_sha(branch)}"
+    value = nil
+    if memcache_servers
+      @@memcache ||= MemCache.new memcache_servers, :namespace => "#{File.basename(db_root)}-#{memcache_namespace}"
+      value = @@memcache.get(key)
+      if value.nil?
+        logger.info("✗ memcache MISS for key #{key}")
+        value = yield
+        @@memcache.set(key, value)
+      else
+        logger.info("✔ memcache HIT for key #{key}")
+      end
+    else
+      logger.debug("No memcache servers defined, not checking cache for key #{key}")
+      value = yield
+    end
+    value
+  end
+
+  private
+
+  # A more efficient way to get the SHA of the HEAD of the given branch
+  def self.head_sha(branch_name)
+    ref = File.join(repo.git.git_dir, "refs/heads/#{branch_name}")
+    File.exist?(ref) ? File.read(ref).chomp : nil
+  end
 end

data/lib/gitmodel/index.rb

@@ -4,11 +4,11 @@ module GitModel
       @model_class = model_class
     end
 
-    def generate!
+    def generate!(branch)
       GitModel.logger.debug "Generating indexes for #{@model_class}"
       # TODO it sucks to load every instance here, optimize later
       @indexes = {}
-      @model_class.find_all.each do |o|
+      @model_class.find_all(:branch => branch).each do |o|
         o.attributes.each do |attr, value|
           @indexes[attr] ||= {}
           @indexes[attr][value] ||= SortedSet.new
@@ -19,24 +19,27 @@ module GitModel
 
     def attr_index(attr)
       self.load unless @indexes
-      return nil unless @indexes # this is just so that we can stub self.load in tests
-
-      ret = @indexes[attr.to_s] 
-      raise GitModel::AttributeNotIndexed.new(attr.to_s) unless ret
-      return ret
+      unless @indexes # this is just so that we can stub self.load in tests
+        nil
+      else
+        ret = @indexes[attr.to_s] 
+        raise GitModel::AttributeNotIndexed.new(attr.to_s) unless ret
+        ret
+      end
     end
 
     def filename
       File.join(@model_class.db_subdir, '_indexes.json')
     end
 
-    def generated?
-      (GitModel.current_tree / filename) ? true : false
+    def generated?(branch = GitModel.default_branch)
+      (GitModel.current_tree(branch) / filename) ? true : false
     end
 
     def save(options = {})
       GitModel.logger.debug "Saving indexes for #{@model_class}..."
       transaction = options.delete(:transaction) || GitModel::Transaction.new(options) 
+      branch = transaction.branch || options.delete(:branch) || GitModel.default_branch
       result = transaction.execute do |t|
         # convert to array because JSON hash keys must be strings
         data = []
@@ -52,26 +55,28 @@ module GitModel
       end
     end
 
-    def load
-      unless generated?
-        GitModel.logger.debug "No index generated for #{@model_class}, not loading."
-        return
-      end
-
-      GitModel.logger.debug "Loading indexes for #{@model_class}..."
-      @indexes = {}
-      blob = GitModel.current_tree / filename
-      
-      data = Yajl::Parser.parse(blob.data)
-      data.each do |attr_and_values|
-        attr = attr_and_values[0]
-        values = {}
-        attr_and_values[1].each do |value_and_ids|
-          value = value_and_ids[0]
-          ids = SortedSet.new(value_and_ids[1])
-          values[value] = ids
+    def load(branch = GitModel.default_branch)
+      @indexes = GitModel.cache(branch, "#{@model_class.db_subdir}-index-load") do
+        unless generated?(branch)
+          GitModel.logger.debug "No index generated for #{@model_class}, on branch #{branch}, not loading."
+        else
+          GitModel.logger.debug "Loading indexes for #{@model_class}..."
+          indexes = {}
+          blob = GitModel.current_tree(branch) / filename
+          
+          data = Yajl::Parser.parse(blob.data)
+          data.each do |attr_and_values|
+            attr = attr_and_values[0]
+            values = {}
+            attr_and_values[1].each do |value_and_ids|
+              value = value_and_ids[0]
+              ids = SortedSet.new(value_and_ids[1])
+              values[value] = ids
+            end
+            indexes[attr] = values
+          end
         end
-        @indexes[attr] = values
+        indexes
       end
     end
 

data/lib/gitmodel/persistable.rb

@@ -132,13 +132,13 @@ module GitModel
 
     private
 
-    def load(dir)
+    def load(dir, branch)
       _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?
+        raise GitModel::RecordNotFound if GitModel.current_tree(branch).nil?
 
         self.id = File.basename(dir)
         @new_record = false
@@ -146,13 +146,13 @@ module GitModel
         GitModel.logger.debug "Loading #{self.class.name} with id: #{id}"
 
         # load the attributes
-        object = GitModel.current_tree / File.join(dir, 'attributes.json')
+        object = GitModel.current_tree(branch) / File.join(dir, 'attributes.json')
         raise GitModel::RecordNotFound if object.nil?
 
         self.attributes = Yajl::Parser.parse(object.data)
 
         # 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 = (GitModel.current_tree(branch) / dir).blobs.reject{|b| b.name[0] == '.' || b.name == 'attributes.json'}
         blobs.each do |b|
           self.blobs[b.name] = b.data
         end
@@ -181,95 +181,115 @@ module GitModel
         EOF
       end
 
-      def find(id)
+      def find(id, branch = GitModel.default_branch)
         GitModel.logger.debug "Finding #{name} with id: #{id}"
-        o = new
-        dir = File.join(db_subdir, id)
-        o.send :load, dir
-        return o
+        result = GitModel.cache(branch, "#{db_subdir}-find-#{id}") do
+          o = new
+          dir = File.join(db_subdir, id)
+          o.send :load, dir, branch
+          o
+        end
+        return result
       end
 
-      def exists?(id)
+      def exists?(id, branch = GitModel.default_branch)
         GitModel.logger.debug "Checking existence of #{name} with id: #{id}"
-        GitModel.repo.commits.any? && !(GitModel.current_tree / File.join(db_subdir, id, 'attributes.json')).nil?
+        result = GitModel.cache(branch, "#{db_subdir}-exists-#{id}") do
+          GitModel.repo.commits.any? && !(GitModel.current_tree(branch) / File.join(db_subdir, id, 'attributes.json')).nil?
+        end
+        return result
       end
 
+      # TODO document conditions
+      # :branch
+      # :cache_key
+      # :order_by
+      # :order
+      # any model attribute
       def find_all(conditions = {})
+        branch = conditions.delete(:branch) || GitModel.default_branch
         # TODO Refactor this spaghetti
         GitModel.logger.debug "Finding all #{name.pluralize} with conditions: #{conditions.inspect}"
-        return [] unless GitModel.current_tree
+        cache_key = "#{db_subdir}-find_all-#{format_conditions_hash_for_cache_key(conditions)}"
+        cached_results = GitModel.cache(branch, cache_key) do
+          current_tree = GitModel.current_tree(branch)
+          unless current_tree
+            []
+          else
+            order = conditions.delete(:order) || :asc
+            order_by = conditions.delete(:order_by) || :id
+            limit = conditions.delete(:limit)
+
+            matching_ids = []
+            if conditions.empty?  # load all objects
+              trees = (current_tree / db_subdir).trees
+              trees.each do |t|
+                matching_ids << t.name if t.blobs.any?
+              end
+            else # only load objects that match conditions
+              matching_ids_for_condition = {}
+              conditions.each do |k,v|
+                matching_ids_for_condition[k] = []
+                if k == :id # id isn't indexed
+                  if v.is_a?(Proc)
+                    trees = (current_tree / db_subdir).trees
+                    trees.each do |t|
+                      matching_ids_for_condition[k] << t.name if t.blobs.any? && v.call(t.name)
+                    end
+                  else
+                    # an unlikely use case but supporting it for completeness
+                    matching_ids_for_condition[k] << v if (current_tree / db_subdir / v)
+                  end
+                else
+                  raise GitModel::IndexRequired unless index.generated?
+                  attr_index = index.attr_index(k)
+                  if v.is_a?(Proc)
+                    attr_index.each do |value, ids|
+                      matching_ids_for_condition[k] += ids.to_a if v.call(value)
+                    end
+                  else
+                    matching_ids_for_condition[k] += attr_index[v].to_a
+                  end
+                end
+              end
+              matching_ids += matching_ids_for_condition.values.inject{|memo, obj| memo & obj}
+            end
 
-        order = conditions.delete(:order) || :asc
-        order_by = conditions.delete(:order_by) || :id
-        limit = conditions.delete(:limit)
+            results = nil
+            if order_by != :id
+              GitModel.logger.warn "Ordering by an attribute other than id requires loading all matching objects before applying limit, this will be slow" if limit
+              results = matching_ids.map{|k| find(k)}
 
-        matching_ids = []
-        if conditions.empty?  # load all objects
-          trees = (GitModel.current_tree / db_subdir).trees
-          trees.each do |t|
-            matching_ids << t.name if t.blobs.any?
-          end
-        else # only load objects that match conditions
-          matching_ids_for_condition = {}
-          conditions.each do |k,v|
-            matching_ids_for_condition[k] = []
-            if k == :id # id isn't indexed
-              if v.is_a?(Proc)
-                trees = (GitModel.current_tree / db_subdir).trees
-                trees.each do |t|
-                  matching_ids_for_condition[k] << t.name if t.blobs.any? && v.call(t.name)
-                end
+              if order == :asc
+                results = results.sort{|a,b| a.send(order_by) <=> b.send(order_by)}
+              elsif order == :desc
+                results = results.sort{|b,a| a.send(order_by) <=> b.send(order_by)}
               else
-                # an unlikely use case but supporting it for completeness
-                matching_ids_for_condition[k] << v if (GitModel.current_tree / db_subdir / v)
+                raise GitModel::InvalidParams("invalid order: '#{order}'")
+              end
+
+              if limit
+                results = results[0, limit]
               end
             else
-              raise GitModel::IndexRequired unless index.generated?
-              attr_index = index.attr_index(k)
-              if v.is_a?(Proc)
-                attr_index.each do |value, ids|
-                  matching_ids_for_condition[k] += ids.to_a if v.call(value)
-                end
+              if order == :asc
+                matching_ids = matching_ids.sort{|a,b| a <=> b}
+              elsif order == :desc
+                matching_ids = matching_ids.sort{|b,a| a <=> b}
               else
-                matching_ids_for_condition[k] += attr_index[v].to_a
+                raise GitModel::InvalidParams("invalid order: '#{order}'")
               end
-            end
-          end
-          matching_ids += matching_ids_for_condition.values.inject{|memo, obj| memo & obj}
-        end
-
-        results = nil
-        if order_by != :id
-          GitModel.logger.warn "Ordering by an attribute other than id requires loading all matching objects before applying limit, this will be slow" if limit
-          results = matching_ids.map{|k| find(k)}
+              if limit
 
-          if order == :asc
-            results = results.sort{|a,b| a.send(order_by) <=> b.send(order_by)}
-          elsif order == :desc
-            results = results.sort{|b,a| a.send(order_by) <=> b.send(order_by)}
-          else
-            raise GitModel::InvalidParams("invalid order: '#{order}'")
-          end
-
-          if limit
-            results = results[0, limit]
-          end
-        else
-          if order == :asc
-            matching_ids = matching_ids.sort{|a,b| a <=> b}
-          elsif order == :desc
-            matching_ids = matching_ids.sort{|b,a| a <=> b}
-          else
-            raise GitModel::InvalidParams("invalid order: '#{order}'")
-          end
-          if limit
+                matching_ids = matching_ids[0, limit]
+              end
+              results = matching_ids.map{|k| find(k)}
+            end
 
-            matching_ids = matching_ids[0, limit]
+            results
           end
-          results = matching_ids.map{|k| find(k)}
-        end
-
-        return results
+        end # cached block
+        return cached_results
       end
 
       def all_values_for_attr(attr)
@@ -302,7 +322,8 @@ module GitModel
         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)
+          branch = t.branch || options[:branch] || GitModel.default_branch
+          delete_tree(path, t.index, branch, options)
         end
       end
 
@@ -310,19 +331,20 @@ module GitModel
         GitModel.logger.debug "Deleting all #{name.pluralize}"
         transaction = options.delete(:transaction) || GitModel::Transaction.new(options) 
         result = transaction.execute do |t|
-          delete_tree(db_subdir, t.index, options)
+          branch = t.branch || options[:branch] || GitModel.default_branch
+          delete_tree(db_subdir, t.index, branch, options)
         end
       end
 
-      def index!
-        index.generate!
-        index.save
+      def index!(branch)
+        index.generate!(branch)
+        index.save(:branch => branch)
       end
 
 
       private
 
-      def delete_tree(path, index, options = {})
+      def delete_tree(path, index, branch, 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.
@@ -347,6 +369,25 @@ module GitModel
         return hash
       end
 
+      def format_conditions_hash_for_cache_key(hash)
+        # allow setting an explicit cache key, mostly because Proc.hash is
+        # usually different even with the same code and same parameters
+        cache_key = hash.delete(:cache_key)
+
+        unless cache_key
+          cache_key = ""
+          hash.inject('') do |s,kv|
+            key = kv[0]
+            val = kv[1]
+            if val.is_a?(Proc)
+              val = "proc-#{val.hash}"
+            end
+            cache_key += "#{key}:#{val};"
+          end
+        end
+        cache_key
+      end
+
     end # module ClassMethods
     
   end # module Persistable

data/spec/gitmodel/index_spec.rb

@@ -7,7 +7,7 @@ describe GitModel::Index do
     TestEntity.create!(:id => "baz", :attributes => {:x => 2, :y => 2})
 
     @i = GitModel::Index.new(TestEntity)
-    @i.generate!
+    @i.generate!(GitModel.default_branch)
   end
 
   it "has a hash for each attribute of the model" do
@@ -23,7 +23,7 @@ describe GitModel::Index do
   it "can regenerate itself" do
     @i.attr_index(:x).clear
     @i.attr_index(:x).should be_empty
-    @i.generate!
+    @i.generate!(GitModel.default_branch)
     @i.attr_index(:x).should == {1 => SortedSet.new(["foo", "bar"]), 2 => SortedSet.new(["baz"])}
   end
 

data/spec/gitmodel/persistable_spec.rb

@@ -202,15 +202,16 @@ describe GitModel::Persistable do
     it 'also deletes blobs associated with the given object' do
       id = 'Lemuridae'
       TestEntity.create!(:id => id, :blobs => {:crowned => "Eulemur coronatus", :brown => "Eulemur fulvus"})
-      (GitModel.current_tree / File.join(TestEntity.db_subdir, id, 'crowned')).data.should_not be_nil
-      (GitModel.current_tree / File.join(TestEntity.db_subdir, id, 'brown')).data.should_not be_nil
+      b = GitModel.default_branch
+      (GitModel.current_tree(b) / File.join(TestEntity.db_subdir, id, 'crowned')).data.should_not be_nil
+      (GitModel.current_tree(b) / File.join(TestEntity.db_subdir, id, 'brown')).data.should_not be_nil
       TestEntity.delete(id)
 
-      (GitModel.current_tree / File.join(TestEntity.db_subdir, id, 'attributes.json')).should be_nil
-      (GitModel.current_tree / File.join(TestEntity.db_subdir, id, 'attributes.json')).should be_nil
+      (GitModel.current_tree(b) / File.join(TestEntity.db_subdir, id, 'attributes.json')).should be_nil
+      (GitModel.current_tree(b) / File.join(TestEntity.db_subdir, id, 'attributes.json')).should be_nil
 
-      (GitModel.current_tree / File.join(TestEntity.db_subdir, id, 'crowned')).should be_nil
-      (GitModel.current_tree / File.join(TestEntity.db_subdir, id, 'brown')).should be_nil
+      (GitModel.current_tree(b) / File.join(TestEntity.db_subdir, id, 'crowned')).should be_nil
+      (GitModel.current_tree(b) / File.join(TestEntity.db_subdir, id, 'brown')).should be_nil
     end
 
 
@@ -223,7 +224,7 @@ describe GitModel::Persistable do
       TestEntity.create!(:id => 'ape')
 
       TestEntity.delete_all
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
       TestEntity.find_all.should be_empty
     end
 
@@ -347,7 +348,7 @@ describe GitModel::Persistable do
           TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 1})
           TestEntity.create!(:id => 'two', :attributes => {:a => 2, :b => 2})
           TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 3})
-          TestEntity.index!
+          TestEntity.index!(GitModel.default_branch)
 
           r = TestEntity.find_all(:a => 1)
           r.size.should == 2
@@ -361,7 +362,7 @@ describe GitModel::Persistable do
           TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 1})
           TestEntity.create!(:id => 'two', :attributes => {:a => 2, :b => 2})
           TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 3})
-          TestEntity.index!
+          TestEntity.index!(GitModel.default_branch)
 
           r = TestEntity.find_all(:b => lambda{|b| b > 1}, :order => :asc)
           r.size.should == 2
@@ -377,7 +378,7 @@ describe GitModel::Persistable do
           TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 2})
           TestEntity.create!(:id => 'two', :attributes => {:a => 1, :b => 2})
           TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 1})
-          TestEntity.index!
+          TestEntity.index!(GitModel.default_branch)
 
           r = TestEntity.find_all(:a => 1, :b => 2, :order => :asc)
           r.size.should == 2
@@ -392,7 +393,7 @@ describe GitModel::Persistable do
           TestEntity.create!(:id => 'two', :attributes => {:a => 2, :b => 2})
           TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 1})
           TestEntity.create!(:id => 'four', :attributes => {:a => 3, :b => 3})
-          TestEntity.index!
+          TestEntity.index!(GitModel.default_branch)
 
           r = TestEntity.find_all(:a => lambda{|a| a > 1}, :b => lambda{|b| b > 2}, :order => :asc)
           r.size.should == 1
@@ -434,7 +435,7 @@ describe GitModel::Persistable do
       TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 1})
       TestEntity.create!(:id => 'two', :attributes => {:a => 2, :b => 2})
       TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 3})
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
 
       r = TestEntity.find_all(:a => 1, :order => :asc)
       r.size.should == 2
@@ -446,7 +447,7 @@ describe GitModel::Persistable do
       TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 1})
       TestEntity.create!(:id => 'two', :attributes => {:a => 2, :b => 2})
       TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 3})
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
 
       r = TestEntity.find_all(:a => 1, :order => :desc)
       r.size.should == 2
@@ -458,7 +459,7 @@ describe GitModel::Persistable do
       TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 1})
       TestEntity.create!(:id => 'two', :attributes => {:a => 1, :b => 2})
       TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 3})
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
 
       r = TestEntity.find_all(:a => 1, :order => :asc, :limit => 2)
       r.size.should == 2
@@ -470,7 +471,7 @@ describe GitModel::Persistable do
       TestEntity.create!(:id => 'one', :attributes => {:a => 1, :b => 1})
       TestEntity.create!(:id => 'two', :attributes => {:a => 1, :b => 2})
       TestEntity.create!(:id => 'three', :attributes => {:a => 1, :b => 3})
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
 
       r = TestEntity.find_all(:a => 1, :order => :desc, :limit => 2)
       r.size.should == 2
@@ -497,7 +498,7 @@ describe GitModel::Persistable do
     it "generates and saves the index" do
       TestEntity.index.should_receive(:generate!)
       TestEntity.index.should_receive(:save)
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
     end
   end
 
@@ -505,7 +506,7 @@ describe GitModel::Persistable do
     it 'returns a list of all values that exist for a given attribute' do
       o = TestEntity.create!(:id => 'first', :attributes => {"a" => 1, "b" => 2})
       o = TestEntity.create!(:id => 'second', :attributes => {"a" => 3, "b" => 4})
-      TestEntity.index!
+      TestEntity.index!(GitModel.default_branch)
       TestEntity.all_values_for_attr("a").should == [1, 3]
     end
   end

data/spec/gitmodel_spec.rb

@@ -4,7 +4,7 @@ describe GitModel do
 
   describe ".last_commit" do
     it "returns nil if there are no commits" do
-      GitModel.last_commit.should == nil
+      GitModel.last_commit(GitModel.default_branch).should == nil
     end
 
     it "returns the most recent commit on a branch" do
@@ -14,13 +14,13 @@ describe GitModel do
       index.add "foo", "foo"
       sha = index.commit nil, nil, nil, nil, 'master'
             
-      GitModel.last_commit.to_s.should == sha
+      GitModel.last_commit(GitModel.default_branch).to_s.should == sha
     end
   end
 
   describe ".current_tree" do
     it "returns nil if there are no commits" do
-      GitModel.current_tree.should == nil
+      GitModel.current_tree(GitModel.default_branch).should == nil
     end
 
     it "returns the tree for the most recent commit on a branch" do
@@ -40,7 +40,7 @@ describe GitModel do
     it "calls index! on each Persistable model class" do
       TestEntity.should_receive(:index!)
       TestEntity2.should_receive(:index!)
-      GitModel.index!
+      GitModel.index!(GitModel.default_branch)
     end
   end
 

data/spec/spec_helper.rb

@@ -18,3 +18,4 @@ class TestEntity2
 end
 
 #GitModel.logger.level = ::Logger::DEBUG
+GitModel.memcache_servers = ['localhost']

metadata

@@ -1,114 +1,125 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: gitmodel
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.5
   prerelease: 
-  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - Paul Dowman
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-07-04 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-08-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activemodel
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70218492110080 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.0.1
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: activesupport
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492110080
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70218492109600 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 3.0.1
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: grit
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492109600
+- !ruby/object:Gem::Dependency
+  name: grit
+  requirement: &70218492135740 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.3.0
   type: :runtime
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: lockfile
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492135740
+- !ruby/object:Gem::Dependency
+  name: lockfile
+  requirement: &70218492135280 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.4.3
   type: :runtime
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: yajl-ruby
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492135280
+- !ruby/object:Gem::Dependency
+  name: memcache-client
+  requirement: &70218492134820 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70218492134820
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70218492134360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.8.2
   type: :runtime
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: ZenTest
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492134360
+- !ruby/object:Gem::Dependency
+  name: ZenTest
+  requirement: &70218492133900 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 4.4.0
   type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: autotest
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492133900
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: &70218492133440 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 4.4.1
   type: :development
-  version_requirements: *id007
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  version_requirements: *70218492133440
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70218492132980 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.0.1
   type: :development
-  version_requirements: *id008
-description: 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.
+  prerelease: false
+  version_requirements: *70218492132980
+description: 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.
 email: paul@pauldowman.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .document
 - .gitignore
 - .rspec
@@ -132,32 +143,30 @@ files:
 - spec/support/setup.rb
 homepage: http://github.com/pauldowman/gitmodel
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
-summary: An ActiveModel-compliant persistence framework for Ruby that uses Git for versioning and remote syncing.
-test_files: 
+summary: An ActiveModel-compliant persistence framework for Ruby that uses Git for
+  versioning and remote syncing.
+test_files:
 - spec/gitmodel/index_spec.rb
 - spec/gitmodel/persistable_spec.rb
 - spec/gitmodel/transaction_spec.rb