hyper-model 1.0.alpha1.3 → 1.0.alpha1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 071e8cc562ebddf1c0a260587a123d91db9f2a7c52d43b06fcf063079d66129f
-  data.tar.gz: 4cb7539129b7367f3156c0726ac3ed164e1db391f7806457253d303e9940941c
+  metadata.gz: caef9d023cb5294a2d4f95feb2bfea4234adc0b780881da6c011d1d765504203
+  data.tar.gz: c80e5ed0e014d3013250e0b31cd897e086feb89d916c9967e9a08a9ba4ecbce7
 SHA512:
-  metadata.gz: 2c1bcd8fee396593e2f31d072f35cbf88467be2b02c198d523c052b67a211d9fea4501ca86c4f0a388cee35bc34f4ac9156147a13aac9aec4842616a5c3c1772
-  data.tar.gz: c226e31b1882e96c8a7a080114aea90aacdb0bb77331fc36854f79fe118fabd119f278bc20b94d3693bcc69d7382bc6e4d2f1e91c042b41eb660d2214e75c45d
+  metadata.gz: 610334f5accd3678c94efa95b50614efd4d12685c0b288a17cae7ffef4688635657a23b97605e747cc3606a36632a8803d8f159f027cf9653fd514647ad657fc
+  data.tar.gz: 7a6c022f86b1f9718bb162822f8bece902c649dfcdd8891936afed03e57ab7da70374c9fbc85e3544b0d1cc8f3bdfcd3a266cebf98f26dca80c9a34784d7dd74

data/.gitignore

@@ -11,7 +11,6 @@ spec/test_app/tmp/
 spec/test_app/db/test.sqlite3
 spec/test_app/log/test.log
 spec/test_app/log/development.log
-spec/test_app/Gemfile.lock
 /synchromesh-simple-poller-store
 /synchromesh-pusher-channel-store
 /examples/action-cable/rails_cache_dir/
@@ -34,3 +33,7 @@ public/assets/*
 # ingore Idea
 .idea
 .vscode
+
+# ignore Gemfile.locks https://yehudakatz.com/2010/12/16/clarifying-the-roles-of-the-gemspec-and-gemfile/
+/spec/test_app/Gemfile.lock
+/Gemfile.lock

data/.rspec

@@ -1,2 +1 @@
---format documentation
 --color

data/Gemfile

@@ -1,10 +1,11 @@
 source 'https://rubygems.org'
-#gem "opal-jquery", git: "https://github.com/opal/opal-jquery.git", branch: "master"
-# hyper-model is still using an ancient inlined version of hyper-spec
-#gem 'hyper-spec',       path: '../hyper-spec'
-gem 'hyperstack-config', path: '../hyperstack-config'
 gem 'hyper-state',      path: '../hyper-state'
 gem 'hyper-component',  path: '../hyper-component'
 gem 'hyper-operation',  path: '../hyper-operation'
-
+gem 'hyper-spec', path: '../hyper-spec'
+gem 'hyper-trace', path: '../hyper-trace'
+gem 'hyperstack-config', path: '../hyperstack-config'
+unless ENV['OPAL_VERSION']&.match("0.11")
+  gem 'opal-browser', git: 'https://github.com/opal/opal-browser'
+end
 gemspec

data/Rakefile

@@ -1,29 +1,41 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
+def run_batches(batches)
+  failed = false
+  batches.each do |batch|
+    begin
+      Rake::Task["spec:batch#{batch}"].invoke
+    rescue SystemExit
+      failed = true
+    end
+  end
+  exit 1 if failed
+end
+
+
 task :part1 do
-  (1..2).each { |batch| Rake::Task["spec:batch#{batch}"].invoke rescue nil }
+  run_batches(1..2)
 end
 
 task :part2 do
-  (3..4).each { |batch| Rake::Task["spec:batch#{batch}"].invoke rescue nil }
+  run_batches(3..4)
 end
 
 task :part3 do
-  (5..7).each { |batch| Rake::Task["spec:batch#{batch}"].invoke rescue nil }
+  run_batches(5..7)
 end
 
 task :spec do
-  (1..7).each { |batch| Rake::Task["spec:batch#{batch}"].invoke rescue nil }
+  run_batches(1..7)
 end
 
 namespace :spec do
   task :prepare do
-    sh %(cd spec/test_app; bundle exec rails db:setup)
+    sh %(cd spec/test_app; rm db/schema.rb; RAILS_ENV=test bundle exec rails db:setup; RAILS_ENV=test bundle exec rails db:migrate)
   end
   (1..7).each do |batch|
     RSpec::Core::RakeTask.new(:"batch#{batch}") do |t|
-      t.fail_on_error = false unless batch == 7
       t.pattern = "spec/batch#{batch}/**/*_spec.rb"
     end
   end

