poro 0.1.1 → 0.1.2

data/README.rdoc

@@ -160,6 +160,10 @@ mailto:jeff@paploo.net
 
 = Version History
 
+[0.1.2 - 2010-Sep-30] Feature Additions
+                      * Added a module namespace factory.
+                      * HashContext: Find one is faster when the conditions restrict on the primary key.
+                      * Many HashContext bugs fixed.
 [0.1.1 - 2010-Sep-24] Minor Additions and Bug Fixes.
                       * MongoContext now can optionally encode Symbols as hashes
                         or just leave them as strings.

data/lib/poro/context.rb

@@ -37,7 +37,7 @@ module Poro
     #
     # This really just fetches (and creates, if necessary) the
     # Context for the class, and then yields it to the block.  Returns the context.
-    def self.configure_for_klass(klass)
+    def self.configure_for_class(klass)
       context = self.fetch(klass)
       yield(context) if block_given?
       return context
@@ -53,6 +53,11 @@ module Poro
       ContextFactory.instance = context_factory
     end
     
+    # Returns true if there is a factory assigned to the application.
+    def self.factory?
+      ContextFactory.has_instance?
+    end
+    
     # Initizialize this context for the given class.  Yields self if a block
     # is given, so that instances can be easily configured at instantiation.
     #

data/lib/poro/context_factories.rb

@@ -1 +1,2 @@
-require 'poro/context_factories/single_store'
+require 'poro/context_factories/single_store'
+require 'poro/context_factories/namespace_factory'

data/lib/poro/context_factories/namespace_factory.rb

@@ -0,0 +1,118 @@
+module Poro
+  module ContextFactories
+    # The NamespaceFactory uses the module namespace of the class to determine
+    # which factory should be used to create a class instance.
+    #
+    # On initialization, the default factory should be set.  Until other
+    # factories are registerd, all classes will recieve contexts created by
+    # this factory.
+    #
+    # Other factories can be registered against various namespaces.  Namespaces
+    # are given as a string and are evaluated from the bottom up.  For example,
+    # if a factory is registered against the class Foo::Bar, then Foo::Bar and
+    # Foo::Bar::Baz would each recieve contexts created via that factory, while
+    # contexts registered against Foo::Zap would use the default context.
+    class NamespaceFactory < ContextFactory
+      
+      # Initialize this namespace factory instance with the given default
+      # factory.  Use <tt>register_factory</tt> to add more kinds of factories
+      # to this app.
+      #
+      # If given a block, it is yielded self for further configuration.  This
+      # departs slightly from the standard of yielding a Class or
+      # Class and Context for configuration, but as this is more useful for
+      # practicle applications.  (It also doesn't configure a context itself,
+      # so giving separate blocks to the sub-factories given to it is more
+      # appropriate.
+      def initialize(default_factory=nil)
+        @root_node = CacheNode.new
+        @root_node.factory = default_factory
+        
+        yield(self) if block_given?
+        
+        super() do |klass|
+          factory = self.fetch_factory(klass)
+          factory.nil? ? nil : factory.fetch(klass)
+        end
+      end
+      
+      # Registers a factory for a given namespace, given by a string.  If a
+      # factory is already registered for this namespace, it overrides it.
+      #
+      # This registers the given factory not only for this namespace, but for
+      # any sub-namespaces that haven't been specifically overriden.  Sub-namespace
+      # overrides can be registered either before or after the namespace it overrides.
+      def register_factory(factory, namespace='')
+        namespace_stack = namespace.to_s.split('::')
+        
+        parse_block = lambda do |factory, namespace_stack, node|
+          if( namespace_stack.length == 0 )
+            node.factory = factory
+          else
+            name, *rest = namespace_stack
+            child_node = node.children[name] || CacheNode.new
+            node.children[name] = child_node
+            parse_block.call(factory, rest, child_node)
+          end
+        end
+        
+        parse_block.call(factory, namespace_stack, @root_node)
+        
+        return factory
+      end
+      
+      # Fetches the factory for a given namespace.
+      #
+      # This grabs the factory for the most specific matching namespace.
+      def fetch_factory(namespace='')
+        namespace_stack = namespace.to_s.split('::')
+        
+        lookup_block = lambda do |namespace_stack, last_seen_factory, node|
+          last_seen_factory = node.factory || last_seen_factory
+          if( namespace_stack.length == 0 )
+            last_seen_factory
+          elsif( !(node.children.include?(namespace_stack[0])) )
+            last_seen_factory
+          else
+            name, *rest = namespace_stack
+            lookup_block.call(rest, last_seen_factory, node.children[name])
+          end
+        end
+        
+        return lookup_block.call(namespace_stack, nil, @root_node)
+      end
+      
+      # The internal class used to manage the namespace tree.  This should
+      # never be used outside of this factory.
+      #
+      # This class stores the child notes for the namespace, as well as the
+      # factory for this level in the namespace.
+      class CacheNode
+        
+        # Initialize an empty node.
+        def initialize
+          @children = {}
+          @factory = nil
+        end
+        
+        # Returns the children--as a hash.  The keys are the module/class name,
+        # and the values are the associated child node.
+        #
+        # This is the raw hash and can be manipulated directly.
+        attr_reader :children
+        
+        # Returns the factory for this node, or nil if there is none.
+        attr_reader :factory
+        
+        # Sets the factory for this node.
+        attr_writer :factory
+        
+        def to_s
+          return {:factory => factory, :children => children}.inspect
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/poro/context_factory.rb

