empty_eye 0.4.2 → 0.4.3

data/CHANGELOG.md

@@ -1,4 +1,9 @@
-# 0.4.1 / 2012-03-11 / Grady Griffin
+# 0.4.3 / 2012-03-11 / Grady Griffin
+
+* major refactor to do less in active record base
+* add view versioning to prevent creating views when not necessary
+
+# 0.4.2 / 2012-03-11 / Grady Griffin
 
 * reorganized some methods
 * added logic to free up complex data structures once they are not needed

data/lib/empty_eye/active_record/base.rb

@@ -5,122 +5,78 @@ module ActiveRecord
     
       #am i a mti class? easier than making a new class type ... i tried
       def mti_class?
-        extended_with.any?
+        !!@shard_wrangler
       end
-    
+  
       #interface for building mti_class
       #primary table is not necessary if the table named correctly (Bar => bars_core)
       #OR if the class inherits a primary table
       #simply wrap your greasy associations in this block
       def mti_class(primary_table = nil)
-        self.primary_key = "id"
         raise(EmptyEye::AlreadyExtended, "MTI class method already invoked") if mti_class?
-        set_mti_primary_table(primary_table)
-        self.table_name = compute_view_name
-        extended_with.primary_table(mti_primary_table)
+        self.primary_key = "id"
+        @shard_wrangler = EmptyEye::ShardWrangler.create(self, primary_table)
+        self.table_name = @shard_wrangler.compute_view_name
         before_yield = reflect_on_multiple_associations(:has_one)
         yield nil if block_given?
-        mti_associations = reflect_on_multiple_associations(:has_one) - before_yield
-        extend_mti_class(mti_associations)
+        mti_ancestors = reflect_on_multiple_associations(:has_one) - before_yield
+        @shard_wrangler.wrangle_shards(mti_ancestors)
         true
       end
-
-      #all data for mti class is stored here
-      #when empty it is not so MT-I
-      def extended_with
-        @extended_with ||= EmptyEye::ViewExtensionCollection.new(self)
+    
+      #we need this when we add new associaton types to extend with
+      #we could use the baked in version for now
+      def reflect_on_multiple_associations(*assoc_types)
+        assoc_types.collect do |assoc_type| 
+          reflect_on_all_associations(assoc_type)
+        end.flatten.uniq
       end
 
-      #the class of primary shard
-      def mti_primary_shard
-        extended_with.primary.shard
-      end
-      
       #we dont need no freakin' type condition
       #the view handles this
       def finder_needs_type_condition?
         !mti_class? and super
       end
-      
-      private
-      
-      #we know the associations and we know what they can do
-      #we will make a mti class accordingly here
-      def extend_mti_class(mti_associations)
-        mti_associations.each do |assoc|
-          extended_with.association(assoc)
-        end
-        create_view
-        reset_column_information
-        inherit_mti_validations
-      end
-      
-      #we need a name for the view
-      #need to have a way to set this
-      def compute_view_name
-        descends_from_active_record? ? compute_table_name : name.underscore.pluralize
-      end
-      
-      #determine the primary table
-      #first determine if our view name exists; this will need to change one day
-      #if they didnt specify try using the core convention else the superclass
-      #if they specified use what they set
-      def set_mti_primary_table(primary_table_name)
-        @mti_primary_table = if ordinary_table_exists?
-          raise(EmptyEye::ViewNameError, "MTI view cannot be created because a table named '#{compute_view_name}' already exists")
-        elsif primary_table_name.nil?
-          descends_from_active_record? ? "#{compute_table_name}_core" : superclass.table_name
-        else
-          primary_table_name
-        end
-      end
-      
-      def mti_primary_table
-        @mti_primary_table
-      end
-      
-      #we need this when we add new associaton types to extend with
-      #we could use the baked in version for now
-      def reflect_on_multiple_associations(*assoc_types)
-        assoc_types.collect do |assoc_type| 
-          reflect_on_all_associations(assoc_type)
-        end.flatten.uniq
+
+      #remove the schema_version for mti_class views
+      def column_names
+        @column_names ||= columns.map { |column| column.name } - (mti_class? ? ["schema_version"] : [])
       end
 
