hyper-mesh 1.0.0.lap27 → 1.0.0.lap28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae2e1bd29b4c0fd94efb2466949a271d478a5585d2e81045e88871c02e412256
-  data.tar.gz: abf0a91cc51d3b62e3053392082b0df4a1f80113bb0cd3d8876aca6fbb994a54
+  metadata.gz: 496e78b04675fc8421cf1bf977361c6a6049769a8fd2d2dd9c0f0766735a41d5
+  data.tar.gz: 55513ce6b73c89665be0dddc74843cc59df11079233569ea404302eb10eddd1f
 SHA512:
-  metadata.gz: 7867946eaf76d99ef08323ccbf6c78fe20c7cb440e4cbe43b379bbd34e5ea168808b3d525c8649ce04f20e5ea37f196b6b1a1b0f7a0bca849abbbc14373c97f5
-  data.tar.gz: 820061867257b00bb28cedfc11212e3f5d0a28439a1080c0aca2651977673ea13eb9a6d997fca5a7b4dd333ffa1f88ceca07daa4923f7ed682c2b2a6ccf42156
+  metadata.gz: a0a0152a43aaeb0e3ecadc152db2e71a3a0fe24e4775ead3f95276c5d4d8351b53d8ef2e766309bdb36b574273b3ae0bb845b2d2d38ba2363dcda2a59892ace3
+  data.tar.gz: 3316b9c3a125034a8bbed27a5263412f863b160dd7246eec08bddba0f081623fb11df34c3e51b52f2fce8faae522335171c988905e5fc54635210b7846cb7cd1

data/.gitignore

@@ -17,6 +17,7 @@ spec/test_app/Gemfile.lock
 /Gemfile.lock
 /examples/action-cable/rails_cache_dir/
 rails_cache_dir/
+react_prerendering_src.js
 
 .bundle/
 log/*.log

data/.rubocop.yml

@@ -1,11 +1,15 @@
+
 Metrics/LineLength:
   Max: 100
 
 Style/MutableConstant:
   Enabled: false
 
-Lint/LiteralInCondition:
-  Enabled: false
+# Lint/LiteralInCondition:
+#   Enabled: false
 
 Style/CommandLiteral:
   EnforcedStyle: mixed
+
+AllCops:
+  TargetRubyVersion: 2.4.1

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
-gem 'hyper-operation', git: 'https://github.com/ruby-hyperloop/hyper-operation.git', branch: 'edge'
 gem "opal-jquery", git: "https://github.com/opal/opal-jquery.git", branch: "master"
 gemspec

data/Rakefile

@@ -4,7 +4,7 @@ require "rspec/core/rake_task"
 
 
 task :spec do
-  (1..6).each { |batch| Rake::Task["spec:batch#{batch}"].invoke }
+  (1..7).each { |batch| Rake::Task["spec:batch#{batch}"].invoke rescue nil }
 end
 
 namespace :spec do
@@ -12,7 +12,7 @@ namespace :spec do
     sh %{bundle update}
     sh %{cd spec/test_app; bundle update; bundle exec rails db:setup} # may need ;bundle exec rails db:setup as well
   end
-  (1..6).each do |batch|
+  (1..7).each do |batch|
     RSpec::Core::RakeTask.new(:"batch#{batch}") do |t|
       t.pattern = "spec/batch#{batch}/**/*_spec.rb"
     end

data/hyper-mesh.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
   # }
 
   spec.files          = `git ls-files`.split("\n").reject { |f| f.match(%r{^(examples|gemfiles|pkg|reactive_record_test_app|spec)/}) }
-  spec.executables    = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  # spec.executables    = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   spec.test_files     = `git ls-files -- {spec}/*`.split("\n")
   spec.require_paths  = ['lib']
 

data/lib/active_record_base.rb

@@ -41,7 +41,7 @@ module ActiveRecord
       attr_accessor :acting_user
       def __secure_collection_check(acting_user)
         return self if __synchromesh_permission_granted