@@ -23,6 +23,11 @@ module Poro
       @instance = instance
     end
     
+    # Returns true if a context factory instance is configured.
+    def self.has_instance?
+      return (@instance != nil)
+    end
+    
     # Takes a factory block that delivers a configured context for the class
     # passed to it.
     def initialize(&context_factory_block)
@@ -31,7 +36,7 @@ module Poro
     end
     
     def context_managed_class?(klass)
-      return klass.include?(Poro::Persistify)
+      return klass && klass.include?(Poro::Persistify)
     end
     
     # Fetches the context for a given class, or returns nil if the given object

data/lib/poro/contexts/hash_context.rb

@@ -18,9 +18,12 @@ module Poro
       # Save the object in the underlying hash, using the object id as the key.
       def save(obj)
         pk_id = self.primary_key_value(obj)
-        self.set_primary_key_value(obj, obj.object_id) if(pk_id.nil?)
+        if(pk_id.nil?)
+          pk_id = obj.object_id
+          self.set_primary_key_value(obj, pk_id)
+        end
         
-        data_store[obj.id] = convert_to_data(obj)
+        data_store[pk_id] = convert_to_data(obj)
         return self
       end
       
@@ -28,7 +31,7 @@ module Poro
       def remove(obj)
         pk_id = self.primary_key_value(obj)
         if( pk_id != nil )
-          data_store.delete(obj.id)
+          data_store.delete(pk_id)
           self.set_primary_key_value(obj, nil)
         end
         return self
@@ -44,24 +47,42 @@ module Poro
       
       private
       
-      def clean_id(id)
-        return id && id.to_i
-      end
-      
       # Searching a hash is incredibly slow because the following steps must
       # be taken:
       # 1. If there is an order, we first have to sort ALL values by the order.
       # 2. Then we must find all matching records.
       # 3. Then we must apply limit and offset to fetch the correct record.
       #
+      # There are several optimizations to this that have already been done:
+      # * If the conditions include the primary key, use fetch and drop that
+      #   condition.
+      # * If the offset is higher than the total number of stored records, then
+      #    we know there will be no matches.
+      #
       # There are several optimizations that can be made in the future:
-      # 1. When matching the last key in the list, we can stop processing when
+      # * When matching the last key in the list, we can stop processing when
       #    we reach the limit+offset number of records.
-      # 2. If the offset is higher than the total number of stored records, then
-      #    we know there will be no matches.
       def find_all(opts)
         opts = clean_find_opts(opts)
