globe-composite_primary_keys 3.0.1

data/lib/composite_primary_keys/finder_methods.rb

@@ -0,0 +1,68 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module FinderMethods
+      module InstanceMethods
+        def exists?(id = nil)
+          case id
+          when Array
+            # CPK
+            if id.first.is_a?(String) and id.first.match(/\?/)
+              where(id).exists?
+            else
+              where(ids_predicate(id)).exists?
+            end
+          when Hash
+            where(id).exists?
+          else
+            relation = select(primary_key).limit(1)
+            # CPK
+            #relation = relation.where(primary_key.eq(id)) if id
+            relation = relation.where(ids_predicate(id)) if id
+            relation.first ? true : false
+          end
+        end
+
+        def find_with_ids(*ids, &block)
+          return to_a.find(&block) if block_given?
+
+          ids.pop if ids.last.nil?
+
+          # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
+          # if ids is list of lists, then each inner list must follow rule above
+          if ids.first.is_a? String
+            # find '2,1' -> ids = ['2,1']
+            # find '2,1;7,3' -> ids = ['2,1;7,3']
+            match = ids.first.match(/^\[(.*)\]$/)
+            ids = (match ? match[1] : ids.first).split(ID_SET_SEP).map {|id_set| id_set.split(CompositePrimaryKeys::ID_SEP).to_composite_ids}
+            # find '2,1;7,3' -> ids = [['2','1'],['7','3']], inner [] are CompositeIds
+          end
+
+          ids = [ids.to_composite_ids] if not ids.first.kind_of?(Array)
+          ids.each do |id_set|
+            unless id_set.is_a?(Array)
+              raise "Ids must be in an Array, instead received: #{id_set.inspect}"
+            end
+            unless id_set.length == @klass.primary_keys.length
+              raise "#{id_set.inspect}: Incorrect number of primary keys for #{class_name}: #{primary_keys.inspect}"
+            end
+          end
+
+          new_relation = clone
+          ids.each do |id_set|
+            [@klass.primary_keys, id_set].transpose.map do |key, id|
+              new_relation = new_relation.where(key => id)
+            end
+          end
+
+          result = new_relation.to_a
+
+          if result.size == ids.size
+            ids.size == 1 ? result[0] : result
+          else
+            raise ::ActiveRecord::RecordNotFound, "Couldn't find all #{@klass.name} with IDs (#{ids.inspect})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/fixtures.rb

@@ -0,0 +1,8 @@
+class Fixture #:nodoc:
+  def [](key)
+    if key.is_a? Array
+      return key.map { |a_key| self[a_key.to_s] }.to_composite_ids
+    end
+    @fixture[key]
+  end
+end

data/lib/composite_primary_keys/read.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module AttributeMethods
+    module Read
+      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?)
+        if !(value = @attributes[attr_name]).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
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/reflection.rb

@@ -0,0 +1,39 @@
+module ActiveRecord
+  module Reflection
+    class AssociationReflection
+      def derive_primary_key
+        result = if options[:foreign_key]
+          options[:foreign_key]
+        elsif belongs_to?
+          #CPK
+          #"#{name}_id"
+          class_name.foreign_key
+        elsif options[:as]
+          options[:as]
+        else
+          active_record.name.foreign_key
+        end
+      end
+
+      def cpk_primary_key
+        # Make sure the returned key(s) are an array
+        @cpk_primary_key ||= [derive_primary_key].flatten
+      end
+
+      def primary_key_name
+        @primary_key_name ||= derive_primary_key_name
+      end
+
+      def derive_primary_key_name
+        result = derive_primary_key
+
+        # CPK
+        if result.is_a?(Array)
+          result.to_composite_keys.to_s
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation.rb

@@ -0,0 +1,31 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module Relation
+      module InstanceMethods
+        def ids_predicate(id)
+          predicate = nil
+          self.primary_key.zip(id).each do |key, value|
+            eq = key.eq(value)
+            predicate = predicate ? predicate.and(eq) : eq
+          end
+          predicate
+        end
+
+        def delete(id_or_array)
+          # CPK
+          # where(@klass.primary_key => id_or_array).delete_all
+          where(ids_predicate(id_or_array)).delete_all
+        end
+
+        def destroy(id)
+          # CPK
+          #if id.is_a?(Array)
+          #  id.map { |one_id| destroy(one_id) }
+          #else
+            find(id).destroy
+          #end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/through_association_scope.rb

