poro 0.1.0 → 0.1.1

data/README.rdoc

@@ -22,6 +22,11 @@ through whatever inferior homogenized API Poro may try to provide.
 
 = Installation
 
+At this time, Poro has only ever been tested on ruby 1.9.2.  It is expected to
+work on any 1.9.x, but may require some effort to make work on 1.8.6 or later.
+By version 1.0 I hope to have 1.8.6 and 1.8.7 support, however the development
+of a production worthy gem in 1.9.2 takes the priority.
+
 Basic usage only requires the installation of the gem:
     gem install poro
 However to utilize any meaningful persistence data store, the underlying gems
@@ -155,6 +160,13 @@ mailto:jeff@paploo.net
 
 = Version History
 
+[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.
+                      * MongoContext can have conversion to BSON::ObjectId turned off.
+                      * MongoContext can save Sets in various formats.
+                      * MongoContext handles namespaced models better.
+                      * Context doesn't error when trying to find by id.
 [0.1.0 - 2010-Sep-18] Initial public release.
                       * Major base functionality is complete, though is subject
                         to big changes as it is used in the real world.
@@ -167,7 +179,18 @@ mailto:jeff@paploo.net
 
 The following are the primary TODO items, roughly in priority order:
 
+* YAML Connection Configuration:
+  * Make a Util module that is able to use a rails-compatible YAML
+    file--given by path--to get the elements needed for configuration of a
+    SingleStore factory.
+  * Modify SingleStore to use this file for configuration when appropriate.
 * Modelify: Break into modules for each piece of functionality.
+* Modelify: Add callback functionality to Modelify (e.g. before/after save, after initialize).
+  * Add the callbacks to the Context first.
+* Mongo Context: Add option to encode Sets as one of:
+  * A Set with the raw internal Hash.
+  * A Set with the internal Hash as an Array.
+  * An Array (which will have to be manually turned back into a Set).
 * Specs: Add specs for Context Find methods.
   * Check that private methods are private.  (Should do on subclasses too.)
   * Check that the two main find methods pass through to the correct underlying
@@ -176,6 +199,8 @@ The following are the primary TODO items, roughly in priority order:
 * Mongo Context: Split into modules in separate files.
 * Context: Split out modules into files.
 * Contexts: Add SQL Context.
+* Ruby: Verify support for ruby 1.9.x.
+* Ruby: Evaluate adding support for ruby 1.8.6 and 1.8.7.
 
 = License
 

data/lib/poro.rb

@@ -1,4 +1,5 @@
 # Require foundation.
+require 'poro/version'
 require 'poro/util'
 
 # Require core classes and modules.

data/lib/poro/context.rb

@@ -316,7 +316,7 @@ module Poro
         #
         # Subclasses SHOULD override this method.
         #
-        # By default, this method aggregates separate calls to find_by_id.  For
+        # By default, this method aggregates separate calls to fetch.  For
         # most data stores this makes N calls to the server, decreasing performance.
         #
         # When possible, this method should be overriden by subclasses to be more
@@ -324,7 +324,7 @@ module Poro
         # filtered by the <tt>clean_id</tt> private method.
         def find_with_ids(*ids)
           ids = ids.flatten
-          return ids.map {|id| find_by_id(id)}
+          return ids.map {|id| fetch(id)}
         end
         
       end
@@ -423,7 +423,7 @@ module Poro
         elsif( arg.respond_to?(:map) )
           return find_with_ids(arg)
         else
-          return find_by_id(arg)
+          return fetch(arg)
         end
       end
       
@@ -440,9 +440,9 @@ module Poro
       # * :first or :one
       def data_store_find(first_or_all, *args, &block)
         if(first_or_all == :all || first_or_all == :many)
-          return data_store_find_all(*first_or_all, &block)
+          return data_store_find_all(*args, &block)
         elsif( first_or_all == :first || first_or_all == :one)
-          return data_store_find_first(*first_or_all, &block)
+          return data_store_find_first(*args, &block)
         else
           raise ArgumentError, "#{__method__} expects the first argument to be one of :all, :many, :first, or :one."
         end

data/lib/poro/context_factories/single_store/mongo_factory.rb

@@ -22,7 +22,7 @@ module Poro
           raise ArgumentError, "No mongo connection was supplied to #{self.class.name}." if @connection.nil?
           
           super() do |klass|
-            collection_name = Util::Inflector.pluralize(Util::Inflector.underscore(klass.name.to_s))
+            collection_name = Util::Inflector.pluralize(Util::Inflector.underscore(klass.name.to_s)).gsub('/', '_')
             context = Contexts::MongoContext.new(klass)
             context.data_store = @connection[collection_name]
             yield(klass, context) if block_given?

data/lib/poro/contexts/mongo_context.rb

@@ -45,6 +45,12 @@ module Poro
         @persistent_attributes_whitelist = nil
         @persistent_attributes_blacklist = nil
         
+        # Some configuration variables
+        @encode_symbols = false
+        @attempt_id_conversion = true
+        @set_encoding_method = :embedded_array
+        
+        
         # Initialize
         super(klass)
       end
@@ -62,6 +68,27 @@ module Poro
       attr_reader :persistent_attributes_blacklist
       attr_writer :persistent_attributes_blacklist
       
+      # If true, it encodes Symbol as a hash with a class name property, and
+      # then decodes them back into Symbol.  If false, it converts them to
+      # String for storage.  Defaults to false.
+      #
+      # While one would think they want to preserve the type of the saved element,
+      # the change in storage method makes it harder to write Mongo queries on the
+      # data.  Thus it is normally best to save symbols as strings for storage.
+      attr_reader :encode_symbols
+      attr_writer :encode_symbols
+      
+      # Normally, one uses BSON::ObjectId instances for the IDs on a stored
+      # Mongo object.  However, one can design a database to use many different
+      # values as sthe primary key.
+      #
+      # When this is set to true, fetch tries to convert the given ID into a
+      # BSON::ObjectId before doing a fetch.  If the conversion fails, it tries using
+      # the raw value given.  If this is set to false, then it always passes
+      # along the raw value, skipping the conversion step.
+      attr_reader :attempt_id_conversion
+      attr_writer :attempt_id_conversion
+      
       def fetch(id)
         data = data_store.find_one( clean_id(id) )
         return convert_to_plain_object(data)
@@ -94,9 +121,8 @@ module Poro
       private
       
       def clean_id(id)
-        #TODO: Make the attempted transform configurable; mongo doesn't require an ObjectId as the key.
         # Attempt to convert to an ObjectID if it looks like it should be.
-        if( !(id.kind_of?(BSON::ObjectId)) && BSON::ObjectId.legal?(id.to_s) )
+        if( self.attempt_id_conversion && !(id.kind_of?(BSON::ObjectId)) && BSON::ObjectId.legal?(id.to_s) )
           id = BSON::ObjectId.from_string(id.to_s)
         end
         return id
@@ -123,6 +149,7 @@ module Poro
           obj.kind_of?(Float) ||
           obj.kind_of?(String) ||
           obj.kind_of?(Time) ||
+          (self.encode_symbols && obj.kind_of?(Symbol)) ||
           obj==true ||
           obj==false ||
           obj.nil? ||
@@ -178,6 +205,10 @@ module Poro
           return encode_array(obj)
         elsif( obj.kind_of?(Class) )
           return encode_class(obj)
+        elsif( obj.kind_of?(Set) )
+          return encode_set(obj)
+        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)
         elsif( Context.managed_class?(obj.class))
