empty_eye 0.4.2 → 0.4.3

data/lib/empty_eye/shard_collection.rb

@@ -0,0 +1,192 @@
+module EmptyEye
+  class ShardCollection
+    
+    #a collection of all the view_shards
+    #these are wranglers for the shards
+    #uses 'array' as a proxy
+    #performs array methods by passing things off in method missing
+    
+    def initialize(primary_shard_klass)
+      @master_class = primary_shard_klass.master_class
+      @primary = PrimaryShard.new(primary_shard_klass)
+      @array = [@primary]
+    end
+    
+    #the proxy object for instances
+    def array
+      @array
+    end
+    
+    #we want to see the proxy object not the class info
+    def inspect
+      array.inspect
+    end
+    
+    #the class to which the shards belongs
+    def master_class
+      @master_class
+    end
+    
+    def descend(klass)
+      @master_class = klass
+      self
+    end
+    
+    #add shard based on association from master_class
+    def create_with(assoc)
+      new_shard = Shard.new(assoc)
+      reject! {|shard| shard.name == new_shard.name}
+      push(new_shard)
+      new_shard
+    end
+    
+    def schema_version
+      @schema_version
+    end
+    
+    #takes the name of shard and a hash of intended updates from master instance
+    #returns a subset of hash with only values the shard handles
+    def delegate_map(name, hash)
+      keys = update_mapping[name] & hash.keys
+      keys.inject({}) do |res, col|
+        res[col] = hash[col] if hash[col]
+        res
+      end
+    end
+
+    #the primary shard
+    def primary
+      @primary
+    end
+    
+    #array of shard classes
+    def klasses
+      map(&:klass)
+    end
+    
+    def names
+      map(&:name)
+    end
+    
+    #this object responds to array methods
+    def respond_to?(m)
+      super || array.respond_to?(m)
+    end
+    
+    #delegate to the array proxy when the method is missing
+    def method_missing(m, *args, &block)
+      if respond_to?(m)
+        array.send(m, *args, &block)
+      else
+        super
+      end
+    end
+    
+    def view_sql
+      @view_sql
+    end
+    
+    #generates view sql
+    def create_view_sql
+      #determine what shard will handle what columns
+      map_attribute_management
+      #start with primary table
+      query = primary_arel_table
+      
+      #build select clause with correct table handling the appropriate columns
+      query = query.project(*arel_columns)
+      
+      #build joins
+      each do |shard|
+        next if shard.primary
+        current = shard.arel_table
+        key = shard.foreign_key.to_sym
+        if shard.type_column
+          query.join(current).on(
+            primary.key.eq(current[key]), shard.type_column.eq(shard.type_value)
+          )
+        else
+          query.join(current).on(
+            primary.key.eq(current[key])
+          )
+        end
+      end
+      
+      self.schema_version = Digest::MD5.hexdigest(query.to_sql)
+      query.project("'#{schema_version}' AS mti_schema_version")
+      
+      #we dont need to keep this data
+      free_arel_columns
+      
+      #STI condition if needed
+      if primary.sti_also?
+        query.where(primary.type_column.eq(primary.type_value))
+      end
+      
+      #build view creation statement
+      @view_sql = "CREATE VIEW #{primary.klass.compute_view_name} AS\n#{query.to_sql}"
+    end
+    
+    private
+    
+    def schema_version=(md5_hash)
+      @schema_version = md5_hash
+    end
+    
+    #all of the arel columns mapped to the right arel tables
+    def arel_columns
+      @arel_columns ||= []
+    end
+    
+    #we dont need to keep this data
+    def free_arel_columns
+      @arel_columns = nil
+    end
+    
+    #tracks the attributes with the shard that will handle it
+    def update_mapping
+      @update_mapping ||= {}
+    end
+    
+    #generate a foreign_key if it is missing
+    def default_foreign_key
+      view_name = master_class.table_name.singularize
+      "#{view_name}_id"
+    end
+    
+    #the primary arel table
+    def primary_arel_table
+      primary.arel_table
+    end
+    
+    #all the tables
+    def tables
+      map(&:table)
+    end
+    
+    #map the columns to the shard that will handle it
+    def map_attribute_management
+      #clear out what we know
+      arel_columns.clear
+      #use this to track and remove dupes
+      tracker = {}
+      each do |shard|
+        #mimic the master_class's associations through primary shard
+        primary.has_another(shard)
+        shard.columns.each do |col|
+          column = col.to_sym
+          #skip if we already have this column
+          next if tracker[column]
+          #set to true so we wont do again
+          tracker[column] = true
+          #add the column based on the shard's arel_table
+          arel_columns << shard.arel_table[column]
+          #later we need to know how to update thing correctly
+          update_mapping[shard.name] = update_mapping[shard.name].to_a << col
+          #delegate the setter for column to klass of shard through primary shard
+          primary.delegate_to(column, shard) unless shard.primary
+        end
+      end
+    end
+  end
+end