-        data = limit( filter( sort( data_store.dup, opts[:order] ), opts[:conditions] ), opts[:limit])
+        
+        # If the offset is bigger than the stored number of records, we know that
+        # we'll get nothing:
+        return [] if( (opts[:limit]&&opts[:limit][:offset]).to_i > data_store.length )
+        
+        # If a search condition is the primary key, we can significantly limit our work.
+        values = nil
+        data = nil
+        if( opts[:conditions].has_key?( self.primary_key ) )
+          pk_value = opts[:conditions].delete(self.primary_key)
+          obj = self.fetch( pk_value )
+          values = obj.nil? ? [] : [obj]
+          data = limit( filter( values, opts[:conditions]), opts[:limit] )
+        else
+          values = data_store.values
+          data = limit( filter( sort( values, opts[:order] ), opts[:conditions] ), opts[:limit])
+        end
+        
+        # Now do the search.
         return data.map {|data| convert_to_plain_object(data)}
       end
       

data/lib/poro/contexts/mongo_context.rb

@@ -149,7 +149,7 @@ module Poro
           obj.kind_of?(Float) ||
           obj.kind_of?(String) ||
           obj.kind_of?(Time) ||
-          (self.encode_symbols && obj.kind_of?(Symbol)) ||
+          (!self.encode_symbols && obj.kind_of?(Symbol)) ||
           obj==true ||
           obj==false ||
           obj.nil? ||
@@ -207,7 +207,7 @@ module Poro
           return encode_class(obj)
         elsif( obj.kind_of?(Set) )
           return encode_set(obj)
-        elsif( !self.encode_symbols && obj.kind_of?(Symbol) )
+        elsif( self.encode_symbols && obj.kind_of?(Symbol) )
           return encode_symbol(obj)
         elsif( Context.managed_class?(obj.class) && Context.fetch(obj.class).kind_of?(self.class) )
           return encode_mongo_managed_object(obj)
@@ -223,7 +223,7 @@ module Poro
       # Recursively encode a hash's contents.
       def encode_hash(hash)
         return hash.inject({}) do |hash,(k,v)|
-          hash[k] = self.convert_to_data(value, :embedded => true)
+          hash[k] = self.convert_to_data(v, :embedded => true)
           hash
         end
       end
@@ -387,7 +387,7 @@ module Poro
       # Decode the set depending on if it was encoded as an array or as a raw
       # object.
       def decode_set(set_data)
-        if( set_data.include?['values'] )
+        if( set_data.include?('values') )
           return Set.new(set_data['values'])
         else
           return decode_unmanaged_object(set_data)

data/lib/poro/version.rb

@@ -3,5 +3,5 @@
 # existing plain ol' ruby objects as little as possible.  For more information
 # see README.rdoc.
 module Poro
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/spec/hash_context_spec.rb

@@ -76,18 +76,21 @@ describe "HashContext" do
       
       class HashContextPerson
         include Poro::Persistify
-        def initialize(id, first_name, last_name, friends)
+        def initialize(id, first_name, last_name, friends=[])
           @id = id
           @first_name = first_name
           @last_name = last_name
           @friends = friends
         end
+        
+        attr_reader :id
+        attr_writer :id
       end
       
-      george_smith = HashContextPerson.new(1, 'George', 'Smith', [])
+      george_smith = HashContextPerson.new(1, 'George', 'Smith')
       george_archer = HashContextPerson.new(2, 'George', 'Archer', [george_smith])
-      bridgette_smith = {'id' => 3, 'first_name' => 'Bridgette', 'last_name' => 'Smith'}
-      karen_zeta = {:id => 4, :first_name => 'Karen', :last_name => 'Zeta', :friends => [george_archer, george_smith]}
+      bridgette_smith = HashContextPerson.new(3, 'Bridgette', 'Smith')
+      karen_zeta = HashContextPerson.new(4, 'Karen', 'Zeta', [george_archer, george_smith])
       @data = [
         george_smith,
         george_archer,
@@ -96,9 +99,7 @@ describe "HashContext" do
       ]
       
       @context = Poro::Contexts::HashContext.new(HashContextPerson)
-      
-      # Cheat to jam the data in there:
-      @context.data_store = @data
+      @data.each {|person| @context.save(person)}
     end
     
     it 'should get shallow values' do

