composite_primary_keys 3.1.11 → 4.0.0.beta1

data/lib/composite_primary_keys/associations/join_dependency/join_association.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+          # CPK
+          # constraint = table[key].eq(foreign_table[foreign_key])
+          constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+
+          if reflection.klass.finder_needs_type_condition?
+            constraint = table.create_and([
+              constraint,
+              reflection.klass.send(:type_condition, table)
+            ])
+          end
+
+          constraint
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/join_dependency/join_part.rb

@@ -0,0 +1,39 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinPart
+        def aliased_primary_key
+          # CPK
+          # "#{aliased_prefix}_r0"
+
+          active_record.composite? ?
+            primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
+            "#{ aliased_prefix }_r0"
+        end
+
+        def record_id(row)
+          # CPK
+          # row[aliased_primary_key]
+          active_record.composite? ?
+            aliased_primary_key.map {|key| row[key]}.to_composite_keys :
+            row[aliased_primary_key]
+        end
+
+        def column_names_with_alias
+          unless @column_names_with_alias
+            @column_names_with_alias = []
+
+            # CPK
+            #([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+            keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
+
+            (keys + (column_names - keys)).each_with_index do |column_name, i|
+              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
+            end
+          end
+          @column_names_with_alias
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -0,0 +1,61 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association
+        def records_for(ids)
+          # CPK
+          # scoped.where(association_key.in(ids))
+          predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
+          scoped.where(predicate)
+        end
+        
+        def associated_records_by_owner
+          # CPK
+          # owner_keys = owners.map { |owner| owner[owner_key_name] }.compact.uniq
+          owner_keys = owners.map do |owner|
+            Array(owner_key_name).map do |owner_key|
+              owner[owner_key]
+            end
+          end.compact.uniq
+
+          if klass.nil? || owner_keys.empty?
+            records = []
+          else
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
+            records = sliced.map { |slice| records_for(slice) }.flatten
+          end
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = Hash[owners.map { |owner| [owner, []] }]
+          records.each do |record|
+            # CPK
+            # owner_key = record[association_key_name].to_s
+            owner_key = Array(association_key_name).map do |key_name|
+              record[key_name]
+            end.join(CompositePrimaryKeys::ID_SEP)
+
+            owners_by_key[owner_key].each do |owner|
+              records_by_owner[owner] << record
+            end
+          end
+          records_by_owner
+        end
+
+        def owners_by_key
+          @owners_by_key ||= owners.group_by do |owner|
+            # CPK
+            # key = owner[owner_key_name]
+            key = Array(owner_key_name).map do |key_name|
+              owner[key_name]
+            end
+            # CPK
+            # key && key.to_s
+            key && key.join(CompositePrimaryKeys::ID_SEP)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/belongs_to.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo
+        def records_for(ids)
+          # CPK
+          predicate = cpk_in_predicate(table, association_key_name, ids)
+          scoped.where(predicate)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/has_and_belongs_to_many.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasAndBelongsToMany
+        def records_for(ids)
+          # CPK
+          #scope = super
+          predicate = cpk_in_predicate(join_table, reflection.foreign_key, ids)
+          scope = scoped.where(predicate)
+
+          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
+        end
+
+        def join
+          # CPK
+          #condition = table[reflection.association_primary_key].eq(
+           # join_table[reflection.association_foreign_key])
+          condition = cpk_join_predicate(table, reflection.association_primary_key,
+                                         join_table, reflection.association_foreign_key)
+
+          table.create_join(join_table, table.create_on(condition))
+        end
+
+        def association_key_alias(field)
+          "ar_association_key_name_#{field.to_s}"
+        end
+
+        def join_select
+          # CPK
+          # association_key.as(Arel.sql(association_key_name))
+          Array(reflection.foreign_key).map do |key|
+            join_table[key].as(Arel.sql(association_key_alias(key)))
+          end
+        end
+
+        def association_key_name
+          # CPK
+          # 'ar_association_key_name'
+          Array(reflection.foreign_key).map do |key|
+            association_key_alias(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/dirty.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module AttributeMethods
+    module Dirty
+      def write_attribute(attr, value)
+        # CPK
+        # attr = attr.to_s
+        attr = attr.to_s unless self.composite?
+
+        # The attribute already has an unsaved change.
+        if attribute_changed?(attr)
+          old = @changed_attributes[attr]
+          @changed_attributes.delete(attr) unless field_changed?(attr, old, value)
+        else
+          old = clone_attribute_value(:read_attribute, attr)
+          # Save Time objects as TimeWithZone if time_zone_aware_attributes == true
+          old = old.in_time_zone if clone_with_time_zone_conversion_attribute?(attr, old)
+          @changed_attributes[attr] = old if field_changed?(attr, old, value)
+        end
+
+        # Carry on.
+        super(attr, value)
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  alias :[]= :write_attribute
+  public :[]=
+end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      module ClassMethods
+        def define_read_method(method_name, attr_name, column)
+          cast_code = column.type_cast_code('v')
+          # CPK - this is a really horrid hack, needed to get
+          # right class namespace :(
+          if cast_code.match(/^ActiveRecord/)
+            cast_code = "::#{cast_code}"
+          end
+
+          access_code = "(v=@attributes['#{attr_name}']) && #{cast_code}"
+
+          # CPK
+          # unless attr_name.to_s == self.primary_key.to_s
+          #   access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+          # end
+          primary_keys = Array(self.primary_key)
+
+          unless primary_keys.include?(attr_name.to_s)
+            access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+          end
+
+          if cache_attribute?(attr_name)
+            access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
+          end
+
+          # Where possible, generate the method by evalling a string, as this will result in
+          # faster accesses because it avoids the block eval and then string eval incurred
+          # by the second branch.
+          #
+          # The second, slower, branch is necessary to support instances where the database
+          # returns columns with extra stuff in (like 'my_column(omg)').
+          if method_name =~ ActiveModel::AttributeMethods::COMPILABLE_REGEXP
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__
+              def _#{method_name}
+                #{access_code}
+              end
+
+              alias #{method_name} _#{method_name}
+            STR
+          else
+            generated_attribute_methods.module_eval do
+              define_method("_#{method_name}") { eval(access_code) }
+              alias_method(method_name, "_#{method_name}")
+            end
+          end
+        end
+      end
+
+      def read_attribute(attr_name)
+        # CPK
+        if attr_name.kind_of?(Array)
+          attr_name.map {|name| read_attribute(name)}.to_composite_keys
+        elsif respond_to? "_#{attr_name}"
+          send "_#{attr_name}" if @attributes.has_key?(attr_name.to_s)
+        else
+          _read_attribute attr_name
+        end
+      end
+
+
+      def _read_attribute(attr_name)
+        attr_name = attr_name.to_s
+        # CPK
+        # attr_name = self.class.primary_key if attr_name == 'id'
+        attr_name = self.class.primary_key if (attr_name == 'id' and !self.composite?)
+        value = @attributes[attr_name]
+        unless value.nil?
+          if column = column_for_attribute(attr_name)
+            if unserializable_attribute?(attr_name, column)
+              unserialize_attribute(attr_name)
+            else
+              column.type_cast(value)
+            end
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  alias :[] :read_attribute
+end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module AttributeMethods
+    module Write
+      def write_attribute(attr_name, value)
+        # CPK
+        if attr_name.kind_of?(Array)
+          unless value.length == attr_name.length
+            raise "Number of attr_names and values do not match"
+          end
+          [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+          value
+        else
+          attr_name = attr_name.to_s
+          # CPK
+          # attr_name = self.class.primary_key if attr_name == 'id'
+          attr_name = self.class.primary_key if (attr_name == 'id' and !self.composite?)
+          @attributes_cache.delete(attr_name)
+          if (column = column_for_attribute(attr_name)) && column.number?
+            @attributes[attr_name] = convert_number_column_value(value)
+          else
+            @attributes[attr_name] = value
+          end
+        end
+      end
+    end
+  end
+end
+
+#ActiveRecord::Base.class_eval do
+#  alias :[]= :write_attribute
+#  alias :raw_write_attribute :write_attribute
+#  public :[]=
+#end

data/lib/composite_primary_keys/base.rb

@@ -16,12 +16,11 @@ module ActiveRecord
         end
 
         cattr_accessor :primary_keys
-        self.primary_keys = keys.map { |k| k.to_sym }
+        self.primary_keys = keys.map { |k| k.to_sym }.to_composite_keys
 
         class_eval <<-EOV
-          extend CompositeClassMethods
+          extend  CompositeClassMethods
           include CompositeInstanceMethods
-          include CompositePrimaryKeys::ActiveRecord::AssociationPreload
         EOV
       end
 
@@ -34,38 +33,6 @@ module ActiveRecord
       self.class.composite?
     end
 
-    def [](attr_name)
-      # CPK
-      if attr_name.is_a?(String) and attr_name != attr_name.split(CompositePrimaryKeys::ID_SEP).first
-        attr_name = attr_name.split(CompositePrimaryKeys::ID_SEP)
-      end
-
-      # CPK
-      if attr_name.is_a?(Array)
-        values = attr_name.map {|name| read_attribute(name)}
-        CompositePrimaryKeys::CompositeKeys.new(values)
-      else
-        read_attribute(attr_name)
-      end
-    end
-
-    def []=(attr_name, value)
-      # CPK
-      if attr_name.is_a?(String) and attr_name != attr_name.split(CompositePrimaryKeys::ID_SEP).first
-        attr_name = attr_name.split(CompositePrimaryKeys::ID_SEP)
-      end
-
-      if attr_name.is_a? Array
-        unless value.length == attr_name.length
-          raise "Number of attr_names and values do not match"
-        end
-        [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
-        value
-      else
-         write_attribute(attr_name, value)
-      end
-    end
-    
     module CompositeClassMethods
       def primary_key
         primary_keys
@@ -84,20 +51,6 @@ module ActiveRecord
       def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
         many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
       end
-
-      def relation #:nodoc:
-        @relation ||= begin
-          result = Relation.new(self, arel_table)
-          # CPK
-          class << result
-            include CompositePrimaryKeys::ActiveRecord::FinderMethods::InstanceMethods
-            include CompositePrimaryKeys::ActiveRecord::Relation::InstanceMethods
-          end
-          result
-        end
-
-        finder_needs_type_condition? ? @relation.where(type_condition) : @relation
-      end
     end
 
     module CompositeInstanceMethods
@@ -143,35 +96,30 @@ module ActiveRecord
         ids.is_a?(Array) ? super(comparison_object) && ids.all? {|id| id.present?} : super(comparison_object)
       end
 
-      # Cloned objects have no id assigned and are treated as new records. Note that this is a "shallow" clone
-      # as it copies the object's attributes only, not its associations. The extent of a "deep" clone is
-      # application specific and is therefore left to the application to implement according to its need.
-      def initialize_copy(other)
-        # Think the assertion which fails if the after_initialize callback goes at the end of the method is wrong. The
-        # deleted clone method called new which therefore called the after_initialize callback. It then went on to copy
-        # over the attributes. But if it's copying the attributes afterwards then it hasn't finished initializing right?
-        # For example in the test suite the topic model's after_initialize method sets the author_email_address to
-        # test@test.com. I would have thought this would mean that all cloned models would have an author email address
-        # of test@test.com. However the test_clone test method seems to test that this is not the case. As a result the
-        # after_initialize callback has to be run *before* the copying of the atrributes rather than afterwards in order
-        # for all tests to pass. This makes no sense to me.
-        callback(:after_initialize) if respond_to_without_attributes?(:after_initialize)
+      def initialize_dup(other)
         cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
         # CPK
         #cloned_attributes.delete(self.class.primary_key)
         self.class.primary_key.each {|key| cloned_attributes.delete(key.to_s)}
 
         @attributes = cloned_attributes
-        clear_aggregation_cache
-        @attributes_cache = {}
-        @new_record = true
-        ensure_proper_type
 
-        if scope = self.class.send(:current_scoped_methods)
-          create_with = scope.scope_for_create
-          create_with.each { |att,value| self.send("#{att}=", value) } if create_with
+        _run_after_initialize_callbacks if respond_to?(:_run_after_initialize_callbacks)
+
+        @changed_attributes = {}
+        attributes_from_column_definition.each do |attr, orig_value|
+          @changed_attributes[attr] = orig_value if field_changed?(attr, orig_value, @attributes[attr])
         end
+
+        @aggregation_cache = {}
+        @association_cache = {}
+        @attributes_cache = {}
+        @new_record  = true
+
+        ensure_proper_type
+        populate_with_current_scope_attributes
+        clear_timestamp_attributes
       end
     end
   end
-end
+end