poro 0.1.0

data/lib/poro/util/inflector/methods.rb

@@ -0,0 +1,153 @@
+module Poro
+  module Util
+    # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+    # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
+    # in inflections.rb.
+    #
+    # The Rails core team has stated patches for the inflections library will not be accepted
+    # in order to avoid breaking legacy applications which may be relying on errant inflections.
+    # If you discover an incorrect inflection and require it for your application, you'll need
+    # to correct it yourself (explained below).
+    module Inflector
+      extend self
+
+      # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+      # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+      #
+      # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+      #
+      # Examples:
+      #   "active_record".camelize                # => "ActiveRecord"
+      #   "active_record".camelize(:lower)        # => "activeRecord"
+      #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+      #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+      #
+      # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
+      # though there are cases where that does not hold:
+      #
+      #   "SSLError".underscore.camelize # => "SslError"
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+        end
+      end
+
+      # Makes an underscored, lowercase form from the expression in the string.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      # Examples:
+      #   "ActiveRecord".underscore         # => "active_record"
+      #   "ActiveRecord::Errors".underscore # => active_record/errors
+      #
+      # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
+      # though there are cases where that does not hold:
+      #
+      #   "SSLError".underscore.camelize # => "SslError"
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      # Replaces underscores with dashes in the string.
+      #
+      # Example:
+      #   "puni_puni" # => "puni-puni"
+      def dasherize(underscored_word)
+        underscored_word.gsub(/_/, '-')
+      end
+
+      # Removes the module part from the expression in the string.
+      #
+      # Examples:
+      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+      #   "Inflections".demodulize                                       # => "Inflections"
+      def demodulize(class_name_in_module)
+        class_name_in_module.to_s.gsub(/^.*::/, '')
+      end
+
+      # Creates a foreign key name from a class name.
+      # +separate_class_name_and_id_with_underscore+ sets whether
+      # the method should put '_' between the name and 'id'.
+      #
+      # Examples:
+      #   "Message".foreign_key        # => "message_id"
+      #   "Message".foreign_key(false) # => "messageid"
+      #   "Admin::Post".foreign_key    # => "post_id"
+      def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+        underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+      end
+
+      # Ruby 1.9 introduces an inherit argument for Module#const_get and
+      # #const_defined? and changes their default behavior.
+      if Module.method(:const_get).arity == 1
+        # Tries to find a constant with the name specified in the argument string:
+        #
+        #   "Module".constantize     # => Module
+        #   "Test::Unit".constantize # => Test::Unit
+        #
+        # The name is assumed to be the one of a top-level constant, no matter whether
+        # it starts with "::" or not. No lexical context is taken into account:
+        #
+        #   C = 'outside'
+        #   module M
+        #     C = 'inside'
+        #     C               # => 'inside'
+        #     "C".constantize # => 'outside', same as ::C
+        #   end
+        #
+        # NameError is raised when the name is not in CamelCase or the constant is
+        # unknown.
+        def constantize(camel_cased_word)
+          names = camel_cased_word.split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          constant = Object
+          names.each do |name|
+            constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+          end
+          constant
+        end
+      else
+        def constantize(camel_cased_word) #:nodoc:
+          names = camel_cased_word.split('::')
+          names.shift if names.empty? || names.first.empty?
+
+          constant = Object
+          names.each do |name|
+            constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+          end
+          constant
+        end
+      end
+
+      # Turns a number into an ordinal string used to denote the position in an
+      # ordered sequence such as 1st, 2nd, 3rd, 4th.
+      #
+      # Examples:
+      #   ordinalize(1)     # => "1st"
+      #   ordinalize(2)     # => "2nd"
+      #   ordinalize(1002)  # => "1002nd"
+      #   ordinalize(1003)  # => "1003rd"
+      def ordinalize(number)
+        if (11..13).include?(number.to_i % 100)
+          "#{number}th"
+        else
+          case number.to_i % 10
+            when 1; "#{number}st"
+            when 2; "#{number}nd"
+            when 3; "#{number}rd"
+            else    "#{number}th"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/poro/util/module_finder.rb

