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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 071e8cc562ebddf1c0a260587a123d91db9f2a7c52d43b06fcf063079d66129f
-  data.tar.gz: 4cb7539129b7367f3156c0726ac3ed164e1db391f7806457253d303e9940941c
+  metadata.gz: '0583cd6276013eed8abad6c7e12454455c6915e9773eb195b51977c8d748217f'
+  data.tar.gz: a3e3f3e0aa5065281103566c6178bd2e4045a09863e1697d7587a5d2321f17dc
 SHA512:
-  metadata.gz: 2c1bcd8fee396593e2f31d072f35cbf88467be2b02c198d523c052b67a211d9fea4501ca86c4f0a388cee35bc34f4ac9156147a13aac9aec4842616a5c3c1772
-  data.tar.gz: c226e31b1882e96c8a7a080114aea90aacdb0bb77331fc36854f79fe118fabd119f278bc20b94d3693bcc69d7382bc6e4d2f1e91c042b41eb660d2214e75c45d
+  metadata.gz: 7d21d5c7def5a3217d00757c611042da17efcaf639eba5fd5c021f79ffaa7e9f98334186d51c5c5353188c56b528286b91cc3d48ed4e8ecadf73cdae40cae04e
+  data.tar.gz: 5aeaf368b37b2f4224ec0d7d3af83f44708f9093e97f7261d49d65e78af6ac0e5078c055d4fb974b4c2041491911087175e12e5988fc6873bec17ed388dee8ff

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/Rakefile

@@ -1,20 +1,33 @@
 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
@@ -23,7 +36,6 @@ namespace :spec do
   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

@@ -63,7 +63,7 @@ Gem::Specification.new do |spec|
   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 'sqlite3', '~> 1.3.6' # 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

@@ -87,7 +87,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,20 +255,6 @@ 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|
           alias_method :"pre_syncromesh_#{macro}", macro
           define_method(macro) do |name, *aargs, &block|
@@ -329,6 +315,37 @@ 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
     end
   end
 

data/lib/hyper_model/version.rb

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

data/lib/reactive_record/active_record/base.rb

@@ -6,5 +6,22 @@ module ActiveRecord
 
     scope :limit, ->() {}
     scope :offset, ->() {}
+
+    finder_method :__hyperstack_internal_scoped_last
+    scope :__hyperstack_internal_scoped_last_n, ->(n) { last(n) }
+
+    ReactiveRecord::ScopeDescription.new(
+      self, :___hyperstack_internal_scoped_find_by,
+      client: ->(attrs) { !attrs.detect { |attr, value| attributes[attr] != value } }
+    )
+
+    def self.__hyperstack_internal_scoped_find_by(attrs)
+      collection = all.apply_scope(:___hyperstack_internal_scoped_find_by, attrs)
+      if !collection.collection
+        collection._find_by_initializer(self, attrs)
+      else
+        collection.first
+      end
+    end
   end
 end

data/lib/reactive_record/active_record/class_methods.rb

@@ -51,14 +51,24 @@ module ActiveRecord
       @model_name ||= ActiveModel::Name.new(self)
     end
 
+    def __hyperstack_preprocess_attrs(attrs)
+      if inheritance_column && self < base_class && !attrs.key?(inheritance_column)
+        attrs = attrs.merge(inheritance_column => model_name.to_s)
+      end
+      dealiased_attrs = {}
+      attrs.each { |attr, value| dealiased_attrs[_dealias_attribute(attr)] = value }
+    end
+
     def find(id)
-      ReactiveRecord::Base.find(self, primary_key => id)
+      find_by(primary_key => id)
     end
 
-    def find_by(opts = {})
-      dealiased_opts = {}
-      opts.each { |attr, value| dealiased_opts[_dealias_attribute(attr)] = value }
-      ReactiveRecord::Base.find(self, dealiased_opts)
+    def find_by(attrs = {})
+      attrs = __hyperstack_preprocess_attrs(attrs)
+      # r = ReactiveRecord::Base.find_locally(self, attrs, new_only: true)
+      # return r.ar_instance if r
+      (r = __hyperstack_internal_scoped_find_by(attrs)) || return
+      r.backing_record.sync_attributes(attrs).set_ar_instance!
     end
 
     def enum(*args)
