dbview_cti 0.1.4 → 0.1.5

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.5 (25/04/2014)
+
+* Made associations respect the class_name option
+* Fixed cti_recreate_views_after_change_to so it also works for the base class
+
 ## 0.1.4 (8/04/2014)
 
 * Fixed association issues

data/README.md

@@ -175,7 +175,7 @@ end
 
 ## Associations
 
-Associations (`has_many`, `has_one`, etc.) work and are inherited as you would expect. There are two caveats:
+Associations (`has_many`, `has_one`, etc.) work and are inherited as you would expect. There are three caveats:
 
 * In the base class, you have to call `cti_base_class` before defining any associations:
 
@@ -199,6 +199,8 @@ class SpaceShip < Vehicle
 end
 ```
 
+* You have to make sure that the association is defined in both classes, e.g. if you have `belongs_to :car` in a class called Part then Car should also define the association with `has_many :parts` (or `has_one :part`).
+
 ## API
 
 ### Models

data/lib/db_view_cti/connection_adapters/schema_statements.rb

@@ -22,19 +22,18 @@ module DBViewCTI
       # use with block in up/down methods
       def cti_recreate_views_after_change_to(class_name, options = {})
         klass = class_name.constantize
-        classes = [ class_name ] + klass.cti_all_descendants
+        classes = klass.cti_all_descendants
+        # only add class_name if it is not the base class
+        classes = classes.unshift( class_name ) unless klass.cti_base_class?
         # drop all views in reverse order
         classes.reverse.each do |kklass|
           cti_drop_view(kklass, options)
         end
         yield # perform table changes in block (e.g. add column)
         # recreate views in forward order
+        cti_reset_column_information(class_name) if klass.cti_base_class?
         classes.each do |kklass|
-          # any column changes are reflected in the real table cache, but not in the
-          # view cache, so we have to make sure it is cleared
-          true_klass = kklass.constantize
-          true_klass.connection.schema_cache.clear_table_cache!(true_klass.table_name) 
-          true_klass.reset_column_information 
+          cti_reset_column_information(kklass)
           cti_create_view(kklass, options)
         end
       end
@@ -47,6 +46,16 @@ module DBViewCTI
           execute(query)
         end
       end
+      
+      private
+      
+        def cti_reset_column_information(class_name)
+          # any column changes are reflected in the real table cache, but not in the
+          # view cache, so we have to make sure it is cleared
+          klass = class_name.constantize
+          klass.connection.schema_cache.clear_table_cache!(klass.table_name) 
+          klass.reset_column_information 
+        end
 
     end
   end

data/lib/db_view_cti/model/cti/association_validations.rb

@@ -0,0 +1,57 @@
+module DBViewCTI
+  module Model
+    module CTI
+      module AssociationValidations
+        extend ActiveSupport::Concern
+
+        included do
+          # validations
+          validate :cti_validate_associations, :cti_no_disable => true
+          attr_accessor :cti_disable_validations
+        end
+        
+        def cti_validate_associations
+          return_value = true
+          self.class.cti_association_proxies.each_key do |proxy_name|
+            proxy = instance_variable_get(proxy_name)
+            if proxy && !proxy.valid?
+              errors.messages.merge!(proxy.errors.messages)
+              return_value = false
+            end
+          end
+          return_value
+        end
+  
+        module ClassMethods
+
+          # redefine validate to always add :unless proc so we can disable the validations for an object
+          # by setting the cti_disable_validations accessor to true
+          def validate(*args, &block)
+            # we specifically don't want to disable balidations belonging to associations. Based on the naming
+            # rails uses, we return immediately in such cases (there must be a cleaner way to do this...)
+            return super if args.first && args.first.to_s =~ /^validate_associated_records_for_/
+            # rest of implementation insipred by the validate implementation in rails
+            options = args.extract_options!.dup
+            return super if options[:cti_no_disable]
+            if options.key?(:unless)
+              options[:unless] = Array(options[:unless])
+              options[:unless].unshift( cti_validation_unless_proc )
+            else
+              options[:unless] = cti_validation_unless_proc
+            end
+            args << options
+            return super(*args, &block)
+          end
+          
+          def cti_validation_unless_proc
+            @cti_validation_unless_proc ||= Proc.new do |object| 
+              object.respond_to?(:cti_disable_validations) && object.cti_disable_validations
+            end
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/lib/db_view_cti/model/cti/associations.rb

@@ -0,0 +1,180 @@
+module DBViewCTI
+  module Model
+    module CTI
+      module Associations
+        extend ActiveSupport::Concern
+
+        included do
+          # for associations:
+          alias_method_chain :association, :cti
+          # save callbacks (necessary for saving associations)
+          after_save :cti_save_associations
+        end
+        
+        def cti_save_associations
+          self.class.cti_association_proxies.each_key do |proxy_name|
+            proxy = instance_variable_get(proxy_name)
+            proxy.save if proxy
+          end
+          true
+        end
+        
+        def association_with_cti(*args)
+          return association_without_cti(*args) unless args.length == 1
+          association_name = args[0]
+          proxy = cti_association_proxy(association_name)
+          proxy ||= self
+          proxy.association_without_cti(association_name)
+        end
+        
+        def cti_association_proxy(association_name)
+          return nil if self.class.reflect_on_all_associations(:belongs_to).map(&:name).include?(association_name.to_sym)
+          proxy_name = self.class.cti_association_proxy_name(association_name)
+          proxy = instance_variable_get(proxy_name)
+          if !proxy && !self.class.cti_has_association?(association_name)
+            instance_variable_set(proxy_name, 
+                                  ModelDelegator.new(self, self.class.cti_association_proxies[proxy_name]))
+            proxy = instance_variable_get(proxy_name)
+          end
+          proxy
+        end
+  
+        module ClassMethods
+          
+          # redefine association class methods
+          [:has_many, :has_and_belongs_to_many, :has_one].each do |name|
+            self.class_eval <<-eos, __FILE__, __LINE__+1
+              def #{name}(*args, &block)
+                cti_initialize_cti_associations
+                @cti_associations[:#{name}] << args.first
+                super
+              end
+            eos
+          end
+  
+          def cti_create_association_proxies
+            # create hash with proxy and class names. The proxies themselves will be created
+            # by the 'association' instance method when the association is used for the first time.
+            @cti_association_proxies ||= {}
+            @cti_ascendants.each do |ascendant|
+              [:has_many, :has_and_belongs_to_many, :has_one].each do |association_type|
+                ascendant.constantize.cti_associations[association_type].each do |association|
+                  proxy_name = cti_association_proxy_name(association)
+                  @cti_association_proxies[proxy_name] = ascendant
+                end
+              end
+            end
+          end
+          
+           # fix the 'remote' (i.e. belongs_to) part of any has_one of has_many association in this class
+          def cti_redefine_remote_associations
+            cti_initialize_cti_associations
+            # redefine remote belongs_to associations
+            [:has_many, :has_one].each do |association_type|
+              @cti_associations[association_type].each do |association|
+                next if @cti_redefined_remote_associations[association_type].include?( association )
+                if cti_reciprocal_association_present_for?( association, :belongs_to )
+                  remote_association = cti_reciprocal_association_for( association, :belongs_to )
+                  remote_class = cti_association_name_to_class_name( association ).constantize
+                  cti_redefine_remote_belongs_to_association(remote_class, remote_association.name.to_sym)
+                  @cti_redefined_remote_associations[association_type] << association
+                end
+              end
+            end
+            # redefine remote has_many and has_and_belongs_to_many associations
+            [:has_many, :has_and_belongs_to_many].each do |association_type|
+              @cti_associations[association_type].each do |association|
+                next if @cti_redefined_remote_associations[association_type].include?( association )
+                if cti_reciprocal_association_present_for?( association, association_type)
+                  remote_association = cti_reciprocal_association_for( association, association_type )
+                  remote_class = cti_association_name_to_class_name( association ).constantize
+                  cti_redefine_remote_to_many_association(remote_class, remote_association.name.to_sym)
+                  @cti_redefined_remote_associations[association_type] << association
+                end
+              end
+            end
+          end
+
+          # Gets reciprocal association of type 'type' for the given association.
+          # (example: if a has_many association has a corresponding belongs_to  in the remote class).
+          # Normally, the method checks if the remote association refers to this class, but it is possible to
+          # pass in 'class_name' to check different classes
+          def cti_reciprocal_association_for(association, type, class_name = nil)
+            class_name ||= self.name
+            remote_class = cti_association_name_to_class_name( association, class_name ).constantize
+            remote_associations = remote_class.reflect_on_all_associations( type ).select { |a| a.class_name == class_name }
+            remote_associations.first
+          end
+
+          # Check if a reciprocal association of type 'type' is present for the given association.
+          # (example: check if a has_many association has a corresponding belongs_to  in the remote class).
+          # Normally, the method checks if the remote association refers to this class, but it is possible to
+          # pass in 'class_name' to check different classes
+          def cti_reciprocal_association_present_for?(association, type, class_name = nil)
+            !cti_reciprocal_association_for(association, type, class_name).nil?
+          end
+
+          # converts e.g. :space_ships to SpaceShip
+          # Normally operates on associations of this class, but it is possible to
+          # pass in 'class_name' if 'association_name' is an association on a different classes
+          def cti_association_name_to_class_name(association_name, class_name = nil)
+            klass = self
+            klass = class_name.constantize if class_name
+            klass.reflect_on_all_associations.select { |a| a.name == association_name }.first.class_name
+          end
+
+          def cti_redefine_remote_belongs_to_association(remote_class, remote_association)
+            remote_class.class_eval <<-eos, __FILE__, __LINE__+1
+              def #{remote_association}=(object, *args, &block)
+                super( object.try(:convert_to, '#{self.name}'), *args, &block )
+              end
+            eos
+          end
+  
+          def cti_redefine_remote_to_many_association(remote_class, remote_association)
+            remote_class.class_eval <<-eos, __FILE__, __LINE__+1
+              def #{remote_association}=(objects, *args, &block)
+                super( objects.map { |o| o.try(:convert_to, '#{self.name}') }, *args, &block)
+              end
+              def #{remote_association}(*args, &block)
+                collection = super
+                DBViewCTI::Model::CollectionDelegator.new(collection, '#{self.name}')
+              end
+            eos
+          end
+          
+          def cti_association_proxy_name(association)
+            "@cti_#{association}_association_proxy"
+          end
+  
+          def cti_associations
+            cti_initialize_cti_associations
+            @cti_associations
+          end
+          
+          def cti_has_association?(association_name)
+            if !@cti_all_associations
+              @cti_all_associations = @cti_associations.keys.inject([]) do |result, key|
+                result += @cti_associations[key]
+                result 
+              end
+            end
+            @cti_all_associations.include?(association_name.to_sym)
+          end
+          
+          def cti_initialize_cti_associations
+            @cti_associations ||= {}
+            @cti_redefined_remote_associations ||= {}
+            [:has_many, :has_and_belongs_to_many, :has_one].each do |name|
+              @cti_associations[name] ||= []
+              @cti_redefined_remote_associations[name] ||= []
+            end
+            @cti_association_proxies ||= {}
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/lib/db_view_cti/model/cti/destroy.rb

@@ -0,0 +1,30 @@
+module DBViewCTI
+  module Model
+    module CTI
+      module Destroy
+        extend ActiveSupport::Concern
+
+        # change destroy and delete methods to operate on most specialized object
+        included do
+          alias_method_chain :destroy, :cti
+          alias_method_chain :delete, :cti
+          # destroy! seems te be defined in Rails 4
+          alias_method_chain :destroy!, :cti if self.method_defined?(:destroy!)
+        end
+        
+        def destroy_with_cti
+          specialize.destroy_without_cti
+        end
+        
+        def destroy_with_cti!
+          specialize.destroy_without_cti!
+        end
+        
+        def delete_with_cti
+          specialize.delete_without_cti
+        end
+        
+      end
+    end
+  end
+end

data/lib/db_view_cti/model/cti/hierarchy.rb

@@ -0,0 +1,58 @@
+module DBViewCTI
+  module Model
+    module CTI
+      module Hierarchy
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          
+          def cti_base_class?
+            !!@cti_base_class
+          end
+    
+          def cti_derived_class?
+            !!@cti_derived_class
+          end
+          
+          attr_accessor :cti_descendants, :cti_ascendants, :cti_association_proxies
+          
+          # registers a derived class and its descendants in the current class
+          # class_name: name of derived class (the one calling cti_register_descendants on this class)
+          # descendants: the descendants of the derived class
+          def cti_register_descendants(class_name, descendants = {})
+            @cti_descendants ||= {}
+            @cti_descendants[class_name] = descendants
+            if cti_derived_class?
+              # call up the chain. This will also cause the register_ascendants callbacks
+              self.superclass.cti_register_descendants(self.name, @cti_descendants)
+            end
+            # call back to calling class
+            @cti_ascendants ||= []
+            class_name.constantize.cti_register_ascendants(@cti_ascendants + [ self.name ])
+          end
+          
+          # registers the ascendants of the current class. Called on this class by the parent class.
+          # ascendants: array of ascendants. The first element is the highest level class, derived
+          # classes follow, the last element is the parent of this class.
+          def cti_register_ascendants(ascendants)
+            @cti_ascendants = ascendants
+          end
+          
+          # returns a list of all descendants
+          def cti_all_descendants
+            result = []
+            block = Proc.new do |klass, descendants|
+              result << klass
+              descendants.each(&block)
+            end
+            @cti_descendants ||= {}
+            @cti_descendants.each(&block)
+            result
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/db_view_cti/model/cti/sql.rb

@@ -0,0 +1,23 @@
+module DBViewCTI
+  module Model
+    module CTI
+      module SQL
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          include DBViewCTI::SQLGeneration::Model
+          
+          # this method is only used in testing. It returns the number of rows present in the real database
+          # table, not the number of rows present in the view (as returned by count)
+          def cti_table_count
+            result = connection.execute("SELECT COUNT(*) FROM #{DBViewCTI::Names.table_name(self)};")
+            result[0]['count'].to_i
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/lib/db_view_cti/model/cti/type_conversion.rb

@@ -0,0 +1,55 @@
+module DBViewCTI
+  module Model
+    module CTI
+      module TypeConversion
+
+        def specialize
+          class_name, id = type(true)
+          return self if class_name == self.class.name
+          class_name.constantize.find(id)
+        end
+        
+        # Return the 'true' (i.e. most specialized) classname of this object
+        # When return_id is true, the 'specialized' database id is also returned
+        def type(return_id = false)
+          query, levels = self.class.cti_outer_join_sql(id)
+          result = self.class.connection.execute(query).first
+          # replace returned ids with the levels corresponding to their classes
+          result_levels = result.inject({}) do |hash, (k,v)|
+            hash[k] = levels[k] unless v.nil?
+            hash
+          end
+          # find class with maximum level value
+          foreign_key = result_levels.max_by { |k,v| v }.first
+          class_name = DBViewCTI::Names.table_to_class_name(foreign_key[0..-4])
+          if return_id
+            id_ = result[foreign_key].to_i
+            [class_name, id_]
+          else
+            class_name
+          end
+        end
+        
+        def convert_to(type)
+          return nil unless persisted?
+          type_string = type.to_s
+          type_string = type_string.camelize if type.is_a?(Symbol)
+          return self if type_string == self.class.name
+          query = self.class.cti_inner_join_sql(id, type_string)
+          # query is nil when we try to cenvert to a descendant class (instead of an ascendant),
+          # or when we try to convert to a class outside of the hierarchy
+          if query.nil?
+            specialized = specialize
+            return nil if specialized == self
+            return specialized.convert_to(type_string)
+          end
+          result = self.class.connection.execute(query).first
+          id = result[ DBViewCTI::Names.foreign_key(type.to_s) ]
+          return nil if id.nil?
+          type_string.constantize.find(id.to_i)
+        end
+        
+      end
+    end
+  end
+end

data/lib/db_view_cti/model/cti.rb

@@ -3,328 +3,12 @@ module DBViewCTI
     module CTI
       extend ActiveSupport::Concern
       
-      def specialize
-        class_name, id = type(true)
-        return self if class_name == self.class.name
-        class_name.constantize.find(id)
-      end
-      
-      # Return the 'true' (i.e. most specialized) classname of this object
-      # When return_id is true, the 'specialized' database id is also returned
-      def type(return_id = false)
-        query, levels = self.class.cti_outer_join_sql(id)
-        result = self.class.connection.execute(query).first
-        # replace returned ids with the levels corresponding to their classes
-        result_levels = result.inject({}) do |hash, (k,v)|
-          hash[k] = levels[k] unless v.nil?
-          hash
-        end
-        # find class with maximum level value
-        foreign_key = result_levels.max_by { |k,v| v }.first
-        class_name = DBViewCTI::Names.table_to_class_name(foreign_key[0..-4])
-        if return_id
-          id_ = result[foreign_key].to_i
-          [class_name, id_]
-        else
-          class_name
-        end
-      end
-      
-      def convert_to(type)
-        return nil unless persisted?
-        type_string = type.to_s
-        type_string = type_string.camelize if type.is_a?(Symbol)
-        return self if type_string == self.class.name
-        query = self.class.cti_inner_join_sql(id, type_string)
-        # query is nil when we try to cenvert to a descendant class (instead of an ascendant),
-        # or when we try to convert to a class outside of the hierarchy
-        if query.nil?
-          specialized = specialize
-          return nil if specialized == self
-          return specialized.convert_to(type_string)
-        end
-        result = self.class.connection.execute(query).first
-        id = result[ DBViewCTI::Names.foreign_key(type.to_s) ]
-        return nil if id.nil?
-        type_string.constantize.find(id.to_i)
-      end
-      
-      # change destroy and delete methods to operate on most specialized object
-      included do
-        alias_method_chain :destroy, :cti
-        alias_method_chain :delete, :cti
-        # destroy! seems te be defined in Rails 4
-        alias_method_chain :destroy!, :cti if self.method_defined?(:destroy!)
-
-        # for associations:
-        alias_method_chain :association, :cti
-        # save callbacks (necessary for saving associations)
-        after_save :cti_save_associations
-
-        # validations
-        validate :cti_validate_associations, :cti_no_disable => true
-        attr_accessor :cti_disable_validations
-      end
-      
-      def destroy_with_cti
-        specialize.destroy_without_cti
-      end
-      
-      def destroy_with_cti!
-        specialize.destroy_without_cti!
-      end
-      
-      def delete_with_cti
-        specialize.delete_without_cti
-      end
-      
-      def cti_validate_associations
-        return_value = true
-        self.class.cti_association_proxies.each_key do |proxy_name|
-          proxy = instance_variable_get(proxy_name)
-          if proxy && !proxy.valid?
-            errors.messages.merge!(proxy.errors.messages)
-            return_value = false
-          end
-        end
-        return_value
-      end
-
-      def cti_save_associations
-        self.class.cti_association_proxies.each_key do |proxy_name|
-          proxy = instance_variable_get(proxy_name)
-          proxy.save if proxy
-        end
-        true
-      end
-      
-      def association_with_cti(*args)
-        return association_without_cti(*args) unless args.length == 1
-        association_name = args[0]
-        proxy = cti_association_proxy(association_name)
-        proxy ||= self
-        proxy.association_without_cti(association_name)
-      end
-      
-      def cti_association_proxy(association_name)
-        return nil if self.class.reflect_on_all_associations(:belongs_to).map(&:name).include?(association_name.to_sym)
-        proxy_name = self.class.cti_association_proxy_name(association_name)
-        proxy = instance_variable_get(proxy_name)
-        if !proxy && !self.class.cti_has_association?(association_name)
-          instance_variable_set(proxy_name, 
-                                ModelDelegator.new(self, self.class.cti_association_proxies[proxy_name]))
-          proxy = instance_variable_get(proxy_name)
-        end
-        proxy
-      end
-
-      module ClassMethods
-        
-        def cti_base_class?
-          !!@cti_base_class
-        end
-  
-        def cti_derived_class?
-          !!@cti_derived_class
-        end
-        
-        attr_accessor :cti_descendants, :cti_ascendants, :cti_association_proxies
-        
-        # registers a derived class and its descendants in the current class
-        # class_name: name of derived class (the one calling cti_register_descendants on this class)
-        # descendants: the descendants of the derived class
-        def cti_register_descendants(class_name, descendants = {})
-          @cti_descendants ||= {}
-          @cti_descendants[class_name] = descendants
-          if cti_derived_class?
-            # call up the chain. This will also cause the register_ascendants callbacks
-            self.superclass.cti_register_descendants(self.name, @cti_descendants)
-          end
-          # call back to calling class
-          @cti_ascendants ||= []
-          class_name.constantize.cti_register_ascendants(@cti_ascendants + [ self.name ])
-        end
-        
-        # registers the ascendants of the current class. Called on this class by the parent class.
-        # ascendants: array of ascendants. The first element is the highest level class, derived
-        # classes follow, the last element is the parent of this class.
-        def cti_register_ascendants(ascendants)
-          @cti_ascendants = ascendants
-        end
-        
-        # returns a list of all descendants
-        def cti_all_descendants
-          result = []
-          block = Proc.new do |klass, descendants|
-            result << klass
-            descendants.each(&block)
-          end
-          @cti_descendants ||= {}
-          @cti_descendants.each(&block)
-          result
-        end
-        
-        # redefine validate to always add :unless proc so we can disable the validations for an object
-        # by setting the cti_disable_validations accessor to true
-        def validate(*args, &block)
-          # we specifically don't want to disable balidations belonging to associations. Based on the naming
-          # rails uses, we return immediately in such cases (there must be a cleaner way to do this...)
-          return super if args.first && args.first.to_s =~ /^validate_associated_records_for_/
-          # rest of implementation insipred by the validate implementation in rails
-          options = args.extract_options!.dup
-          return super if options[:cti_no_disable]
-          if options.key?(:unless)
-            options[:unless] = Array(options[:unless])
-            options[:unless].unshift( cti_validation_unless_proc )
-          else
-            options[:unless] = cti_validation_unless_proc
-          end
-          args << options
-          return super(*args, &block)
-        end
-        
-        def cti_validation_unless_proc
-          @cti_validation_unless_proc ||= Proc.new do |object| 
-            object.respond_to?(:cti_disable_validations) && object.cti_disable_validations
-          end
-        end
-        
-        # redefine association class methods
-        [:has_many, :has_and_belongs_to_many, :has_one].each do |name|
-          self.class_eval <<-eos, __FILE__, __LINE__+1
-            def #{name}(*args, &block)
-              cti_initialize_cti_associations
-              @cti_associations[:#{name}] << args.first
-              super
-            end
-          eos
-        end
-
-        def cti_create_association_proxies
-          # create hash with proxy and class names. The proxies themselves will be created
-          # by the 'association' instance method when the association is used for the first time.
-          @cti_association_proxies ||= {}
-          @cti_ascendants.each do |ascendant|
-            [:has_many, :has_and_belongs_to_many, :has_one].each do |association_type|
-              ascendant.constantize.cti_associations[association_type].each do |association|
-                proxy_name = cti_association_proxy_name(association)
-                @cti_association_proxies[proxy_name] = ascendant
-              end
-            end
-          end
-        end
-        
-         # fix the 'remote' (i.e. belongs_to) part of any has_one of has_many association in this class
-        def cti_redefine_remote_associations
-          cti_initialize_cti_associations
-          # redefine remote belongs_to associations
-          [:has_many, :has_one].each do |association_type|
-            @cti_associations[association_type].each do |association|
-              next if @cti_redefined_remote_associations[association_type].include?( association )
-              if cti_reciprocal_association_present_for?( association, :belongs_to )
-                remote_class = cti_association_name_to_class_name( association ).constantize
-                cti_redefine_remote_belongs_to_association(remote_class, cti_class_name_to_association_name.to_sym)
-                @cti_redefined_remote_associations[association_type] << association
-              end
-            end
-          end
-          # redefine remote has_many and has_and_belongs_to_many associations
-          [:has_many, :has_and_belongs_to_many].each do |association_type|
-            @cti_associations[association_type].each do |association|
-              next if @cti_redefined_remote_associations[association_type].include?( association )
-              if cti_reciprocal_association_present_for?( association, association_type, true )
-                remote_class = cti_association_name_to_class_name( association ).constantize
-                cti_redefine_remote_to_many_association(remote_class, cti_class_name_to_association_name( true ).to_sym)
-                @cti_redefined_remote_associations[association_type] << association
-              end
-            end
-          end
-        end
-        
-        # Check if a reciprocal association of type 'type' is present for the given association.
-        # (example: check if a has_many association has a corresponding belongs_to  in the remote class).
-        # Plural indicates wether the remote association we're looking for is plural (i.e. has_many :space_ships)
-        # or singular (i.e. belongs_to :space_ship).
-        # Normally, the method checks if the remote association refers to this class, but it is possible to
-        # pass in 'class_name' to check different classes
-        def cti_reciprocal_association_present_for?(association, type, plural = false, class_name = nil)
-          remote_class = cti_association_name_to_class_name( association ).constantize
-          remote_associations = remote_class.reflect_on_all_associations( type ).map(&:name)
-          remote_associations.include?( cti_class_name_to_association_name(plural, class_name).to_sym )
-        end
-        
-        # converts e.g. SpaceShip to :space_ship (for plural == false), or :space_ships (for plural true)
-        def cti_class_name_to_association_name(plural = false, class_name = nil)
-          class_name ||= self.name
-          association_name = class_name.underscore
-          association_name = association_name.pluralize if plural
-          association_name
-        end
-
-        # converts e.g. :space_ships to SpaceShip
-        def cti_association_name_to_class_name(association_name)
-          association_name.to_s.camelize.singularize
-        end
-
-        def cti_redefine_remote_belongs_to_association(remote_class, remote_association)
-          remote_class.class_eval <<-eos, __FILE__, __LINE__+1
-            def #{remote_association}=(object, *args, &block)
-              super( object.try(:convert_to, '#{self.name}'), *args, &block )
-            end
-          eos
-        end
-
-        def cti_redefine_remote_to_many_association(remote_class, remote_association)
-          remote_class.class_eval <<-eos, __FILE__, __LINE__+1
-            def #{remote_association}=(objects, *args, &block)
-              super( objects.map { |o| o.try(:convert_to, '#{self.name}') }, *args, &block)
-            end
-            def #{remote_association}(*args, &block)
-              collection = super
-              DBViewCTI::Model::CollectionDelegator.new(collection, '#{self.name}')
-            end
-          eos
-        end
-        
-        def cti_association_proxy_name(association)
-          "@cti_#{association}_association_proxy"
-        end
-
-        def cti_associations
-          cti_initialize_cti_associations
-          @cti_associations
-        end
-        
-        def cti_has_association?(association_name)
-          if !@cti_all_associations
-            @cti_all_associations = @cti_associations.keys.inject([]) do |result, key|
-              result += @cti_associations[key]
-              result 
-            end
-          end
-          @cti_all_associations.include?(association_name.to_sym)
-        end
-        
-        include DBViewCTI::SQLGeneration::Model
-        
-        # this method is only used in testing. It returns the number of rows present in the real database
-        # table, not the number of rows present in the view (as returned by count)
-        def cti_table_count
-          result = connection.execute("SELECT COUNT(*) FROM #{DBViewCTI::Names.table_name(self)};")
-          result[0]['count'].to_i
-        end
-        
-        def cti_initialize_cti_associations
-          @cti_associations ||= {}
-          @cti_redefined_remote_associations ||= {}
-          [:has_many, :has_and_belongs_to_many, :has_one].each do |name|
-            @cti_associations[name] ||= []
-            @cti_redefined_remote_associations[name] ||= []
-          end
-          @cti_association_proxies ||= {}
-        end
-        
-      end
+      include Hierarchy
+      include TypeConversion
+      include Destroy
+      include SQL
+      include Associations
+      include AssociationValidations
     end
   end
 end

data/lib/db_view_cti/version.rb

@@ -1,3 +1,3 @@
 module DBViewCTI
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/dbview_cti.rb

@@ -1,3 +1,8 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.acronym('CTI')
+  inflect.acronym('CTIs')
+end
+
 module DBViewCTI
   extend ActiveSupport::Autoload
   autoload :Names
@@ -30,6 +35,12 @@ module DBViewCTI
     autoload :Extensions
     autoload :ModelDelegator
     autoload :CollectionDelegator
+    autoload :TypeConversion, 'db_view_cti/model/cti/type_conversion'
+    autoload :Hierarchy, 'db_view_cti/model/cti/hierarchy'
+    autoload :Destroy, 'db_view_cti/model/cti/destroy'
+    autoload :SQL, 'db_view_cti/model/cti/sql'
+    autoload :Associations, 'db_view_cti/model/cti/associations'
+    autoload :AssociationValidations, 'db_view_cti/model/cti/association_validations'
   end
 end
 

data/spec/dummy-rails-3/app/models/space_ship.rb

@@ -16,4 +16,6 @@ class SpaceShip < Vehicle
   has_many :experiment_space_ship_performances
   has_many :experiments, :through => :experiment_space_ship_performances
   accepts_nested_attributes_for :experiments
+  
+  has_many :upgraded_to, :class_name => 'SpaceShuttle', :foreign_key => 'upgraded_from_id'
 end

data/spec/dummy-rails-3/app/models/space_shuttle.rb

@@ -1,4 +1,9 @@
 class SpaceShuttle < SpaceShip
   attr_accessible :single_use unless Rails::VERSION::MAJOR > 3
+  
+  belongs_to :upgraded_from, :class_name => 'SpaceShip'
+
+  # cti_derived_class has to come after te above belongs_to, otherwise the association will not work correctly.
+  # This is only because SpaceShuttle is a leaf class (i.e. had no descendants).
   cti_derived_class
 end

data/spec/dummy-rails-3/db/migrate/20140411001620_add_upgraded_from_to_space_shuttles.rb

@@ -0,0 +1,15 @@
+class AddUpgradedFromToSpaceShuttles < ActiveRecord::Migration
+  def up
+    cti_recreate_views_after_change_to('SpaceShuttle') do
+      add_column(:space_shuttles, :upgraded_from_id, :integer)
+    end
+    add_foreign_key :space_shuttles, :space_ships, :column => 'upgraded_from_id'
+  end
+
+  def down
+    cti_recreate_views_after_change_to('SpaceShuttle') do
+      remove_column(:space_shuttles, :upgraded_from_id)
+    end
+    remove_foreign_key :space_shuttles, :space_ships, :column => 'upgraded_from_id'
+  end
+end

data/spec/dummy-rails-3/db/migrate/20140425182847_add_field_to_base_class.rb

@@ -0,0 +1,14 @@
+class AddFieldToBaseClass < ActiveRecord::Migration
+  def up
+    # this makes cti_recreate_views_after_change_to also works for the base class
+    cti_recreate_views_after_change_to('Vehicle') do
+      add_column(:vehicles, :bogus_field, :string)
+    end
+  end
+
+  def down
+    cti_recreate_views_after_change_to('Vehicle') do
+      remove_column(:vehicles, :bogus_field)
+    end
+  end
+end

data/spec/dummy-rails-4/db/schema.rb

@@ -11,7 +11,10 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20131022020655) do
+ActiveRecord::Schema.define(version: 20140425182847) do
+
+  # These are extensions that must be enabled in order to support this database
+  enable_extension "plpgsql"
 
   create_table "astronauts", force: true do |t|
     t.string   "name"
@@ -39,6 +42,26 @@ ActiveRecord::Schema.define(version: 20131022020655) do
     t.datetime "updated_at"
   end
 
+  create_table "categories", force: true do |t|
+    t.string   "name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "experiment_space_ship_performances", force: true do |t|
+    t.integer  "experiment_id"
+    t.integer  "space_ship_id"
+    t.date     "performed_at"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  create_table "experiments", force: true do |t|
+    t.string   "name"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
   create_table "launches", force: true do |t|
     t.integer  "space_ship_id"
     t.date     "date"
@@ -70,6 +93,7 @@ ActiveRecord::Schema.define(version: 20131022020655) do
 
   create_table "space_ships", force: true do |t|
     t.integer  "vehicle_id"
+    t.integer  "category_id"
     t.boolean  "single_use"
     t.datetime "created_at"
     t.datetime "updated_at"
@@ -81,6 +105,7 @@ ActiveRecord::Schema.define(version: 20131022020655) do
     t.integer  "power"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.integer  "upgraded_from_id"
   end
 
   create_table "vehicles", force: true do |t|
@@ -88,6 +113,7 @@ ActiveRecord::Schema.define(version: 20131022020655) do
     t.integer  "mass"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.string   "bogus_field"
   end
 
   cti_create_view('MotorVehicle')
@@ -101,12 +127,17 @@ ActiveRecord::Schema.define(version: 20131022020655) do
 
   add_foreign_key "captains", "space_ships", :name => "captains_space_ship_id_fk"
 
+  add_foreign_key "experiment_space_ship_performances", "experiments", :name => "experiment_space_ship_performances_experiment_id_fk"
+  add_foreign_key "experiment_space_ship_performances", "space_ships", :name => "experiment_space_ship_performances_space_ship_id_fk"
+
   add_foreign_key "launches", "space_ships", :name => "launches_space_ship_id_fk"
 
   add_foreign_key "rocket_engines", "space_ships", :name => "rocket_engines_space_ship_id_fk"
 
+  add_foreign_key "space_ships", "categories", :name => "space_ships_category_id_fk"
   add_foreign_key "space_ships", "vehicles", :name => "space_ships_vehicle_id_fk"
 
   add_foreign_key "space_shuttles", "space_ships", :name => "space_shuttles_space_ship_id_fk"
+  add_foreign_key "space_shuttles", "space_ships", :name => "space_shuttles_upgraded_from_id_fk", :column => "upgraded_from_id"
 
 end

data/spec/models/car_spec.rb

@@ -18,11 +18,13 @@ describe Car do
     @car.name = 'Porsche'
     @car.fuel = 'gasoline'
     @car.convertible = true
+    @car.bogus_field = 'bogus'
     @car.save!
     car = Car.find(id)
     car.name.should eq 'Porsche'
     car.mass.should eq 1000
     car.fuel.should eq 'gasoline'
+    car.bogus_field.should eq 'bogus'
     car.stick_shift.should be_true
     car.convertible.should be_true
   end

data/spec/models/space_shuttle_spec.rb

@@ -441,6 +441,21 @@ describe SpaceShuttle do
       }.to change(SpaceShuttle, :count).by(1)
     end
     
+    it "association logic also works for associations with non-standard names" do
+      # check has_many side
+      shuttle2 = SpaceShuttle.create(:name => 'Endeavour', :reliability => 100)
+      @shuttle.upgraded_to << shuttle2
+      @shuttle.save!
+      shuttle2.reload
+      shuttle2.upgraded_from.specialize.id.should eq @shuttle.id
+      # check belongs_to side
+      shuttle3 = SpaceShuttle.create(:name => 'Endeavour', :reliability => 100)
+      @shuttle.upgraded_from = shuttle3
+      @shuttle.save!
+      @shuttle.reload
+      @shuttle.upgraded_from.specialize.id.should eq shuttle3.id
+    end
+
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dbview_cti
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-08 00:00:00.000000000 Z
+date: 2014-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -80,6 +80,12 @@ files:
 - lib/db_view_cti/migration/command_recorder.rb
 - lib/db_view_cti/model/collection_delegator.rb
 - lib/db_view_cti/model/cti.rb
+- lib/db_view_cti/model/cti/association_validations.rb
+- lib/db_view_cti/model/cti/associations.rb
+- lib/db_view_cti/model/cti/destroy.rb
+- lib/db_view_cti/model/cti/hierarchy.rb
+- lib/db_view_cti/model/cti/sql.rb
+- lib/db_view_cti/model/cti/type_conversion.rb
 - lib/db_view_cti/model/extensions.rb
 - lib/db_view_cti/model/model_delegator.rb
 - lib/db_view_cti/names.rb
@@ -149,6 +155,8 @@ files:
 - spec/dummy-rails-3/db/migrate/20131022030659_create_experiments.rb
 - spec/dummy-rails-3/db/migrate/20131022030720_create_experiment_space_ship_performances.rb
 - spec/dummy-rails-3/db/migrate/20140408013710_check_view_exists.rb
+- spec/dummy-rails-3/db/migrate/20140411001620_add_upgraded_from_to_space_shuttles.rb
+- spec/dummy-rails-3/db/migrate/20140425182847_add_field_to_base_class.rb
 - spec/dummy-rails-3/db/schema.rb
 - spec/dummy-rails-3/lib/assets/.gitkeep
 - spec/dummy-rails-3/log/.gitkeep
@@ -215,7 +223,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1297181597632204944
+      hash: 1166807647709519992
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -224,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1297181597632204944
+      hash: 1166807647709519992
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25