initial STI spec passes only

Author: catmando

.rubocop.yml

@@ -1,3 +1,4 @@
+
 Metrics/LineLength:
   Max: 100
 
@@ -9,3 +10,6 @@ Style/MutableConstant:
 
 Style/CommandLiteral:
   EnforcedStyle: mixed
+
+AllCops:
+  TargetRubyVersion: 2.4.1

lib/hyper-mesh.rb

@@ -8,6 +8,7 @@
   require 'date'
   require 'kernel/itself' unless Object.instance_methods.include?(:itself)
   require 'object/tap'
+  require "reactive_record/active_record_error"
   require "reactive_record/active_record/errors"
   require "reactive_record/active_record/error"
   require "reactive_record/server_data_cache"

lib/reactive_record/active_record/class_methods.rb

@@ -2,11 +2,10 @@ module ActiveRecord
 
   module ClassMethods
 
-    def inherited(subclass)
-      ['_attribute_aliases'].each do |inheritable_attribute|
-        instance_var = "@#{inheritable_attribute}"
-        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
-      end
+    alias _new_without_sti_type_cast new
+
+    def new(*args, &block)
+      _new_without_sti_type_cast(*args, &block).cast_to_current_sti_type
     end
 
     def base_class
@@ -16,10 +15,8 @@ def base_class
 
       if superclass == Base || superclass.abstract_class?
         self
-      elsif respond_to?(:each)
-        superclass.base_class
       else
-        self
+        superclass.base_class
       end
     end
 
@@ -28,19 +25,26 @@ def abstract_class?
     end
 
     def primary_key
-      base_class.instance_eval { @primary_key_value || :id }
+      @primary_key_value ||= (self == base_class) ? :id : base_class.primary_key
     end
 
     def primary_key=(val)
-      base_class.instance_eval { @primary_key_value = val }
+      @primary_key_value = val.to_s
     end
 
     def inheritance_column
-      base_class.instance_eval { @inheritance_column_value || "type" }
+      return nil if @no_inheritance_column
+      @inheritance_column_value ||=
+        if self == base_class
+          @inheritance_column_value || 'type'
+        else
+          superclass.inheritance_column.tap { |v| @no_inheritance_column = !v }
+        end
     end
 
     def inheritance_column=(name)
-      base_class.instance_eval { @inheritance_column_value = name }
+      @no_inheritance_column = !name
+      @inheritance_column_value = name
     end
 
     def model_name
@@ -49,15 +53,11 @@ def model_name
     end
 
     def find(id)
-      klass = self
-      base_class.instance_eval { ReactiveRecord::Base.find(klass, primary_key, id) }
+      ReactiveRecord::Base.find(self, primary_key, id)
     end
 
     def find_by(opts = {})
-      klass = self
-      base_class.instance_eval do
-        ReactiveRecord::Base.find(klass, _dealias_attribute(opts.first.first), opts.first.last)
-      end
+      ReactiveRecord::Base.find(self, _dealias_attribute(opts.first.first), opts.first.last)
     end
 
     def enum(*args)
@@ -69,7 +69,11 @@ def serialize(attr, *args)
     end
 
     def _dealias_attribute(new)
-      _attribute_aliases[new] || new
+      if self == base_class
+        _attribute_aliases[new] || new
+      else
+        _attribute_aliases[new] ||= superclass._dealias_attribute(new)
+      end
     end
 
     def _attribute_aliases
@@ -80,7 +84,7 @@ def alias_attribute(new_name, old_name)
       ['', '=', '_changed?'].each do |variant|
         define_method("#{new_name}#{variant}") { |*args, &block| send("#{old_name}#{variant}", *args, &block) }
       end
-      _attribute_aliases[new_name] = old_name
+      @_attribute_aliases[new_name] = old_name
     end
 
     # ignore any of these methods if they get called on the client.   This list should be trimmed down to include only
@@ -222,15 +226,43 @@ def default_scope(*args, &block)
     def all
       ReactiveRecord::Base.default_scope[self] ||=
         begin