@@ -176,7 +186,7 @@ module ActiveRecord
 
     def method_missing(name, *args, &block)
       if args.count == 1 && name.start_with?("find_by_") && !block
-        find_by(_dealias_attribute(name.sub(/^find_by_/, "")) => args[0])
+        find_by(name.sub(/^find_by_/, '') => args[0])
       elsif [].respond_to?(name)
         all.send(name, *args, &block)
       elsif name.end_with?('!')
@@ -193,16 +203,6 @@ module ActiveRecord
     # Any method ending with ! just means apply the method after forcing a reload
     # from the DB.
 
-    # alias pre_synchromesh_method_missing method_missing
-    #
-    # def method_missing(name, *args, &block)
-    #   return all.send(name, *args, &block) if [].respond_to?(name)
-    #   if name.end_with?('!')
-    #     return send(name.chop, *args, &block).send(:reload_from_db) rescue nil
-    #   end
-    #   pre_synchromesh_method_missing(name, *args, &block)
-    # end
-
     def create(*args, &block)
       new(*args).save(&block)
     end
@@ -213,9 +213,6 @@ module ActiveRecord
       singleton_class.send(:define_method, name) do |*vargs|
         all.build_child_scope(scope_description, *name, *vargs)
       end
-      # singleton_class.send(:define_method, "#{name}=") do |_collection|
-      #   raise 'NO LONGER IMPLEMENTED - DOESNT PLAY WELL WITH SYNCHROMESH'
-      # end
     end
 
     def default_scope(*args, &block)
@@ -249,10 +246,6 @@ module ActiveRecord
       end
     end
 
-    # def all=(_collection)
-    #   raise "NO LONGER IMPLEMENTED DOESNT PLAY WELL WITH SYNCHROMESH"
-    # end
-
     def unscoped
       ReactiveRecord::Base.unscoped[self] ||=
         ReactiveRecord::Collection
@@ -261,10 +254,11 @@ module ActiveRecord
     end
 
     def finder_method(name)
-      ReactiveRecord::ScopeDescription.new(self, "_#{name}", {}) # was adding _ to front
+      ReactiveRecord::ScopeDescription.new(self, "_#{name}", {})
       [name, "#{name}!"].each do |method|
         singleton_class.send(:define_method, method) do |*vargs|
-          all.apply_scope("_#{method}", *vargs).first # was adding _ to front
+          collection = all.apply_scope("_#{method}", *vargs)
+          collection.first
         end
       end
     end
@@ -370,7 +364,9 @@ module ActiveRecord
             # TODO: changed values as changes while just updating the synced values.
             target =
               if param[primary_key]
-                find(param[primary_key])
+                ReactiveRecord::Base.find(self, primary_key => param[primary_key]).tap do |r|
+                  r.backing_record.loaded_id = param[primary_key]
+                end
               else
                 new
               end

data/lib/reactive_record/active_record/instance_methods.rb

@@ -144,10 +144,12 @@ module ActiveRecord
       @backing_record.destroyed
     end
 
-    def new?
+    def new_record?
       @backing_record.new?
     end
 
+    alias new? new_record?
+
     def errors
       Hyperstack::Internal::State::Variable.get(@backing_record, @backing_record)
       @backing_record.errors

data/lib/reactive_record/active_record/reactive_record/backing_record_inspector.rb

@@ -26,11 +26,28 @@ module ReactiveRecord
     end
 
     def loading_details
-      "[loading #{vector}]"
+      "[loading #{pretty_vector}]"
     end
 
     def dirty_details
       "[changed id: #{id} #{changes}]"
     end
