hyper-model 1.0.alpha1.2 → 1.0.alpha1.7

data/lib/reactive_record/active_record/base.rb

@@ -6,5 +6,37 @@ module ActiveRecord
 
     scope :limit, ->() {}
     scope :offset, ->() {}
+
+    finder_method :__hyperstack_internal_scoped_last
+    scope :__hyperstack_internal_scoped_last_n, ->(n) { last(n) }
+
+    def self.where(*args)
+      if args[0].is_a? Hash
+        # we can compute membership in the scope when the arg is a hash
+        __hyperstack_internal_where_hash_scope(args[0])
+      else
+        # otherwise the scope has to always be computed on the server
+        __hyperstack_internal_where_sql_scope(*args)
+      end
+    end
+
+    scope :__hyperstack_internal_where_hash_scope,
+          client: ->(attrs) { !attrs.detect { |k, v| self[k] != v } }
+
+    scope :__hyperstack_internal_where_sql_scope
+
+    ReactiveRecord::ScopeDescription.new(
+      self, :___hyperstack_internal_scoped_find_by,
+      client: ->(attrs) { !attrs.detect { |attr, value| attributes[attr] != value } }
+    )
+
+    def self.__hyperstack_internal_scoped_find_by(attrs)
+      collection = all.apply_scope(:___hyperstack_internal_scoped_find_by, attrs).observed
+      if !collection.collection
+        collection._find_by_initializer(self, attrs)
+      else
+        collection.first
+      end
+    end
   end
 end

data/lib/reactive_record/active_record/class_methods.rb

@@ -1,11 +1,20 @@
 module ActiveRecord
-
   module ClassMethods
-
-    alias _new_without_sti_type_cast new
-
-    def new(*args, &block)
-      _new_without_sti_type_cast(*args, &block).cast_to_current_sti_type
+    begin
+      # Opal 0.11 super did not work with new, but new was defined
+      alias _new_without_sti_type_cast new
+      def new(*args, &block)
+        _new_without_sti_type_cast(*args, &block).cast_to_current_sti_type
+      end
+    rescue NameError
+      def self.extended(base)
+        base.singleton_class.class_eval do
+          alias_method :_new_without_sti_type_cast, :new
+          define_method :new do |*args, &block|
+            _new_without_sti_type_cast(*args, &block).cast_to_current_sti_type
+          end
+        end
+      end
     end
 
     def base_class
@@ -51,14 +60,27 @@ module ActiveRecord
       @model_name ||= ActiveModel::Name.new(self)
     end
 
-    def find(id)
-      ReactiveRecord::Base.find(self, primary_key => id)
+    def __hyperstack_preprocess_attrs(attrs)
+      if inheritance_column && self < base_class && !attrs.key?(inheritance_column)
+        attrs = attrs.merge(inheritance_column => model_name.to_s)
+      end
+      dealiased_attrs = {}
+      attrs.each { |attr, value| dealiased_attrs[_dealias_attribute(attr)] = value }
+      dealiased_attrs
+    end
+
+    def find(*args)
+      args = args[0] if args[0].is_a? Array
+      return args.collect { |id| find(id) } if args.count > 1
+      find_by(primary_key => args[0])
     end
 
-    def find_by(opts = {})
-      dealiased_opts = {}
-      opts.each { |attr, value| dealiased_opts[_dealias_attribute(attr)] = value }
-      ReactiveRecord::Base.find(self, dealiased_opts)
+    def find_by(attrs = {})
+      attrs = __hyperstack_preprocess_attrs(attrs)
+      # r = ReactiveRecord::Base.find_locally(self, attrs, new_only: true)
+      # return r.ar_instance if r
+      (r = __hyperstack_internal_scoped_find_by(attrs)) || return
+      r.backing_record.sync_attributes(attrs).set_ar_instance!
     end
 
     def enum(*args)
@@ -162,7 +184,7 @@ module ActiveRecord
       :full_table_name_prefix, :full_table_name_suffix, :reset_sequence_name, :sequence_name=, :next_sequence_value, :column_defaults, :content_columns,
       :readonly_attributes, :attr_readonly, :create, :create!, :instantiate, :find, :type_caster, :arel_table, :find_by, :find_by!, :initialize_find_by_cache,
       :generated_association_methods, :arel_engine, :arel_attribute, :predicate_builder, :collection_cache_key, :relation_delegate_class,
