poro 0.1.0

data/lib/poro/modelify.rb

@@ -0,0 +1,100 @@
+module Poro
+  # When this module is mixed into a a persistent object, it adds the
+  # object oriented methods directly to the class, making it behave like a model
+  # in other ORMs.
+  #
+  # If this module is not mixed in, the object can still persist, but the context
+  # must be directly accessed to fetch, save, and remove the data.
+  #
+  # Additionally, this module also ensures that the appropriate
+  # primary key accessor methods exist on the object, creating them if necessary.
+  #
+  # WARNING: You should configure the primary keys on the class' Context before
+  # including this module if you want to use an accessor other than the
+  # Context's default.
+  #
+  # See Modelify::ClassMethods and Modelify::InstanceMethods for the methods
+  # added by this mixin.
+  #
+  # = TODO: Piecewise Modelfication
+  #
+  # Modelfication should be done in a piece-meal way, so that we can layer
+  # in features such as pk accesor generation, basic model methods, find methods,
+  # and hook methods.  We may still keep this top-level include to add the full
+  # suite, but we should break up the pieces.  (In doing this, we could to manage
+  # dependencies so that we get the basic pieces included in when we need things
+  # they depend on, but by not managing this, it gives more flexability for
+  # advanced users to replace segments.
+  module Modelify
+    
+    def self.included(mod) # :nodoc:
+      mod.send(:extend, ClassMethods)
+      mod.send(:include, InstanceMethods)
+      mod.send(:include, FindMethods)
+      
+      context = Context.fetch(mod)
+      pk = context.primary_key.to_s.gsub(/[^A-Za-z0-9]/, '_').strip
+      raise NameError, "Cannot create a primary key method from #{context.primary_key.inspect}" if pk.nil? || pk.empty?
+      mod.class_eval("def #{pk}; return @#{pk}; end")
+      mod.class_eval("def #{pk}=(value); @#{pk} = value; end")
+    end
+    
+    # These methods are added as class methods when including Modelify.
+    # See Modelify for more information.
+    module ClassMethods
+      # Find the object for the given id.
+      def fetch(id)
+        return context.fetch(id)
+      end
+      
+      # Get the context instance for this class.
+      def context
+        return Context.fetch(self)
+      end
+    end
+    
+    # These methods are addes as instance methods when including Modelify.
+    # See Modelify for more information.
+    module InstanceMethods
+      
+      # Save the given object to persistent storage.
+      def save
+        return context.save(self)
+      end
+      
+      # Remove the given object from persistent storage.
+      def remove
+        return context.remove(self)
+      end
+      
+      # Return the context instance for this object.
+      def context
+        return Context.fetch(self)
+      end
+    end
+    
+    # The find methods.  See FindMethods::ClassMethods for details.
+    module FindMethods
+      
+      def self.included(mod) # :nodoc:
+        mod.send(:extend, ClassMethods)
+      end
+      
+      # The model find class methods.
+      module ClassMethods
+        
+        # Calls find on the Context.  See Poro::Context::FindMethods for details.
+        def find(arg, opts={})
+          return context.find(arg, opts)
+        end
+        
+        # Calls data_store_find on the Context.  See Poro::Context::FindMethods for details.
+        def data_store_find(first_or_all, *args, &block)
+          return context.data_store_find(first_or_all, *args, &block)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/poro/persistify.rb

@@ -0,0 +1,42 @@
+module Poro
+  # Include this module into any class in order to flag it for persistence.
+  #
+  # This is the only required change to a class in order to make it persistent.
+  # This flags it so that the factories know that it is okay to generate a
+  # context for this class and persist it.
+  #
+  # The only method this adds is a convenience class method for configuring
+  # the Context instance that backs the class it is included in.
+  #
+  # This module represents the only required breech of the hands off your code
+  # philosophy that Poro embodies.
+  #
+  # For those looking to add more model like behaviors, include Poro::Modelify
+  # as well.
+  module Persistify
+    
+    def self.included(mod) # :nodoc:
+      mod.send(:extend, ClassMethods)
+      
+      # Force the initialization of the context now, as one would expect it to
+      # exist after including this module.  This also makes sure that on load
+      # all the contexts that are going to exist are known for introspection.
+      Context.fetch(mod)
+    end
+    
+    module ClassMethods
+      
+      # A convenience method to more easily call
+      # <tt>Context.configure_for_class</tt> from within a class decleration.
+      #
+      # This was added to ease the transition from existing model based ORMs,
+      # and is up for debate.  It may be better to directly use
+      # <tt>Context.configure_for_class</tt>.
+      def configure_context(&configuration_block)
+        return Context.configure_for_class(self, &configuration_block)
+      end
+      
+    end
+    
+  end
+end

data/lib/poro/util.rb