data/spec/namespace_context_factory_spec.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Namespace Context Factory" do
+  
+  it 'should register and fetch a default factory' do
+    default_factory = :default_factory
+    
+    factory = Poro::ContextFactories::NamespaceFactory.new(default_factory)
+    factory.fetch_factory.should == default_factory
+  end
+  
+  it 'should register and fetch a namespaced factory' do
+    default_factory = :default_factory
+    foo_factory = :foo_factory
+    
+    factory = Poro::ContextFactories::NamespaceFactory.new(default_factory)
+    factory.register_factory(foo_factory, "Foo")
+    
+    factory.fetch_factory.should == default_factory
+    factory.fetch_factory("Foo").should == foo_factory
+  end
+  
+  it 'should get the nearest matching factory' do
+    default_factory = :default_factory
+    foo_factory = :foo_factory
+    bar_factory = :bar_factory
+    chocolate_factory = :chocolate_factory
+    
+    factory = Poro::ContextFactories::NamespaceFactory.new(default_factory)
+    factory.register_factory(foo_factory, "Foo")
+    factory.register_factory(bar_factory, "Foo::Bar")
+    factory.register_factory(chocolate_factory, "Candy::Chocolate")
+    
+    factory.fetch_factory.should == default_factory
+    
+    factory.fetch_factory("Foo").should == foo_factory
+    factory.fetch_factory("Foo::Bar").should == bar_factory
+    factory.fetch_factory("Foo::Bar::Baz").should == bar_factory
+    factory.fetch_factory("Foo::Fiz").should == foo_factory
+    
+    factory.fetch_factory("Chocolate").should == default_factory
+    factory.fetch_factory("Candy::Chocolate").should == chocolate_factory
+    factory.fetch_factory("Candy::Chocolate::Dark").should == chocolate_factory
+    factory.fetch_factory("Candy").should == default_factory
+  end
+  
+  it 'should fetch a context' do
+    @klass_1 = Class.new(Object)
+    @klass_1.send(:include, Poro::Persistify)
+    @klass_2 = Class.new(Object)
+    @klass_2.send(:include, Poro::Persistify)
+    ::PoroNamespacedContextFactoryTestFetchOne = @klass_1
+    ::PoroNamespacedContextFactoryTestFetcgTwo = @klass_2
+    
+    @klass_1.name.should_not == @klass_2.name
+    
+    default_factory = Poro::ContextFactory.new {|klass| "default #{klass.name}"}
+    foo_factory = Poro::ContextFactory.new {|klass| "foo #{klass.name}"}
+    
+    factory = Poro::ContextFactories::NamespaceFactory.new(default_factory)
+    factory.register_factory(foo_factory, @klass_2.name)
+    
+    context = factory.fetch(@klass_1)
+    context.should == "default #{@klass_1.name}"
+    
+    context = factory.fetch(@klass_2)
+    context.should == "foo #{@klass_2.name}"
+  end
+  
+  it 'should take a configuration block' do
+    @klass_1 = Class.new(Object)
+    @klass_1.send(:include, Poro::Persistify)
+    @klass_2 = Class.new(Object)
+    @klass_2.send(:include, Poro::Persistify)
+    ::PoroNamespacedContextFactoryTestBlockOne = @klass_1
+    ::PoroNamespacedContextFactoryTestBlockTwo = @klass_2
+    
+    @klass_1.name.should_not == @klass_2.name
+    
+    default_factory = Poro::ContextFactory.new {|klass| "default #{klass.name}"}
+    foo_factory = Poro::ContextFactory.new {|klass| "foo #{klass.name}"}
+    
+    factory = Poro::ContextFactories::NamespaceFactory.new(default_factory) do |f|
+      f.register_factory(foo_factory, @klass_2.name)
+    end
+    
+    context = factory.fetch(@klass_1)
+    context.should == "default #{@klass_1.name}"
+    
+    context = factory.fetch(@klass_2)
+    context.should == "foo #{@klass_2.name}"
+  end
+  
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Jeff Reinecke
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-24 00:00:00 -07:00
+date: 2010-09-30 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,7 @@ files:
 - LICENSE.txt
 - Rakefile
 - lib/poro/context.rb
+- lib/poro/context_factories/namespace_factory.rb
 - lib/poro/context_factories/README.txt
 - lib/poro/context_factories/single_store/hash_factory.rb
 - lib/poro/context_factories/single_store/mongo_factory.rb
@@ -56,6 +57,7 @@ files:
 - spec/modelfy.rb
 - spec/module_finder_spec.rb
 - spec/mongo_context_spec.rb
+- spec/namespace_context_factory_spec.rb
 - spec/single_store_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true