-      :initialize_relation_delegate_cache, :enum, :collecting_queries_for_explain, :exec_explain, :i18n_scope, :lookup_ancestors, :human_attribute_name,
+      :initialize_relation_delegate_cache, :enum, :collecting_queries_for_explain, :exec_explain, :i18n_scope, :lookup_ancestors,
       :references, :uniq, :maximum, :none, :exists?, :second, :limit, :order, :eager_load, :update, :delete_all, :destroy, :ids, :many?, :pluck, :third,
       :delete, :fourth, :fifth, :forty_two, :second_to_last, :third_to_last, :preload, :sum, :take!, :first!, :last!, :second!, :offset, :select, :fourth!,
       :third!, :third_to_last!, :fifth!, :where, :first_or_create, :second_to_last!, :forty_two!, :first, :having, :any?, :one?, :none?, :find_or_create_by,
@@ -175,8 +197,11 @@ module ActiveRecord
     ]
 
     def method_missing(name, *args, &block)
-      if args.count == 1 && name.start_with?("find_by_") && !block
-        find_by(_dealias_attribute(name.sub(/^find_by_/, "")) => args[0])
+      if name == 'human_attribute_name'
+        opts = args[1] || {}
+        opts[:default] || args[0]
+      elsif args.count == 1 && name.start_with?("find_by_") && !block
+        find_by(name.sub(/^find_by_/, '') => args[0])
       elsif [].respond_to?(name)
         all.send(name, *args, &block)
       elsif name.end_with?('!')
@@ -193,16 +218,6 @@ module ActiveRecord
     # Any method ending with ! just means apply the method after forcing a reload
     # from the DB.
 
-    # alias pre_synchromesh_method_missing method_missing
-    #
-    # def method_missing(name, *args, &block)
-    #   return all.send(name, *args, &block) if [].respond_to?(name)
-    #   if name.end_with?('!')
-    #     return send(name.chop, *args, &block).send(:reload_from_db) rescue nil
-    #   end
-    #   pre_synchromesh_method_missing(name, *args, &block)
-    # end
-
     def create(*args, &block)
       new(*args).save(&block)
     end
@@ -213,9 +228,6 @@ module ActiveRecord
       singleton_class.send(:define_method, name) do |*vargs|
         all.build_child_scope(scope_description, *name, *vargs)
       end
-      # singleton_class.send(:define_method, "#{name}=") do |_collection|
-      #   raise 'NO LONGER IMPLEMENTED - DOESNT PLAY WELL WITH SYNCHROMESH'
-      # end
     end
 
     def default_scope(*args, &block)
@@ -249,10 +261,6 @@ module ActiveRecord
       end
     end
 
-    # def all=(_collection)
-    #   raise "NO LONGER IMPLEMENTED DOESNT PLAY WELL WITH SYNCHROMESH"
-    # end
-
     def unscoped
       ReactiveRecord::Base.unscoped[self] ||=
         ReactiveRecord::Collection
@@ -264,7 +272,8 @@ module ActiveRecord
       ReactiveRecord::ScopeDescription.new(self, "_#{name}", {})
       [name, "#{name}!"].each do |method|
         singleton_class.send(:define_method, method) do |*vargs|
-          all.apply_scope("_#{method}", *vargs).first
+          collection = all.apply_scope("_#{method}", *vargs)
+          collection.first
         end
       end
     end
@@ -298,24 +307,34 @@ module ActiveRecord
         assoc = Associations::AssociationReflection.new(self, macro, name, opts)
         if macro == :has_many
           define_method(name) { @backing_record.get_has_many(assoc, nil) }
-          define_method("#{name}=") { |val| @backing_record.set_has_many(assoc, val) }
+          define_method("_hyperstack_internal_setter_#{name}") { |val| @backing_record.set_has_many(assoc, val) }
         else
           define_method(name) { @backing_record.get_belongs_to(assoc, nil) }