-        return self if __secure_remote_access_to_unscoped(acting_user).__synchromesh_permission_granted
+        return self if __secure_remote_access_to_unscoped(self, acting_user).__synchromesh_permission_granted
         denied!
       end
     end
@@ -62,11 +62,11 @@ module ActiveRecord
         # Here we set up the base `all` and `unscoped` methods.  See below for more on how
         # access protection works on relationships.
 
-        def __secure_remote_access_to_all(_acting_user)
+        def __secure_remote_access_to_all(_self, _acting_user)
           all
         end
 
-        def __secure_remote_access_to_unscoped(_acting_user, *args)
+        def __secure_remote_access_to_unscoped(_self, _acting_user, *args)
           unscoped(*args)
         end
 
@@ -77,8 +77,8 @@ module ActiveRecord
         # For finder_method we have to preapply `all` so that we always have a relationship
 
         def finder_method(name, &block)
-          singleton_class.send(:define_method, :"__secure_remote_access_to__#{name}") do |acting_user, *args|
-            this = respond_to?(:acting_user) ? self : all
+          singleton_class.send(:define_method, :"__secure_remote_access_to__#{name}") do |this, acting_user, *args|
+            this = respond_to?(:acting_user) ? this : all
             begin
               old = this.acting_user
               this.acting_user = acting_user
@@ -98,7 +98,7 @@ module ActiveRecord
           # callable from the server internally
           define_method(name, &block)
           # callable remotely from the client
-          define_method("__secure_remote_access_to_#{name}") do |acting_user, *args|
+          define_method("__secure_remote_access_to_#{name}") do |_self, acting_user, *args|
             begin
               old = self.acting_user
               self.acting_user = acting_user
@@ -166,17 +166,17 @@ module ActiveRecord
         end
 
         # helper method to set the value of __synchromesh_permission_granted on the relationship
-        # Get the current value of __synchromesh_permission_granted, set acting_user on the
-        # object, and or in the result of running the block in context of the obj
+        # Set acting_user on the object, then or in the result of running the block in context
+        # of the obj with the current value of __synchromesh_permission_granted
 
-        def __set_synchromesh_permission_granted(r, obj, acting_user, args = [], &block)
-          r.__synchromesh_permission_granted = try(:__synchromesh_permission_granted)
-          old = acting_user
+        def __set_synchromesh_permission_granted(old_rel, new_rel, obj, acting_user, args = [], &block)
+          saved_acting_user = obj.acting_user
           obj.acting_user = acting_user
-          r.__synchromesh_permission_granted ||= obj.instance_exec(*args, &block)
-          r
+          new_rel.__synchromesh_permission_granted =
+            obj.instance_exec(*args, &block) || (old_rel && old_rel.try(:__synchromesh_permission_granted))
+          new_rel
         ensure
-          obj.acting_user = old
+          obj.acting_user = saved_acting_user
         end
 
         # regulate scope has to deal with the special case that the scope returns an
@@ -184,16 +184,17 @@ module ActiveRecord
 
         def regulate_scope(name, &block)
           name, block = __synchromesh_parse_regulator_params(name, block)
-          singleton_class.send(:define_method, :"__secure_remote_access_to_#{name}") do |acting_user, *args|
-            r = send(name, *args)
+          singleton_class.send(:define_method, :"__secure_remote_access_to_#{name}") do |this, acting_user, *args|
+            r = this.send(name, *args)
             r = ReactiveRecordPsuedoRelationArray.new(r) if r.is_a? Array
-            __set_synchromesh_permission_granted(r, r, acting_user, args, &block)
+            __set_synchromesh_permission_granted(this, r, r, acting_user, args, &block)
           end
         end
 
         # regulate_default_scope
 
-        def regulate_default_scope(&block)
+        def regulate_default_scope(*args, &block)
+          block = __synchromesh_parse_regulator_params({ all: args[0] }, block).last unless args.empty?
           regulate_scope(:all, &block)
         end
 
@@ -229,9 +230,9 @@ module ActiveRecord
 
         def regulate_relationship(name, &block)
           name, block = __synchromesh_parse_regulator_params(name, block)