-      #determine if what we want to name our view already exists
-      def ordinary_table_exists?
-        connection.tables_without_views.include?(compute_view_name)
+      #the class of primary shard
+      def shard_wrangler
+        @shard_wrangler
       end
     
-      #drop the view; dont check if we can, just rescue any errors
-      #create the view
-      def create_view
-        connection.execute("DROP VIEW #{table_name}") rescue nil
-        connection.execute(extended_with.create_view_sql)
+      def descends_from_active_record?
+        if superclass.abstract_class?
+          superclass.descends_from_active_record?
+        elsif mti_class?
+          superclass == Base
+        else
+          superclass == Base || !columns_hash.include?(inheritance_column)
+        end
       end
     
-      #we may need to inherit these... not using for now
-      def superclass_extensions
-        superclass.extended_with.dup.descend(self) unless descends_from_active_record?
-      end
+      private
       
-      #we know how to rebuild the validations from the shards
-      #lets call our inherited validations here
-      def inherit_mti_validations
-        extended_with.validations.each {|args| send(*args)}
-        #no need to keep these in memory
-        extended_with.free_validations
-      end
+    end
+    
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      return errors.empty? && output unless mti_class?
+      shard_wrangler.valid?(context) && errors.empty? && output
     end
     
     private
     
     #a pseudo association method mapping us back to instances primary shard
-    def mti_primary_shard
-      @mti_primary_shard ||= if new_record?
-        self.class.mti_primary_shard.new(:mti_instance => self)
+    def shard_wrangler
+      @shard_wrangler ||= if new_record?
+        self.class.shard_wrangler.new(:mti_instance => self)
       else
-        rtn = self.class.mti_primary_shard.find_by_id(id)
+        rtn = self.class.shard_wrangler.find_by_id(id)
         rtn.mti_instance = self
         rtn
       end

data/lib/empty_eye/associations/shard_association_scope.rb

@@ -45,7 +45,7 @@ module EmptyEye
             scope = scope.where(table[key].eq(owner[foreign_key]))
 
             if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.mti_master_class.base_class.name))
+              scope = scope.where(table[reflection.type].eq(owner.master_class.base_class.name))
             end
 
             conditions.each do |condition|

data/lib/empty_eye/associations/shard_has_one_association.rb

@@ -22,7 +22,7 @@ module EmptyEye
           attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
 
           if reflection.options[:as]
-            attributes[reflection.type] = owner.mti_master_class.base_class.name
+            attributes[reflection.type] = owner.master_class.base_class.name
           end
         end
 

data/lib/empty_eye/persistence.rb

@@ -6,7 +6,7 @@ module EmptyEye
     #else let the primary shard do the saving
     def update(attribute_names = @attributes.keys)
       return super unless mti_class?
-      mti_primary_shard.cascade_save
+      shard_wrangler.cascade_save
       1
     end
 
@@ -15,7 +15,7 @@ module EmptyEye
     #come back and cleanup
     def create
       return super unless mti_class?
-      mti_primary_shard.cascade_save
+      shard_wrangler.cascade_save
       ActiveRecord::IdentityMap.add(self) if ActiveRecord::IdentityMap.enabled?
       @new_record = false
       self.id
@@ -26,7 +26,7 @@ module EmptyEye
     #come back and cleanup
     def destroy
       return super unless mti_class?
-      mti_primary_shard.destroy
+      shard_wrangler.destroy
       if ActiveRecord::IdentityMap.enabled? and persisted?
         ActiveRecord::IdentityMap.remove(self)
       end
@@ -39,7 +39,7 @@ module EmptyEye
     #come back and cleanup
     def delete
       return super unless mti_class?
-      self.class.delete_all(:id => id)
+      shard_wrangler.class.cascade_delete_all(:id => id)
       if ActiveRecord::IdentityMap.enabled? and persisted?
         ActiveRecord::IdentityMap.remove(self)
       end

data/lib/empty_eye/{primary_view_extension.rb → primary_shard.rb}

@@ -1,14 +1,14 @@
 module EmptyEye
-  class PrimaryViewExtension
+  class PrimaryShard
     
-    #primary extension for parent class
+    #primary shard for master_class class
     #manages associations for database updates
-    #has many of the same interfaces as view extensions
+    #has many of the same interfaces as view shards
 