-          define_method("#{name}=") { |val| @backing_record.set_belongs_to(assoc, val) }
+          define_method("_hyperstack_internal_setter_#{name}") { |val| @backing_record.set_belongs_to(assoc, val) }
         end
+        alias_method "#{name}=", "_hyperstack_internal_setter_#{name}"
         assoc
       end
     end
 
+    def table_name
+      @table_name || name.downcase.pluralize
+    end
+
+    def table_name=(name)
+      @table_name = name
+    end
+
     def composed_of(name, opts = {})
       reflection = Aggregations::AggregationReflection.new(base_class, :composed_of, name, opts)
       if reflection.klass < ActiveRecord::Base
         define_method(name) { @backing_record.get_ar_aggregate(reflection, nil) }
-        define_method("#{name}=") { |val| @backing_record.set_ar_aggregate(reflection, val) }
+        define_method("_hyperstack_internal_setter_#{name}") { |val| @backing_record.set_ar_aggregate(reflection, val) }
       else
         define_method(name) { @backing_record.get_non_ar_aggregate(name, nil) }
-        define_method("#{name}=") { |val| @backing_record.set_non_ar_aggregate(reflection, val) }
+        define_method("_hyperstack_internal_setter_#{name}") { |val| @backing_record.set_non_ar_aggregate(reflection, val) }
       end
+      alias_method "#{name}=", "_hyperstack_internal_setter_#{name}"
     end
 
     def column_names
@@ -340,16 +359,31 @@ module ActiveRecord
         vector = args.count.zero? ? name : [[name] + args]
         @backing_record.get_server_method(vector, true)
       end
+      define_method("_hyperstack_internal_setter_#{name}") do |val|
+        backing_record.set_attr_value(name, val)
+      end
     end
 
+    # define all the methods for each column.  To allow overriding the methods they will NOT
+    # be defined if already defined (i.e. by the model)  See the instance_methods module for how
+    # super calls are handled in this case.   The _hyperstack_internal_setter_... methods
+    # are used by the load_from_json method when bringing in data from the server, and so therefore
+    # does not want to be overriden.
+
     def define_attribute_methods
       columns_hash.each do |name, column_hash|
-        next if name == primary_key
-        define_method(name) { @backing_record.get_attr_value(name, nil) }
-        define_method("#{name}!") { @backing_record.get_attr_value(name, true) }
-        define_method("#{name}=") { |val| @backing_record.set_attr_value(name, val) }
-        define_method("#{name}_changed?") { @backing_record.changed?(name) }
-        define_method("#{name}?") { @backing_record.get_attr_value(name, nil).present? }
+        next if name == :id
+        # only add serialized key if its serialized.  This just makes testing a bit
+        # easier by keeping the columns_hash the same if there are no seralized strings
+        # see rspec ./spec/batch1/column_types/column_type_spec.rb:100
+        column_hash[:serialized?] = true if ReactiveRecord::Base.serialized?[self][name]
+
+        define_method(name) { @backing_record.get_attr_value(name, nil) } unless method_defined?(name)
+        define_method("#{name}!") { @backing_record.get_attr_value(name, true) } unless method_defined?("#{name}!")
+        define_method("_hyperstack_internal_setter_#{name}") { |val| @backing_record.set_attr_value(name, val) }
+        alias_method "#{name}=", "_hyperstack_internal_setter_#{name}" unless method_defined?("#{name}=")
+        define_method("#{name}_changed?") { @backing_record.changed?(name) } unless method_defined?("#{name}_changed?")
+        define_method("#{name}?") { @backing_record.get_attr_value(name, nil).present? } unless method_defined?("#{name}?")
       end
       self.inheritance_column = nil if inheritance_column && !columns_hash.key?(inheritance_column)
     end
@@ -370,29 +404,67 @@ module ActiveRecord
             # TODO: changed values as changes while just updating the synced values.
             target =
               if param[primary_key]
-                find(param[primary_key])
+                ReactiveRecord::Base.find(self, primary_key => param[primary_key]).tap do |r|
+                  r.backing_record.loaded_id = param[primary_key]
+                end
               else
                 new
               end
 
             associations = reflect_on_all_associations
 
+            already_processed_keys = Set.new
+
             param = param.collect do |key, value|