+
+    def pretty_vector
+      v = []
+      i = 0
+      while i < vector.length
+        if vector[i] == 'all' && vector[i + 1].is_a?(Array) &&
+           vector[i + 1][0] == '___hyperstack_internal_scoped_find_by' &&
+           vector[i + 2] == '*0'
+          v << ['find_by', vector[i + 1][1]]
+          i += 3
+        else
+          v << vector[i]
+          i += 1
+        end
+      end
+      v
+    end
   end
 end

data/lib/reactive_record/active_record/reactive_record/base.rb

@@ -67,30 +67,35 @@ module ReactiveRecord
       load_data { ServerDataCache.load_from_json(json, target) }
     end
 
+    def self.find_locally(model, attrs, new_only: nil)
+      if (id_to_find = attrs[model.primary_key])
+        !new_only && lookup_by_id(model, id_to_find)
+      else
+        @records[model].detect do |r|
+          (r.new? || !new_only) &&
+            !attrs.detect { |attr, value| r.synced_attributes[attr] != value }
+        end
+      end
+    end
+
+    def self.find_by_id(model, id)
+      find(model, model.primary_key => id)
+    end
+
     def self.find(model, attrs)
       # will return the unique record with this attribute-value pair
       # value cannot be an association or aggregation
 
       # add the inheritance column if this is an STI subclass
 
-      inher_col = model.inheritance_column
-      if inher_col && model < model.base_class && !attrs.key?(inher_col)
-        attrs = attrs.merge(inher_col => model.model_name.to_s)
-      end
+      attrs = model.__hyperstack_preprocess_attrs(attrs)
 
       model = model.base_class
       primary_key = model.primary_key
 
       # already have a record with these attribute-value pairs?
 
-      record =
-        if (id_to_find = attrs[primary_key])
-          lookup_by_id(model, id_to_find)
-        else
-          @records[model].detect do |r|
-            !attrs.detect { |attr, value| r.synced_attributes[attr] != value }
-          end
-        end
+      record = find_locally(model, attrs)
 
       unless record
         # if not, and then the record may be loaded, but not have this attribute set yet,
@@ -102,10 +107,8 @@ module ReactiveRecord
           attrs = attrs.merge primary_key => id
         end
         # if we don't have a record then create one
-        # (record = new(model)).vector = [model, [:find_by, attribute => value]] unless record
-        record ||= set_vector_lookup(new(model), [model, [:find_by, attrs]])
-        # and set the values
-        attrs.each { |attr, value| record.sync_attribute(attr, value) }
+        record ||= set_vector_lookup(new(model), [model, *find_by_vector(attrs)])
+        record.sync_attributes(attrs)
       end
       # finally initialize and return the ar_instance
       record.set_ar_instance!
@@ -122,7 +125,6 @@ module ReactiveRecord
       # record = @records[model].detect { |record| record.vector == vector }
       record = lookup_by_vector(vector)
       unless record
-
         record = new model
         set_vector_lookup(record, vector)
       end
@@ -175,6 +177,7 @@ module ReactiveRecord
         @ar_instance.instance_variable_set(:@backing_record, existing_record)
         existing_record.attributes.merge!(attributes) { |key, v1, v2| v1 }
       end
+      @id = value
       value
     end
 
@@ -211,7 +214,7 @@ module ReactiveRecord
 
     def initialize_collections
       if (!vector || vector.empty?) && id && id != ''
-        Base.set_vector_lookup(self, [@model, [:find_by, @model.primary_key => id]])
+        Base.set_vector_lookup(self, [@model, *find_by_vector(@model.primary_key => id)])
       end
       Base.load_data do
         @model.reflect_on_all_associations.each do |assoc|
@@ -251,8 +254,12 @@ module ReactiveRecord
       @synced_with_unscoped = !@synced_with_unscoped
     end
 
-    def sync_attribute(attribute, value)
+    def sync_attributes(attrs)
+      attrs.each { |attr, value| sync_attribute(attr, value) }
+      self
+    end
 