-    def initialize(table_name, parent)
-      @table = table_name
-      @parent = parent
-      create_shard
+    def initialize(wrangler)
+      @table = wrangler.table_name
+      @master_class = wrangler.master_class
+      @klass = wrangler
     end
 
     def self.connection
@@ -17,12 +17,12 @@ module EmptyEye
     
     #never include the type field as it shouldnt be needed and cant be updated anyway
     def self.exclude_always
-      ['type']
+      ['type', 'mti_schema_version']
     end
     
-    #class to which this extension belongs
-    def parent
-      @parent
+    #class to which this shard belongs
+    def master_class
+      @master_class
     end
     
     #to let the outside word know it is primary
@@ -30,9 +30,9 @@ module EmptyEye
       true
     end
     
-    #class that will mimic the associations of the parent for updating db
-    def shard
-      @shard
+    #class that will mimic the associations of the master_class for updating db
+    def klass
+      @klass
     end
     
     # the tablename
@@ -50,7 +50,7 @@ module EmptyEye
       @arel_table ||= Arel::Table.new(table)
     end
     
-    #this may change but for now the key is the primary id of the parent and shard
+    #this may change but for now the key is the primary id of the master_class and shard
     def key
       arel_table[:id]
     end
@@ -60,19 +60,19 @@ module EmptyEye
     end
     
     def sti_also?
-      !parent.descends_from_active_record?
+      !master_class.descends_from_active_record?
     end
     
     #arel column of type field
     def type_column
       if sti_also? 
-        arel_table[parent.inheritance_column.to_sym]
+        arel_table[master_class.inheritance_column.to_sym]
       end
     end
     
     #value of the polymorphic column
     def type_value
-      parent.name if type_column
+      master_class.name if type_column
     end
     
     #always null for primary
@@ -82,7 +82,8 @@ module EmptyEye
 
     #table columns
     def table_columns
-      self.class.connection.columns(table).collect(&:name)
+      klass.column_names
+      #self.class.connection.columns(table).collect(&:name)
     end
     
     def exclude
@@ -94,22 +95,22 @@ module EmptyEye
       table_columns - exclude
     end
     
-    #create associations for shard class to mimic parent
-    def have_one(ext)
+    #create associations for shard class to mimic master_class
+    def has_another(shard)
       #this is myself; dont associate
-      return if ext.primary
-      mimic = ext.association
-      return if shard.reflect_on_association(mimic.name)
+      return if shard.primary
+      mimic = shard.association
+      return if klass.reflect_on_association(mimic.name)
       options = mimic.options.dup
       options.merge!(default_has_one_options)
-      options.merge!(:foreign_key => ext.foreign_key)
-      shard.send(mimic.macro, mimic.name, options)
+      options.merge!(:foreign_key => shard.foreign_key)
+      klass.send(mimic.macro, mimic.name, options)
     end
     
     #delegate setters to appropriate associations
-    def delegate_to(col, ext)
-      return if ext.primary
-      shard.send(:delegate, "#{col}=", {:to => ext.name})
+    def delegate_to(col, shard)
+      return if shard.primary
+      klass.send(:delegate, "#{col}=", {:to => shard.name})
     end
     
     private
@@ -118,20 +119,6 @@ module EmptyEye
     def default_has_one_options
       {:autosave => true, :validate => true, :dependent => :destroy}
     end
-
-    #if possible shard inherits from the superclass
-    def shard_inherit_from
-      parent.base_class == parent ? ActiveRecord::Base : parent.send(:superclass)
-    end
-    
-    #create a class to manage the parents associations
-    def create_shard
-      new_class = Class.new(shard_inherit_from)
-      new_class.send(:include, Shard)
-      new_class.table_name = table
-      new_class.mti_master_class = parent
-      @shard = EmptyEye.const_set("#{parent.to_s}Shard", new_class)
-    end
     
   end
 end

data/lib/empty_eye/relation.rb

@@ -9,77 +9,14 @@ module EmptyEye
       
       def delete_all(conditions = nil)
         return super unless mti_class?