-              assoc = associations.detect do |association|
-                association.association_foreign_key == key
+              next if already_processed_keys.include? key
+
+              model_name = model_id = nil
+
+              # polymorphic association is where the belongs_to side holds the
+              # id, and the type of the model the id points to
+
+              # belongs_to :duplicate_of, class_name: 'Report', required: false
+              # has_many :duplicates, class_name: 'Report', foreign_key: 'duplicate_of_id'
+
+              assoc = associations.detect do |poly_assoc|
+                if key == poly_assoc.polymorphic_type_attribute
+                  model_name = value
+                  already_processed_keys << poly_assoc.association_foreign_key
+                elsif key == poly_assoc.association_foreign_key && (poly_assoc.polymorphic_type_attribute || poly_assoc.macro == :belongs_to)
+                  model_id = value
+                  already_processed_keys << poly_assoc.polymorphic_type_attribute
+                end
               end
 
               if assoc
-                if value
-                  [assoc.attribute, { id: [value] }]
-                else
+                if !value
                   [assoc.attribute, [nil]]
+                elsif assoc.polymorphic?
+                  model_id ||= param.detect { |k, *| k == assoc.association_foreign_key }&.last
+                  model_id ||= target.send(assoc.attribute)&.id
+                  if model_id.nil?
+                    raise "Error in #{self.name}._react_param_conversion. \n"\
+                          "Could not determine the id of #{assoc.attribute} of #{target.inspect}.\n"\
+                          "It was not provided in the conversion data, "\
+                          "and it is unknown on the client"
+                  end
+                  model_name ||= param.detect { |k, *| k == assoc.polymorphic_type_attribute }&.last
+                  model_name ||= target.send(assoc.polymorphic_type_attribute)
+                  unless Object.const_defined?(model_name)
+                    raise "Error in #{self.name}._react_param_conversion. \n"\
+                          "Could not determine the type of #{assoc.attribute} of #{target.inspect}.\n"\
+                          "It was not provided in the conversion data, "\
+                          "and it is unknown on the client"
+                  end
+
+                  [assoc.attribute, { id: [model_id], model_name: [model_name] }]
+                else
+                  [assoc.attribute, { id: [value]}]
                 end
               else
-                [key, [value]]
+                [*key, [value]]
               end
-            end
-            # TODO: verify wrapping with load_data was added so broadcasting works in 1.0.0.lap28
+            end.compact
             ReactiveRecord::Base.load_data do
               ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
             end

data/lib/reactive_record/active_record/error.rb

@@ -24,6 +24,8 @@ module ActiveModel
       @messages.clear
     end
 
+    alias non_reactive_clear clear
+
     def add(attribute, message = :invalid, _options = {})
       @messages[attribute] << message unless @messages[attribute].include? message
     end

data/lib/reactive_record/active_record/errors.rb

@@ -89,7 +89,7 @@ module ActiveModel
     #   person.errors.values   # => [["cannot be nil", "must be specified"]]
     def values
       messages.select do |key, value|
-        !value.empty?
+        !value&.empty?
       end.values
     end
 
@@ -105,9 +105,9 @@ module ActiveModel
       attr_name =
         attribute.to_s.tr('.', '_').tr('_', ' ').gsub(/_id$/, '').capitalize
       # attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
-      # if @base.class.respond_to?(:human_attribute_name)
+      if @base.class.respond_to?(:human_attribute_name)
         attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
-      # end
+      end
       # I18n.t(:"errors.format",
       #   default:  "%{attribute} %{message}",
       #   attribute: attr_name,
@@ -219,8 +219,12 @@ module ActiveModel
     #   person.errors.clear
     #   person.errors.full_messages # => []
     def clear
+      non_reactive_clear.tap { reactive_empty! true }
+    end
+
+    def non_reactive_clear
       messages.clear
-      details.clear.tap { reactive_empty! true }
+      details.clear
     end
 
     # Merges the errors from <tt>other</tt>.

data/lib/reactive_record/active_record/instance_methods.rb

@@ -1,5 +1,59 @@
 module ActiveRecord
   module InstanceMethods
