empty_eye 0.4.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# 0.4.0 / 2012-03-11 / Grady Griffin
+
+* added tests for validation and configurations
+* reorganized files
+* added more comments
+
+
+# 0.3.1 / 2012-03-11 / Grady Griffin
+
+* Cleaned up some sti problems
+* added more comments
+* removed some unnecessary codez
+
+# 0.3.0 / 2012-03-11 / Grady Griffin
+
+* inherits validations as well
+* MTI to MTI is working
+* STI to STI is working
+* MTI to STI to MTI is working
+* bulletproofed shard system by giving it its own association classes
+
+# 0.2.1 / 2012-03-09 / Grady Griffin
+
+* added some reasonable defaults for shard associations
+* already had CRU added D for CRUD
+* updated logic to support polymorphic associations
+* added crud tests
+
+# 0.2.0 / 2012-03-09 / Grady Griffin
+
+* revamped entire library to use associations as table shards
+* general cleanup
+* added more options for associations
+
+
+# 0.1.0 / 2012-03-08 / Grady Griffin
+
+* can make a simple MTI class
+* modified schema dumper to omit views
+
+# 0.0.1 / 2012-03-07 / Grady Griffin
+
+* initial commit

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in empty_eye.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Grady Griffin
+
+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.

data/README.md

@@ -0,0 +1,109 @@
+# Empty Eye
+
+ActiveRecord based MTI gem powered by database views
+
+#Issues
+
+* No known issues major issues; has been successful within data structures of high complexity (MTI to MTI, MTI to STI to MTI relationships)
+* Not sure why but new mti instances have a id of zero; this has caused no problems so far however.
+* No mechanism to change mti class table name but that is minor
+* More complex testing needed to ensure reliability
+* Uses ARel so should be compatible with ARel supported database that support view; only tested with MySQL
+* SchemaDumper support for omitting views with databases other than MySQL is untested
+
+Create MTI classes by renaming your base table with the core suffix and wrapping your associations in a mti\_class block
+
+Test example from http://techspry.com/ruby_and_rails/multiple-table-inheritance-in-rails-3/ which uses mixins to accomplish MTI:
+
+      ActiveRecord::Migration.create_table :restaurants_core, :force => true do |t|
+        t.boolean :kids_area
+        t.boolean :wifi
+        t.integer :food_genre
+        t.datetime :created_at
+        t.datetime :updated_at
+        t.datetime :deleted_at
+      end
+
+      ActiveRecord::Migration.create_table :bars_core, :force => true do |t|
+        t.string :music_genre
+        t.string :best_nights
+        t.string :dress_code
+        t.datetime :created_at
+        t.datetime :updated_at
+        t.datetime :deleted_at
+      end
+
+      ActiveRecord::Migration.create_table :businesses, :force => true do |t|
+        t.integer :biz_id
+        t.string :biz_type
+        t.string :name
+        t.string :address
+        t.string :phone
+      end
+
+      class Business < ActiveRecord::Base
+        belongs_to  :biz, :polymorphic => true
+      end
+
+      class Restaurant < ActiveRecord::Base
+        mti_class do
+          has_one :business, :as => :biz
+        end
+      end
+
+      class Bar < ActiveRecord::Base
+        mti_class(:bars_core) do
+          has_one :business, :as => :biz
+        end
+      end
+      
+For now the convention is to name the base tables with the suffix core as the view will use the rails table name
+
+In the background the following association options are used :autosave => true, :validate => true, :dependent => :destroy
+
+MTI associations take the only and except options to limit the inherited columns.
+
+      class SmallMechanic < ActiveRecord::Base
+        mti_class :mechanics_core do |t|
+          has_one :garage, :foreign_key => :mechanic_id, :except => 'specialty'
+        end
+      end
+
+      class TinyMechanic < ActiveRecord::Base
+        mti_class :mechanics_core do |t|
+          has_one :garage, :foreign_key => :mechanic_id, :only => 'specialty'
+        end
+      end
+
+Validations are also inherited but only for validations for attributes/columns that are inherited
+
+Changing or adding these options will have no effect but the MTI would be senseless without them
+
+If the class does not descend active record the correct table will be used.
+
+If you dont want to use the core suffix convention a table can be specified (see Bar class mti implementation)
+
+
+      1.9.3p0 :005 > Bar
+      => Bar(id: integer, music_genre: string, best_nights: string, dress_code: string, created_at: datetime, updated_at: datetime, deleted_at: datetime, name: string, address: string, phone: string)
+      
+      1.9.3p0 :006 > bar = Bar.create(:music_genre => "Latin", :best_nights => "Tuesdays", :dress_code => "casual", :address => "1904 Easy Kaley Orlando, FL 32806", :name => 'Chicos', :phone => '123456789')
+      => #<Bar id: 2, music_genre: "Latin", best_nights: "Tuesdays", dress_code: "casual", created_at: "2012-03-09 18:41:17", updated_at: "2012-03-09 18:41:17", deleted_at: nil, name: "Chicos", address: "1904 Easy Kaley Orlando, FL 32806", phone: "123456789">
+      
+      1.9.3p0 :008 > bar.phone = '987654321'
+       => "987654321" 
+      1.9.3p0 :009 > bar.save
+       => true
+      
+      1.9.3p0 :010 > bar.reload
+       => #<Bar id: 2, music_genre: "Latin", best_nights: "Tuesdays", dress_code: "casual", created_at: "2012-03-09 18:41:17", updated_at: "2012-03-09 18:41:17", deleted_at: nil, name: "Chicos", address: "1904 Easy Kaley Orlando, FL 32806", phone: "987654321">
+       
+       1.9.3p0 :011 > bar.destroy
+        => #<Bar id: 2, music_genre: "Latin", best_nights: "Tuesdays", dress_code: "casual", created_at: "2012-03-09 18:41:17", updated_at: "2012-03-09 18:41:17", deleted_at: nil, name: "Chicos", address: "1904 Easy Kaley Orlando, FL 32806", phone: "987654321">
+      
+       1.9.3p0 :013 > Bar.find_by_id(2)
+        => nil
+      
+      
+      
+

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r empty_eye.rb"
+end
+
+task :test_console do
+  sh "irb -rubygems -I lib -r empty_eye.rb -I spec -r spec_helper.rb "
+end
+  

