adaptive_alias 0.0.2 → 0.2.0

data/lib/adaptive_alias/active_model_patches/remove_alias_attribute.rb

@@ -1,27 +1,24 @@
-require 'active_model'
-
-module ActiveModel::AttributeMethods
-  module ClassMethods
-    def remove_proxy_call(mod, name)
-      defn = if NAME_COMPILABLE_REGEXP.match?(name)
-               "undef #{name}"
-             else
-               "remove_method(:'#{name}')"
-             end
-
-      mod.module_eval defn, __FILE__, __LINE__ + 1
-    end
-
-    def remove_alias_attribute(new_name)
-      # association_scope -> add_constraints -> last_chain_scope -> where!(key => model[foreign_key])
-      # self[attr_name] -> read_attribute(attr_name) -> attribute_aliases
-      # where! -> where_clause_factory.build -> attributes = predicate_builder.resolve_column_aliases(opts) -> attribute_aliases
-      self.attribute_aliases = attribute_aliases.except(new_name.to_s)
-
-      attribute_method_matchers.each do |matcher|
-        matcher_new = matcher.method_name(new_name).to_s
-        remove_proxy_call self, matcher_new
-      end
-    end
-  end
-end
+require 'active_model'
+
+module AdaptiveAlias
+  module ActiveModelPatches
+    module RemoveAliasAttribute
+      def remove_proxy_call(mod, name)
+        mod.module_eval "remove_method(:'#{name}')", __FILE__, __LINE__ + 1
+      end
+
+      def remove_alias_attribute(new_name)
+        self.attribute_aliases = attribute_aliases.except(new_name.to_s)
+
+        attribute_method_matchers.each do |matcher|
+          matcher_new = matcher.method_name(new_name).to_s
+          remove_proxy_call self, matcher_new
+        end
+      end
+    end
+  end
+end
+
+module ActiveModel::AttributeMethods::ClassMethods
+  include AdaptiveAlias::ActiveModelPatches::RemoveAliasAttribute
+end

data/lib/adaptive_alias/active_model_patches/write_attribute.rb

@@ -0,0 +1,25 @@
+require 'active_record'
+
+module AdaptiveAlias
+  module ActiveModelPatches
+    module WriteAttribute
+      def write_attribute(attr_name, value)
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+        super(name, value)
+      end
+
+      # This method exists to avoid the expensive primary_key check internally, without
+      # breaking compatibility with the write_attribute API
+      def _write_attribute(attr_name, value) # :nodoc:
+        name = attr_name.to_s
+        name = self.class.attribute_aliases[name] || name
+        super(name, value)
+      end
+    end
+  end
+end
+
+module ActiveRecord::AttributeMethods::Write
+  prepend AdaptiveAlias::ActiveModelPatches::WriteAttribute
+end

data/lib/adaptive_alias/hooks/association.rb

@@ -1,13 +1,17 @@
-module AdaptiveAlias
-  module Hooks
-    module Association
-      def find_target(*)
-        AdaptiveAlias.rescue_statement_invalid(nil){ super }
-      end
-    end
-  end
-end
-
-class ActiveRecord::Associations::Association
-  prepend AdaptiveAlias::Hooks::Association
-end
+module AdaptiveAlias
+  module Hooks
+    module Association
+      def find_target(*)
+        AdaptiveAlias.rescue_statement_invalid(nil, reflection){ super }
+      end
+
+      def create!(attributes = {}, &block)
+        AdaptiveAlias.rescue_statement_invalid(association_scope, reflection){ super }
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::Association
+  prepend AdaptiveAlias::Hooks::Association
+end

data/lib/adaptive_alias/hooks/association_scope.rb

