composite_primary_keys 8.1.8 → 9.0.0.beta1

data/lib/composite_primary_keys/relation/predicate_builder.rb

@@ -1,37 +1,26 @@
 module ActiveRecord
   class PredicateBuilder
-    def self.expand(klass, table, column, value)
-      queries = []
-
-      # Find the foreign key when using queries such as:
-      # Post.where(author: author)
-      #
-      # For polymorphic relationships, find the foreign key and type:
-      # PriceEstimate.where(estimate_of: treasure)
-      if klass && reflection = klass._reflect_on_association(column)
-        base_class = polymorphic_base_class_from_value(value)
-
-        if reflection.polymorphic? && base_class
-          queries << build(table[reflection.foreign_type], base_class)
-        end
-
-        column = reflection.foreign_key
+    silence_warnings do
+      def expand(column, value)
+        # Find the foreign key when using queries such as:
+        # Post.where(author: author)
+        #
+        # For polymorphic relationships, find the foreign key and type:
+        # PriceEstimate.where(estimate_of: treasure)
 
         # CPK
-        # if base_class
-        if base_class && !(Base === value && value.composite?)
-          primary_key = reflection.association_primary_key(base_class)
-          value = convert_value_to_association_ids(value, primary_key)
+        if Base === Array(value).first && Array(value).first.composite? && reflection = table.associated_with?(column)
+          columns = reflection.foreign_key
+          values = Array(value).map{|v| columns.map{|c| v.public_send(c) }}
+          cpk_predicate_builder = Class.new.extend(CompositePrimaryKeys::Predicates)
+          predicate = cpk_predicate_builder.cpk_in_predicate(table.send(:arel_table), columns, values)
+          return predicate
+        else
+          # Original code
+          value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
+          build(table.arel_attribute(column), value)
         end
       end
-
-      #CPK
-      if Base === value && value.composite?
-        queries << cpk_id_predicate(table, column, value.id)
-      else
-        queries << build(table[column], value)
-      end
-      queries
     end
   end
-end
+end

data/lib/composite_primary_keys/relation/where_clause.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  class Relation
+    class WhereClause
+      silence_warnings do
+        def to_h(table_name = nil)
+          equalities = predicates.grep(Arel::Nodes::Equality)
+
+          # CPK Adds this line, because ours are coming in with AND->{EQUALITY, EQUALITY}
+          equalities = predicates.grep(Arel::Nodes::And).map(&:children).flatten.grep(Arel::Nodes::Equality) if equalities.empty?
+
+          if table_name
+            equalities = equalities.select do |node|
+              node.left.relation.name == table_name
+            end
+          end
+
+          binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
+
+          equalities.map do |node|
+            name = node.left.name
+            [name, binds.fetch(name.to_s) {
+              case node.right
+              when Array then node.right.map(&:val)
+              when Arel::Nodes::Casted, Arel::Nodes::Quoted
+                node.right.val
+              end
+            }]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/sanitization.rb

@@ -1,54 +1,61 @@
 module ActiveRecord
   module Sanitization
     module ClassMethods
+
       protected
       # Accepts a hash of SQL conditions and replaces those attributes
-      # that correspond to a +composed_of+ relationship with their expanded
-      # aggregate attribute values.
+      # that correspond to a {#composed_of}[rdoc-ref:Aggregations::ClassMethods#composed_of]
+      # relationship with their expanded aggregate attribute values.
+      #
       # Given:
-      #     class Person < ActiveRecord::Base
-      #       composed_of :address, class_name: "Address",
-      #         mapping: [%w(address_street street), %w(address_city city)]
-      #     end
+      #
+      #   class Person < ActiveRecord::Base
+      #     composed_of :address, class_name: "Address",
+      #       mapping: [%w(address_street street), %w(address_city city)]
+      #   end
+      #
       # Then:
-      #     { address: Address.new("813 abc st.", "chicago") }
-      #       # => { address_street: "813 abc st.", address_city: "chicago" }
-      def expand_hash_conditions_for_aggregates(attrs)
-        expanded_attrs = {}
-        attrs.each do |attr, value|
-          # CPK
-          # if aggregation = reflect_on_aggregation(attr.to_sym)
-          if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
-            attr.each_with_index do |key,i|
-              expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
-            end
-          elsif aggregation = reflect_on_aggregation(attr.to_sym)
-            mapping = aggregation.mapping
-            mapping.each do |field_attr, aggregate_attr|
-              if mapping.size == 1 && !value.respond_to?(aggregate_attr)
-                expanded_attrs[field_attr] = value
-              else
-                expanded_attrs[field_attr] = value.send(aggregate_attr)
+      #
+      #   { address: Address.new("813 abc st.", "chicago") }
+      #   # => { address_street: "813 abc st.", address_city: "chicago" }
+      silence_warnings do
+        def expand_hash_conditions_for_aggregates(attrs)
+          expanded_attrs = {}
+          attrs.each do |attr, value|
+            # CPK
+            # if aggregation = reflect_on_aggregation(attr.to_sym)
+            if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
+              attr.each_with_index do |key,i|
+                expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
               end
