hyper-model 1.0.alpha1.4 → 1.0.alpha1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0583cd6276013eed8abad6c7e12454455c6915e9773eb195b51977c8d748217f'
-  data.tar.gz: a3e3f3e0aa5065281103566c6178bd2e4045a09863e1697d7587a5d2321f17dc
+  metadata.gz: a2458d824d9c7121f8e628dca72a9df1f6a87ecfc947361046887ea1eca56657
+  data.tar.gz: 4e6d8aa0a03d07c0080d73aa8bddbc876c1fa56eaebca3f7615425914f8fee07
 SHA512:
-  metadata.gz: 7d21d5c7def5a3217d00757c611042da17efcaf639eba5fd5c021f79ffaa7e9f98334186d51c5c5353188c56b528286b91cc3d48ed4e8ecadf73cdae40cae04e
-  data.tar.gz: 5aeaf368b37b2f4224ec0d7d3af83f44708f9093e97f7261d49d65e78af6ac0e5078c055d4fb974b4c2041491911087175e12e5988fc6873bec17ed388dee8ff
+  metadata.gz: 2e0e89354d96b059f62b51023a568e2b334ac2b47bc5940bc8ac6621940259e0b03ec90a61e5e9e135a07954d0cd75a93c6f765486412f80470aedb5a5dc96d0
+  data.tar.gz: 6b1642506f04f6fc00fd6e6be388632e1157e6405c629928a61d5a8d525fac8666b0f6611d4e261060573b2dc3b184ea3fe0c5640f1a955d2193899b6223202e

data/lib/active_record_base.rb

@@ -255,7 +255,7 @@ module ActiveRecord
           pre_syncromesh_has_many name, *args, opts.except(:regulate), &block
         end
 
-        %i[belongs_to has_one].each do |macro|
+        %i[belongs_to has_one composed_of].each do |macro|
           alias_method :"pre_syncromesh_#{macro}", macro
           define_method(macro) do |name, *aargs, &block|
             define_method(:"__secure_remote_access_to_#{name}") do |this, _acting_user, *args|

data/lib/hyper-model.rb

@@ -20,6 +20,7 @@ if RUBY_ENGINE == 'opal'
   require "reactive_record/active_record/reactive_record/isomorphic_base"
   require 'reactive_record/active_record/reactive_record/dummy_value'
   require 'reactive_record/active_record/reactive_record/column_types'
+  require 'reactive_record/active_record/reactive_record/dummy_polymorph'
   require "reactive_record/active_record/aggregations"
   require "reactive_record/active_record/associations"
   require "reactive_record/active_record/reactive_record/backing_record_inspector"

data/lib/hyper_model/version.rb

@@ -1,3 +1,3 @@
 module HyperModel
-  VERSION = '1.0.alpha1.4'
+  VERSION = '1.0.alpha1.5'
 end

data/lib/hyper_react/input_tags.rb

@@ -42,7 +42,8 @@ module Hyperstack
               Hyperstack::Internal::Component::RenderingContext.render(tag, opts) { children.each(&:render) }
             end
           end
-          const_set component, klass
+
+          Object.const_set component, klass
         end
       end
     end

data/lib/reactive_record/active_record/associations.rb

@@ -38,16 +38,45 @@ module ActiveRecord
       attr_reader :macro
       attr_reader :owner_class
       attr_reader :source
+      attr_reader :source_type
+      attr_reader :options
+      attr_reader :polymorphic_type_attribute
 
       def initialize(owner_class, macro, name, options = {})
         owner_class.reflect_on_all_associations << self
         @owner_class = owner_class
         @macro =       macro
         @options =     options