+    def sync_attribute(attribute, value)
       @synced_attributes[attribute] = @attributes[attribute] = value
       Base.set_id_lookup(self) if attribute == primary_key
 
@@ -260,7 +267,7 @@ module ReactiveRecord
 
       if value.is_a? Collection
         @synced_attributes[attribute] = value.dup_for_sync
-      elsif aggregation = model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+      elsif (aggregation = model.reflect_on_aggregation(attribute)) && (aggregation.klass < ActiveRecord::Base)
         value.backing_record.sync!
       elsif aggregation
         @synced_attributes[attribute] = aggregation.deserialize(aggregation.serialize(value))
@@ -278,6 +285,14 @@ module ReactiveRecord
       Base.lookup_by_id(model, id)
     end
 
+    def id_loaded?
+      @id
+    end
+
+    def loaded_id=(id)
+      @id = id
+    end
+
     def revert
       @changed_attributes.dup.each do |attribute|
         @ar_instance.send("#{attribute}=", @synced_attributes[attribute])

data/lib/reactive_record/active_record/reactive_record/collection.rb

@@ -29,7 +29,7 @@ module ReactiveRecord
       @owner = owner  # can be nil if this is an outer most scope
       @association = association
       @target_klass = target_klass
-      if owner and !owner.id and vector.length <= 1
+      if owner && !owner.id && vector.length <= 1
         @collection = []
       elsif vector.length > 0
         @vector = vector
@@ -59,10 +59,12 @@ module ReactiveRecord
         @collection = []
         if ids = ReactiveRecord::Base.fetch_from_db([*@vector, "*all"])
           ids.each do |id|
-            @collection << @target_klass.find_by(@target_klass.primary_key => id)
+            @collection << ReactiveRecord::Base.find_by_id(@target_klass, id)
           end
         else
           @dummy_collection = ReactiveRecord::Base.load_from_db(nil, *@vector, "*all")
+          # this calls back to all now that the collection is initialized,
+          # so it has the side effect of creating a dummy value in collection[0]
           @dummy_record = self[0]
         end
       end
@@ -103,7 +105,7 @@ module ReactiveRecord
     end
     # todo move following to a separate module related to scope updates ******************
     attr_reader   :vector
-    attr_writer   :scope_description
+    attr_accessor :scope_description
     attr_writer   :parent
     attr_reader   :pre_sync_related_records
 
@@ -222,7 +224,6 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def filter_records(related_records)
-      # possibly we should never get here???
       scope_args = @vector.last.is_a?(Array) ? @vector.last[1..-1] : []
       @scope_description.filter_records(related_records, scope_args)
     end
@@ -231,16 +232,22 @@ To determine this sync_scopes first asks if the record being changed is in the s
       @live_scopes ||= Set.new
     end
 
+    def in_this_collection(related_records)
+      return related_records unless @association
+      related_records.select do |r|
+        r.backing_record.attributes[@association.inverse_of] == @owner
+      end
+    end
+
     def set_pre_sync_related_records(related_records, _record = nil)
-      #related_records = related_records.intersection([*@collection]) <- deleting this works
-      @pre_sync_related_records = related_records #in_this_collection related_records <- not sure if this works
+      @pre_sync_related_records = in_this_collection(related_records)
       live_scopes.each { |scope| scope.set_pre_sync_related_records(@pre_sync_related_records) }
     end
 
     # NOTE sync_scopes is overridden in scope_description.rb
     def sync_scopes(related_records, record, filtering = true)
       #related_records = related_records.intersection([*@collection])
-      #related_records = in_this_collection related_records
+      related_records = in_this_collection(related_records) if filtering
       live_scopes.each { |scope| scope.sync_scopes(related_records, record, filtering) }
       notify_of_change unless related_records.empty?
     ensure
@@ -301,7 +308,7 @@ To determine this sync_scopes first asks if the record being changed is in the s
           @collection = []
         elsif filter?
           # puts "#{self}.sync_collection_with_parent (@parent = #{@parent}) calling filter records on (#{@parent.collection})"