+
+    # if methods are missing, then they must be a column, which we look up
+    # in the columns_hash.
+
+    # For effeciency all attributes will by default have all the methods defined,
+    # when the class is loaded.  See define_attribute_methods class method.
+    # However a model may override the attribute methods definition, but then call
+    # super.  Which will result in the method missing call.
+
+    # When loading data from the server we do NOT want to call overridden methods
+    # so we also define a _hyperstack_internal_setter_... method for each attribute
+    # as well as for belongs_to relationships, server_methods, and the special
+    # type and model_name methods.  See the ClassMethods module for details.
+
+    # meanwhile in Opal 1.0 there is currently an issue where the name of the method
+    # does not get passed to method_missing from super.
+    # https://github.com/opal/opal/issues/2165
+    # So the following hack works around that issue until its fixed.
+
+    %x{
+      Opal.orig_find_super_dispatcher = Opal.find_super_dispatcher
+      Opal.find_super_dispatcher = function(obj, mid, current_func, defcheck, allow_stubs) {
+        Opal.__name_of_super = mid;
+        return Opal.orig_find_super_dispatcher(obj, mid, current_func, defcheck, allow_stubs)
+      }
+    }
+
+    def method_missing(missing, *args, &block)
+      missing ||= `Opal.__name_of_super`
+      column = self.class.columns_hash.detect { |name, *| missing =~ /^#{name}/ }
+      if column
+        name = column[0]
+        case missing
+        when /\!\z/ then @backing_record.get_attr_value(name, true)
+        when /\=\z/ then @backing_record.set_attr_value(name, *args)
+        when /\_changed\?\z/ then @backing_record.changed?(name)
+        when /\?/ then @backing_record.get_attr_value(name, nil).present?
+        else @backing_record.get_attr_value(name, nil)
+        end
+      else
+        super
+      end
+    end
+
+    # the system assumes that there is "virtual" model_name and type attribute so
+    # we define the internal setter here.  If the user defines some other attributes
+    # or uses these names no harm is done since the exact same method would have been
+    # defined by the define_attribute_methods class method anyway.
+    %i[model_name type].each do |attr|
+      define_method("_hyperstack_internal_setter_#{attr}") do |val|
+        @backing_record.set_attr_value(:model_name, val)
+      end
+    end
+
     def inspect
       "<#{model_name}:#{ReactiveRecord::Operations::Base::FORMAT % to_key} "\
       "(#{ReactiveRecord::Operations::Base::FORMAT % object_id}) "\
@@ -38,7 +92,7 @@ module ActiveRecord
           end
           self.class.load_data do
             h.each do |attribute, value|
-              next if attribute == primary_key
+              next if attribute == :id
               @ar_instance[attribute] = value
               changed_attributes << attribute
             end
@@ -72,8 +126,8 @@ module ActiveRecord
       @backing_record.revert
     end
 
-    def changed?
-      @backing_record.changed?
+    def changed?(attr = nil)
+      @backing_record.changed?(*attr)
     end
 
     def dup
@@ -81,7 +135,11 @@ module ActiveRecord
     end
 
     def ==(ar_instance)
-      @backing_record == ar_instance.instance_eval { @backing_record }
+      return true  if @backing_record == ar_instance.instance_eval { @backing_record }
+      return false unless ar_instance.is_a?(ActiveRecord::Base)
+      return false if ar_instance.new_record?
+      return false unless self.class.base_class == ar_instance.class.base_class
+      id == ar_instance.id
     end
 
     def [](attr)
@@ -104,6 +162,14 @@ module ActiveRecord
       # end
     end
 
+    def increment!(attr)
+      load(attr).then { |current_value| update(attr => current_value + 1) }
+    end
+
+    def decrement!(attr)
+      load(attr).then { |current_value| update(attr => current_value - 1) }
+    end
+
     def load(*attributes, &block)
       first_time = true
       ReactiveRecord.load do
@@ -144,10 +210,12 @@ module ActiveRecord
       @backing_record.destroyed
     end
 
-    def new?
+    def new_record?
       @backing_record.new?
     end
 
+    alias new? new_record?
+
     def errors
       Hyperstack::Internal::State::Variable.get(@backing_record, @backing_record)
       @backing_record.errors