+        puts "defining all for #{self}"
         root = ReactiveRecord::Collection
                .new(self, nil, nil, self, 'all')
                .extend(ReactiveRecord::UnscopedCollection)
-        (@_default_scopes || [{ client: -> () { true } }]).inject(root) do |scope, opts|
+        (@_default_scopes || [{ client: _all_filter }]).inject(root) do |scope, opts|
           scope.build_child_scope(ReactiveRecord::ScopeDescription.new(self, :all, opts))
         end
       end
     end
 
+    def _all_filter
+      # provides a filter for the all scopes taking into account STI subclasses
+      # note: within the lambda `self` will be the model instance
+      defining_class_is_base_class = base_class == self
+      defining_model_name = model_name
+      lambda do
+        # have to delay computation of inheritance column since it might
+        # not be defined when class is first defined
+        ic = self.class.inheritance_column
+        (defining_class_is_base_class || !ic || self[ic] == defining_model_name).tap do |x|
+          puts "_all_filter(#{self}) returns: #{x} defining_model_name: #{defining_model_name}, is base: #{defining_class_is_base_class}, ic: #{ic}, self[ic]: #{self[ic]}"
+        end
+      end
+      #
+      # if base_class == self || !inheritance_column
+      #   puts "creating a base filter: #{model_name} #{base_class} #{self} #{inheritance_column}"
+      #   # always return true for the base_class (or if there is no inheritance column)
+      #   -> () { puts "#{model_name} #{self.class.base_class} #{self.class} #{self.class.inheritance_column} base all filter"; true }
+      # else
+      #   # otherwise we are in a STI subclass so inheritance column name must match model name
+      #   # optimize by capturing the inheritance column and model_name as local vars
+      #   klass_inheritance_column = inheritance_column
+      #   klass_model_name = model_name
+      #   -> () { puts "subclass all filter #{klass_inheritance_column} #{klass_model_name} #{self[klass_inheritance_column] == klass_model_name}"; self[klass_inheritance_column] == klass_model_name }
+      # end
+    end
+
     # def all=(_collection)
     #   raise "NO LONGER IMPLEMENTED DOESNT PLAY WELL WITH SYNCHROMESH"
     # end
@@ -333,6 +365,7 @@ def define_attribute_methods
         define_method("#{name}_changed?") { @backing_record.changed?(name) }
         define_method("#{name}?") { @backing_record.get_attr_value(name, nil).present? }
       end
+      self.inheritance_column = nil if inheritance_column && !columns_hash.key?(inheritance_column)
     end
 
     def _react_param_conversion(param, opt = nil)

lib/reactive_record/active_record/instance_methods.rb

@@ -19,18 +19,20 @@ def initialize(hash = {})
         # standard active_record new -> creates a new instance, primary key is ignored if present
         # we have to build the backing record first then initialize it so associations work correctly
         @backing_record = ReactiveRecord::Base.new(self.class, {}, self)
+        if self.class.inheritance_column && !hash.key?(self.class.inheritance_column)
+          hash[self.class.inheritance_column] = self.class.name
+        end
         @backing_record.instance_eval do
-          h = Hash.new
+          h = {}
           hash.each do |a, v|
             a = model._dealias_attribute(a)
             h[a] = convert(a, v).itself
           end
           self.class.load_data do
             h.each do |attribute, value|
-              unless attribute == primary_key
-                @ar_instance[attribute] = value
-                changed_attributes << attribute
-              end
+              next if attribute == primary_key
+              @ar_instance[attribute] = value
+              changed_attributes << attribute
             end
           end
         end
@@ -160,5 +162,18 @@ def update(attrs = {}, &block)
     def <=>(other)
       id.to_i <=> other.id.to_i
     end
+
+    def becomes(klass)
+      klass._new_without_sti_type_cast(backing_record)
+    end
+
+    def becomes!(klass)
+      self[self.class.inheritance_column] = klass.name
+      becomes(klass)
+    end
+
+    def cast_to_current_sti_type
+      @backing_record.set_ar_instance!
+    end
   end
 end

lib/reactive_record/active_record/reactive_record/base.rb

