fixed regression and other issues raised by #173

Author: catmando

docs/dsl-isomorphic/hyper-operation.md

@@ -2,9 +2,32 @@
 
 **Work in progress - ALPHA (docs and code)**
 
-Operations are the engine rooms of Hyperstack; they orchestrate the interactions between Components, external services, Models, and Stores. Operations provide a tidy place to keep your business logic.
+Operations are Hyperstack's implementation of Service Object which is...  
 
-Operations receive parameters and execute a series of steps. They have a simple structure which is not dissimilar to a Component:
+> "A class that performs an action"   [A simple explanation of Service Objects for Ruby on Rails](https://medium.freecodecamp.org/service-objects-explained-simply-for-ruby-on-rails-5-a8cc42a5441f)
+
+Why do we need Service Objects?  Because in any real world system you have logic that does belong in models or stores because it effects multiple models or stores, and it does not belong in components because the logic of the task is independent of the specific user interface design.
+
+There are also those boundary areas between gathering and processing external data and getting into or out of our stores and models.  You don't want that kind of logic in your model or store, so where does it go?  Into an operation.
+
+Simply put an operation is like a large standalone method that has no internal state of its own.  You run an operation, it does it thing, and it returns an answer.
+
+Any state that an operation needs to retrieve or save is stored somewhere else: in a model, a store, or even in a remote API.  Once the operation completes, it has no memory of its own.  
+
+
+Because this an operation's full time mission the Hyperstack Operation base class is structured to make writing this kind of code easy.
+
+An Operation may take parameters (params) just like any other method.  
+An Operation may validate the parameters
+An Operation then executes a number of steps
+The value of the final step is returned
+
+Hyperstack Operations often involve asynchronous methods such as HTTP requests, and so Operations always return promises
+
+
+; they orchestrate the interactions between Components, external services, Models, and Stores. Operations provide a tidy place to keep your business logic.
+
+Operations receive parameters, va and execute a series of steps They have a simple structure which is not dissimilar to a Component:
 
 ```ruby
 class SimpleOperation < Hyperstack::Operation

ruby/hyper-model/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb

@@ -243,7 +243,7 @@ def self.gather_records(records_to_process, force, record_being_saved)
                   add_new_association.call record, attribute, value.backing_record
                 end
               end
-            elsif aggregation = record.model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+            elsif (aggregation = record.model.reflect_on_aggregation(attribute)) && (aggregation.klass < ActiveRecord::Base)
               add_new_association.call record, attribute, value.backing_record unless value.nil?
             elsif aggregation
               new_value = aggregation.serialize(value)
@@ -483,8 +483,8 @@ def self.save_records(models, associations, acting_user, validate, save)
             next true  if record.frozen?  # skip (but process later) frozen records
             next true  if dont_save_list.include?(record) # skip if the record is on the don't save list
             next true  if record.changed.include?(record.class.primary_key)  # happens on an aggregate
-            next true  if record.persisted? # record may be have been saved as result of has_one assignment
-            next false if record.id && !record.changed? # throw out any existing records with no changes
+            #next true  if record.persisted? # record may be have been saved as result of has_one assignment
+            next record.persisted? if record.id && !record.changed? # throw out any existing records with no changes
             # if we get to here save the record and return true to keep it
             op = new_models.include?(record) ? :create_permitted? : :update_permitted?
             record.check_permission_with_acting_user(acting_user, op).save(validate: false) || true
@@ -500,6 +500,7 @@ def self.save_records(models, associations, acting_user, validate, save)
           # the all the error messages during a save so we can dump them to the server log.
 
           all_messages = []
+          attributes = nil
 
           saved_models = reactive_records.collect do |reactive_record_id, model|
             messages = model.errors.messages if validate && !model.valid?
@@ -522,7 +523,6 @@ def self.save_records(models, associations, acting_user, validate, save)
             end
             raise 'HyperModel saving records failed!'
           end
-
         end
 
         { success: true, saved_models: saved_models }

ruby/hyper-model/lib/reactive_record/active_record/reactive_record/setters.rb

@@ -120,8 +120,9 @@ def change_status_and_notify_helper(attr, changed)
       # || data_loading? added so that model.new can be wrapped in a ReactiveRecord.load_data
       if !changed || data_loading?
         changed_attributes.delete(attr)
-      elsif !changed_attributes.include?(attr)
-        changed_attributes << attr
+      else
+        changed_attributes << attr if !changed_attributes.include?(attr)
+        synced_attributes.delete(attr)
       end
       yield @attributes.key?(attr), @attributes[attr]
       return unless empty_before != changed_attributes.empty?

ruby/hyper-model/spec/batch1/misc/validate_spec.rb

@@ -10,15 +10,22 @@
     # before each test
     stub_const 'TestApplication', Class.new
     stub_const 'TestApplicationPolicy', Class.new
+    User.do_not_synchronize
+    TestModel.do_not_synchronize
     TestApplicationPolicy.class_eval do
-      #always_allow_connection  TURN OFF BROADCAST SO TESTS DON"T EFFECT EACH OTHER
+      always_allow_connection
       regulate_all_broadcasts { |policy| policy.send_all }
       allow_change(to: :all, on: [:create, :update, :destroy]) { true }
     end
-    #size_window(:large, :landscape)
     User.validates :last_name, exclusion: { in: %w[f**k], message: 'no swear words allowed' }
     TestModel.validates_presence_of :child_models
-    client_option raise_on_js_errors: :off
+    client_option raise_on_js_errors: :off # TURN OFF BROADCAST SO TESTS DON"T EFFECT EACH OTHER
+  end
+  
+  after(:step) do
+    # Turn broadcasting back on
+    TestModel.instance_variable_set :@do_not_synchronize, false
+    User.instance_variable_set :@do_not_synchronize, false
   end
 
   it "can validate the presence of an association" do
@@ -72,7 +79,6 @@ class << self
       user = User.new(last_name: 'f**k')
       user.save(validate: true).then { |result| user.valid?}
     end.to be_falsy
-
   end
 
   it "the valid? method reacts to the model being saved" do