data/empty_eye.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "empty_eye/version"
+
+Gem::Specification.new do |s|
+  s.name        = "empty_eye"
+  s.version     = EmptyEye::VERSION::STRING
+  s.authors     = ["thegboat"]
+  s.email       = ["gradygriffin@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Active Record MTI gem}
+  s.description = %q{Active Record MTI gem powered by database views}
+
+  s.rubyforge_project = "empty_eye"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    s.add_runtime_dependency('activerecord', '>= 2.3.0')
+    s.add_runtime_dependency('arel', '>= 3.0.0')
+    s.add_development_dependency("rspec")
+    s.add_development_dependency("mysql2")
+  else
+    s.add_dependency('activerecord', '>= 2.3.0')
+    s.add_dependency('arel', '>= 3.0.0')
+    s.add_development_dependency("rspec")
+    s.add_development_dependency("mysql2")
+  end
+end

data/lib/empty_eye/active_record/base.rb

@@ -0,0 +1,133 @@
+module ActiveRecord
+  class Base
+    
+    class << self
+    
+      #am i an mti class? easier than making a new class type ... i tried
+      def mti_class?
+        extended_with.any?
+      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 association 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)
+        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)
+        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)
+      end
+
+      #the class of primary shard
+      def mti_primary_shard
+        extended_with.primary.shard
+      end
+      
+      #we dont need no freakin' finder
+      #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 detrmine if our view name exists; this will need to chage one day
+      #if they didnt specify try using the core convention else the superclass
+      #if they specified use what the 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
+        end.flatten.uniq
+      end
+
+      #determine if what we want to name our view already exists
+      def ordinary_table_exists?
+        connection.tables_without_views.include?(compute_view_name)
+      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)
+      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
+      
+      #we know how to rebuild the validations from the shards
+      #lets call our inherited validation here
+      def inherit_mti_validations
+        extended_with.validations.each {|args| send(*args)}
+      end
+    end
+    
+    private
+    
+    #a pseudo association method back to instances primary shard
+    def mti_primary_shard
+      @mti_primary_shard ||= if new_record?
+        self.class.mti_primary_shard.new(:mti_instance => self)
+      else
+        rtn = self.class.mti_primary_shard.find_by_id(id)
+        rtn.mti_instance = self
+        rtn
+      end
+    end
+    
+    #is the instance an instance of mti_class?
+    def mti_class?
+      self.class.mti_class?
+    end
+    
+  end
+end

