composite_primary_keys 3.1.11 → 4.0.0.beta1

data/lib/composite_primary_keys/attribute_methods.rb

@@ -1,84 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module AttributeMethods #:nodoc:
-      def self.append_features(base)
-        super
-        base.send(:extend, ClassMethods)
-      end
-
-      module ClassMethods
-        # Define an attribute reader method.  Cope with nil column.
-        def define_read_method(symbol, attr_name, column)
-          cast_code = column.type_cast_code('v') if column
-          cast_code = "::#{cast_code}" if cast_code && cast_code.match('ActiveRecord::.*')
-          access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
-
-          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
-
-          evaluate_attribute_method attr_name, "def #{symbol}; #{access_code}; end"
-        end
-
-        # Evaluate the definition for an attribute related method
-        def evaluate_attribute_method(attr_name, method_definition, method_name=attr_name)
-          unless primary_keys.include?(method_name.to_sym)
-            generated_methods << method_name
-          end
-
-          begin
-            class_eval(method_definition, __FILE__, __LINE__)
-          rescue SyntaxError => err
-            generated_methods.delete(attr_name)
-            if logger
-              logger.warn "Exception occurred during reader method compilation."
-              logger.warn "Maybe #{attr_name} is not a valid Ruby identifier?"
-              logger.warn "#{err.message}"
-            end
-          end
-        end
-      end
-
-      # Allows access to the object attributes, which are held in the @attributes hash, as though they
-      # were first-class methods. So a Person class with a name attribute can use Person#name and
-      # Person#name= and never directly use the attributes hash -- except for multiple assigns with
-      # ActiveRecord#attributes=. A Milestone class can also ask Milestone#completed? to test that
-      # the completed attribute is not nil or 0.
-      #
-      # It's also possible to instantiate related objects, so a Client class belonging to the clients
-      # table with a master_id foreign key can instantiate master through Client#master.
-      def method_missing(method_id, *args, &block)
-        method_name = method_id.to_s
-
-        # If we haven't generated any methods yet, generate them, then
-        # see if we've created the method we're looking for.
-        if !self.class.generated_methods?
-          self.class.define_attribute_methods
-
-          if self.class.generated_methods.include?(method_name)
-            return self.send(method_id, *args, &block)
-          end
-        end
-
-        if self.class.primary_keys.include?(method_name.to_sym)
-          ids[self.class.primary_keys.index(method_name.to_sym)]
-        elsif md = self.class.match_attribute_method?(method_name)
-          attribute_name, method_type = md.pre_match, md.to_s
-          if @attributes.include?(attribute_name)
-            __send__("attribute#{method_type}", attribute_name, *args, &block)
-          else
-            super
-          end
-        elsif @attributes.include?(method_name)
-          read_attribute(method_name)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/calculations.rb

@@ -1,31 +0,0 @@
-module ActiveRecord
-  module Calculations
-    alias :execute_simple_calculation_ar :execute_simple_calculation
-    def execute_simple_calculation(operation, column_name, distinct)
-      # CPK
-      if column_name.kind_of?(Array)
-        execute_simple_calculation_cpk(operation, column_name, distinct)
-      else
-        execute_simple_calculation_ar(operation, column_name, distinct)
-      end
-    end
-
-    def execute_simple_calculation_cpk(operation, column_name, distinct)
-      projection = self.primary_keys.map do |key|
-        attribute = arel_table[key]
-        self.arel.visitor.accept(attribute)
-      end.join(', ')
-
-     # relation = self.clone
-     # relation.select_values = ["DISTINCT #{projection}"]
-
-      manager = Arel::SelectManager.new(arel_engine)
-      manager.project("DISTINCT #{projection}")
-      manager.from(arel_table)
-      
-      query = Arel::Table.new('dummy').project('count(*)')
-      query = query.from("(#{manager.to_sql}) AS subquery")
-      type_cast_calculated_value(@klass.connection.select_value(query.to_sql), column_for(column_name), operation)
-    end
-  end
-end

data/lib/composite_primary_keys/connection_adapters/ibm_db_adapter.rb

@@ -1,21 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class IBM_DBAdapter < AbstractAdapter
-      
-      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
-      def supports_count_distinct? #:nodoc:
-        false
-      end
-      
-      alias_method :quote_original, :quote
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && [:integer, :float].include?(column.type)
-              value = column.type == :integer ? value.to_i : value.to_f
-              value.to_s
-        else
-            quote_original(value, column)
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/connection_adapters/oracle_adapter.rb