@@ -1,13 +1,13 @@
-module AdaptiveAlias
-  module Hooks
-    module AssociationScope
-      def last_chain_scope(*)
-        AdaptiveAlias.rescue_missing_attribute{ super }
-      end
-    end
-  end
-end
-
-class ActiveRecord::Associations::AssociationScope
-  prepend AdaptiveAlias::Hooks::AssociationScope
-end
+module AdaptiveAlias
+  module Hooks
+    module AssociationScope
+      def last_chain_scope(_scope, reflection, owner)
+        AdaptiveAlias.rescue_missing_attribute(owner.class){ super }
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::AssociationScope
+  prepend AdaptiveAlias::Hooks::AssociationScope
+end

data/lib/adaptive_alias/hooks/relation.rb

@@ -1,21 +1,21 @@
-module AdaptiveAlias
-  module Hooks
-    module Relation
-      def pluck(*)
-        AdaptiveAlias.rescue_statement_invalid(self){ super }
-      end
-
-      def select_all(*)
-        AdaptiveAlias.rescue_statement_invalid(self){ super }
-      end
-
-      def exec_queries(*)
-        AdaptiveAlias.rescue_statement_invalid(self){ super }
-      end
-    end
-  end
-end
-
-class ActiveRecord::Relation
-  prepend AdaptiveAlias::Hooks::Relation
-end
+module AdaptiveAlias
+  module Hooks
+    module Relation
+      def pluck(*)
+        AdaptiveAlias.rescue_statement_invalid(self, nil){ super }
+      end
+
+      def select_all(*)
+        AdaptiveAlias.rescue_statement_invalid(self, nil){ super }
+      end
+
+      def exec_queries(*)
+        AdaptiveAlias.rescue_statement_invalid(self, nil){ super }
+      end
+    end
+  end
+end
+
+class ActiveRecord::Relation
+  prepend AdaptiveAlias::Hooks::Relation
+end

data/lib/adaptive_alias/hooks/singular_association.rb

@@ -1,13 +1,13 @@
-module AdaptiveAlias
-  module Hooks
-    module SingularAssociation
-      def reader(*)
-        AdaptiveAlias.rescue_missing_attribute{ super }
-      end
-    end
-  end
-end
-
-class ActiveRecord::Associations::SingularAssociation
-  prepend AdaptiveAlias::Hooks::SingularAssociation
-end
+module AdaptiveAlias
+  module Hooks
+    module SingularAssociation
+      def reader(*)
+        AdaptiveAlias.rescue_missing_attribute(owner.class){ super }
+      end
+    end
+  end
+end
+
+class ActiveRecord::Associations::SingularAssociation
+  prepend AdaptiveAlias::Hooks::SingularAssociation
+end

data/lib/adaptive_alias/patches/backward_patch.rb

@@ -1,21 +1,24 @@
-# frozen_string_literal: true
-
-require 'adaptive_alias/patches/base'
-
-module AdaptiveAlias
-  module Patches
-    class BackwardPatch < Base
-      def apply!
-        AdaptiveAlias.current_patches[[@klass, @old_column, @new_column]] = self
-        @klass.alias_attribute(@old_column, @new_column)
-        add_hooks!(current_column: @new_column, alias_column: @old_column, log_warning: true)
-      end
-
-      def remove!
-        super
-        @klass.remove_alias_attribute(@old_column)
-        ForwardPatch.new(@klass, @old_column, @new_column).apply!
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'adaptive_alias/patches/base'
+
+module AdaptiveAlias
+  module Patches
+    class BackwardPatch < Base
+      def apply!
+        AdaptiveAlias.current_patches[[@klass, @old_column, @new_column]] = self
+        @klass.alias_attribute(@old_column, @new_column)
+        add_hooks!(current_column: @new_column, alias_column: @old_column, log_warning: true)
+      end
+
+      def remove!
+        super
+        @klass.remove_alias_attribute(@old_column)
+        @klass.define_attribute_method(@old_column)
+        new_patch = ForwardPatch.new(@klass, @old_column, @new_column)
+        new_patch.apply!
+        return new_patch
+      end
+    end
+  end
+end

data/lib/adaptive_alias/patches/base.rb