-          define_method(:"__secure_remote_access_to_#{name}") do |acting_user, *args|
-            self.class.__set_synchromesh_permission_granted(
-              send(name, *args), self, acting_user, &block
+          define_method(:"__secure_remote_access_to_#{name}") do |this, acting_user, *args|
+            this.class.__set_synchromesh_permission_granted(
+              nil, this.send(name, *args), this, acting_user, &block
             )
           end
         end
@@ -254,21 +255,21 @@ module ActiveRecord
         # 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(_acting_user, *args)
+        def __secure_remote_access_to_find(_self, _acting_user, *args)
           find(*args)
         end
 
-        def __secure_remote_access_to_find_by(_acting_user, *args)
+        def __secure_remote_access_to_find_by(_self, _acting_user, *args)
           find_by(*args)
         end
 
         %i[belongs_to has_one].each do |macro|
           alias_method :"pre_syncromesh_#{macro}", macro
-          define_method(macro) do |name, scope = nil, opts = {}, &block|
-            define_method(:"__secure_remote_access_to_#{name}") do |_acting_user, *args|
-              send(name, *args)
+          define_method(macro) do |name, *aargs, &block|
+            define_method(:"__secure_remote_access_to_#{name}") do |this, _acting_user, *args|
+              this.send(name, *args)
             end
-            send(:"pre_syncromesh_#{macro}", name, scope, opts, &block)
+            send(:"pre_syncromesh_#{macro}", name, *aargs, &block)
           end
         end
       end
@@ -311,6 +312,17 @@ module ActiveRecord
         return if do_not_synchronize?
         ReactiveRecord::Broadcast.after_commit :destroy, self
       end
+
+      def __hyperloop_secure_attributes(acting_user)
+        accessible_attributes =
+          Hyperloop::InternalPolicy.accessible_attributes_for(self, acting_user)
+        attributes.select { |attr| accessible_attributes.include? attr.to_sym }
+      end
+
+      # regulate built in scopes so they are accesible from the client
+      %i[limit offset].each do |scope|
+        regulate_scope(scope) {}
+      end
     end
   end
 

data/lib/hyper-mesh.rb

@@ -7,6 +7,9 @@ if RUBY_ENGINE == 'opal'
   require 'time'
   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"
   require "reactive_record/active_record/reactive_record/while_loading"
@@ -18,8 +21,10 @@ if RUBY_ENGINE == 'opal'
   require "reactive_record/active_record/aggregations"
   require "reactive_record/active_record/associations"
   require "reactive_record/active_record/reactive_record/backing_record_inspector"
+  require "reactive_record/active_record/reactive_record/getters"
+  require "reactive_record/active_record/reactive_record/setters"
+  require "reactive_record/active_record/reactive_record/lookup_tables"
   require "reactive_record/active_record/reactive_record/base"
-  require "reactive_record/active_record/reactive_record/reactive_set_relationship_helpers"
   require "reactive_record/active_record/reactive_record/collection"
   require "reactive_record/active_record/reactive_record/scoped_collection"
   require "reactive_record/active_record/reactive_record/unscoped_collection"

data/lib/hypermesh/version.rb

@@ -1,3 +1,3 @@
 module Hypermesh
-  VERSION = '1.0.0.lap27'
+  VERSION = '1.0.0.lap28'
 end

data/lib/object/tap.rb

@@ -0,0 +1,7 @@
+class Object
+  def tap
+    val = `self.$$is_boolean` ? self==true : self
+    yield val
+    val
+  end
+end

data/lib/reactive_record/active_record/associations.rb

@@ -6,13 +6,24 @@ module ActiveRecord
       base_class.instance_eval { @associations ||= superclass.instance_eval { (@associations && @associations.dup) || [] } }
     end
 
-    def self.reflect_on_association(attribute)
-      if found = reflect_on_all_associations.detect { |association| association.attribute == attribute and association.owner_class == self }
+    def self.reflect_on_association(attr)
+      reflection_finder { |assoc| assoc.attribute == attr }
+    end
+
+    def self.reflect_on_association_by_foreign_key(key)
+      reflection_finder { |assoc| assoc.association_foreign_key == key }
+    end
+
+    def self.reflection_finder(&block)
+      found = reflect_on_all_associations.detect do |assoc|
+        assoc.owner_class == self && yield(assoc)
+      end
+      if found
         found
       elsif superclass == Base
         nil
       else
-        superclass.reflect_on_association(attribute)
+        superclass.reflection_finder(&block)
       end
     end
 

data/lib/reactive_record/active_record/base.rb

@@ -1,9 +1,8 @@
 module ActiveRecord
   # client side ActiveRecord::Base proxy
   class Base
-    extend  ClassMethods
-
     include InstanceMethods
+    extend  ClassMethods
 
     scope :limit, ->() {}
     scope :offset, ->() {}

data/lib/reactive_record/active_record/class_methods.rb

@@ -2,10 +2,15 @@ module ActiveRecord
 
   module ClassMethods
 
-    def base_class
+    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
       unless self < Base
-        raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+        raise ActiveRecordError, "#{name} doesn't descend from ActiveRecord"
       end
 
       if superclass == Base || superclass.abstract_class?
@@ -13,7 +18,6 @@ module ActiveRecord
       else
         superclass.base_class
       end
-
     end
 
     def abstract_class?
@@ -21,19 +25,26 @@ module ActiveRecord
     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
@@ -42,11 +53,13 @@ module ActiveRecord
     end
 
     def find(id)
-      base_class.instance_eval {ReactiveRecord::Base.find(self, primary_key, id)}
+      ReactiveRecord::Base.find(self, primary_key => id)
     end
 
     def find_by(opts = {})
-      base_class.instance_eval {ReactiveRecord::Base.find(self, opts.first.first, opts.first.last)}
+      dealiased_opts = {}
+      opts.each { |attr, value| dealiased_opts[_dealias_attribute(attr)] = value }
+      ReactiveRecord::Base.find(self, dealiased_opts)
     end
 
     def enum(*args)
@@ -57,6 +70,25 @@ module ActiveRecord
       ReactiveRecord::Base.serialized?[self][attr] = true
     end
 
+    def _dealias_attribute(new)
+      if self == base_class
+        _attribute_aliases[new] || new
+      else
+        _attribute_aliases[new] ||= superclass._dealias_attribute(new)
+      end
+    end
+
+    def _attribute_aliases
+      @_attribute_aliases ||= {}
+    end
+
+    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
+    end
+
     # ignore any of these methods if they get called on the client.   This list should be trimmed down to include only
     # methods to be called as "macros" such as :after_create, etc...
     SERVER_METHODS = [
@@ -145,7 +177,7 @@ module ActiveRecord
 
     def method_missing(name, *args, &block)
       if args.count == 1 && name.start_with?("find_by_") && !block
-        find_by(name.sub(/^find_by_/, "") => args[0])
+        find_by(_dealias_attribute(name.sub(/^find_by_/, "")) => args[0])
       elsif [].respond_to?(name)
         all.send(name, *args, &block)
       elsif name.end_with?('!')
@@ -199,12 +231,25 @@ module ActiveRecord
         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
+      end
+    end
+
     # def all=(_collection)
     #   raise "NO LONGER IMPLEMENTED DOESNT PLAY WELL WITH SYNCHROMESH"
     # end
@@ -250,20 +295,27 @@ module ActiveRecord
     [:belongs_to, :has_many, :has_one].each do |macro|
       define_method(macro) do |*args| # is this a bug in opal?  saying name, scope=nil, opts={} does not work!
         name = args.first
-        define_method(name) { @backing_record.reactive_get!(name, nil) }
-        define_method("#{name}=") do |val|
-          @backing_record.reactive_set!(name, backing_record.convert(name, val).itself)
-        end
         opts = (args.count > 1 and args.last.is_a? Hash) ? args.last : {}
-        Associations::AssociationReflection.new(self, macro, name, opts)
+        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) }
+        else
+          define_method(name) { @backing_record.get_belongs_to(assoc, nil) }
+          define_method("#{name}=") { |val| @backing_record.set_belongs_to(assoc, val) }
+        end
+        assoc
       end
     end
 
     def composed_of(name, opts = {})
