og 0.27.0 → 0.28.0

data/lib/og/ez/condition.rb

@@ -0,0 +1,181 @@
+# gmosx: Work in progress.
+
+module Caboose
+
+  module EZ
+    # EZ::Condition plugin for generating the :conditions where clause
+    # for ActiveRecord::Base.find. And an extension to ActiveRecord::Base
+    # called AR::Base.find_with_conditions that takes a block and builds
+    # the where clause dynamically for you.
+    
+    class Condition
+      # need this so that id doesn't call Object#id
+      # left it open to add more methods that
+      # conflict when I find them
+      [:id].each { |m| undef_method m }
+      
+      # these are also reserved words regarding SQL column names
+      # use esc_* prefix to circumvent any issues
+      attr_reader :clauses      
+      attr_accessor :inner
+      attr_accessor :outer
+      
+      # Initialize @clauses and eval the block so 
+      # it invokes method_missing.
+      def initialize(*args, &block)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        options[:table_name] = args.first if args.first.kind_of? Symbol        
+        @table_name = options.delete(:table_name) || nil
+        @outer = options.delete(:outer) || :and
+        @inner = options.delete(:inner) || :and
+        @clauses = []   
+        instance_eval(&block) if block_given?
+      end
+
+      # When invoked with the name of the column in each statement inside the block: 
+      # A new Clause instance is created and recieves the args. Then the operator
+      # hits method_missing and gets sent to a new Clause instance where it either 
+      # matches one of the defined ops or hits method_missing there.
+      #
+      # When invoked with an attached block a subcondition is created. The name
+      # is regarded as the table_name, additional parameters for outer and inner
+      # are passed on. 
+      def method_missing(name, *args, &block)
+        if block_given?         
+          # handle name as table_name and create a subcondition
+          options = args.last.is_a?(Hash) ? args.last : {}
+          options[:table_name] ||= name
+          define_sub(options, &block)
+        else
+          clause(name, *args)
+        end
+      end
+      
+      # You can define clauses dynamicly using this method. It will take a 
+      # clause and create the correct Clause object to process the conditions
+      def clause(name, *args)
+        if name.kind_of?(Array)
+          c = Clause.new(name.first, name.last)
+        elsif args.last.kind_of?(Symbol)
+          c = Clause.new(args.pop, name)
+        else 
+          c = Clause.new(@table_name, name)
+        end
+        @clauses << c
+        c
+      end
+      
+      # Create subcondition from a block, optionally specifying table_name, outer and inner.
+      # :outer determines how the subcondition is added to the condition, while :inner 
+      # determines the internal 'joining' of conditions inside the subcondition. Both
+      # :inner & :outer defult to 'AND'
+      def define_sub(*args, &block)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        options[:table_name] = args.first if args.first.kind_of? Symbol
+        options[:table_name] ||= @table_name
+        cond = Condition.new(options, &block)
+        self << cond
+      end
+      
+      # Aliases for syntax convenience. :sub or :condition map to :define_sub
+      alias :sub :define_sub
+      alias :condition :define_sub
+            
+      # Shortcut for adding a :and boolean joined subcondition        
+      def and_condition(*args, &block)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        options[:table_name] = args.first if args.first.kind_of? Symbol
+        options[:outer] ||= @outer
+        options[:inner] ||= :and
+        define_sub(options, &block)
+      end
+
+      # Alias :all to be shorthand for :and_condition
+      alias :all :and_condition
+
+      # Shortcut for adding a :or boolean joined subcondition  
+      def or_condition(*args, &block)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        options[:table_name] = args.first if args.first.kind_of? Symbol
+        options[:outer] ||= @outer
+        options[:inner] ||= :or
+        define_sub(options, &block)
+      end
+
+      # Alias :any to stand in for :or_condition
+      alias :any :or_condition
+
+      # Append a condition element, which can be one of the following:
+      # - String: raw sql string
+      # - ActiveRecord instance, for attribute or PK cloning
+      # - Condition or Clause with to_sql method and outer property
+      # - Array in ActiveRecord format ['column = ?', 2]
+      def <<(condition, outer = nil)
+        if condition.kind_of?(String) and not condition.to_s.empty? 
+          cond = SqlClause.new(condition)
+          cond.outer = outer || :and      
+          @clauses << cond
+        elsif condition.kind_of?(Og::EntityMixin)
+          if condition.attributes[condition.class.primary_key].nil?
+            condition.attributes.each { |k, v| clause([condition.class.table_name, k]) == v unless v.to_s.empty? } 
+          else
+            clause([condition.class.table_name, condition.class.primary_key]) == condition.attributes[condition.class.primary_key]
+          end                            
+        else          
+          if condition.kind_of?(Condition) or condition.kind_of?(AbstractClause)
+            logic = condition.outer if outer.nil?
+            condition = condition.to_sql 
+          else
+            logic = outer
+          end
+          if condition.kind_of?(Array) and not condition.empty?
+            array_clause = ArrayClause.new(condition)
+            array_clause.outer = logic
+            @clauses << array_clause
+          end
+        end       
+      end
+      
+      # Aliases for :<<, the method itself deals with what kind
+      # of condition you are appending to the chain so these 
+      # aliases are for a nicer syntax's sake.
+      alias :sql_condition :<<      
+      alias :add_sql :<<
+      alias :clone_from :<<
+      alias :append :<<
+           
+      # Loop over all Clause onjects in @clauses array
+      # and call to_sql on each instance. Then join
+      # the queries and params into the :conditions
+      # array with logic defaulting to AND.
+      # Subqueries are joined together using their 
+      # individual outer property setting if present.
+      # Also defaults to AND.
+      def to_sql(logic=@inner)
+        params = []; query = []
+        @clauses.each do |cv|
+          q, p, e = cv.to_sql                 
+          unless q.to_s.empty?
+            logic = cv.outer ? cv.outer : logic
+            logic = logic.to_s.upcase
+            logic = 'AND NOT' if logic == 'NOT'
+            query << logic unless query.empty?
+            query << q
+            if cv.test == :in 
+              params << p if p.respond_to?(:map)
+            elsif p.kind_of?(Array)
+              p.flatten! unless q =~ /IN/
+              params += p
+            else
+              params << p unless p.nil?
+              params << e unless e.nil?
+            end  
+          end       
+        end       
+        [query.join(' '), *params ]
+      end
+    end
+
+  end # EZ module
+
+end # Caboose module