+            elsif aggregation = reflect_on_aggregation(attr.to_sym)
+              mapping = aggregation.mapping
+              mapping.each do |field_attr, aggregate_attr|
+                if mapping.size == 1 && !value.respond_to?(aggregate_attr)
+                  expanded_attrs[field_attr] = value
+                else
+                  expanded_attrs[field_attr] = value.send(aggregate_attr)
+                end
+              end
+            else
+              expanded_attrs[attr] = value
             end
-          else
-            expanded_attrs[attr] = value
           end
+          expanded_attrs
         end
-        expanded_attrs
-      end
 
-      def quoted_id
-        # CPK
-        # self.class.quote_value(id, column_for_attribute(self.class.primary_key))
-        if self.composite?
-          [self.class.primary_keys, ids].transpose.map { |attr_name,id|
-            self.class.quote_value(id, column_for_attribute(attr_name))
-          }
-        else
-          self.class.quote_value(id, column_for_attribute(self.class.primary_key))
+        def quoted_id
+          # CPK
+          # self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
+          if self.composite?
+            [self.class.primary_keys, ids].transpose.map { |attr_name,id|
+              self.class.quote_value(@attributes[attr_name].value_for_database)
+            }
+          else
+            self.class.quote_value(@attributes[self.class.primary_key].value_for_database)
+          end
         end
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,41 +1,41 @@
 module ActiveRecord
   module Validations
-    class UniquenessValidator
-      def validate_each(record, attribute, value)
-        finder_class = find_finder_class_for(record)
-        table = finder_class.arel_table
-        value = map_enum_attribute(finder_class, attribute, value)
-
-        begin
-          relation = build_relation(finder_class, table, attribute, value)
-          # CPK
-          # relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
-          if record.persisted?
-            not_eq_conditions = Array(finder_class.primary_key).zip(Array(record.send(:id))).map do |name, value|
-              table[name.to_sym].not_eq(value)
-            end
-
-            condition = not_eq_conditions.shift
-            not_eq_conditions.each do |not_eq_condition|
-              condition = condition.or(not_eq_condition)
-            end
-            relation = relation.and(condition)
-          end
-          # End CPK
-          relation = scope_relation(record, table, relation)
-          relation = finder_class.unscoped.where(relation)
-          relation = relation.merge(options[:conditions]) if options[:conditions]
-        rescue RangeError
-          relation = finder_class.none
-        end
-
-        if relation.exists?
-          error_options = options.except(:case_sensitive, :scope, :conditions)
-          error_options[:value] = value
-
-          record.errors.add(attribute, :taken, error_options)
-        end
-      end
-    end
+    # class UniquenessValidator
+    #   def validate_each(record, attribute, value)
+    #     finder_class = find_finder_class_for(record)
+    #     table = finder_class.arel_table
+    #     value = map_enum_attribute(finder_class, attribute, value)
+    #
+    #     begin
+    #       relation = build_relation(finder_class, table, attribute, value)
+    #       # CPK
+    #       # relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
+    #       if record.persisted?
+    #         not_eq_conditions = Array(finder_class.primary_key).zip(Array(record.send(:id))).map do |name, value|
+    #           table[name.to_sym].not_eq(value)
+    #         end
+    #
+    #         condition = not_eq_conditions.shift
+    #         not_eq_conditions.each do |not_eq_condition|
+    #           condition = condition.or(not_eq_condition)
+    #         end
+    #         relation = relation.and(condition)
+    #       end
+    #       # End CPK
+    #       relation = scope_relation(record, table, relation)
+    #       relation = finder_class.unscoped.where(relation)
+    #       relation = relation.merge(options[:conditions]) if options[:conditions]
+    #     rescue RangeError
+    #       relation = finder_class.none
+    #     end
+    #
+    #     if relation.exists?
+    #       error_options = options.except(:case_sensitive, :scope, :conditions)
+    #       error_options[:value] = value
+    #
+    #       record.errors.add(attribute, :taken, error_options)
+    #     end
+    #   end
+    # end
   end
 end

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
 module CompositePrimaryKeys
   module VERSION
-    MAJOR = 8
-    MINOR = 1
-    TINY  = 8
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    MAJOR = 9
+    MINOR = 0
+    TINY  = 0
+    STRING = [MAJOR, MINOR, TINY, 'beta1'].join('.')
   end
 end

data/scripts/console.rb