-        mti_clear_identity_map
-        affected = 0
-        #if something goes wrong forget it all
-        transaction do
-          if conditions
-            #batch up ids
-            ids = select("`#{table_name}`.`#{primary_key}`").where(conditions).collect(&:id)
-            #delete all the shards of the mti class matching ids
-            mti_batch_perform(ids) do |ext, batch|
-              if ext.polymorphic_type
-                ext.shard.delete_all(ext.foreign_key => batch, ext.polymorphic_type => ext.type_value)
-              else
-                ext.shard.delete_all(ext.foreign_key => batch)
-              end
-            end
-          else
-            #way simpler if there are no conditions; kill everyone
-            extended_with.each do |ext|
-              affected = [affected, ext.shard.delete_all].max
-            end
-          end
-        end
-        affected
+        shard_wrangler.cascade_delete_all(conditions)
       end
       
       def update_all(updates, conditions = nil, options = {})
         return super unless mti_class?
         raise(EmptyEye::InvalidUpdate, "update values for a MTI class must be a hash") unless updates.is_a?(Hash)
-        mti_clear_identity_map
-        stringified_updates = updates.stringify_keys
-        affected = 0
-        transaction do
-          if conditions
-            #batch up ids
-            ids = select(arel_table[primary_key.to_sym]).where(conditions).apply_finder_options(options.slice(:limit, :order)).collect(&:id)
-            #update all the shards of the mti class matching ids
-            affected = mti_batch_perform(ids) do |ext, batch|
-              #delegate map ingests the update hash and regurgitates a smaller hash of the values the shard can handle
-              cols = extended_with.delegate_map(ext.name, stringified_updates)
-              cols.empty? ? 0 : ext.shard.update_all(cols, ext.foreign_key => batch)
-            end
-          else
-            #way simpler if there are no conditions; change the world!
-            extended_with.each do |ext|
-              cols = extended_with.delegate_map(ext.name, stringified_updates)
-              affected = [(cols.empty? ? 0 : ext.shard.update_all(cols)), affected].max
-            end
-          end
-        end
-        affected
+        shard_wrangler.cascade_update_all(updates, conditions, options)
       end
-      
-      private
-      
-      def mti_clear_identity_map
-        ActiveRecord::IdentityMap.repository[symbolized_base_class].clear if ActiveRecord::IdentityMap.enabled?
-      end
-      
-      #lets do 10000 at a time
-      def mti_batch_perform(ids)
-        affected = 0
-        until ids.to_a.empty?
-          current_ids =  ids.pop(10000)
-          extended_with.each do |ext|
-            rtn = yield(ext, current_ids)
-            affected = [affected,rtn].max
-          end
-        end
-        affected
-      end
-    
     end
   end
 end

data/lib/empty_eye/shard.rb

@@ -1,133 +1,108 @@
 module EmptyEye
-  module Shard
+  class Shard
     
-    #module which extends the class that serves as a pointer to the primary table
-    #when there is a superclass the shard will inherit from that, else it will inherit from ActiveRecord
-    #the primary shard manages all the MTI associated tables for the master class
-    
-    def self.included(base)
-      base.extend ClassMethods
+    #shard for master_class class
+    #tracks associations for database updates managed by primary shard
+    #has many of the same interfaces as primary view shard
+
+    def initialize(association)
+      @association = association
     end
     
-    #the instance that owns this primary shard
-    #we usually know the master instance ahead of time
-    #so we should take care to set this manually
-    #we want to avoid the lookup
-    def mti_instance
-      @mti_instance || mti_master_class.find_by_id(id)
+    #exclude from view generation always
+    def self.exclude_always
+      ['id','created_at','updated_at','deleted_at', 'type', 'mti_schema_version']
     end
     
-    #setter used to associate the primary shard with the master instance
-    def mti_instance=(instance)
-      @mti_instance = instance
+    #association that this shard will build upon
+    def association
+      @association
     end
     
-    #special save so that the primary shard can keep the master instances tables consistent
-    def cascade_save
-      #make sure all the shards are there
-      cascade_build_associations 
-      #this will propagate setters to the appropriate shards
-      assign_attributes(mti_safe_attributes)
-      self.type = mti_master_class.name if respond_to?("type=")
-      #this will autosave shards
-      save
-      #reset the id and then reload
-      mti_instance.id = id
-      mti_instance.reload
+    #the table columns that will be extended in sql
+    def columns
+      restrictions - exclude
+    end
+
+    #never the primary
+    def primary
+      false
     end
     
-    #reflection on master class; this should never change
-    def mti_master_class
-      self.class.mti_master_class
+    #table of the shard
+    def table
+      association.table_name
     end