data/lib/og/manager.rb

@@ -1,5 +1,5 @@
-require 'mega/pool'
-require 'nano/class/descendents'
+require 'facet/pool'
+require 'facet/class/descendents'
 
 require 'og/entity'
 require 'og/store'
@@ -10,6 +10,15 @@ module Og
 # managed by Og.
 
 class Manager
+  def self.managers
+    managers = []
+    ObjectSpace.each_object(self) { |o| managers << o }
+    managers
+  end
+
+  def self.managed?(klass)
+    self.managers.any? { |m| m.managed? klass }
+  end
 
   # Information about an Entity class.
 
@@ -34,9 +43,15 @@ class Manager
 
   attr_accessor :store
 
-  # The collection of Entities managed by this manager.
+  # The collection of Entities (managed classes) managed by 
+  # this manager.
 
   attr_accessor :entities
+    
+  # The managed object cache. This cache is optional. When
+  # used it improves object lookups.
+  
+  attr_accessor :cache
 
   def initialize(options)
     @options = options
@@ -135,7 +150,7 @@ class Manager
   #++
 
   def manageable?(klass)
-    klass.respond_to?(:properties) and (!klass.properties.empty?) # and klass.ann.self.polymorphic.nil?
+    klass.respond_to?(:properties) and (!klass.properties.empty?) # and !self.class.managed?(klass) # and klass.ann.self.polymorphic.nil?
   end
 
   # Is the class managed by Og?
@@ -145,9 +160,8 @@ class Manager
   end
   alias_method :entity?, :managed?
 
-  # ==
   # Returns an array containing all classes managed by this manager.
-  # ==
+  
   def managed_classes
     @entities.map {|e| e[0]}
   end
@@ -186,29 +200,6 @@ class Manager
     classes.each { |c| Relation.resolve_targets(c) }
     classes.each { |c| Relation.resolve_names(c) }
     classes.each { |c| manage(c) }