data/lib/empty_eye/active_record/connection_adapter.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      #we need this logic to correctly build schema file
+      def tables_without_views
+        #trying to make compatible with rails 2.3.x; failing
+        if respond_to?('execute_and_free')
+          execute_and_free(tables_without_views_sql) do |result|
+            result.collect { |field| field.first }
+          end
+        else
+          result = execute(tables_without_views_sql)
+          rtn = result.collect { |field| field.first }
+          result.free rescue nil
+          rtn
+        end
+      end
+    
+      private
+    
+      #i coulda made this more OO but this seemed to handle more unknown speed bumps
+      #perusing rails_sql_views helped a bit
+      # https://github.com/aeden/rails_sql_views
+      def tables_without_views_sql
+        case self.to_s
+        when /^mysql/i
+          "SHOW FULL TABLES WHERE table_type = 'BASE TABLE'"
+        when /postgresql/i
+          %{SELECT tablename
+          FROM pg_tables
+          WHERE schemaname = ANY (current_schemas(false)) AND table_type = 'BASE TABLE'}
+        when /sqlite/i
+          %{SELECT name
+          FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'}
+        when /oracle/i
+          "SELECT TABLE_NAME FROM USER_TABLES"
+        when /sqlserver/i
+          "SELECT table_name FROM information_schema.tables"
+        else
+          "SHOW FULL TABLES WHERE table_type = 'BASE TABLE'"
+        end
+      end
+    end
+  end
+end

data/lib/empty_eye/active_record/schema_dumper.rb

@@ -0,0 +1,18 @@
+module ActiveRecord
+  class SchemaDumper
+    #we dont want views in our schema file
+    def tables(stream)
+      @connection.tables_without_views.sort.each do |tbl|
+        next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
+          case ignored
+          when String; tbl == ignored
+          when Regexp; tbl =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+          end
+        end 
+        table(tbl, stream)
+      end
+    end
+  end
+end

data/lib/empty_eye/associations/builder/shard_has_one.rb

@@ -0,0 +1,20 @@
+module EmptyEye
+  module Associations
+    module Builder
+      class ShardHasOne < ActiveRecord::Associations::Builder::HasOne
+        #special association builder for shard
+        #very verbose but will be easier to update later
+        #better than monkey patching
+        #this builder allows the other special shard association-ish classes to be created
+        #the ground floor ...
+        
+        def build
+          reflection = super
+          configure_dependency unless options[:through]
+          reflection
+        end
+        
+      end
+    end
+  end
+end

data/lib/empty_eye/associations/shard_association_scope.rb

@@ -0,0 +1,79 @@
+module EmptyEye
+  module Associations
+    class ShardAssociationScope < ActiveRecord::Associations::AssociationScope
+      #special association scope for shard
+      #very verbose but will be easier to update later
+      #better than monkey patching
+      #here we are patching the need to set the polymorphic type for a association lookup
+      #the shard is the 'owner' but we want the type to be the master class
+      
+      
+      def add_constraints(scope)
+        tables = construct_tables
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            join_table = tables.shift
+
+            scope = scope.joins(join(
+              join_table,
+              table[reflection.association_primary_key].
+                eq(join_table[reflection.association_foreign_key])
+            ))
+
+            table, foreign_table = join_table, tables.first
+          end
+
+          if reflection.source_macro == :belongs_to
+            if reflection.options[:polymorphic]
+              key = reflection.association_primary_key(klass)
+            else
+              key = reflection.association_primary_key
+            end
+
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          conditions = self.conditions[i]
+
+          if reflection == chain.last
+            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))
+            end
+
+            conditions.each do |condition|
+              if options[:through] && condition.is_a?(Hash)
+                condition = { table.name => condition }
+              end
+
+              scope = scope.where(interpolate(condition))
+            end
+          else
+            constraint = table[key].eq(foreign_table[foreign_key])
+
+            if reflection.type
+              type = chain[i + 1].klass.base_class.name
+              constraint = constraint.and(table[reflection.type].eq(type))
+            end
+
+            scope = scope.joins(join(foreign_table, constraint))
+
+            unless conditions.empty?
+              scope = scope.where(sanitize(conditions, table))
+            end
+          end
+        end
+
+        scope
+      end
+      
+    end
+  end
+end