data/hyper-model.gemspec

@@ -27,31 +27,24 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'activemodel'
   spec.add_dependency 'activerecord', '>= 4.0.0'
-  spec.add_dependency 'hyper-component', HyperModel::VERSION
   spec.add_dependency 'hyper-operation', HyperModel::VERSION
-  spec.add_development_dependency 'bundler', ['>= 1.17.3', '< 2.1']
-  spec.add_development_dependency 'capybara'
-  spec.add_development_dependency 'chromedriver-helper', '1.2.0'
-  spec.add_development_dependency 'libv8'
-  spec.add_development_dependency 'mini_racer', '~> 0.2.4'
-  spec.add_development_dependency 'selenium-webdriver'
+
+  spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'factory_bot_rails'
-  #spec.add_development_dependency 'hyper-spec', HyperModel::VERSION
-  spec.add_development_dependency 'mysql2'
-  spec.add_development_dependency 'opal-activesupport', '~> 0.3.1'
-  spec.add_development_dependency 'opal-browser', '~> 0.2.0'
-  spec.add_development_dependency 'opal-rails', '~> 0.9.4'
-  spec.add_development_dependency 'parser'
-  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'hyper-spec', HyperModel::VERSION
+  spec.add_development_dependency 'hyper-trace', HyperModel::VERSION
+  spec.add_development_dependency 'mini_racer'
+  spec.add_development_dependency 'pg'
+  spec.add_development_dependency 'opal-rails', '>= 0.9.4', '< 2.0'
   spec.add_development_dependency 'pry-rescue'
+  spec.add_development_dependency 'pry-stack_explorer'
   spec.add_development_dependency 'puma'
   spec.add_development_dependency 'pusher'
   spec.add_development_dependency 'pusher-fake'
-  spec.add_development_dependency 'rails', '>= 4.0.0'
+  spec.add_development_dependency 'rails', ENV['RAILS_VERSION'] || '>= 5.0.0', '< 7.0'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'react-rails', '>= 2.4.0', '< 2.5.0'
-  spec.add_development_dependency 'reactrb-rails-generator'
   spec.add_development_dependency 'rspec-collection_matchers'
   spec.add_development_dependency 'rspec-expectations'
   spec.add_development_dependency 'rspec-its'
@@ -59,11 +52,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec-rails'
   spec.add_development_dependency 'rspec-steps', '~> 2.1.1'
   spec.add_development_dependency 'rspec-wait'
-  spec.add_development_dependency 'rubocop', '~> 0.51.0'
+  spec.add_development_dependency 'rubocop' #, '~> 0.51.0'
   spec.add_development_dependency 'shoulda'
   spec.add_development_dependency 'shoulda-matchers'
-  spec.add_development_dependency 'spring-commands-rspec'
-  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'spring-commands-rspec', '~> 1.0.4'
+  spec.add_development_dependency 'sqlite3', '~> 1.4.2' # see https://github.com/rails/rails/issues/35153, '~> 1.3.6'
   spec.add_development_dependency 'timecop', '~> 0.8.1'
-  spec.add_development_dependency 'unparser'
 end

data/lib/active_record_base.rb

@@ -5,17 +5,46 @@ module ActiveRecord
   # processes these arguments, and the will always leave the true server side scoping
   # proc in the `:server` opts.   This method is common to client and server.
   class Base
