composite_primary_keys 8.1.8 → 9.0.0.beta1

data/lib/composite_primary_keys/arel/visitors/to_sql.rb

@@ -1,36 +0,0 @@
-module Arel
-  module Visitors
-    class ToSql
-      def visit_Arel_Attributes_Attribute o, collector
-        join_name = o.relation.table_alias || o.relation.name
-        table_name = quote_table_name join_name
-
-        if o.name.is_a? Array
-          collector <<
-            o.name.map{ |field| "#{table_name}.#{quote_column_name(field)}" }.join(",")
-        else
-          collector << "#{table_name}.#{quote_column_name o.name}"
-        end
-      end
-
-      def visit_Arel_Nodes_In o, collector
-        if Array === o.right && o.right.empty?
-          collector << '1=0'
-        else
-          # CPK
-          # collector = visit o.left, collector
-          if o.left.respond_to?(:name) && o.left.name.is_a?(Array)
-            collector << "("
-            collector = visit(o.left, collector)
-            collector << ")"
-          else
-            collector = visit o.left, collector
-          end
-
-          collector << " IN ("
-          visit(o.right, collector) << ")"
-        end
-      end
-    end
-  end
-end

data/lib/composite_primary_keys/attribute_methods/dirty.rb

@@ -1,29 +0,0 @@
-module ActiveRecord
-  module AttributeMethods
-    module Dirty
-      def write_attribute(attr, value)
-        # CPK
-        if attr.kind_of?(Array)
-          # A *composite* attribute can't be marked as changed! So do nothing now.
-          # We will come back in here with an *individual* attribute when Write#write_attribute looks through the individual attributes comprising this composite key:
-          value = [nil] * attr.length if value.nil?
-          [attr, value].transpose.map {|name,val| write_attribute(name, val)}
-        else
-          attr = attr.to_s
-
-          old_value = old_attribute_value(attr)
-
-          result = super
-          store_original_raw_attribute(attr)
-          save_changed_attribute(attr, old_value)
-          result
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.class_eval do
-  alias :[]= :write_attribute
-  public :[]=
-end

data/lib/composite_primary_keys/autosave_association.rb

@@ -1,67 +0,0 @@
-module ActiveRecord
-  module AutosaveAssociation
-    private
-      # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.
-      #
-      # In addition, it will destroy the association if it was marked for destruction.
-      def save_belongs_to_association(reflection)
-        association = association_instance_get(reflection.name)
-        record      = association && association.load_target
-        if record && !record.destroyed?
-          autosave = reflection.options[:autosave]
-
-          if autosave && record.marked_for_destruction?
-            self[reflection.foreign_key] = nil
-            record.destroy
-          elsif autosave != false
-            saved = record.save(:validate => !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
-
-            if association.updated?
-              # CPK
-              # association_id = record.send(reflection.options[:primary_key] || :id)
-              association_id = reflection.options[:primary_key] ? record.read_attribute(reflection.options[:primary_key]) : record.id
-              self[reflection.foreign_key] = association_id
-              association.loaded!
-            end
-
-            saved if autosave
-          end
-        end
-      end
-
-      # Saves the associated record if it's new or <tt>:autosave</tt> is enabled
-      # on the association.
-      #
-      # In addition, it will destroy the association if it was marked for
-      # destruction with mark_for_destruction.
-      #
-      # This all happens inside a transaction, _if_ the Transactions module is included into
-      # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
-      def save_has_one_association(reflection)
-        association = association_instance_get(reflection.name)
-        record      = association && association.load_target
-
-        if record && !record.destroyed?
-          autosave = reflection.options[:autosave]
-
-          if autosave && record.marked_for_destruction?
-            record.destroy
-          elsif autosave != false
-            # CPK
-            #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-            key = reflection.options[:primary_key] ? read_attribute(reflection.options[:primary_key]) : id
-
-            if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
-              unless reflection.through_reflection
-                record[reflection.foreign_key] = key
-              end
-
-              saved = record.save(:validate => !autosave)
-              raise ActiveRecord::Rollback if !saved && autosave
-              saved
-            end
-          end
-        end
-      end
-  end
-end

data/lib/composite_primary_keys/connection_adapters/abstract_mysql_adapter.rb

@@ -1,23 +0,0 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class AbstractMysqlAdapter < AbstractAdapter
-      # MySQL is too stupid to create a temporary table for use subquery, so we have
-      # to give it some prompting in the form of a subsubquery. Ugh!
-      def subquery_for(key, select)
-        subsubselect = select.clone
-        subsubselect.projections = [key]
-
-        # Materialize subquery by adding distinct
-        # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
-        subsubselect.distinct unless select.limit || select.offset || select.orders.any?
-
-        subselect = Arel::SelectManager.new(select.engine)
-
-        # subselect.project Arel.sql(key.name)
-        arel_table = select.engine.arel_table
-        subselect.project *[key].map { |x| arel_table[x.name] }
-        subselect.from subsubselect.as('__active_record_temp')
-      end
-    end
-  end
-end

data/test/fixtures/pk_called_id.rb

@@ -1,5 +0,0 @@
-class PkCalledId < ActiveRecord::Base
-  self.primary_keys = :id, :reference_code
-
-  validates_presence_of :reference_code, :code_label, :abbreviation
-end

data/test/fixtures/pk_called_ids.yml

@@ -1,11 +0,0 @@
-name_prefix_mr:
-  id: 1
-  reference_code: 1
-  code_label: MR
-  abbreviation: Mr
-
-name_prefix_mrs:
-  id: 2
-  reference_code: 1
-  code_label: MRS
-  abbreviation: Mrs

data/test/test_find_in_batches.rb

@@ -1,30 +0,0 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestFindInBatches < ActiveSupport::TestCase
-  fixtures :capitols
-
-  def test_in_batches
-    capitols = []
-    Capitol.find_in_batches do |chunk|
-      capitols += chunk.map(&:country)
-    end
-    assert_equal(capitols, ['Canada', 'France', 'Mexico', 'The Netherlands'])
-  end
-
-  def test_in_small_batches
-    capitols = []
-    Capitol.find_in_batches(batch_size: 2) do |chunk|
-        capitols += chunk.map(&:country)
-      end
-
-    assert_equal(capitols, ['Canada', 'France', 'Mexico', 'The Netherlands'])
-  end
-
-  def test_in_one_unit_batch
-    capitols = []
-    Capitol.find_in_batches(batch_size: 1) do |chunk|
-        capitols += chunk.map(&:country)
-      end
-    assert_equal(capitols, ['Canada', 'France', 'Mexico', 'The Netherlands'])
-  end
-end

data/test/test_update_all.rb

@@ -1,17 +0,0 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestUpdateAll < ActiveSupport::TestCase
-  fixtures :articles, :users
-
-  def test_update_all
-    first_article = Article.first
-    users_count = first_article.users.count
-    # limit forces a subquery
-    first_article.users.limit(1).update_all(name: 'test')
-    assert_equal(
-      User.joins(readings: :article)
-        .merge(Article.where(id: first_article))
-        .where(name: 'test').count, users_count
-    )
-  end
-end