@@ -0,0 +1,66 @@
+module Poro
+  module Util
+    module ModuleFinder
+      
+      # Finds the given module by string.
+      #
+      # Arguments:
+      # [arg] The module/class name to find.
+      # [relative_root] If given, tries to find the requested class/module
+      #                 within this module/class.  May be a string.
+      # [strict] Normally--mostly like Ruby--a top-level class will be returned
+      #          at any step if no module/class matches in the namespace it is
+      #          searching.  If this is true, then a last check is made to see
+      #          if the returned module/class is actually inside of the relative
+      #          root.
+      #
+      # If given a class, it returns it directly.  TODO: Make it look it up if
+      # relative_root is not Module or Object.
+      def self.find(arg, relative_root=Module, strict=false)
+        # If the argument is a kind of class, just return right away.
+        return arg if arg.kind_of?(Module) || arg.kind_of?(Class)
+        
+        # Now we need to treat it as a string:
+        arg = arg.to_s
+        raise NameError, "Could not find a module or class from nothing." if arg.nil? || arg.empty?
+        
+        # First, define the recursive function.
+        recursive_resolve = lambda do |curr_mod, names|
+          head, *rest = names.to_a
+          if( head.nil? && rest.empty? )
+            curr_mod
+          elsif( !(head.to_s.empty?) && curr_mod.respond_to?(:const_defined?) && curr_mod.const_defined?(head) )
+            recursive_resolve.call( curr_mod.const_get(head), rest)
+          else
+            raise NameError, "Could not find a module or class from #{arg.inspect}"
+          end
+        end
+        
+        # If starting with ::, then the constant is aboslutely referenced.
+        relative_root = Module if arg[0,2]=='::'
+        
+        # Split into names
+        start_index = arg[0,2]=='::' ? 2 : 0
+        mod_names = arg[start_index..-1].split('::')
+        
+        # Now get the module or class.
+        relative_root = self.send(__method__, relative_root)
+        mod = recursive_resolve.call(relative_root, mod_names)
+        
+        # Now, if we are strict, verify it is of the type we are looking for.
+        if (relative_root!=Module || relative_root!=Object) && !(mod.name.include?(relative_root.name))
+          base_message = "Could not find a module or class #{mod.name.inspect} inside of #{relative_root.name.inspect}"
+          if( strict )
+            raise NameError, base_message
+          else
+            STDERR.puts "WARNING: #{base_message}, top level mod/class used instead."
+          end
+        end
+        
+        # Return
+        return mod
+      end
+      
+    end
+  end
+end

data/spec/context_factory_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "ContextFactory" do
+  
+  before(:all) do
+    @context_manager_klass = Poro::ContextFactory
+    
+    @klass_one = Class.new(Object)
+    @klass_two = Class.new(String)
+  end
+  
+  it 'should save the context instance' do
+    testObject = @context_manager_klass.new
+    @context_manager_klass.instance = testObject
+    @context_manager_klass.instance.should == testObject
+  end
+  
+  it 'should error if the application context manager is set to an inappropriate object kind' do
+    lambda {@context_manager_klass.instance = :foo}.should raise_error
+    lambda {@context_manager_klass.instance = nil}.should_not raise_error
+  end
+  
+  it 'should error if the application context manager is unset' do
+    @context_manager_klass.instance = nil
+    lambda {@context_manager_klass.instance}.should raise_error
+  end
+  
+  it 'should run the context block on fetch' do
+    @context_manager_klass.instance = manager = @context_manager_klass.new do |klass|
+      if( klass == @klass_one )
+        :alpha
+      else
+        :beta
+      end
+    end
+    
+    @klass_one.send(:include, Poro::Persistify)
+    @klass_two.send(:include, Poro::Persistify)
+    
+    manager.fetch(@klass_one).should == :alpha
+    manager.fetch(@klass_two).should == :beta
+  end
+  
+  it 'should cache the fetched result' do
+    @context_manager_klass.instance = manager = @context_manager_klass.new do |klass|
+      o = Object.new
+      o.instance_variable_set(:@klass, klass)
+      o
+    end
+    
+    @klass_one.send(:include, Poro::Persistify)
+    @klass_two.send(:include, Poro::Persistify)
+    
+    context_one = manager.fetch(@klass_one)
+    context_two = manager.fetch(@klass_two)
+    
+    manager.fetch(@klass_one).should == context_one
+    manager.fetch(@klass_two).should_not == context_one
+    manager.fetch(@klass_two).should == context_two
+  end
+  
+  it 'should error when a class is not persistable' do
+    manager = @context_manager_klass.new do |klass|
+      Object.new
+    end
+    
+    lambda {manager.fetch(@klass_one)}.should_not raise_error
+    lambda {manager.fetch(Object)}.should raise_error(Poro::ContextFactory::FactoryError)
+  end
+  
+end