-    def self._synchromesh_scope_args_check(args)
-      opts = if args.count == 2 && args[1].is_a?(Hash)
-               args[1].merge(server: args[0])
-             elsif args[0].is_a? Hash
-               args[0]
-             else
-               { server: args[0] }
-             end
-      return opts if opts && opts[:server].respond_to?(:call)
-      raise 'must provide either a proc as the first arg or by the '\
-            '`:server` option to scope and default_scope methods'
+    class << self
+      def _synchromesh_scope_args_check(args)
+        opts = if args.count == 2 && args[1].is_a?(Hash)
+                 args[1].merge(server: args[0])
+               elsif args[0].is_a? Hash
+                 args[0]
+               else
+                 { server: args[0] }
+               end
+        return opts if opts[:server].respond_to?(:call) || RUBY_ENGINE == 'opal'
+        raise 'must provide either a proc as the first arg or by the '\
+              '`:server` option to scope and default_scope methods'
+      end
+
+      alias pre_hyperstack_has_and_belongs_to_many has_and_belongs_to_many unless RUBY_ENGINE == 'opal'
+
+      def has_and_belongs_to_many(other, opts = {}, &block)
+        join_table_name = [other.to_s, table_name].sort.join('_')
+        join_model_name = "HyperstackInternalHabtm#{join_table_name.singularize.camelize}"
+        join_model =
+          if Object.const_defined? join_model_name
+            Object.const_get(join_model_name)
+          else
+            Object.const_set(join_model_name, Class.new(ActiveRecord::Base))
+          end
+
+        join_model.class_eval { belongs_to other.to_s.singularize.to_sym }
+
+        has_many join_model_name.underscore.pluralize.to_sym
+
+        if RUBY_ENGINE == 'opal'
+          Object.const_set("HABTM_#{other.to_s.camelize}", join_model)
+          join_model.inheritance_column = nil
+          has_many other, through: join_model_name.underscore.pluralize.to_sym
+        else
+          join_model.table_name = join_table_name
+          join_model.belongs_to other
+          pre_hyperstack_has_and_belongs_to_many(other, opts, &block)
+        end
+      end
     end
   end
   if RUBY_ENGINE != 'opal'
@@ -87,7 +116,7 @@ module ActiveRecord
               this.acting_user = acting_user
               # returns a PsuedoRelationArray which will respond to the
               # __secure_collection_check method
-              ReactiveRecordPsuedoRelationArray.new([this.instance_exec(*args, &block)])
+              ReactiveRecordPsuedoRelationArray.new([*this.instance_exec(*args, &block)])
             ensure
               this.acting_user = old
             end
@@ -255,21 +284,7 @@ module ActiveRecord
           pre_syncromesh_has_many name, *args, opts.except(:regulate), &block
         end
 
-        # add secure access for find, find_by, and belongs_to and has_one relations.
-        # No explicit security checks are needed here, as the data returned by these objects
-        # will be further processedand checked before returning.  I.e. it is not possible to
-        # simply return `find(1)` but if you try returning `find(1).name` the permission system
-        # will check to see if the name attribute can be legally sent to the current acting user.
-
-        def __secure_remote_access_to_find(_self, _acting_user, *args)
-          find(*args)
-        end
-
-        def __secure_remote_access_to_find_by(_self, _acting_user, *args)
-          find_by(*args)
-        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|
@@ -284,6 +299,12 @@ module ActiveRecord
         Hyperstack::InternalPolicy.raise_operation_access_violation(:scoped_denied, "#{self.class} regulation denies scope access.  Called from #{caller_locations(1)}")
       end
 
+      unless method_defined? :saved_changes # for backwards compatibility to Rails < 5.1.7
+        def saved_changes
+          previous_changes
+        end
+      end
+
       # call do_not_synchronize to block synchronization of a model
 
       def self.do_not_synchronize
@@ -300,17 +321,28 @@ module ActiveRecord
         self.class.do_not_synchronize?
       end
 
+      before_create  :synchromesh_mark_update_time
+      before_update  :synchromesh_mark_update_time
+      before_destroy :synchromesh_mark_update_time
+
+      attr_reader :__synchromesh_update_time
+
+      def synchromesh_mark_update_time
+        @__synchromesh_update_time = Time.now.to_f
+      end
+
       after_commit :synchromesh_after_create,  on: [:create]
       after_commit :synchromesh_after_change,  on: [:update]
       after_commit :synchromesh_after_destroy, on: [:destroy]
 
       def synchromesh_after_create
+        puts "#{self}.synchromesh_after_create: #{do_not_synchronize?} channels: #{Hyperstack::Connection.active}" if Hyperstack::Connection.show_diagnostics
         return if do_not_synchronize?
         ReactiveRecord::Broadcast.after_commit :create, self
       end
 
       def synchromesh_after_change