-          @collection = filter_records(@parent.collection) # .tap { |rr| puts "returns #{rr} #{rr.to_a}" }
+          @collection = filter_records(@parent.collection).to_a
         end
       elsif !@linked && @parent._count_internal(false).zero?
         # don't check _count_internal if already linked as this cause an unnecessary rendering cycle
@@ -391,7 +398,7 @@ To determine this sync_scopes first asks if the record being changed is in the s
       # child.test_model = 1
       # so... we go back starting at this collection and look for the first
       # collection with an owner... that is our guy
-      child = proxy_association.klass.find(id)
+      child = ReactiveRecord::Base.find_by_id(proxy_association.klass, id)
       push child
       set_belongs_to child
     end
@@ -463,13 +470,29 @@ To determine this sync_scopes first asks if the record being changed is in the s
       notify_of_change self
     end
 
-    [:first, :last].each do |method|
-      define_method method do |*args|
-        if args.count == 0
-          all.send(method)
-        else
-          apply_scope(method, *args)
-        end
+    # [:first, :last].each do |method|
+    #   define_method method do |*args|
+    #     if args.count == 0
+    #       all.send(method)
+    #     else
+    #       apply_scope(method, *args)
+    #     end
+    #   end
+    # end
+
+    def first(n = nil)
+      if n
+        apply_scope(:first, n)
+      else
+        self[0]
+      end
+    end
+
+    def last(n = nil)
+      if n
+        apply_scope(:__hyperstack_internal_scoped_last_n, n)
+      else
+        __hyperstack_internal_scoped_last
       end
     end
 
@@ -539,19 +562,47 @@ To determine this sync_scopes first asks if the record being changed is in the s
       @dummy_collection.loading?
     end
 
+    def loaded?
+      false && @collection && (!@dummy_collection || !@dummy_collection.loading?) && (!@owner || @owner.id || @vector.length > 1)
+    end
+
     def empty?
       # should be handled by method missing below, but opal-rspec does not deal well
       # with method missing, so to test...
       all.empty?
     end
 
+    def find_by(attrs)
+      attrs = @target_klass.__hyperstack_preprocess_attrs(attrs)
+      # r = @collection&.detect { |lr| lr.new_record? && !attrs.detect { |k, v| lr.attributes[k] != v } }
+      # return r if r
+      (r = __hyperstack_internal_scoped_find_by(attrs)) || return
+      r.backing_record.sync_attributes(attrs).set_ar_instance!
+    end
+
+    def find(id)
+      find_by @target_klass.primary_key => id
+    end
+
+    def _find_by_initializer(scope, attrs)
+      found =
+        if scope.is_a? Collection
+          scope.parent.collection&.detect { |lr| !attrs.detect { |k, v| lr.attributes[k] != v } }
+        else
+          ReactiveRecord::Base.find_locally(@target_klass, attrs)&.ar_instance
+        end
+      return first unless found
+      @collection = [found]
+      found
+    end
+
     def method_missing(method, *args, &block)
-      if [].respond_to? method
+      if args.count == 1 && method.start_with?('find_by_')
+        find_by(method.sub(/^find_by_/, '') => args[0])
+      elsif [].respond_to? method
         all.send(method, *args, &block)
       elsif ScopeDescription.find(@target_klass, method)
         apply_scope(method, *args)
-      elsif args.count == 1 && method.start_with?('find_by_')
-        apply_scope(:find_by, method.sub(/^find_by_/, '') => args.first)
       elsif @target_klass.respond_to?(method) && ScopeDescription.find(@target_klass, "_#{method}")
         apply_scope("_#{method}", *args).first
       else
@@ -577,7 +628,6 @@ To determine this sync_scopes first asks if the record being changed is in the s
       Hyperstack::Internal::State::Variable.set(self, "collection", collection) unless ReactiveRecord::Base.data_loading?
       value
     end
-
   end
 
 end