composite_primary_keys 3.1.8 → 3.1.9

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

@@ -1,13 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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/primary_key.rb

@@ -1,19 +0,0 @@
-module ActiveRecord
-  module AttributeMethods #:nodoc:
-    module PrimaryKey
-      def to_key
-        # CPK
-        #key = send(self.class.primary_key)
-        #[key] if key
-
-        primary_key = self.class.primary_key
-        if primary_key.is_a?(Array)
-          primary_key.collect{|k| send(k)}
-        else
-          key = send(primary_key)
-          [key] if key
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -1,88 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module AttributeMethods
-      module Read
-        def self.included(base)
-          base.send(:extend, ClassMethods)
-          alias [] read_attribute
-        end
-
-        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
-            unless self.primary_keys.include?(attr_name.to_sym)
-              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
-end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -1,40 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module AttributeMethods
-      module Write
-        def self.included(base)
-          alias []= write_attribute
-          alias_method :raw_write_attribute, :write_attribute
-        end
-
-        def write_attribute(attr_name, value)
-          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
-            _write_attribute(attr_name, value)
-          end
-        end
-        
-        def _write_attribute(attr_name, value)
-          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

data/lib/composite_primary_keys/composite_predicates.rb

@@ -1,44 +0,0 @@
-module CompositePrimaryKeys
-  module Predicates
-    def cpk_or_predicate(predicates)
-      result = predicates.shift
-      predicates.each do |predicate|
-        result = result.or(predicate)
-      end
-      result
-    end
-
-    def cpk_id_predicate(table, keys, values)
-      eq_predicates = keys.zip(values).map do |key, value|
-        table[key].eq(value)
-      end
-      Arel::Nodes::And.new(eq_predicates)
-    end
-
-    def cpk_join_predicate(table1, key1, table2, key2)
-      key1_fields = Array(key1).map {|key| table1[key]}
-      key2_fields = Array(key2).map {|key| table2[key]}
-
-      predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
-        key_field1.eq(key_field2)
-      end
-      Arel::Nodes::And.new(predicates)
-    end
-
-    def cpk_in_predicate(table, primary_keys, ids)
-      and_predicates = ids.map do |id_set|
-        eq_predicates = Array(primary_keys).zip(id_set).map do |primary_key, value|
-          table[primary_key].eq(value)
-        end
-        Arel::Nodes::And.new(eq_predicates)
-      end
-
-      cpk_or_predicate(and_predicates)
-    end
-  end
-end
-
-ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)

data/lib/composite_primary_keys/named_scope.rb