-        @klass_name =  options[:class_name] || (collection? && name.camelize.singularize) || name.camelize
-        @association_foreign_key = options[:foreign_key] || (macro == :belongs_to && "#{name}_id") || "#{@owner_class.name.underscore}_id"
-        @source = options[:source] || @klass_name.underscore if options[:through]
+        unless options[:polymorphic]
+          @klass_name = options[:class_name] || (collection? && name.camelize.singularize) || name.camelize
+        end
+
+        if @klass_name < ActiveRecord::Base
+          @klass = @klass_name
+          @klass_name = @klass_name.name
+        end rescue nil
+
+        @association_foreign_key =
+          options[:foreign_key] ||
+          (macro == :belongs_to && "#{name}_id") ||
+          (options[:as] && "#{options[:as]}_id") ||
+          (options[:polymorphic] && "#{name}_id") ||
+          "#{@owner_class.name.underscore}_id"
+        if options[:through]
+          @source = options[:source] || @klass_name.underscore
+          @source_type = options[:source_type] || @klass_name
+        end
+        @polymorphic_type_attribute = "#{name}_type" if options[:polymorphic]
         @attribute = name
+        @through_associations = Hash.new { |_h, k| [] unless k }
+      end
+
+      def collection?
+        @macro == :has_many
+      end
+
+      def singular?
+        @macro != :has_many
       end
 
       def through_association
@@ -62,63 +91,119 @@ module ActiveRecord
 
       alias through_association? through_association
 
-      def through_associations
+      # class Membership < ActiveRecord::Base
+      #   belongs_to :uzer
+      #   belongs_to :memerable, polymorphic: true
+      # end
+      #
+      # class Project < ActiveRecord::Base
+      #   has_many :memberships, as: :memerable, dependent: :destroy
+      #   has_many :uzers, through: :memberships
+      # end
+      #
+      # class Group < ActiveRecord::Base
+      #   has_many :memberships, as: :memerable, dependent: :destroy
+      #   has_many :uzers, through: :memberships
+      # end
+      #
+      # class Uzer < ActiveRecord::Base
+      #   has_many :memberships
+      #   has_many :groups,   through: :memberships, source: :memerable, source_type: 'Group'
+      #   has_many :projects, through: :memberships, source: :memerable, source_type: 'Project'
+      # end
+
+      # so find the belongs_to relationship whose attribute == ta.source
+      # now find the inverse of that relationship using source_value as the model
+      # now find any has many through relationships that use that relationship as there source.
+      # each of those attributes in the source_value have to be updated.
+
+      # self is the through association
+
+
+      def through_associations(model)
+        # given self is a belongs_to association currently pointing to model
         # find all associations that use the inverse association as the through association
         # that is find all associations that are using this association in a through relationship
-        @through_associations ||= klass.reflect_on_all_associations.select do |assoc|
-          assoc.through_association && assoc.inverse == self
+        the_klass = klass(model)
+        @through_associations[the_klass] ||= the_klass.reflect_on_all_associations.select do |assoc|
+          assoc.through_association&.inverse == self
         end
       end
 
-      def source_associations
-        # find all associations that use this association as the source
-        # that is final all associations that are using this association as the source in a
-        # through relationship
-        @source_associations ||= owner_class.reflect_on_all_associations.collect do |sibling|
-          sibling.klass.reflect_on_all_associations.select do |assoc|
-            assoc.source == attribute
+      def source_belongs_to_association  # private
+        # given self is a has_many_through association return the corresponding belongs_to association
+        # for the source
+        @source_belongs_to_association ||=
+          through_association.inverse.owner_class.reflect_on_all_associations.detect do |sibling|
+            sibling.attribute == source
           end
-        end.flatten
       end
 
-      def inverse
-        @inverse ||=
-          through_association ? through_association.inverse : find_inverse
+      def source_associations(model)
+        # given self is a has_many_through association find the source_association for the given model
+        source_belongs_to_association.through_associations(model)
       end
 
-      def inverse_of
-        @inverse_of ||= inverse.attribute
+      alias :polymorphic? polymorphic_type_attribute
+
+      def inverse(model = nil)
+        return @inverse if @inverse
+        ta = through_association
+        found = ta ? ta.inverse : find_inverse(model)
+        @inverse = found unless polymorphic?
+        found
       end
 
-      def find_inverse
-        klass.reflect_on_all_associations.each do |association|
+      def inverse_of(model = nil)
+        inverse(model).attribute
+      end
+
+      def find_inverse(model)  # private
+        the_klass = klass(model)
+        the_klass.reflect_on_all_associations.each do |association|
           next if association.association_foreign_key != @association_foreign_key