data/lib/empty_eye/shard_wrangler.rb

@@ -0,0 +1,300 @@
+module EmptyEye
+  module ShardWrangler
+    #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
+    end
+    
+    #this module method creates a ShardWrangler extended ActiveRecord inherited class
+    #the class will wrangle our shards 
+    def self.create(master_class, t_name)
+      inherit_from = if master_class.base_class == master_class
+        ActiveRecord::Base
+      else
+        master_class.superclass
+      end
+      
+      table_name = if t_name
+        t_name
+      elsif master_class.descends_from_active_record?
+        "#{master_class.name.underscore.pluralize}_core"
+      else
+        master_class.superclass.table_name
+      end
+      
+      new_class = Class.new(inherit_from)
+      new_class.send(:include, ShardWrangler)
+      new_class.table_name = table_name
+      new_class.master_class = master_class
+      EmptyEye.const_set("#{master_class.to_s}Wrangler", new_class)
+      new_class
+    end
+    
+    #the instance that owns this wrangler
+    #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 || master_class.find_by_id(id)
+    end
+    
+    #setter used to associate the wrangler with the master instance
+    def mti_instance=(instance)
+      @mti_instance = instance
+    end
+    
+    #special save so that the wrangler can keep the master's instance tables consistent
+    def cascade_save
+      write_attributes
+      #this will autosave shards
+      save
+      #reset the id and then reload
+      mti_instance.id = id
+      mti_instance.reload
+    end
+    
+    #reflection on master class; this should never change
+    def master_class
+      self.class.master_class
+    end
+    
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      write_attributes
+      output = super(context)
+      errors.each do |attr, message|
+        mti_instance.errors.add(attr, message)
+      end
+      errors.empty? && output
+    end
+  
+    private
+    
+    def write_attributes
+      #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 = master_class.name if respond_to?("type=")
+      self
+    end
+    
+    def shards
+      self.class.shards
+    end
+  
+    #make sure the primary shard only tries to update what he should
+    def mti_safe_attributes
+      mti_instance.attributes.except(
+        *self.class.primary_shard.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 shard making sure it is exists and is loaded
+      shards.each do |shard|
+        next if shard.primary
+        assoc = send(shard.name)
+        assoc ||= send("build_#{shard.name}")
+        send("#{shard.name}=", assoc)
+      end
+    end
+    
+    module ClassMethods
+      
+      #the wrangler 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
+      end
+
+      #finder methods should use the master class's type not the wrangler's
+      def type_condition(table = arel_table)
+        sti_column = table[inheritance_column.to_sym]
+
+        sti_column.eq(master_class.name)
+      end
+      
+      #overriding find_by_id
+      #this is used to retrieve the wrangler 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 wrangler uses a special association builder
+      def has_one(name, options = {})
+        Associations::Builder::ShardHasOne.build(self, name, options)
+      end
+
+      #reflection on master class; this should never change
+      def master_class
+        @master_class
+      end
+
+      #the master_class value is set with this setter; should happen only once
+      def master_class=(klass)
+        @master_class = klass
+      end
+      
+      #overriding to reset the special instance variable
+      def reset_column_information
+        @columns_except_type = nil
+        super
+      end
+      
+      #the primary shard
+      def primary_shard
+        shards.primary
+      end
+      
+      #we know the associations and we know what they can do
+      #we will make a mti class accordingly here
+      def wrangle_shards(mti_ancestors)
+        mti_ancestors.each do |assoc|
+          shards.create_with(assoc)
+        end
+        create_view if create_view?
+        master_class.reset_column_information
+      end
+      
+      #batch deletion when there are conditions
+      #kill indiscriminately otherwise
+      def cascade_delete_all(conditions)
+        mti_clear_identity_map
+        affected = 0
+        ids = []
+        ids = conditions ? select(arel_table[primary_key.to_sym]).where(conditions).collect(&:id) : []
+        transaction do
+          begin
+            batch = ids.pop(10000)
+            shards.each do |shard|
+              result = if conditions.nil?
+                shard.klass.delete_all
+              elsif shard.polymorphic_type
+                shard.klass.delete_all(shard.foreign_key => batch, shard.polymorphic_type => shard.type_value)
+              else
+                shard.klass.delete_all(shard.foreign_key => batch)
+              end
+              affected = [affected, result].max
+            end 
+          end until ids.to_a.empty?
+        end
+        affected
+      end
+      
+      def cascade_update_all(updates, conditions, options)
+        mti_clear_identity_map
+        affected = 0
+        stringified_updates = updates.stringify_keys
+        ids = conditions ? select(arel_table[primary_key.to_sym]).where(conditions).apply_finder_options(options.slice(:limit, :order)).collect(&:id) : []
+        transaction do
+          begin
+            batch = ids.pop(10000)
+            shards.each do |shard|
+              cols = shards.delegate_map(shard.name, stringified_updates)
+              next if cols.empty?
+              result = if conditions.nil?
+                shard.klass.update_all(cols)
+              elsif shard.polymorphic_type
+                shard.klass.update_all(cols, shard.foreign_key => batch, shard.polymorphic_type => shard.type_value)
+              else
+                shard.klass.update_all(cols, shard.foreign_key => batch)
+              end
+              affected = [affected, result].max
+            end
+          end until ids.to_a.empty?
+        end
+        affected
+      end
+      
+      def shards
+        @shards ||= EmptyEye::ShardCollection.new(self)
+      end
+      
+      #we need a name for the view
+      #need to have a way to set this
+      def compute_view_name
+        if master_class.descends_from_active_record?
+          master_class.send(:compute_table_name)
+        else
+          master_class.name.underscore.pluralize
+        end
+      end
+      
+      private
+      
+      def mti_clear_identity_map
+        ActiveRecord::IdentityMap.repository[symbolized_base_class].clear if ActiveRecord::IdentityMap.enabled?
+      end
+      
+      #get the schema version
+      #we shouldnt recreate views that we donth have to
+      def mti_schema_version
+        check_for_name_error
+        return nil unless connection.table_exists?(compute_view_name)
+        return nil unless mti_view_versioned?
+        t = Arel::Table.new(compute_view_name)
+        q = t.project(t[:mti_schema_version])
+        connection.select_value(q.to_sql)
+      rescue
+        nil
+      end
+
+      #determine if what we want to name our view already exists
+      def check_for_name_error
+        if connection.tables_without_views.include?(compute_view_name)
+          raise(EmptyEye::ViewNameError, "MTI view cannot be created because a table named '#{compute_view_name}' already exists")
+        end
+      end
+      
+      #we need to create the sql first to determine the schema_version
+      #if the current schema version is the same as the old dont recreate the view
+      #if it is nil then recreate
+      def create_view?
+        shards.create_view_sql
+        schema_version = mti_schema_version
+        schema_version.nil? or schema_version != shards.schema_version
+      end
+      
+      #always recreate
+      def mti_view_versioned?
+        connection.columns(compute_view_name).any? {|c| c.name == 'mti_schema_version'}
+      end
+    
+      #drop the view; dont check if we can, just rescue any errors
+      #create the view
+      def create_view
+        connection.execute("DROP VIEW #{compute_view_name}") rescue nil
+        connection.execute(shards.view_sql)
+      end
+      
+      #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
+    
+
+    end
+  end
+end

data/lib/empty_eye/version.rb

@@ -2,7 +2,7 @@ module EmptyEye
   module VERSION
     MAJOR = 0
     MINOR = 4
-    TINY = 2
+    TINY = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/empty_eye.rb

@@ -1,15 +1,16 @@
 require "active_record"
 require "arel"
+require 'digest'
 
 require "empty_eye/version"
 
 require "empty_eye/persistence"
 require "empty_eye/relation"
 require "empty_eye/errors"
-require "empty_eye/view_extension"
-require "empty_eye/primary_view_extension"
-require "empty_eye/view_extension_collection"
 require "empty_eye/shard"
+require "empty_eye/primary_shard"
+require "empty_eye/shard_collection"
+require "empty_eye/shard_wrangler"
 require "empty_eye/associations/builder/shard_has_one"
 require "empty_eye/associations/shard_has_one_association"
 require "empty_eye/associations/shard_association_scope"
@@ -20,7 +21,7 @@ require "empty_eye/active_record/schema_dumper"
 require "empty_eye/active_record/connection_adapter"
 
 module EmptyEye
-  # Your code goes here...
+
 end
 
 ::ActiveRecord::Base.send :include, EmptyEye::Persistence

data/spec/spec_helper.rb

@@ -50,12 +50,6 @@ ActiveRecord::Migration.create_table :eating_venues_core, :force => true do |t|
   t.string :longitude
 end
 
-ActiveRecord::Migration.create_table :eating_venues_core, :force => true do |t|
-  t.string :api_venue_id
-  t.string :latitude
-  t.string :longitude
-end
-
 ActiveRecord::Migration.create_table :garages, :force => true do |t|
   t.boolean :privately_owned
   t.integer :max_wait_days

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: empty_eye
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 4
-  - 2
-  version: 0.4.2
+  - 3
+  version: 0.4.3
 platform: ruby
 authors: 
 - thegboat
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-10 23:00:00 -05:00
+date: 2012-03-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -104,13 +104,13 @@ files:
 - lib/empty_eye/associations/shard_has_one_association.rb
 - lib/empty_eye/errors.rb
 - lib/empty_eye/persistence.rb
-- lib/empty_eye/primary_view_extension.rb
+- lib/empty_eye/primary_shard.rb
 - lib/empty_eye/relation.rb
 - lib/empty_eye/shard.rb
 - lib/empty_eye/shard_association_reflection.rb
+- lib/empty_eye/shard_collection.rb
+- lib/empty_eye/shard_wrangler.rb
 - lib/empty_eye/version.rb
-- lib/empty_eye/view_extension.rb
-- lib/empty_eye/view_extension_collection.rb
 - spec/configuration_spec.rb
 - spec/mti_crud_spec.rb
 - spec/mti_to_sti_to_mti_crud_spec.rb

data/lib/empty_eye/view_extension.rb

@@ -1,114 +0,0 @@
-module EmptyEye
-  class ViewExtension
-    
-    #extension for parent class
-    #tracks associations for database updates managed by primary extension
-    #has many of the same interfaces as primary view extension
-
-    def initialize(association)
-      @association = association
-    end
-    
-    #exclude from view generation always
-    def self.exclude_always
-      ['id','created_at','updated_at','deleted_at', 'type']
-    end
-    
-    #association that this extension will build upon
-    def association
-      @association
-    end
-    
-    #the table columns that will be extended in sql
-    def columns
-      restrictions - exclude
-    end
-
-    #never the primary
-    def primary
-      false
-    end
-    
-    #table of the shard
-    def table
-      association.table_name
-    end
-    
-    #name of the association
-    def name
-      association.name
-    end
-    
-    #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
-
-    #foreign key of the shard; used in view generation and database updates
-    def foreign_key
-      association.foreign_key 
-    end
-
-    #the shard is simply the class of the association
-    def shard
-      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
-      parent.base_class.name if polymorphic_type
-    end
-
-    def polymorphic_type
-      return unless association.options[:as]
-      "#{association.options[:as]}_type"
-    end
-    
-    private
-    
-    #class to whom this extension belongs
-    def parent
-      association.active_record
-    end
-    
-    #class of the extension table
-    def klass
-      association.klass
-    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 parent inheritance
-    def exceptions
-      association.options[:except].to_a.collect(&:to_s)
-    end
-    
-    #user declared restrictions ... restrict parent 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 extensions table
-    def table_columns
-      klass.column_names
-    end
-  end
-end