@@ -0,0 +1,212 @@
+module ActiveRecord
+  module Associations
+    module ThroughAssociationScope
+      def composite_join_clause(table1, keys1, table2, keys2)
+        predicates = composite_join_predicates(table1, keys1, table2, keys2)
+
+        join_clause = predicates.map do |predicate|
+          predicate.to_sql
+        end.join(" AND ")
+
+        "(#{join_clause})"
+      end
+
+      def composite_join_predicates(table1, keys1, table2, keys2)
+        attributes1 = [keys1].flatten.map do |key|
+          table1[key]
+        end
+
+        attributes2 = [keys2].flatten.map do |key|
+          table2[key]
+        end
+
+        [attributes1, attributes2].transpose.map do |attribute1, attribute2|
+          attribute1.eq(attribute2)
+        end
+      end
+
+      def composite_ids_hash(keys, ids)
+        [keys].flatten.zip([ids].flatten).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
+        end
+      end
+      
+      def construct_quoted_owner_attributes(reflection)
+        if as = reflection.options[:as]
+          { "#{as}_id" => owner_quoted_id,
+            "#{as}_type" => reflection.klass.quote_value(
+              @owner.class.base_class.name.to_s,
+              reflection.klass.columns_hash["#{as}_type"]) }
+        elsif reflection.macro == :belongs_to
+          # CPK
+          # { reflection.klass.primary_key => @owner[reflection.primary_key_name] }
+          composite_ids_hash(reflection.klass.primary_key, @owner.quoted_id)
+        else
+          # CPK
+         #{ reflection.primary_key_name => owner_quoted_id }
+          composite_ids_hash(reflection.cpk_primary_key, @owner.quoted_id)
+        end
+      end
+
+      # Construct attributes for associate pointing to owner.
+      def construct_owner_attributes(reflection)
+        if as = reflection.options[:as]
+          { "#{as}_id" => @owner.id,
+            "#{as}_type" => @owner.class.base_class.name.to_s }
+        else
+          # CPK
+          # { reflection.primary_key_name => @owner.id }
+          composite_ids_hash(reflection.cpk_primary_key, @owner.id)
+        end
+      end
+
+      def construct_joins(custom_joins = nil)
+        polymorphic_join = nil
+        if @reflection.source_reflection.macro == :belongs_to
+          reflection_primary_key = @reflection.klass.primary_key
+          source_primary_key     = @reflection.source_reflection.cpk_primary_key
+          if @reflection.options[:source_type]
+            polymorphic_join = "AND %s.%s = %s" % [
+              @reflection.through_reflection.quoted_table_name, "#{@reflection.source_reflection.options[:foreign_type]}",
+              @owner.class.quote_value(@reflection.options[:source_type])
+            ]
+          end
+        else
+          reflection_primary_key = @reflection.source_reflection.cpk_primary_key
+          source_primary_key     = @reflection.through_reflection.klass.primary_key
+          if @reflection.source_reflection.options[:as]
+            polymorphic_join = "AND %s.%s = %s" % [
+              @reflection.quoted_table_name, "#{@reflection.source_reflection.options[:as]}_type",
+              @owner.class.quote_value(@reflection.through_reflection.klass.name)
+            ]
+          end
+        end
+
+        # CPK
+        # "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
+        #   @reflection.through_reflection.quoted_table_name,
+        #   @reflection.quoted_table_name, reflection_primary_key,
+        #   @reflection.through_reflection.quoted_table_name, source_primary_key,
+        #   polymorphic_join
+        # ]
+
+        "INNER JOIN %s ON %s %s #{@reflection.options[:joins]} #{custom_joins}" % [
+            @reflection.through_reflection.quoted_table_name,
+            composite_join_clause(@reflection.klass.arel_table, reflection_primary_key,
+                                  @reflection.through_reflection.klass.arel_table, source_primary_key),
+            polymorphic_join
+          ]
+      end
+    end
+
+    module ClassMethods
+      class JoinAssociation
+        # Ugly to include this twice, but I couldn't figure out how to make this
+        # work via a module
+        def composite_join_predicates(table1, keys1, table2, keys2)
+          attributes1 = [keys1].flatten.map do |key|
+            table1[key]
+          end
+
+          attributes2 = [keys2].flatten.map do |key|
+            table2[key]
+          end
+
+          [attributes1, attributes2].transpose.map do |attribute1, attribute2|
+            attribute1.eq(attribute2)
+          end
+        end
+        
+        def association_join
+          return @join if @join
+
+          aliased_table = Arel::Table.new(table_name, :as => @aliased_table_name, :engine => arel_engine)
+          parent_table = Arel::Table.new(parent.table_name, :as => parent.aliased_table_name, :engine => arel_engine)
+
+          @join = case reflection.macro
+          when :has_and_belongs_to_many
+            join_table = Arel::Table.new(options[:join_table], :as => aliased_join_table_name, :engine => arel_engine)
+            fk = options[:foreign_key] || reflection.active_record.to_s.foreign_key
+            klass_fk = options[:association_foreign_key] || klass.to_s.foreign_key
+
+            [
+              join_table[fk].eq(parent_table[reflection.active_record.primary_key]),
+              aliased_table[klass.primary_key].eq(join_table[klass_fk])
+            ]
+          when :has_many, :has_one
+            if reflection.options[:through]
+              join_table = Arel::Table.new(through_reflection.klass.table_name, :as => aliased_join_table_name, :engine => arel_engine)
+              jt_foreign_key = jt_as_extra = jt_source_extra = jt_sti_extra = nil
+              first_key = second_key = as_extra = nil
+
+              if through_reflection.options[:as] # has_many :through against a polymorphic join
+                jt_foreign_key = through_reflection.options[:as].to_s + '_id'
+                jt_as_extra = join_table[through_reflection.options[:as].to_s + '_type'].eq(parent.active_record.base_class.name)
+              else
+                jt_foreign_key = through_reflection.primary_key_name
+              end
+
+              case source_reflection.macro
+              when :has_many
+                if source_reflection.options[:as]
+                  first_key   = "#{source_reflection.options[:as]}_id"
+                  second_key  = options[:foreign_key] || primary_key
+                  as_extra    = aliased_table["#{source_reflection.options[:as]}_type"].eq(source_reflection.active_record.base_class.name)
+                else
+                  first_key   = through_reflection.klass.base_class.to_s.foreign_key
+                  second_key  = options[:foreign_key] || primary_key
+                end
+
+                unless through_reflection.klass.descends_from_active_record?
+                  jt_sti_extra = join_table[through_reflection.active_record.inheritance_column].eq(through_reflection.klass.sti_name)
+                end
+              when :belongs_to
+                first_key = primary_key
+                if reflection.options[:source_type]
+                  second_key = source_reflection.association_foreign_key
+                  jt_source_extra = join_table[reflection.source_reflection.options[:foreign_type]].eq(reflection.options[:source_type])
+                else
+                  second_key = source_reflection.primary_key_name
+                end
+              end
+
+              [
+                [parent_table[parent.primary_key].eq(join_table[jt_foreign_key]), jt_as_extra, jt_source_extra, jt_sti_extra].reject{|x| x.blank? },
+                aliased_table[first_key].eq(join_table[second_key])
+              ]
+            elsif reflection.options[:as]
+              id_rel = aliased_table["#{reflection.options[:as]}_id"].eq(parent_table[parent.primary_key])
+              type_rel = aliased_table["#{reflection.options[:as]}_type"].eq(parent.active_record.base_class.name)
+              [id_rel, type_rel]
+            else
+              foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
+              # CPK
+              # [aliased_table[foreign_key].eq(parent_table[reflection.options[:primary_key] || parent.primary_key])]
+              composite_join_predicates(aliased_table, foreign_key,
+                                        parent_table, reflection.options[:primary_key] || parent.primary_key)
+            end
+          when :belongs_to
+            [aliased_table[options[:primary_key] || reflection.klass.primary_key].eq(parent_table[options[:foreign_key] || reflection.cpk_primary_key])]
+          end
+
+          unless klass.descends_from_active_record?
+            sti_column = aliased_table[klass.inheritance_column]
+            sti_condition = sti_column.eq(klass.sti_name)
+            klass.send(:subclasses).each {|subclass| sti_condition = sti_condition.or(sti_column.eq(subclass.sti_name)) }
+
+            @join << sti_condition
+          end
+
+          [through_reflection, reflection].each do |ref|
+            if ref && ref.options[:conditions]
+              @join << interpolate_sql(sanitize_sql(ref.options[:conditions], aliased_table_name))
+            end
+          end
+
+          @join
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -0,0 +1,118 @@
+module ActiveRecord
+  module Validations
+    class UniquenessValidator
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        table = finder_class.unscoped
+
+        table_name   = record.class.quoted_table_name
+        sql, params  = mount_sql_and_params(finder_class, table_name, attribute, value)
+
+        relation = table.where(sql, *params)
+
+        Array.wrap(options[:scope]).each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.where(scope_item => scope_value)
+        end
+
+        unless record.new_record?
+          # CPK
+          # TODO : This should be in Arel
+          #relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
+          if record.composite?
+            predicate = nil
+            record.ids_hash.each do |key, value|
+              neq = relation.table[key].not_eq(value)
+              predicate = predicate ? predicate.and(neq) : neq
+            end
+            relation = relation.where(predicate)
+          else
+            relation = relation.where("#{record.class.quoted_table_name}.#{record.class.primary_key} <> ?", record.send(:id))
+          end
+        end
+
+        if relation.first
+          record.errors.add(attribute, :taken, :default => options[:message], :value => value)
+        end
+      end
+    end
+  end
+end
+
+#module CompositePrimaryKeys
+#  module ActiveRecord
+#    module Validations
+#      module Uniqueness
+#        module ClassMethods
+#          def validates_uniqueness_of(*attr_names)
+#            configuration = { :case_sensitive => true }
+#            configuration.update(attr_names.extract_options!)
+#
+#            validates_each(attr_names,configuration) do |record, attr_name, value|
+#              # The check for an existing value should be run from a class that
+#              # isn't abstract. This means working down from the current class
+#              # (self), to the first non-abstract class. Since classes don't know
+#              # their subclasses, we have to build the hierarchy between self and
+#              # the record's class.
+#              class_hierarchy = [record.class]
+#              while class_hierarchy.first != self
+#                class_hierarchy.insert(0, class_hierarchy.first.superclass)
+#              end
+#
+#              # Now we can work our way down the tree to the first non-abstract
+#              # class (which has a database table to query from).
+#              finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
+#
+#              column = finder_class.columns_hash[attr_name.to_s]
+#
+#              if value.nil?
+#                comparison_operator = "IS ?"
+#              elsif column.text?
+#                comparison_operator = "#{connection.case_sensitive_equality_operator} ?"
+#                value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
+#              else
+#                comparison_operator = "= ?"
+#              end
+#
+#              sql_attribute = "#{record.class.quoted_table_name}.#{connection.quote_column_name(attr_name)}"
+#
+#              if value.nil? || (configuration[:case_sensitive] || !column.text?)
+#                condition_sql = "#{sql_attribute} #{comparison_operator}"
+#                condition_params = [value]
+#              else
+#                condition_sql = "LOWER(#{sql_attribute}) #{comparison_operator}"
+#                condition_params = [value.mb_chars.downcase]
+#              end
+#
+#              if scope = configuration[:scope]
+#                Array(scope).map do |scope_item|
+#                  scope_value = record.send(scope_item)
+#                  condition_sql << " AND " << attribute_condition("#{record.class.quoted_table_name}.#{scope_item}", scope_value)
+#                  condition_params << scope_value
+#                end
+#              end
+#
+#              unless record.new_record?
+#                if record.class.composite?
+#                  record.class.primary_keys.each do |key|
+#                    condition_sql << " AND #{record.class.quoted_table_name}.#{key} <> ?"
+#                    condition_params << record.send(key)
+#                  end
+#                else
+#                  condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
+#                  condition_params << record.send(:id)
+#                end
+#              end
+#
+#              finder_class.with_exclusive_scope do
+#                if finder_class.exists?([condition_sql, *condition_params])
+#                  record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
+#                end
+#              end
+#            end
+#          end
+#        end
+#      end
+#    end
+#  end
+#end