-  
-    private
-  
-    #make sure the primary shard only tries to update what he should
-    def mti_safe_attributes
-      mti_instance.attributes.except(
-        *self.mti_master_class.extended_with.primary.exclude
-      )
-    end
-  
-    #all the instance shards should exist but lets be certain
-    #using an autobuild would be more efficient here
-    #we shouldnt load associations we dont need to
-    def cascade_build_associations
-      #go through each extension making sure it is exists and is loaded
-      mti_instance.class.extended_with.each do |ext|
-        next if ext.primary
-        assoc = send(ext.name)
-        assoc ||= send("build_#{ext.name}")
-        send("#{ext.name}=", assoc)
-      end
+    
+    #name of the association
+    def name
+      association.name
     end
     
-    module ClassMethods
-      
-      #the shard uses special reflection; overriden here
-      def create_reflection(macro, name, options, active_record)
-        raise(EmptyEye::NotYetSupported, "through associations are not yet spported") if options[:through]
-        klass = options[:through] ? ShardThroughReflection : ShardAssociationReflection
-        reflection = klass.new(macro, name, options, active_record)
-
-        self.reflections = self.reflections.merge(name => reflection)
-        reflection
+    #used to create view
+    def arel_table
+      @arel_table ||= begin
+        t= Arel::Table.new(table)
+        t.table_alias = alias_name if alias_name != table
+        t
       end
+    end
 
-      #finder methods should use the master class's type not the shard's
-      def type_condition(table = arel_table)
-        sti_column = table[inheritance_column.to_sym]
-
-        sti_column.eq(mti_master_class.name)
-      end
-      
-      #overriding find_by_id
-      #this is used to retrieve the shard instance for the master instance
-      #the type column is removed
-      def find_by_id(val)
-        query = columns_except_type
-        query = query.where(arel_table[:id].eq(val))
-        find_by_sql(query.to_sql).first
-      end
-      
-      #the shard uses a special association builder
-      def has_one(name, options = {})
-        Associations::Builder::ShardHasOne.build(self, name, options)
-      end
+    #foreign key of the shard; used in view generation and database updates
+    def foreign_key
+      association.foreign_key 
+    end
 
-      #reflection on master class; this should never change
-      def mti_master_class
-        @mti_master_class
-      end
+    def klass
+      association.klass
+    end
+    
+    #arel column of polymorphic type field
+    def type_column
+      arel_table[polymorphic_type.to_sym] if polymorphic_type
+    end
+    
+    #value of the polymorphic column
+    def type_value
+      master_class.base_class.name if polymorphic_type
+    end
 
-      #the mti_master_class value is set with this setter; should happen only once
-      def mti_master_class=(klass)
-        @mti_master_class = klass
-      end
-      
-      #overriding to reset the special instance variable
-      def reset_column_information
-        @columns_except_type = nil
-        super
-      end
-      
-      private
-      
-      #build the arel query once and memoize it
-      #this is essentially the select to remove type column
-      def columns_except_type
-        @columns_except_type ||= begin
-          query = arel_table
-          (column_names - [inheritance_column]).each do |c|
-            query = query.project(arel_table[c.to_sym])
-          end
-          query
-        end
-        @columns_except_type.dup
-      end
+    def polymorphic_type
+      return unless association.options[:as]
+      "#{association.options[:as]}_type"
+    end
+    
+    private
     
+    #class to whom this shard belongs
+    def master_class
+      association.active_record
+    end
+    
+    #uses association name to create alias to prevent non unique aliases
+    def alias_name
+      name.to_s.pluralize
+    end
+    
+    #user declared exceptions ... exclude these columns from the master_class inheritance
+    def exceptions
+      association.options[:except].to_a.collect(&:to_s)
+    end
+    
+    #user declared restrictions ... restrict master_class inheritance columns to these
+    def restrictions
+      only = association.options[:only].to_a.collect(&:to_s)
+      only.empty? ? table_columns : only
+    end
+
+    #we want to omit these columns
+    def exclude
+      [exceptions, self.class.exclude_always, foreign_key, polymorphic_type].flatten.uniq
+    end
 
+    #all the columns of the shards table
+    def table_columns
+      klass.column_names
     end
   end
 end