@@ -1,29 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module NamedScope
-      module ClassMethods
-        def scoped(options = nil)
-          result = if options
-            scoped.apply_finder_options(options)
-          else
-            if current_scope
-              current_scope.clone
-            else
-              scope = relation.clone
-              scope.default_scoped = true
-              scope
-            end
-          end
-
-          # CPK
-          class << result
-            include CompositePrimaryKeys::ActiveRecord::FinderMethods
-            include CompositePrimaryKeys::ActiveRecord::QueryMethods
-            include CompositePrimaryKeys::ActiveRecord::Relation
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -1,119 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module FinderMethods
-      def construct_limited_ids_condition(relation)
-        orders = relation.order_values
-        # CPK
-        # values = @klass.connection.distinct("#{@klass.connection.quote_table_name table_name}.#{primary_key}", orders)
-        keys = @klass.primary_keys.map do |key|
-          "#{@klass.connection.quote_table_name @klass.table_name}.#{key}"
-        end
-        values = @klass.connection.distinct(keys.join(', '), orders)
-
-        relation = relation.dup
-
-        ids_array = relation.select(values).collect {|row| row[primary_key]}
-        # CPK
-        # ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
-
-        # OR together each and expression (key=value and key=value) that matches an id set
-        # since we only need to match 0 or more records
-        or_expressions = ids_array.map do |id_set|
-          # AND together "key=value" exprssios to match each id set
-          and_expressions = [self.primary_keys, id_set].transpose.map do |key, id|
-            table[key].eq(id)
-          end
-          Arel::Nodes::And.new(and_expressions)
-        end
-
-        first = or_expressions.shift
-        Arel::Nodes::Grouping.new(or_expressions.inject(first) do |memo, expr|
-            Arel::Nodes::Or.new(memo, expr)
-        end)
-      end
-
-      def exists?(id = nil)
-        # ID can be:
-        #   Array - ['department_id = ? and location_id = ?', 1, 1]
-        #   Array -> [1,2]
-        #   CompositeKeys -> [1,2]
-
-        id = id.id if ::ActiveRecord::Base === id
-
-        join_dependency = construct_join_dependency_for_association_find
-        relation = construct_relation_for_association_find(join_dependency)
-        relation = relation.except(:select).select("1").limit(1)
-
-        # CPK
-        #case id
-        #when Array, Hash
-        #  relation = relation.where(id)
-        #else
-        #  relation = relation.where(table[primary_key].eq(id)) if id
-        #end
-
-        case id
-        when CompositePrimaryKeys::CompositeKeys
-          relation = relation.where(cpk_id_predicate(table, primary_key, id))
-        when Array
-          if !id.first.kind_of?(String)
-            return self.exists?(id.to_composite_keys)
-          else
-            relation = relation.where(id)
-          end
-        when Hash
-          relation = relation.where(id)
-        else
-          raise(ArgumentError, "Unsupported id sent to exists?")
-        end
-        connection.select_value(relation.to_sql) ? true : false
-      end
-
-      def find_with_ids(*ids, &block)
-        return to_a.find { |*block_args| yield(*block_args) } if block_given?
-
-        # Supports:
-        #   find('1,2')             ->  ['1,2']
-        #   find(1,2)               ->  [1,2]
-        #   find([1,2])             -> [['1,2']]
-        #   find([1,2], [3,4])      -> [[1,2],[3,4]]
-        #
-        # Does *not* support:
-        #   find('1,2', '3,4')      ->  ['1,2','3,4']
-
-        # Normalize incoming data.  Note the last arg can be nil.  Happens
-        # when find is called with nil options like the reload method does.
-        ids.compact!
-        ids = [ids] unless ids.first.kind_of?(Array)
-
-        results = ids.map do |cpk_ids|
-          cpk_ids = if cpk_ids.length == 1
-            cpk_ids.first.split(CompositePrimaryKeys::ID_SEP).to_composite_keys
-          else
-            cpk_ids.to_composite_keys
-          end
-
-          unless cpk_ids.length == @klass.primary_keys.length
-            raise "#{cpk_ids.inspect}: Incorrect number of primary keys for #{@klass.name}: #{@klass.primary_keys.inspect}"
-          end
-
-          new_relation = clone
-          [@klass.primary_keys, cpk_ids].transpose.map do |key, id|
-            new_relation = new_relation.where(key => id)
-          end
-
-          records = new_relation.to_a
-
-          if records.empty?
-            conditions = new_relation.arel.where_sql
-            raise(::ActiveRecord::RecordNotFound,
-                  "Couldn't find #{@klass.name} with ID=#{cpk_ids} #{conditions}")
-          end
-          records
-        end.flatten
-
-        ids.length == 1 ? results.first : results
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/relation/query_methods.rb

@@ -1,24 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module QueryMethods
-      def reverse_order
-        order_clause = arel.order_clauses
-
-        # CPK
-        # order = order_clause.empty? ?
-        #  "#{table_name}.#{primary_key} DESC" :
-        #  reverse_sql_order(order_clause).join(', ')
-
-        order = unless order_clause.empty?
-          reverse_sql_order(order_clause).join(', ')
-        else
-          klass.primary_key.map do |key|
-            "#{table_name}.#{key} DESC"
-          end.join(", ")
-        end
-
-        except(:order).order(Arel.sql(order))
-      end
-    end
-  end
-end

data/test/fixtures/article_group.rb

@@ -1,4 +0,0 @@
-class ArticleGroup < ActiveRecord::Base
-  belongs_to :article
-  belongs_to :group
-end

data/test/fixtures/article_groups.yml

@@ -1,7 +0,0 @@
-cpk:
-  article_id: 1
-  group_id: 1
-
-transformers:
-  article_id: 1
-  group_id: 2