-      Aggregations::AggregationReflection.new(base_class, :composed_of, name, opts)
-      define_method(name) { @backing_record.reactive_get!(name, nil) }
-      define_method("#{name}=") do |val|
-        @backing_record.reactive_set!(name, backing_record.convert(name, val))
+      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) }
+      else
+        define_method(name) { @backing_record.get_non_ar_aggregate(name, nil) }
+        define_method("#{name}=") { |val| @backing_record.set_non_ar_aggregate(reflection, val) }
       end
     end
 
@@ -282,73 +334,74 @@ module ActiveRecord
     def server_method(name, default: nil)
       server_methods[name] = { default: default }
       define_method(name) do |*args|
-        vector = args.count.zero? ? name : [[name]+args]
-        @backing_record.reactive_get!(vector, nil)
+        vector = args.count.zero? ? name : [[name] + args]
+        @backing_record.get_server_method(vector, nil)
       end
       define_method("#{name}!") do |*args|
-        vector = args.count.zero? ? name : [[name]+args]
-        @backing_record.reactive_get!(vector, true)
+        vector = args.count.zero? ? name : [[name] + args]
+        @backing_record.get_server_method(vector, true)
       end
     end
 
     def define_attribute_methods
-      columns_hash.keys.each do |name|
-        next if name == :id
-        define_method(name) { @backing_record.reactive_get!(name, nil) }
-        define_method("#{name}!") { @backing_record.reactive_get!(name, true) }
-        define_method("#{name}=") do |val|
-          @backing_record.reactive_set!(name, backing_record.convert(name, val))
-        end
+      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? }
       end