@@ -0,0 +1,2 @@
+require 'poro/util/inflector'
+require 'poro/util/module_finder'

data/lib/poro/util/inflector.rb

@@ -0,0 +1,103 @@
+module Poro
+  module Util
+    # = License
+    #
+    # Inflector is from AcitveSupport, which is distributed via the following
+    # MIT license:
+    #
+    # Copyright (c) 2005-2010 David Heinemeier Hansson
+    # 
+    # 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.
+    #
+    # = Overview
+    #
+    # This module contains the inflector from ActiveSupport, but in its own
+    # namespace and without being injected into the String class.  This prevents
+    # Poro's implementation from clobbering that of ActiveSupport, should the
+    # rest of your project be using it, even if you include ActiveSupport before
+    # Poro.
+    module Inflector
+      # Space intentionally left blank.
+    end
+  end
+end
+
+require 'poro/util/inflector/inflections'
+require 'poro/util/inflector/methods'
+
+module Poro
+  module Util
+    Inflector.inflections do |inflect|
+      inflect.plural(/$/, 's')
+      inflect.plural(/s$/i, 's')
+      inflect.plural(/(ax|test)is$/i, '\1es')
+      inflect.plural(/(octop|vir)us$/i, '\1i')
+      inflect.plural(/(alias|status)$/i, '\1es')
+      inflect.plural(/(bu)s$/i, '\1ses')
+      inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+      inflect.plural(/([ti])um$/i, '\1a')
+      inflect.plural(/sis$/i, 'ses')
+      inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+      inflect.plural(/(hive)$/i, '\1s')
+      inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+      inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+      inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+      inflect.plural(/([m|l])ouse$/i, '\1ice')
+      inflect.plural(/^(ox)$/i, '\1en')
+      inflect.plural(/(quiz)$/i, '\1zes')
+
+      inflect.singular(/s$/i, '')
+      inflect.singular(/(n)ews$/i, '\1ews')
+      inflect.singular(/([ti])a$/i, '\1um')
+      inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+      inflect.singular(/(^analy)ses$/i, '\1sis')
+      inflect.singular(/([^f])ves$/i, '\1fe')
+      inflect.singular(/(hive)s$/i, '\1')
+      inflect.singular(/(tive)s$/i, '\1')
+      inflect.singular(/([lr])ves$/i, '\1f')
+      inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+      inflect.singular(/(s)eries$/i, '\1eries')
+      inflect.singular(/(m)ovies$/i, '\1ovie')
+      inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+      inflect.singular(/([m|l])ice$/i, '\1ouse')
+      inflect.singular(/(bus)es$/i, '\1')
+      inflect.singular(/(o)es$/i, '\1')
+      inflect.singular(/(shoe)s$/i, '\1')
+      inflect.singular(/(cris|ax|test)es$/i, '\1is')
+      inflect.singular(/(octop|vir)i$/i, '\1us')
+      inflect.singular(/(alias|status)es$/i, '\1')
+      inflect.singular(/^(ox)en/i, '\1')
+      inflect.singular(/(vert|ind)ices$/i, '\1ex')
+      inflect.singular(/(matr)ices$/i, '\1ix')
+      inflect.singular(/(quiz)zes$/i, '\1')
+      inflect.singular(/(database)s$/i, '\1')
+
+      inflect.irregular('person', 'people')
+      inflect.irregular('man', 'men')
+      inflect.irregular('child', 'children')
+      inflect.irregular('sex', 'sexes')
+      inflect.irregular('move', 'moves')
+      inflect.irregular('cow', 'kine')
+
+      inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
+    end
+  end
+end
+

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