@@ -1,75 +1,110 @@
-# frozen_string_literal: true
-
-module AdaptiveAlias
-  module Patches
-    class Base
-      attr_reader :fix_association
-      attr_reader :fix_missing_attribute
-      attr_reader :removed
-
-      def initialize(klass, old_column, new_column)
-        @klass = klass
-        @old_column = old_column
-        @new_column = new_column
-      end
-
-      def add_hooks!(current_column:, alias_column:, log_warning: false)
-        patch = self
-        old_column = @old_column
-        new_column = @new_column
-
-        AdaptiveAlias.get_or_create_model_module(@klass).instance_exec do
-          remove_method(new_column) if method_defined?(new_column)
-          define_method(new_column) do
-            AdaptiveAlias.rescue_missing_attribute{ self[new_column] }
-          end
-
-          remove_method(old_column) if method_defined?(old_column)
-          define_method(old_column) do
-            patch.log_warning if log_warning
-            AdaptiveAlias.rescue_missing_attribute{ self[old_column] }
-          end
-        end
-
-        expected_error_message = "Mysql2::Error: Unknown column '#{@klass.table_name}.#{current_column}' in 'where clause'".freeze
-
-        @fix_missing_attribute = proc do
-          next false if patch.removed
-
-          patch.remove!
-          next true
-        end
-
-        @fix_association = proc do |target, error|
-          next false if patch.removed || error.message != expected_error_message
-
-          patch.remove!
-
-          if target
-            hash = target.where_values_hash
-            hash[alias_column] = hash.delete(current_column) if hash.key?(current_column)
-            target.instance_variable_set(:@arel, nil)
-            target.unscope!(:where).where!(hash)
-          end
-
-          next true
-        end
-      end
-
-      def log_warning
-        if @prev_warning_time == nil || @prev_warning_time < AdaptiveAlias.log_interval.ago
-          @prev_warning_time = Time.now
-          AdaptiveAlias.unexpected_old_column_proc&.call
-        end
-      end
-
-      def remove!
-        @removed = true
-        @klass.send(:reload_schema_from_cache)
-        @klass.initialize_find_by_cache
-        @fix_association = nil
-        @fix_missing_attribute = nil
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module AdaptiveAlias
+  module Patches
+    class Base
+      attr_reader :fix_association
+      attr_reader :fix_missing_attribute
+      attr_reader :removed
+      attr_reader :removable
+
+      def initialize(klass, old_column, new_column)
+        @klass = klass
+        @old_column = old_column
+        @new_column = new_column
+      end
+
+      def add_hooks!(current_column:, alias_column:, log_warning: false)
+        patch = self
+        klass = @klass
+        old_column = @old_column
+        new_column = @new_column
+
+        AdaptiveAlias.get_or_create_model_module(klass).instance_exec do
+          remove_method(new_column) if method_defined?(new_column)
+          define_method(new_column) do
+            AdaptiveAlias.rescue_missing_attribute(klass){ self[new_column] }
+          end
+
+          remove_method("#{new_column}=") if method_defined?("#{new_column}=")
+          define_method("#{new_column}=") do |*args|
+            AdaptiveAlias.rescue_missing_attribute(klass){ super(*args) }
+          end
+
+          remove_method(old_column) if method_defined?(old_column)
+          define_method(old_column) do
+            patch.log_warning if log_warning
+            AdaptiveAlias.rescue_missing_attribute(klass){ self[old_column] }
+          end
+
+          remove_method("#{old_column}=") if method_defined?("#{old_column}=")
+          define_method("#{old_column}=") do |*args|
+            patch.log_warning if log_warning
+            AdaptiveAlias.rescue_missing_attribute(klass){ super(*args) }
+          end
+        end
+
+        expected_association_err_msgs = [
+          "Mysql2::Error: Unknown column '#{klass.table_name}.#{current_column}' in 'where clause'".freeze,
+          "Mysql2::Error: Unknown column '#{current_column}' in 'field list'".freeze,
+        ].freeze
+
+        expected_attribute_err_msgs = [
+          "can't write unknown attribute `#{current_column}`".freeze,
+          "missing attribute: #{current_column}".freeze,
+        ].freeze
+
+        @fix_missing_attribute = proc do |error_klass, error|
+          next false if not patch.removable
+          next false if patch.removed
+          next false if klass != error_klass
+          next false if not expected_attribute_err_msgs.include?(error.message)
+
+          patch.remove!
+          next true
+        end
+
+        @fix_association = proc do |relation, reflection, error|
+          next false if not patch.removable
+          next false if patch.removed
+          next false if not expected_association_err_msgs.include?(error.message)
+
+          patch.remove!
+
+          if relation
+            relation.where_clause.send(:predicates).each do |node|
+              next if node.left.name != current_column.to_s
+              next if klass.table_name != node.left.relation.name
+
+              node.left = node.left.clone
+              node.left.name = alias_column.to_s
+            end
+          end
+
+          reflection.clear_association_scope_cache if reflection
+
+          next true
+        end
+      end
+
+      def log_warning
+        if @prev_warning_time == nil || @prev_warning_time < Time.now - AdaptiveAlias.log_interval
+          @prev_warning_time = Time.now
+          AdaptiveAlias.unexpected_old_column_proc&.call
+        end
+      end
+
+      def remove!
+        @removed = true
+        @klass.reset_column_information
+        @klass.columns_hash
+        @fix_association = nil
+        @fix_missing_attribute = nil
+      end
+
+      def mark_removable
+        @removable = true
+      end
+    end
+  end
+end