+      self.inheritance_column = nil if inheritance_column && !columns_hash.key?(inheritance_column)
     end
 
     def _react_param_conversion(param, opt = nil)
       param = Native(param)
       param = JSON.from_object(param.to_n) if param.is_a? Native::Object
-      result = if param.is_a? self
-        param
-      elsif param.is_a? Hash
-        if opt == :validate_only
-          klass = ReactiveRecord::Base.infer_type_from_hash(self, param)
-          klass == self or klass < self
-        else
-          if param[primary_key]
-            target = find(param[primary_key])
+      result =
+        if param.is_a? self
+          param
+        elsif param.is_a? Hash
+          if opt == :validate_only
+            klass = ReactiveRecord::Base.infer_type_from_hash(self, param)
+            klass == self || klass < self
           else
-            target = new
-          end
-          associations = reflect_on_all_associations
-          param = param.collect do |key, value|
-            assoc = reflect_on_all_associations.detect do |assoc|
-              assoc.association_foreign_key == key
-            end
-            if assoc
-              if value
-                [assoc.attribute, {id: [value], type: [nil]}]
+            # TODO: investigate saving .changes here and then replacing the
+            # TODO: changes after the load is complete.  In other words preserve the
+            # TODO: changed values as changes while just updating the synced values.
+            target =
+              if param[primary_key]
+                find(param[primary_key])
               else
-                [assoc.attribute, [nil]]
+                new
               end
-            else
-              [key, [value]]
-            end
-          end
 
-          # We do want to be doing something like this, but this breaks other stuff...
-          #
-          # ReactiveRecord::Base.load_data do
-          #   ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
-          # end
+            associations = reflect_on_all_associations
+
+            param = param.collect do |key, value|
+              assoc = associations.detect do |association|
+                association.association_foreign_key == key
+              end
 
-          ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
-          target
+              if assoc
+                if value
+                  [assoc.attribute, { id: [value] }]
+                else
+                  [assoc.attribute, [nil]]
+                end
+              else
+                [key, [value]]
+              end
+            end
+            # TODO: verify wrapping with load_data was added so broadcasting works in 1.0.0.lap28
+            ReactiveRecord::Base.load_data do
+              ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
+            end
+            target.cast_to_current_sti_type
+          end
         end
-      else
-        nil
-      end
+
       result
     end
-
   end
-
 end