@@ -207,6 +238,23 @@ module Poro
         return {'_class_name' => klass.class, 'name' => klass.name}
       end
       
+      # Encodes a symbol.
+      def encode_symbol(sym)
+        return {'_class_name' => 'Symbol', 'value' => sym.to_s}
+      end
+      
+      # Encodes a Set as either :raw, :embedded_array, :array.
+      def encode_set(set)
+        method = @set_encoding_method
+        if( method == :raw )
+          return encode_unmanaged_object(set)
+        elsif( method == :embedded_array )
+          return {'_class_name' => 'Set', 'values' => self.convert_to_data(set.to_a, :embedded => true)}
+        else
+          return self.convert_to_data(set.to_a, :embedded => true)
+        end
+      end
+      
       # Encode a hash that came from a DBRef dereferenced and decoded by this context.
       #
       # This will save the hash when its owning object is saved!
@@ -294,6 +342,10 @@ module Poro
         class_name = data['_class_name'].to_s
         if( class_name == 'Class' )
           return decode_class(data)
+        elsif( class_name == 'Symbol' )
+          return decode_symbol(data)
+        elsif( class_name == 'Set' )
+          return decode_set(data)
         elsif( class_name == self.klass.to_s )
           return decode_self_managed_object(data)
         elsif( class_name && data['managed'] )
@@ -321,6 +373,27 @@ module Poro
         return Util::ModuleFinder.find(class_data['name'])
       end
       
+      # Decode a symbol reference.  If this users of the Context expect a Symbol
+      # to be encoded as a Symbol, then decode it as a Symbol.  Otherwise the
+      # users of the Context wil be expecting a String.
+      def decode_symbol(symbol_data)
+        if self.encode_symbols
+          return symbol_data['value'].to_sym
+        else
+          return symbol_data['value'].to_s
+        end
+      end
+      
+      # 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'] )
+          return Set.new(set_data['values'])
+        else
+          return decode_unmanaged_object(set_data)
+        end
+      end
+      
       # Decode a BSON::DBRef.  If there is a context for the reference, it is
       # wrapped in that object type.  If there is no context, it is left as
       # a DBRef so that it will re-save as a DBRef (otherwise it'll save as a
@@ -438,7 +511,7 @@ module Poro
         end
         
         def data_store_find_all(*args, &block)
-          return data_store.find(*args, &block).to_a.map {|data| self.convert_to_plain_object(doc)}
+          return data_store.find(*args, &block).to_a.map {|doc| self.convert_to_plain_object(doc)}
         end
         
         def data_store_find_first(*args, &block)

data/lib/poro/version.rb

@@ -0,0 +1,7 @@
+# Poro is a lightweight persistence engine that can use many different data stores
+# to persist information.  Poro takes a hands-off approach, attempting to change
+# existing plain ol' ruby objects as little as possible.  For more information
+# see README.rdoc.
+module Poro
+  VERSION = '0.1.1'
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Jeff Reinecke
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-18 00:00:00 -07:00
+date: 2010-09-24 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -47,6 +47,7 @@ files:
 - lib/poro/util/inflector.rb
 - lib/poro/util/module_finder.rb
 - lib/poro/util.rb
+- lib/poro/version.rb
 - lib/poro.rb
 - spec/context_factory_spec.rb
 - spec/context_spec.rb
@@ -60,7 +61,7 @@ files:
 has_rdoc: true
 homepage: http://www.github.com/paploo/poro
 licenses: 
-- LICENSE
+- BSD
 post_install_message: 
 rdoc_options: []
 
@@ -90,6 +91,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: A lightweight thin persistence engine that can utilize many different persistence engines.
+summary: A lightweight thin persistence engine that can utilize many different persistence data stores.
 test_files: []