data/lib/adaptive_alias/patches/forward_patch.rb

@@ -1,21 +1,24 @@
-# frozen_string_literal: true
-
-require 'adaptive_alias/patches/base'
-
-module AdaptiveAlias
-  module Patches
-    class ForwardPatch < Base
-      def apply!
-        AdaptiveAlias.current_patches[[@klass, @old_column, @new_column]] = self
-        @klass.alias_attribute(@new_column, @old_column)
-        add_hooks!(current_column: @old_column, alias_column: @new_column)
-      end
-
-      def remove!
-        super
-        @klass.remove_alias_attribute(@new_column)
-        BackwardPatch.new(@klass, @old_column, @new_column).apply!
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'adaptive_alias/patches/base'
+
+module AdaptiveAlias
+  module Patches
+    class ForwardPatch < Base
+      def apply!
+        AdaptiveAlias.current_patches[[@klass, @old_column, @new_column]] = self
+        @klass.alias_attribute(@new_column, @old_column)
+        add_hooks!(current_column: @old_column, alias_column: @new_column)
+      end
+
+      def remove!
+        super
+        @klass.remove_alias_attribute(@new_column)
+        @klass.define_attribute_method(@new_column)
+        new_patch = BackwardPatch.new(@klass, @old_column, @new_column)
+        new_patch.apply!
+        return new_patch
+      end
+    end
+  end
+end

data/lib/adaptive_alias/version.rb

@@ -1,3 +1,3 @@
-module AdaptiveAlias
-  VERSION = '0.0.2'
-end
+module AdaptiveAlias
+  VERSION = '0.2.0'
+end

data/lib/adaptive_alias.rb

