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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2458d824d9c7121f8e628dca72a9df1f6a87ecfc947361046887ea1eca56657
-  data.tar.gz: 4e6d8aa0a03d07c0080d73aa8bddbc876c1fa56eaebca3f7615425914f8fee07
+  metadata.gz: b2f63052beefadb742e008e12976afe889105a0cdbd864ea49902654eb82be51
+  data.tar.gz: 2bdf35fb8b4ccd7fd00144be9ba52d8a133797e47825b91cf6acae8dc0673043
 SHA512:
-  metadata.gz: 2e0e89354d96b059f62b51023a568e2b334ac2b47bc5940bc8ac6621940259e0b03ec90a61e5e9e135a07954d0cd75a93c6f765486412f80470aedb5a5dc96d0
-  data.tar.gz: 6b1642506f04f6fc00fd6e6be388632e1157e6405c629928a61d5a8d525fac8666b0f6611d4e261060573b2dc3b184ea3fe0c5640f1a955d2193899b6223202e
+  metadata.gz: 2e7481f8e04d3d464507d7c25c20b3dc55167dd6b8cb368f28113e9f52b4ba95815611b8f4fe740d207860f1bc60cdb4ddcdafb996d83ddf2d51afb8cc397fb5
+  data.tar.gz: e0e5fb04e304496c3d0ef8353a9ed0bd36a303257e3f062d9ed61e75b4af8d1ded8ed18defd37e7e44dd79b618b221d129287a39d9e331bb20b9cc648c668124

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

@@ -32,7 +32,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|

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'
@@ -62,8 +55,7 @@ Gem::Specification.new do |spec|
   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', '~> 1.3.6' # see https://github.com/rails/rails/issues/35153, '~> 1.3.6'
+  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 && 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'
+      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'
@@ -270,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
@@ -286,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
 

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'

data/lib/hyper_model/version.rb

@@ -1,3 +1,3 @@
 module HyperModel
-  VERSION = '1.0.alpha1.5'
+  VERSION = '1.0.alpha1.6'
 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,7 +32,7 @@ module ActiveRecord
   module Associations
 
     class AssociationReflection
-
+      attr_reader :klass_name
       attr_reader :association_foreign_key
       attr_reader :attribute
       attr_reader :macro
@@ -79,6 +79,10 @@ module ActiveRecord
         @macro != :has_many
       end
 
+      def habtm?
+        through_association&.klass_name =~ /^HyperstackInternalHabtm/
+      end
+
       def through_association
         return unless @options[:through]
         @through_association ||= @owner_class.reflect_on_all_associations.detect do |association|
@@ -161,6 +165,7 @@ module ActiveRecord
       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.attribute == attribute
           return association if association.polymorphic? || association.klass == owner_class

data/lib/reactive_record/active_record/base.rb

@@ -16,7 +16,7 @@ module ActiveRecord
     )
 
     def self.__hyperstack_internal_scoped_find_by(attrs)
-      collection = all.apply_scope(:___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

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
@@ -57,10 +66,13 @@ module ActiveRecord
       end
       dealiased_attrs = {}
       attrs.each { |attr, value| dealiased_attrs[_dealias_attribute(attr)] = value }
+      dealiased_attrs
     end
 
-    def find(id)
-      find_by(primary_key => id)
+    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(attrs = {})
@@ -295,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
@@ -337,34 +359,29 @@ 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
 
-    # 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
-
+    # 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
+        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("#{name}=") { |val| @backing_record.set_attr_value(name, val) } 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
@@ -397,18 +414,23 @@ module ActiveRecord
             associations = reflect_on_all_associations
 
             already_processed_keys = Set.new
-            old_param = param.dup
 
             param = param.collect do |key, value|
               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
+                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
@@ -440,7 +462,7 @@ module ActiveRecord
                   [assoc.attribute, { id: [value]}]
                 end
               else
-                [key, [value]]
+                [*key, [value]]
               end
             end.compact
             ReactiveRecord::Base.load_data do

data/lib/reactive_record/active_record/instance_methods.rb

@@ -1,7 +1,34 @@
 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]
@@ -17,6 +44,16 @@ module ActiveRecord
       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}) "\
@@ -55,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
@@ -89,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
@@ -125,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