data/spec/context_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Context" do
+  
+  before(:all) do
+    @context_klass = Poro::Context
+    
+    @klass_one = Class.new(Object)
+  end
+  
+  it 'should know its class' do
+    context = @context_klass.new(Object)
+    context.klass.should == Object
+  end
+  
+  it 'should have an immutable class' do
+    context = @context_klass.new(Object)
+    context.should_not respond_to(:klass=)
+  end
+  
+  it 'should return its data store' do
+    context = @context_klass.new(Object)
+    context.should respond_to(:data_store)
+  end
+   
+  it 'should have an immutable data store' do
+   context = @context_klass.new(Object)
+   context.should_not respond_to(:dat_store=)
+  end
+  
+  it 'should return the saved object from a save' do
+    context = @context_klass.new(Object)
+    obj = Object.new
+    context.save(obj).should == obj
+  end
+  
+  it 'should return the removed object from a remove' do
+    context = @context_klass.new(Object)
+    obj = Object.new
+    context.remove(obj).should == obj
+  end
+  
+  it 'should set the id on a save and unset it on remove' do
+    obj = Object.new
+    class << obj
+      attr_reader :id
+      attr_writer :id
+    end
+    
+    obj.should respond_to(:id)
+    obj.should respond_to(:id=)
+    
+    context = @context_klass.new(obj.class)
+    
+    obj.id.should == nil
+    context.save(obj)
+    obj.id.should_not == nil
+    context.remove(obj)
+    obj.id.should == nil
+  end
+  
+  it 'should have a customizable id method' do
+    obj = Object.new
+    class << obj
+      attr_reader :pk
+      attr_writer :pk
+    end
+    
+    context = @context_klass.new(obj.class)
+    context.primary_key = :pk
+    
+    obj.pk.should be_nil
+    context.primary_key_value(obj).should == obj.pk
+    context.set_primary_key_value(obj, 12345)
+    obj.pk.should == 12345
+    context.primary_key_value(obj).should == obj.pk
+  end
+  
+  it 'should yield self at end of initialization' do
+    block_context = nil
+    context = @context_klass.new(Object) do |c|
+      c.klass.should == Object
+      block_context = c
+    end
+    context.should == block_context
+  end
+  
+  it 'should be able to fetch the context for a class' do
+    x = rand(1000)
+    Poro::ContextFactory.instance = Poro::ContextFactory.new do |klass|
+      "#{klass}, #{x}"
+    end
+    
+    @klass_one.send(:include, Poro::Persistify)
+    
+    Poro::Context.fetch(@klass_one).should == "#{@klass_one}, #{x}"
+  end
+  
+  it 'should be able to fetch the context for an object' do
+    x = rand(1000)
+    Poro::ContextFactory.instance = Poro::ContextFactory.new do |klass|
+      "#{klass}, #{x}"
+    end
+    
+    @klass_one.send(:include, Poro::Persistify)
+    
+    Poro::Context.fetch(@klass_one.new).should == "#{@klass_one}, #{x}"
+  end
+  
+end

data/spec/hash_context_spec.rb