data/lib/empty_eye/associations/shard_has_one_association.rb

@@ -0,0 +1,35 @@
+module EmptyEye
+  module Associations
+    class ShardHasOneAssociation < ActiveRecord::Associations::HasOneAssociation
+      #special association for shard
+      #very verbose but will be easier to update later
+      #better than monkey patching
+      #here we are patching the need to set the polymorphic type for a association
+      #the shard is the 'owner' but we want the type to be the master class
+      
+      def association_scope
+        if klass
+          @association_scope ||= ShardAssociationScope.new(self).scope
+        end
+      end
+    
+      private
+    
+      def creation_attributes
+        attributes = {}
+
+        if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+          attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+
+          if reflection.options[:as]
+            attributes[reflection.type] = owner.mti_master_class.base_class.name
+          end
+        end
+
+        attributes
+      end
+    
+    end
+  end
+end
+  

data/lib/empty_eye/errors.rb

@@ -0,0 +1,5 @@
+module EmptyEye
+  class AlreadyExtended < StandardError; end
+  class ViewNameError < StandardError; end
+  class InvalidUpdate < StandardError; end
+end

data/lib/empty_eye/persistence.rb

@@ -0,0 +1,50 @@
+module EmptyEye
+  module Persistence
+    extend ActiveSupport::Concern
+    
+    #if it is not a mti_class do what you do
+    #else let the primary shard do the saving
+    def update(attribute_names = @attributes.keys)
+      return super unless mti_class?
+      mti_primary_shard.cascade_save
+      1
+    end
+
+    #if it is not a mti_class do what you do
+    #else let the primary shard do the saving
+    #come back and cleanup
+    def create
+      return super unless mti_class?
+      mti_primary_shard.cascade_save
+      ActiveRecord::IdentityMap.add(self) if ActiveRecord::IdentityMap.enabled?
+      @new_record = false
+      self.id
+    end
+    
+    #if it is not a mti_class do what you do
+    #else let the primary shard do the destruction
+    #come back and cleanup
+    def destroy
+      return super unless mti_class?
+      mti_primary_shard.destroy
+      if ActiveRecord::IdentityMap.enabled? and persisted?
+        ActiveRecord::IdentityMap.remove(self)
+      end
+      @destroyed = true
+      freeze
+    end
+    
+    #if it is not a mti_class do what you do
+    #else let the primary shard do the deletion
+    #come back and cleanup
+    def delete
+      return super unless mti_class?
+      self.class.delete_all(:id => id)
+      if ActiveRecord::IdentityMap.enabled? and persisted?
+        ActiveRecord::IdentityMap.remove(self)
+      end
+      @destroyed = true
+      freeze
+    end
+  end
+end