-        return if do_not_synchronize? || previous_changes.empty?
+        return if do_not_synchronize? || saved_changes.empty?
         ReactiveRecord::Broadcast.after_commit :change, self
       end
 
@@ -329,6 +361,41 @@ module ActiveRecord
       %i[limit offset].each do |scope|
         regulate_scope(scope) {}
       end
+
+      finder_method :__hyperstack_internal_scoped_last do
+        last
+      end
+
+      scope :__hyperstack_internal_scoped_last_n, ->(n) { last(n) }
+
+      # implements find_by inside of scopes.  For security reasons we return nil
+      # if we cannot view at least the id of found record.  Otherwise a hacker
+      # could tell if a record exists depending on whether an access violation
+      # (i.e. it exists) or nil (it doesn't exist is returned.)  Note that
+      # view of id is permitted as long as any attribute of the record is
+      # accessible.
+      finder_method :__hyperstack_internal_scoped_find_by do |attrs|
+        begin
+          found = find_by(attrs)
+          found && found.check_permission_with_acting_user(acting_user, :view_permitted?, :id)
+        rescue Hyperstack::AccessViolation => e
+          message = []
+          message << Pastel.new.red("\n\nHYPERSTACK Access violation during find_by operation.")
+          message << Pastel.new.red("Access to the found record's id is not permitted. nil will be returned")
+          message << "    #{self.name}.find_by("
+          message << attrs.collect do |attr, value|
+            "      #{attr}: '#{value.inspect.truncate(120, separator: '...')}'"
+          end.join(",\n")
+          message << "    )"
+          message << "\n#{e.details}\n"
+          Hyperstack.on_error('find_by', self, attrs, message.join("\n"))
+          nil
+        end
+      end
+
+      scope :__hyperstack_internal_where_hash_scope, ->(*args) { where(*args) }
+
+      scope :__hyperstack_internal_where_sql_scope, ->(*args) { where(*args) }
     end
   end
 

data/lib/enumerable/pluck.rb

@@ -1,6 +1,7 @@
 # Add pluck to enumerable... its already done for us in rails 5+
 module Enumerable
-  def pluck(key)
-    map { |element| element[key] }
+  def pluck(*keys)
+    map { |element| keys.map { |key| element[key] } }
+      .flatten(keys.count > 1 ? 0 : 1)
   end
 end unless Enumerable.method_defined? :pluck

data/lib/hyper-model.rb

@@ -1,6 +1,8 @@
 require 'set'
 require 'hyperstack-config'
-require 'hyper-component'
+
+Hyperstack.import 'hyper-model'
+
 if RUBY_ENGINE == 'opal'
   require 'hyper-operation'
   require 'active_support'
@@ -20,6 +22,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.3'
+  VERSION = '1.0.alpha1.8'
 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

@@ -3,7 +3,7 @@ module ActiveRecord
   class Base
 
     def self.reflect_on_all_associations
-      base_class.instance_eval { @associations ||= superclass.instance_eval { (@associations && @associations.dup) || [] } }
+      @associations ||= superclass.instance_eval { @associations&.dup || [] }
     end
 
     def self.reflect_on_association(attr)
@@ -11,7 +11,7 @@ module ActiveRecord
     end
 
     def self.reflect_on_association_by_foreign_key(key)
-      reflection_finder { |assoc| assoc.association_foreign_key == key }
+      reflection_finder { |assoc| assoc.association_foreign_key == key && assoc.macro != :has_many }
     end
 
     def self.reflection_finder(&block)
@@ -32,22 +32,55 @@ module ActiveRecord
   module Associations
 
     class AssociationReflection
-
+      attr_reader :klass_name
       attr_reader :association_foreign_key
       attr_reader :attribute
       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 habtm?
+        through_association&.klass_name =~ /^HyperstackInternalHabtm/
       end
 
       def through_association
@@ -62,63 +95,120 @@ 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 inverse_of(model = nil)
+        inverse(model).attribute
       end
 
-      def find_inverse
-        klass.reflect_on_all_associations.each do |association|
+      def find_inverse(model)  # private
+        the_klass = klass(model)
+        the_klass.reflect_on_all_associations.each do |association|
+          next if association == self
           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