@@ -0,0 +1,231 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "HashContext" do
+  
+  before(:each) do
+    @obj = Object.new
+    class << @obj
+      attr_reader :id
+      attr_writer :id
+    end
+    
+    @context = Poro::Contexts::HashContext.new(@obj.class)
+  end
+  
+  it "should have a hash for a data store" do
+    @context.data_store.should be_kind_of(Hash)
+  end
+  
+  it "should save and fetch a new item" do
+    @obj.id.should be_nil
+    @context.save(@obj)
+    @obj.id.should_not be_nil
+    
+    fetched_obj = @context.fetch(@obj.id)
+    fetched_obj.should == @obj
+  end
+  
+  it "should update an existing item" do
+    # Assume saving a new object works fir this test (there is another test save on new)
+    @context.save(@obj)
+    id_1 = @obj.id
+    id_1.should_not be_nil
+    
+    @context.save(@obj)
+    id_2 = @obj.id
+    id_2.should == id_1
+  end
+  
+  it "should remove an item" do
+    @context.save(@obj)
+    
+    obj_id = @obj.id
+    obj_id.should_not be_nil
+    
+    fetched_obj = @context.fetch(obj_id)
+    fetched_obj.should_not be_nil
+    
+    @context.remove(@obj)
+    
+    new_obj_id = @obj.id
+    new_obj_id.should be_nil
+    
+    refetched_obj = @context.fetch(obj_id)
+    refetched_obj.should be_nil
+  end
+  
+  it "should error when trying to save an object that can't handle IDs" do
+    o = Object.new
+    o.should_not respond_to(:id)
+    o.should_not respond_to(:id=)
+    
+    lambda {@context.save(o)}.should raise_error
+  end
+  
+  it "should error when trying to remove an object that can't handle IDs" do
+    o = Object.new
+    o.should_not respond_to(:id)
+    o.should_not respond_to(:id=)
+    
+    lambda {@context.remove(o)}.should raise_error
+  end
+  
+  describe "Finding" do
+    
+    before(:each) do
+      
+      class HashContextPerson
+        include Poro::Persistify
+        def initialize(id, first_name, last_name, friends)
+          @id = id
+          @first_name = first_name
+          @last_name = last_name
+          @friends = friends
+        end
+      end
+      
+      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]}
+      @data = [
+        george_smith,
+        george_archer,
+        bridgette_smith,
+        karen_zeta
+      ]
+      
+      @context = Poro::Contexts::HashContext.new(HashContextPerson)
+      
+      # Cheat to jam the data in there:
+      @context.data_store = @data
+    end
+    
+    it 'should get shallow values' do
+      expected_first_names = ['George', 'George', 'Bridgette', 'Karen']
+      first_names_sym = @data.map {|record| @context.send(:value_for_key, record, :first_name)[:value]}
+      first_names_str = @data.map {|record| @context.send(:value_for_key, record, 'first_name')[:value]}
+      first_names_sym.should == first_names_str
+      first_names_sym.should == expected_first_names
+      
+      expected_ids = [1, 2, 3, 4]
+      ids_sym = @data.map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      ids_str = @data.map {|record| @context.send(:value_for_key, record, 'id')[:value]}
+      ids_sym.should == ids_str
+      ids_sym.should == expected_ids
+    end
+    
+    it 'should get embedded' do
+      expected_values = [{:found=>false, :value=>nil}, {:found=>true, :value=>1}, {:found=>false, :value=>nil}, {:found=>true, :value=>2}]
+      values = @data.map {|record| @context.send(:value_for_key, record, 'friends.0.id')}
+      values.should == expected_values
+    end
+    
+    it 'should sort' do
+      order_opt = {:first_name => :asc}
+      expected_values = [3,1,2,4]
+      values = @context.send(:sort, @data, order_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      order_opt = {:first_name => :asc, :last_name => :asc}
+      expected_values = [3,2,1,4]
+      values = @context.send(:sort, @data, order_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      order_opt = {:first_name => :asc, :last_name => :desc}
+      expected_values = [3,1,2,4]
+      values = @context.send(:sort, @data, order_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      order_opt = {:last_name => :asc, :first_name => :asc}
+      expected_values = [2,3,1,4]
+      values = @context.send(:sort, @data, order_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      order_opt = {'friends.0.id' => :asc, 'last_name' => :desc, 'first_name' => :desc}
+      expected_values = [1,3,2,4]
+      values = @context.send(:sort, @data, order_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+    end
+    
+    it 'should filter' do
+      filter_opt = {:last_name => 'Smith'}
+      expected_values = [1,3]
+      values = @context.send(:filter, @data, filter_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      filter_opt = {'first_name' => 'George'}
+      expected_values = [1,2]
+      values = @context.send(:filter, @data, filter_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      filter_opt = {:first_name => 'George', 'last_name' => 'Smith'}
+      expected_values = [1]
+      values = @context.send(:filter, @data, filter_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      filter_opt = {'friends.0.id' => nil}
+      expected_values = []
+      values = @context.send(:filter, @data, filter_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      filter_opt = {'friends.0.id' => 2}
+      expected_values = [4]
+      values = @context.send(:filter, @data, filter_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+    end
+    
+    it 'should limit' do
+      limit_opt = {:limit => nil, :offset => 0}
+      expected_values = [1,2,3,4]
+      values = @context.send(:limit, @data, limit_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      limit_opt = {:limit => 2, :offset => 0}
+      expected_values = [1,2]
+      values = @context.send(:limit, @data, limit_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      limit_opt = {:limit => 2, :offset => 3}
+      expected_values = [4]
+      values = @context.send(:limit, @data, limit_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      limit_opt = {:limit => 100, :offset => 2}
+      expected_values = [3,4]
+      values = @context.send(:limit, @data, limit_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      limit_opt = {:limit => nil, :offset => 2}
+      expected_values = [3,4]
+      values = @context.send(:limit, @data, limit_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      limit_opt = {:limit => nil, :offset => 100}
+      expected_values = []
+      values = @context.send(:limit, @data, limit_opt).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+    end
+    
+    it 'should find all' do
+      opts = {:conditions => {:last_name => 'Smith'}, :order => :first_name}
+      expected_values = [3,1]
+      values = @context.find(:all, opts).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+      
+      values = @context.find(:many, opts).map {|record| @context.send(:value_for_key, record, :id)[:value]}
+      values.should == expected_values
+    end
+    
+    it 'should find first' do
+      opts = {:conditions => {:last_name => 'Smith'}, :order => :first_name}
+      record = @context.find(:first, opts)
+      @context.send(:value_for_key, record, :id)[:value].should == 3
+      
+      record = @context.find(:one, opts)
+      @context.send(:value_for_key, record, :id)[:value].should == 3
+    end
+    
+  end
+  
+end