@@ -1,65 +1,79 @@
-# frozen_string_literal: true
-
-require 'adaptive_alias/version'
-require 'adaptive_alias/active_model_patches/read_attribute'
-require 'adaptive_alias/active_model_patches/remove_alias_attribute'
-require 'adaptive_alias/patches/backward_patch'
-require 'adaptive_alias/patches/forward_patch'
-
-require 'adaptive_alias/hooks/association'
-require 'adaptive_alias/hooks/association_scope'
-require 'adaptive_alias/hooks/singular_association'
-require 'adaptive_alias/hooks/relation'
-
-module AdaptiveAlias
-  @log_interval = 10 * 60
-  @current_patches = {}
-  @model_modules ||= {}
-
-  class << self
-    attr_accessor :unexpected_old_column_proc
-    attr_accessor :log_interval
-    attr_accessor :current_patches
-  end
-
-  class << self
-    def [](old_column, new_column)
-      old_column = old_column.to_sym
-      new_column = new_column.to_sym
-
-      Module.new do
-        extend ActiveSupport::Concern
-
-        included do
-          if column_names.include?(new_column)
-            Patches::BackwardPatch.new(self, old_column, new_column).apply!
-          else
-            Patches::ForwardPatch.new(self, old_column, new_column).apply!
-          end
-        end
-      end
-    end
-
-    def rescue_statement_invalid(relation)
-      yield
-    rescue ActiveRecord::StatementInvalid => error
-      raise error if AdaptiveAlias.current_patches.all?{|_key, patch| !patch.fix_association.call(relation, error) }
-      retry
-    end
-
-    def rescue_missing_attribute
-      yield
-    rescue ActiveModel::MissingAttributeError => error
-      raise error if AdaptiveAlias.current_patches.all?{|_key, patch| !patch.fix_missing_attribute.call }
-      retry
-    end
-
-    def get_or_create_model_module(klass)
-      return @model_modules[klass] if @model_modules[klass]
-
-      @model_modules[klass] = Module.new
-      klass.prepend(@model_modules[klass])
-      return @model_modules[klass]
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'adaptive_alias/version'
+require 'adaptive_alias/active_model_patches/read_attribute'
+require 'adaptive_alias/active_model_patches/write_attribute'
+require 'adaptive_alias/active_model_patches/remove_alias_attribute'
+require 'adaptive_alias/active_model_patches/apply_scope'
+require 'adaptive_alias/patches/backward_patch'
+require 'adaptive_alias/patches/forward_patch'
+
+require 'adaptive_alias/hooks/association'
+require 'adaptive_alias/hooks/association_scope'
+require 'adaptive_alias/hooks/singular_association'
+require 'adaptive_alias/hooks/relation'
+
+module AdaptiveAlias
+  @log_interval = 10 * 60
+  @current_patches = {}
+  @model_modules ||= {}
+
+  class << self
+    attr_accessor :unexpected_old_column_proc
+    attr_accessor :log_interval
+    attr_accessor :current_patches
+  end
+
+  class << self
+    def [](old_column, new_column)
+      old_column = old_column.to_sym
+      new_column = new_column.to_sym
+
+      Module.new do
+        extend ActiveSupport::Concern
+
+        included do
+          patch = (column_names.include?(new_column) ? Patches::BackwardPatch : Patches::ForwardPatch).new(self, old_column, new_column)
+          patch.apply!
+          patch.mark_removable
+        end
+      end
+    end
+
+    def rescue_statement_invalid(relation, reflection, &block)
+      yield
+    rescue ActiveRecord::StatementInvalid => error
+      raise error if AdaptiveAlias.current_patches.all?{|_key, patch| !patch.fix_association.call(relation, reflection, error) }
+
+      result = rescue_statement_invalid(relation, reflection, &block)
+      AdaptiveAlias.current_patches.each_value(&:mark_removable)
+      return result
+    end
+
+    def rescue_missing_attribute(klass, &block)
+      yield
+    rescue ActiveModel::MissingAttributeError => error
+      raise error if AdaptiveAlias.current_patches.all?{|_key, patch| !patch.fix_missing_attribute.call(klass, error) }
+
+      result = rescue_missing_attribute(klass, &block)
+      AdaptiveAlias.current_patches.each_value(&:mark_removable)
+      return result
+    end
+
+    def get_or_create_model_module(klass)
+      return @model_modules[klass] if @model_modules[klass]
+
+      @model_modules[klass] = Module.new
+      klass.prepend(@model_modules[klass])
+      return @model_modules[klass]
+    end
+
+    def missing_value?(attributes, klass, name)
+      return false if attributes.key?(name)
+
+      old_name = klass.attribute_aliases.key(name)
+      return false if old_name == nil
+      return !!AdaptiveAlias.current_patches[[klass, old_name.to_sym, name.to_sym]]
+    end
+  end
+end