@@ -0,0 +1,213 @@
+module Poro
+  module Util
+    module Inflector
+      # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
+      # inflection rules. Examples:
+      #
+      #   ActiveSupport::Inflector.inflections do |inflect|
+      #     inflect.plural /^(ox)$/i, '\1\2en'
+      #     inflect.singular /^(ox)en/i, '\1'
+      #
+      #     inflect.irregular 'octopus', 'octopi'
+      #
+      #     inflect.uncountable "equipment"
+      #   end
+      #
+      # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+      # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+      # already have been loaded.
+      class Inflections
+        def self.instance
+          @__instance__ ||= new
+        end
+
+        attr_reader :plurals, :singulars, :uncountables, :humans
+
+        def initialize
+          @plurals, @singulars, @uncountables, @humans = [], [], [], []
+        end
+
+        # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+        # The replacement should always be a string that may include references to the matched data from the rule.
+        def plural(rule, replacement)
+          @uncountables.delete(rule) if rule.is_a?(String)
+          @uncountables.delete(replacement)
+          @plurals.insert(0, [rule, replacement])
+        end
+
+        # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+        # The replacement should always be a string that may include references to the matched data from the rule.
+        def singular(rule, replacement)
+          @uncountables.delete(rule) if rule.is_a?(String)
+          @uncountables.delete(replacement)
+          @singulars.insert(0, [rule, replacement])
+        end
+
+        # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+        # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+        #
+        # Examples:
+        #   irregular 'octopus', 'octopi'
+        #   irregular 'person', 'people'
+        def irregular(singular, plural)
+          @uncountables.delete(singular)
+          @uncountables.delete(plural)
+          if singular[0,1].upcase == plural[0,1].upcase
+            plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+            plural(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + plural[1..-1])
+            singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+          else
+            plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+            plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+            plural(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
+            plural(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
+            singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
+            singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])
+          end
+        end
+
+        # Add uncountable words that shouldn't be attempted inflected.
+        #
+        # Examples:
+        #   uncountable "money"
+        #   uncountable "money", "information"
+        #   uncountable %w( money information rice )
+        def uncountable(*words)
+          (@uncountables << words).flatten!
+        end
+
+        # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
+        # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
+        # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
+        #
+        # Examples:
+        #   human /_cnt$/i, '\1_count'
+        #   human "legacy_col_person_name", "Name"
+        def human(rule, replacement)
+          @humans.insert(0, [rule, replacement])
+        end
+
+        # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
+        # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
+        # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
+        #
+        # Examples:
+        #   clear :all
+        #   clear :plurals
+        def clear(scope = :all)
+          case scope
+            when :all
+              @plurals, @singulars, @uncountables = [], [], []
+            else
+              instance_variable_set "@#{scope}", []
+          end
+        end
+      end
+
+      # Yields a singleton instance of Inflector::Inflections so you can specify additional
+      # inflector rules.
+      #
+      # Example:
+      #   ActiveSupport::Inflector.inflections do |inflect|
+      #     inflect.uncountable "rails"
+      #   end
+      def inflections
+        if block_given?
+          yield Inflections.instance
+        else
+          Inflections.instance
+        end
+      end
+
+      # Returns the plural form of the word in the string.
+      #
+      # Examples:
+      #   "post".pluralize             # => "posts"
+      #   "octopus".pluralize          # => "octopi"
+      #   "sheep".pluralize            # => "sheep"
+      #   "words".pluralize            # => "words"
+      #   "CamelOctopus".pluralize     # => "CamelOctopi"
+      def pluralize(word)
+        result = word.to_s.dup
+
+        if word.empty? || inflections.uncountables.include?(result.downcase)
+          result
+        else
+          inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+          result
+        end
+      end
+
+      # The reverse of +pluralize+, returns the singular form of a word in a string.
+      #
+      # Examples:
+      #   "posts".singularize            # => "post"
+      #   "octopi".singularize           # => "octopus"
+      #   "sheep".singularize            # => "sheep"
+      #   "word".singularize             # => "word"
+      #   "CamelOctopi".singularize      # => "CamelOctopus"
+      def singularize(word)
+        result = word.to_s.dup
+
+        if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/i }
+          result
+        else
+          inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+          result
+        end
+      end
+
+      # Capitalizes the first word and turns underscores into spaces and strips a
+      # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+      #
+      # Examples:
+      #   "employee_salary" # => "Employee salary"
+      #   "author_id"       # => "Author"
+      def humanize(lower_case_and_underscored_word)
+        result = lower_case_and_underscored_word.to_s.dup
+
+        inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+        result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+      end
+
+      # Capitalizes all the words and replaces some characters in the string to create
+      # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+      # used in the Rails internals.
+      #
+      # +titleize+ is also aliased as as +titlecase+.
+      #
+      # Examples:
+      #   "man from the boondocks".titleize # => "Man From The Boondocks"
+      #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+      def titleize(word)
+        humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
+      end
+
+      # Create the name of a table like Rails does for models to table names. This method
+      # uses the +pluralize+ method on the last word in the string.
+      #
+      # Examples
+      #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+      #   "egg_and_ham".tableize     # => "egg_and_hams"
+      #   "fancyCategory".tableize   # => "fancy_categories"
+      def tableize(class_name)
+        pluralize(underscore(class_name))
+      end
+
+      # Create a class name from a plural table name like Rails does for table names to models.
+      # Note that this returns a string and not a Class. (To convert to an actual class
+      # follow +classify+ with +constantize+.)
+      #
+      # Examples:
+      #   "egg_and_hams".classify # => "EggAndHam"
+      #   "posts".classify        # => "Post"
+      #
+      # Singular names are not handled correctly:
+      #   "business".classify     # => "Busines"
+      def classify(table_name)
+        # strip out any leading schema name
+        camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+      end
+    end
+  end
+end