-          next if association.klass != @owner_class
           next if association.attribute == attribute
-          return association if klass == association.owner_class
+          return association if association.polymorphic? || association.klass == owner_class
         end
+        raise "could not find inverse of polymorphic belongs_to: #{model.inspect} #{self.inspect}" if options[:polymorphic]
         # instead of raising an error go ahead and create the inverse relationship if it does not exist.
         # https://github.com/hyperstack-org/hyperstack/issues/89
         if macro == :belongs_to
-          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{klass}.has_many :#{@owner_class.name.underscore.pluralize}, foreign_key: #{@association_foreign_key}", :warning
-          klass.has_many @owner_class.name.underscore.pluralize, foreign_key: @association_foreign_key
+          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{the_klass}.has_many :#{@owner_class.name.underscore.pluralize}, foreign_key: #{@association_foreign_key}", :warning
+          the_klass.has_many @owner_class.name.underscore.pluralize, foreign_key: @association_foreign_key
+        elsif options[:as]
+          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{the_klass}.belongs_to :#{options[:as]}, polymorphic: true", :warning
+          the_klass.belongs_to options[:as], polymorphic: true
         else
-          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{klass}.belongs_to :#{@owner_class.name.underscore}, foreign_key: #{@association_foreign_key}", :warning
-          klass.belongs_to @owner_class.name.underscore, foreign_key: @association_foreign_key
+          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{the_klass}.belongs_to :#{@owner_class.name.underscore}, foreign_key: #{@association_foreign_key}", :warning
+          the_klass.belongs_to @owner_class.name.underscore, foreign_key: @association_foreign_key
         end
       end
 
-      def klass
-        @klass ||= Object.const_get(@klass_name)
+      def klass(model = nil)
+        @klass ||= Object.const_get(@klass_name) if @klass_name
+        if @klass && model && !(model.class <= @klass || @klass <= model.class)
+          # TODO: added || @klass <= model.class can both cases really happen I guess so
+          raise "internal error: provided model #{model} is not subclass of #{@klass}"
+        end
+        raise 'no model supplied for polymorphic relationship' unless @klass || model
+        @klass || model.class
       end
 
       def collection?
         [:has_many].include? @macro
       end
 
-    end
+      def remove_member(member, owner)
+        collection = owner.attributes[attribute]
+        return if collection.nil?
+        collection.delete(member)
+      end
 
+      def add_member(member, owner)
+        owner.attributes[attribute] ||= ReactiveRecord::Collection.new(owner_class, owner, self)
+        owner.attributes[attribute]._internal_push member
+      end
+    end
   end
-
-
 end

data/lib/reactive_record/active_record/class_methods.rb

@@ -172,7 +172,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,
@@ -185,7 +185,10 @@ module ActiveRecord
     ]
 
     def method_missing(name, *args, &block)
-      if args.count == 1 && name.start_with?("find_by_") && !block
+      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)
@@ -336,14 +339,34 @@ module ActiveRecord
       end
     end
 
+    # def define_attribute_methods
+    #   columns_hash.each do |name, column_hash|
+    #     next if name == primary_key
+    #     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("#{name}=") { |val| @backing_record.set_attr_value(name, val) } 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
+
+
     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? }
+        # 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("#{name}=") { |val| @backing_record.set_attr_value(name, val) } 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
@@ -373,22 +396,53 @@ module ActiveRecord
 
             associations = reflect_on_all_associations
 
+            already_processed_keys = Set.new
+            old_param = param.dup
+
             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
+
+              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
+                  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]]
               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,22 @@
 module ActiveRecord
   module InstanceMethods
+
+    def method_missing(missing, *args, &block)
+      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
+
     def inspect
       "<#{model_name}:#{ReactiveRecord::Operations::Base::FORMAT % to_key} "\
       "(#{ReactiveRecord::Operations::Base::FORMAT % object_id}) "\
@@ -81,7 +98,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)