@@ -93,7 +93,7 @@ def self.find(model, attribute, value)
         record.sync_attribute(model.primary_key, id) if id
       end
       # finally initialize and return the ar_instance
-      record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
+      record.set_ar_instance!
     end
 
     def self.new_from_vector(model, aggregate_owner, *vector)
@@ -111,7 +111,7 @@ def self.new_from_vector(model, aggregate_owner, *vector)
         set_vector_lookup(record, vector)
       end
 
-      record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
+      record.set_ar_instance!
 
       if aggregate_owner
         record.aggregate_owner = aggregate_owner
@@ -292,6 +292,12 @@ def new?
       !id && !vector
     end
 
+    def set_ar_instance!
+      klass = self.class.infer_type_from_hash(model, @attributes)
+      @ar_instance = klass._new_without_sti_type_cast(self) unless @ar_instance.class == klass
+      @ar_instance
+    end
+
     class << self
       def infer_type_from_hash(klass, hash)
         klass = klass.base_class
@@ -300,9 +306,9 @@ def infer_type_from_hash(klass, hash)
         begin
           return Object.const_get(type)
         rescue Exception => e
-          message = "Could not subclass #{@model_klass.model_name} as #{type}.  Perhaps #{type} class has not been required. Exception: #{e}"
+          message = "Could not subclass #{klass} as #{type}.  Perhaps #{type} class has not been required. Exception: #{e}"
           `console.error(#{message})`
-        end if type
+        end unless !type || type == ''
         klass
       end
 

lib/reactive_record/active_record/reactive_record/collection.rb

@@ -128,7 +128,9 @@ def apply_to_all_collections(method, record, dont_gather)
           unless dont_gather
             related_records = collection.gather_related_records(record)
           end
+          puts "about to do #{collection}.#{method}(#{related_records.count}, record) (collection.send)"
           collection.send method, related_records, record
+          puts "done"
         end
       end
     end
@@ -142,9 +144,12 @@ def gather_related_records(record, related_records = Set.new)
     end
 
     def merge_related_records(record, related_records)
+      puts "#{self}.merge_related_records(#{record}, #{related_records.count})"
       if filter? && joins_with?(record)
+        puts "merging #{self}"
         related_records.merge(related_records_for(record))
       end
+      puts "merge_related_records returns #{related_records.count}"
       related_records
     end
 
@@ -155,14 +160,22 @@ def filter?
     # is it necessary to check @association in the next 2 methods???
 
     def joins_with?(record)
-      if @association && @association.through_association
+      klass = record.class
+      if @association&.through_association
         @association.through_association.klass == record.class
-      else
-        @target_klass == record.class
-      end
+      elsif @target_klass == klass
+        true
+      elsif !klass.inheritance_column
+        false
+      elsif klass.base_class == @target_class
+        klass < @target_klass
+      elsif klass.base_class == klass
+        @target_klass < klass
+      end.tap { |x| puts "#{self}.joins_with?(#{record}) returns #{x}"}
     end
 
     def related_records_for(record)
+      puts "#{self}.related_records_for(#{record}), @association = #{@association}"
       return [] unless @association
       attrs = record.attributes
       return [] unless attrs[@association.inverse_of] == @owner
@@ -195,6 +208,7 @@ def set_pre_sync_related_records(related_records, _record = nil)
       live_scopes.each { |scope| scope.set_pre_sync_related_records(@pre_sync_related_records) }
     end
 
+    # NOTE sync_scopes is overridden in scope_description.rb
     def sync_scopes(related_records, record, filtering = true)
       #related_records = related_records.intersection([*@collection])
       #related_records = in_this_collection related_records

lib/reactive_record/active_record/reactive_record/getters.rb

@@ -8,7 +8,7 @@ def get_belongs_to(assoc, reload = nil)
         value = Base.fetch_from_db([@model, [:find, id], attr, @model.primary_key]) if id.present?
         value = find_association(assoc, value)
         sync_ignore_dummy attr, value, has_key
-      end
+      end&.cast_to_current_sti_type
     end
 
     def get_has_many(assoc, reload = nil)