-=begin
-    # gmosx: LETS better investigate this.
-
-    # Checks for obsolete tables lying around in the og store.
-    # rp: this shouldn't really be here but I can't think of a better 
-    # way to add this functionality.
-    
-    store = get_store()
-    
-    if store.respond_to? :unmanaged_tables
-      unmanaged_tables = store.unmanaged_tables(self)
-      unmanaged_tables.each do |table|
-
-        if @options[:evolve_schema] == true and @options[:evolve_schema_purge_tables] == true
-          sql = "DROP TABLE #{table}"
-          Logger.debug "Dropping unmanaged database table #{table}"
-          store.conn.exec(sql)
-        else
-          Logger.info "There is a table within the database named '#{table}' that is not managed by an Og class."
-        end
-      end
-    end
-=end
   end
   alias_method :manage_class, :manage_classes
 
@@ -233,7 +224,17 @@ class Manager
   def post_setup
     store.post_setup if store.respond_to?(:post_setup)
   end
-  
+
+  # Dump a nice name for this store.
+=begin  
+  def to_s
+    if store = get_store
+      store.to_s
+    else
+      'Uninitialized'
+    end
+  end  
+=end
 end
 
 end

data/lib/og/relation.rb

@@ -1,8 +1,8 @@
-require 'nano/kernel/constant'
-require 'nano/string/capitalized'
-require 'mega/orm_support'
-require 'mega/inheritor'
-require 'mega/annotation'
+require 'facet/kernel/constant'
+require 'facet/string/capitalized'
+require 'facet/ormsupport'
+require 'facet/inheritor'
+require 'facet/annotation'
 
 module Og
 

data/lib/og/relation/has_many.rb

@@ -1,4 +1,4 @@
-require 'mega/orm_support'
+require 'facet/ormsupport'
 
 require 'og/relation'
 require 'og/collection'
@@ -56,6 +56,8 @@ class HasMany < Relation
 
       def add_#{target_singular_name}(obj, options = nil)
         return unless obj
+        # save the object if needed to generate a primary_key.
+        self.save unless self.saved?
         obj.#{foreign_key} = @#{owner_class.primary_key}
         obj.save
       end

data/lib/og/relation/joins_many.rb

@@ -1,4 +1,4 @@
-require 'mega/orm_support'
+require 'facet/ormsupport'
 
 require 'og/relation'
 require 'og/collection'

data/lib/og/store.rb

@@ -50,9 +50,12 @@ class Store
   # Enchants a class.
 
   def enchant(klass, manager)
-    klass.class.send(:define_method, :index) do |arg|
-      meta :index, arg 
-    end
+    # gmosx, FIXME: 
+    # ARGH, have to update this!
+    #
+    # klass.class.send(:define_method, :index) do |arg|
+    #   meta :index, arg 
+    # end
 
     pk = klass.primary_key.symbol
 

data/lib/og/store/kirby.rb

@@ -68,14 +68,10 @@ class KirbyStore < SqlStore
     klass.send :alias_method, :recno, :oid
     klass.send :alias_method, :recno=, :oid= 
 