@@ -1,48 +1,48 @@
-#!/usr/bin/env ruby
-
-#
-# if run as script, load the file as library while starting irb 
-#
-if __FILE__ == $0
-  irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-  ENV['ADAPTER'] = ARGV[0]
-  exec "#{irb} -f -r #{$0} --simple-prompt"
-end
-
-#
-# check if the given adapter is supported (default: mysql)
-#
-adapters = %w[mysql sqlite oracle oracle_enhanced postgresql ibm_db]
-adapter = ENV['ADAPTER'] || 'mysql'
-unless adapters.include? adapter
-  puts "Usage: #{__FILE__} <adapter>"
-  puts ''
-  puts 'Adapters: '
-  puts adapters.map{ |adapter| "    #{adapter}" }.join("\n")
-  exit 1
-end
-
-#
-# load all necessary libraries
-#
-require 'rubygems'
-require 'local/database_connections'
-
-$LOAD_PATH.unshift 'lib'
-
-begin
-  require 'local/paths'
-  $LOAD_PATH.unshift "#{ENV['EDGE_RAILS_DIR']}/active_record/lib"  if ENV['EDGE_RAILS_DIR']
-  $LOAD_PATH.unshift "#{ENV['EDGE_RAILS_DIR']}/activesupport/lib" if ENV['EDGE_RAILS_DIR']
-rescue
-end
-
-require 'active_support'
-require 'active_record'
-
-require "test/connections/native_#{adapter}/connection"
-require 'composite_primary_keys'
-
-PROJECT_ROOT = File.join(File.dirname(__FILE__), '..')
-Dir[File.join(PROJECT_ROOT,'test/fixtures/*.rb')].each { |model| require model }
-
+#!/usr/bin/env ruby
+
+#
+# if run as script, load the file as library while starting irb 
+#
+if __FILE__ == $0
+  irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+  ENV['ADAPTER'] = ARGV[0]
+  exec "#{irb} -f -r #{$0} --simple-prompt"
+end
+
+#
+# check if the given adapter is supported (default: mysql)
+#
+adapters = %w[mysql sqlite oracle oracle_enhanced postgresql ibm_db]
+adapter = ENV['ADAPTER'] || 'mysql'
+unless adapters.include? adapter
+  puts "Usage: #{__FILE__} <adapter>"
+  puts ''
+  puts 'Adapters: '
+  puts adapters.map{ |adapter| "    #{adapter}" }.join("\n")
+  exit 1
+end
+
+#
+# load all necessary libraries
+#
+require 'rubygems'
+require 'local/database_connections'
+
+$LOAD_PATH.unshift 'lib'
+
+begin
+  require 'local/paths'
+  $LOAD_PATH.unshift "#{ENV['EDGE_RAILS_DIR']}/active_record/lib"  if ENV['EDGE_RAILS_DIR']
+  $LOAD_PATH.unshift "#{ENV['EDGE_RAILS_DIR']}/activesupport/lib" if ENV['EDGE_RAILS_DIR']
+rescue
+end
+
+require 'active_support'
+require 'active_record'
+
+require "test/connections/native_#{adapter}/connection"
+require 'composite_primary_keys'
+
+PROJECT_ROOT = File.join(File.dirname(__FILE__), '..')
+Dir[File.join(PROJECT_ROOT,'test/fixtures/*.rb')].each { |model| require model }
+

data/scripts/txt2html

@@ -1,76 +1,76 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-gem 'RedCloth'
-gem 'syntax'
-
-require 'redcloth'
-require 'syntax/convertors/html'
-require 'erb'
-
-version_path = File.join(File.dirname(__FILE__), '..', 'lib', 'composite_primary_keys', 'version.rb')
-require File.expand_path(version_path)
-
-version  = CompositePrimaryKeys::VERSION::STRING
-download = 'http://rubygems.org/gems/composite_primary_keys'
-
-class Fixnum
-  def ordinal
-    # teens
-    return 'th' if (10..19).include?(self % 100)
-    # others
-    case self % 10
-    when 1
-       return 'st'
-    when 2
-      return 'nd'
-    when 3
-      return 'rd'
-    else
-      return 'th'
-    end
-  end
-end
-
-class Time
-  def pretty
-    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
-  end
-end
-
-def convert_syntax(syntax, source)
-  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
-end
-
-if ARGV.length >= 1
-  src, template = ARGV
-  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
-  
-else
-  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
-  exit!
-end
-
-template = ERB.new(File.open(template).read)
-
-title = nil
-body = nil
-File.open(src) do |fsrc|
-  title_text = fsrc.readline
-  body_text = fsrc.read
-  syntax_items = []
-  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
-    ident = syntax_items.length
-    element, syntax, source = $1, $2, $3
-    syntax_items << "<#{element} class=\"syntax\">#{convert_syntax(syntax, source)}</#{element}>"
-    "syntax-temp-#{ident}"
-  }
-  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
-  body = RedCloth.new(body_text).to_html
-  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
-end
-stat = File.stat(src)
-created = stat.ctime
-modified = stat.mtime
-
-$stdout << template.result(binding)
+#!/usr/bin/env ruby
+
+require 'rubygems'
+gem 'RedCloth'
+gem 'syntax'
+
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+
+version_path = File.join(File.dirname(__FILE__), '..', 'lib', 'composite_primary_keys', 'version.rb')
+require File.expand_path(version_path)
+
+version  = CompositePrimaryKeys::VERSION::STRING
+download = 'http://rubygems.org/gems/composite_primary_keys'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1
+       return 'st'
+    when 2
+      return 'nd'
+    when 3
+      return 'rd'
+    else
+      return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class=\"syntax\">#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)