@@ -1,15 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class OracleAdapter < AbstractAdapter
-      
-      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
-      def supports_count_distinct? #:nodoc:
-        false
-      end
-      
-      def concat(*columns)
-        "(#{columns.join('||')})"
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/connection_adapters/oracle_enhanced_adapter.rb

@@ -1,17 +0,0 @@
-# Added to OracleEnhancedAdapter version 1.1.4
-# 
-# module ActiveRecord
-#   module ConnectionAdapters
-#     class OracleEnhancedAdapter < AbstractAdapter
-#       
-#       # This mightn't be in Core, but count(distinct x,y) doesn't work for me
-#       def supports_count_distinct? #:nodoc:
-#         false
-#       end
-#       
-#       def concat(*columns)
-#         "(#{columns.join('||')})"
-#       end
-#     end
-#   end
-# end

data/lib/composite_primary_keys/connection_adapters/sqlite3_adapter.rb

@@ -1,15 +0,0 @@
-require 'active_record/connection_adapters/sqlite3_adapter'
-
-module ActiveRecord
-  module ConnectionAdapters #:nodoc:
-    class SQLite3Adapter # :nodoc:
-      def supports_count_distinct? #:nodoc:
-        false
-      end
-      
-      def concat(*columns)
-        "(#{columns.join('||')})"
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/finder_methods.rb

@@ -1,123 +0,0 @@
-module CompositePrimaryKeys
-  module ActiveRecord
-    module FinderMethods
-      module InstanceMethods
-        def construct_limited_ids_condition(relation)
-          orders = relation.order_values.join(", ")
-
-          # CPK
-          # values = @klass.connection.distinct("#{@klass.connection.quote_table_name @klass.table_name}.#{@klass.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)
-
-          ids_array = relation.select(values).collect {|row| row[@klass.primary_key]}
-
-          # CPK
-          # ids_array.empty? ? raise(ThrowResult) : 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
-
-            # Merge all the ands together
-            first = and_expressions.shift
-            Arel::Nodes::Grouping.new(and_expressions.inject(first) do |memo, expr|
-                Arel::Nodes::And.new(memo, expr)
-            end)
-          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
-
-          case id
-          # CPK
-          when CompositePrimaryKeys::CompositeKeys
-            relation = select("1").limit(1)
-            relation = relation.where_cpk_id(id) if id
-            relation.first ? true : false
-          when Array
-            # CPK
-            if id.first.is_a?(String) and id.first.match(/\?/)
-              where(id).exists?
-            else
-              exists?(id.to_composite_keys)
-            end
-          when Hash
-            where(id).exists?
-          else
-            # CPK
-            #relation = select(primary_key).limit(1)
-            #relation = relation.where(primary_key.eq(id)) if id
-            relation = select("1").limit(1)
-            relation = relation.where_cpk_id(id) if id
-            relation.first ? true : false
-          end
-        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
-end

data/lib/composite_primary_keys/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/query_methods.rb

@@ -1,24 +0,0 @@
-module ActiveRecord
-  module QueryMethods
-    def reverse_order
-      order_clause = arel.order_clauses.join(', ')
-      relation = except(:order)
-
-      # CPK
-      # order = order_clause.blank? ?
-      #  "#{@klass.table_name}.#{@klass.primary_key} DESC" :
-      #  reverse_sql_order(order_clause)
-
-      order = unless order_clause.blank?
-        reverse_sql_order(order_clause)
-      else
-        primary_keys = composite? ? @klass.primary_keys : [@klass.primary_key]
-        primary_keys.map do |key|
-          "#{@klass.table_name}.#{key} DESC"
-        end.join(", ")
-      end
-
-      relation.order Arel::SqlLiteral.new order
-    end
-  end
-end

data/lib/composite_primary_keys/read.rb

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

@@ -1,37 +0,0 @@
-module ActiveRecord
-  module Reflection
-    class AssociationReflection
-      def derive_primary_key
-        if options[:foreign_key]
-          options[:foreign_key]
-        elsif belongs_to?
-          "#{name}_id"
-        elsif options[:as]
-          "#{options[:as]}_id"
-        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/write.rb

@@ -1,18 +0,0 @@
-module ActiveRecord
-  module AttributeMethods
-    module Write
-      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