-    unless klass.properties.include? :recno
-      klass.property :recno, Fixnum
-    end
-
     symbols = klass.properties.keys
 
     klass.module_eval %{
-      def self.kb_create(#{symbols.join(', ')})
+      def self.kb_create(recno, #{symbols.join(', ')})
         obj = self.allocate
         obj.recno = recno
         #{ symbols.map { |s| "obj.#{s} = #{s}; "} }
@@ -281,6 +277,8 @@ private
 
   def eval_og_insert(klass)
     pk = klass.primary_key.symbol
+    props = klass.properties.values.dup
+    values = props.collect { |p| write_prop(p) }.join(',') 
 
     if klass.schema_inheritance?
       props << Property.new(:symbol => :ogtype, :klass => String)

data/lib/og/store/mysql.rb

@@ -6,7 +6,6 @@ rescue Object => ex
   begin
     # Attempt to use the included pure ruby version.
     require 'og/vendor/mysql'
-    require 'og/vendor/mysql411'
   rescue Object => ex
     Logger.error ex
   end

data/lib/og/store/sql.rb

@@ -1,10 +1,12 @@
 require 'yaml'
 require 'time'
 
-require 'nano/kernel/constant'
+require 'facet/kernel/constant'
 
 module Og
 
+# A collection of useful SQL utilities.
+
 module SqlUtils
 
   # Escape an SQL string
@@ -174,7 +176,6 @@ module SqlUtils
   end
 
   def join_table_info(owner_class, target_class, postfix = nil)
-
     # some fixes for schema inheritance.
     
     raise "Undefined owner_class in #{target_class}" unless owner_class
@@ -304,7 +305,6 @@ class SqlStore < Store
   # Enchants a class.
 
   def enchant(klass, manager)
-
     # setup the table where this class is mapped.
 
     if klass.schema_inheritance_child?
@@ -314,6 +314,11 @@ class SqlStore < Store
       klass.const_set 'OGTABLE', table(klass)
     end
 
+    #--
+    # FIXME: use an SQL agnostic name like schema instead
+    # of table.
+    #++
+    
     klass.module_eval 'def self.table; OGTABLE; end'
 
     eval_og_allocate(klass)
@@ -322,12 +327,14 @@ class SqlStore < Store
 
     unless klass.polymorphic_parent?
       # precompile class specific lifecycle methods.
+      
       eval_og_create_schema(klass)
       eval_og_insert(klass)
       eval_og_update(klass)
       eval_og_delete(klass)
 
       # create the table if needed.
+      
       klass.allocate.og_create_schema(self)
 
       # finish up with eval_og_read, since we can't do that
@@ -335,7 +342,8 @@ class SqlStore < Store
       # Possible FIXME:  This means you can't do any find-type
       # operations in og_create_schema.  Luckily, you're most
       # likely to want to do .create, which is covered by 
-       # og_insert.
+      # og_insert.
+      
       eval_og_read(klass)
     end
   end
@@ -828,8 +836,21 @@ private
   end
 
   # Resolve the finder options. Also takes scope into account.
+  # This method handles among other the following cases:
+  #
+  # User.find :condition => "name LIKE 'g%'", :order => 'name ASC'
+  # User.find :where => "name LIKE 'g%'", :order => 'name ASC'
+  # User.find :sql => "WHERE name LIKE 'g%' ORDER BY name ASC"
+  # User.find :condition => [ 'name LIKE ?', 'g%' ], :order => 'name ASC', :limit => 10
+  #
+  # If an array is passed as a condition, use prepared statement
+  # style escaping. For example:
+  #
+  # User.find :condition => [ 'name = ? AND age > ?', 'gmosx', 12 ]
+  #
+  # Proper escaping is performed to avoid SQL injection attacks. 
   #--
-  # FIXME: cleanup/refactor.
+  # FIXME: cleanup/refactor, this is an IMPORTANT method.
   #++
   
   def resolve_options(klass, options)
@@ -888,7 +909,9 @@ private
     
     update_condition(options, scond) if scond
 
-    # rp: type is not set in all instances such as Class.first so this fix goes here for now.
+    # rp: type is not set in all instances such as Class.first 
+    # so this fix goes here for now.
+    
     if ogtype = options[:type] || (klass.schema_inheritance_child? ? "#{klass}" : nil)
       update_condition options, "ogtype='#{ogtype}'"
     end
@@ -896,6 +919,16 @@ private
     sql = "SELECT #{fields} FROM #{tables.join(',')}"
 
     if condition = options[:condition] || options[:where]
+      # If an array is passed as a condition, use prepared 
+      # statement style escaping. 
+             
+      if condition.is_a?(Array)
+        args = condition.dup
+        str = args.shift
+        args.each { |arg| str.sub!(/\?/, quote(arg)) }
+        condition = str
+      end
+
       sql << " WHERE #{condition}"
     end
 
@@ -969,7 +1002,10 @@ private
     end
 
     res_row = res.next
-    # causes STI classes to come back as the correct child class if accessed from the superclass
+    
+    # causes STI classes to come back as the correct child class 
+    # if accessed from the superclass.
+    
     klass = Og::Entity::entity_from_string(res_row.result.flatten[res_row.fieldnum('ogtype')]) if klass.schema_inheritance?
     obj = klass.og_allocate(res_row, 0)