reactive-record 0.7.35 → 0.7.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b2c3452956a7f5f694a3e57dbb0de12a11727854
-  data.tar.gz: 5dfbe5870446dafaf6481ed27cd362d4e3e832b6
+  metadata.gz: 71c7a7abb7ea51cdb5f5139725724b0a1cd773fd
+  data.tar.gz: c1d222084866c7aa0f8b3f77d495825b504f3e35
 SHA512:
-  metadata.gz: 1e91839b1180ae6bff126b71555bf7eaecde136b95f4d223f5edfa90e67e2508dcd73875ed3e3806da39f256d1f65aa798a29a51aaf8a8c259bd5efcf57b3776
-  data.tar.gz: 5168e51dae8c78c0b049e0718b07bd22939fd75cf08b45b9b5de8a54013dc2846b65d5e6093cd7f99dd611784de6a539544bce3b7c54baeda6edec9fc8fceef6
+  metadata.gz: 0332dfa333ea3344e970d4b37c24a1ff9703823c5f53c645754de0b815a4254655f5da7dc15b3c0dbbd33b8adc522815395e6871d4eb61b826f9d16d5034125a
+  data.tar.gz: 1262dc1375cbbc0f423dde4d4e181bc69b2c44acad615944fd8833cd29efac2f6cb5d2338daa6f8b12b017cac75f4a93dd5b78cebdf0c032b5ec382c4e84177b

data/app/controllers/reactive_record/reactive_record_controller.rb

@@ -11,9 +11,10 @@ module ReactiveRecord
         params[:pending_fetches],
         acting_user
       ]
+    rescue Exception => e
+      render json: {error: e.message, backtrace: e.backtrace}, status: 500
     end
 
-
     def save
       render :json => ReactiveRecord::Base.save_records(
         (params[:models] || []).map(&:with_indifferent_access),
@@ -22,6 +23,8 @@ module ReactiveRecord
         params[:validate],
         true
       )
+    rescue Exception => e
+      render json: {error: e.message, backtrace: e.backtrace}, status: 500
     end
 
     def destroy
@@ -31,6 +34,8 @@ module ReactiveRecord
         params[:vector],
         acting_user
       )
+    rescue Exception => e
+      render json: {error: e.message, backtrace: e.backtrace}, status: 500
     end
 
   end

data/lib/reactive-record.rb

@@ -44,6 +44,7 @@ else
   require "reactive_record/server_data_cache"
   require "reactive_record/active_record/reactive_record/isomorphic_base"
   require "reactive_record/serializers"
+  require "reactive_record/pry"
 
   Opal.append_path File.expand_path('../', __FILE__).untaint
   Opal.append_path File.expand_path('../../vendor', __FILE__).untaint

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

@@ -267,11 +267,9 @@ module ReactiveRecord
       if !data_loading?
         React::State.set_state(self, attribute, value)
       elsif on_opal_client? and had_key and current_value.loaded? and current_value != value and args.count > 0  # this is to handle changes in already loaded server side methods
-        puts "setting up delayed change for #{@ar_instance}.#{attribute} current: #{current_value} new: #{value}"
         React::State.set_state(self, attribute, value, true)
       end
       if empty_before != changed_attributes.empty?
-        puts "setting up delayed change on record" unless on_opal_server? or data_loading?
         React::State.set_state(self, "!CHANGED!", !changed_attributes.empty?, true) unless on_opal_server? or data_loading?
         aggregate_owner.update_attribute(aggregate_attribute) if aggregate_owner
       end

data/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb

@@ -324,7 +324,7 @@ module ReactiveRecord
                 backing_records.each { |id, record| record.saved! }
 
               rescue Exception => e
-                puts "Save Failed: #{e}"
+                log("Exception raised while saving - #{e}", :error)
               end
             end
             promise
@@ -372,156 +372,154 @@ module ReactiveRecord
 
       def self.save_records(models, associations, acting_user, validate, save)
 
-        reactive_records = {}
-        vectors = {}
-        new_models = []
-        saved_models = []
-        dont_save_list = []
-
-        models.each do |model_to_save|
-          attributes = model_to_save[:attributes]
-          model = Object.const_get(model_to_save[:model])
-          id = attributes.delete(model.primary_key) if model.respond_to? :primary_key # if we are saving existing model primary key value will be present
-          vector = model_to_save[:vector]
-          vector = [vector[0].constantize] + vector[1..-1].collect do |method|
-            if method.is_a?(Array) and method.first == "find_by_id"
-              ["find", method.last]
-            else
-              method
-            end
-          end
-          reactive_records[model_to_save[:id]] = vectors[vector] = record = find_record(model, id, vector, save)
-          if record and record.respond_to?(:id) and record.id
-            # we have an already exising activerecord model
-            keys = record.attributes.keys
-            attributes.each do |key, value|
-              if keys.include? key
-                record[key] = value
-              elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key.to_sym) and !(aggregation.klass < ActiveRecord::Base)
-                aggregation.mapping.each_with_index do |pair, i|
-                  record[pair.first] = value[i]
+        ReactiveRecord::Pry.rescue do
+          begin
+
+            reactive_records = {}
+            vectors = {}
+            new_models = []
+            saved_models = []
+            dont_save_list = []
+
+            models.each do |model_to_save|
+              attributes = model_to_save[:attributes]
+              model = Object.const_get(model_to_save[:model])
+              id = attributes.delete(model.primary_key) if model.respond_to? :primary_key # if we are saving existing model primary key value will be present
+              vector = model_to_save[:vector]
+              vector = [vector[0].constantize] + vector[1..-1].collect do |method|
+                if method.is_a?(Array) and method.first == "find_by_id"
+                  ["find", method.last]
+                else
+                  method
                 end
-              elsif record.respond_to? "#{key}="
-                record.send("#{key}=",value)
-              else
-                # TODO once reading schema.rb on client is implemented throw an error here
               end
-            end
-          elsif record
-            # either the model is new, or its not even an active record model
-            dont_save_list << record unless save
-            keys = record.attributes.keys
-            attributes.each do |key, value|
-              if keys.include? key
-                record[key] = value
-              elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key) and !(aggregation.klass < ActiveRecord::Base)
-                aggregation.mapping.each_with_index do |pair, i|
-                  record[pair.first] = value[i]
+              reactive_records[model_to_save[:id]] = vectors[vector] = record = find_record(model, id, vector, save)
+              if record and record.respond_to?(:id) and record.id
+                # we have an already exising activerecord model
+                keys = record.attributes.keys
+                attributes.each do |key, value|
+                  if keys.include? key
+                    record[key] = value
+                  elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key.to_sym) and !(aggregation.klass < ActiveRecord::Base)
+                    aggregation.mapping.each_with_index do |pair, i|
+                      record[pair.first] = value[i]
+                    end
+                  elsif record.respond_to? "#{key}="
+                    record.send("#{key}=",value)
+                  else
+                    # TODO once reading schema.rb on client is implemented throw an error here
+                  end
                 end
-              elsif key.to_s != "id" and record.respond_to?("#{key}=")  # server side methods can get included and we won't be able to write them...
-                # for example if you have a server side method foo, that you "get" on a new record, then later that value will get sent to the server
-                # we should track better these server side methods so this does not happen
-                record.send("#{key}=",value)
+              elsif record
+                # either the model is new, or its not even an active record model
+                dont_save_list << record unless save
+                keys = record.attributes.keys
+                attributes.each do |key, value|
+                  if keys.include? key
+                    record[key] = value
+                  elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key) and !(aggregation.klass < ActiveRecord::Base)
+                    aggregation.mapping.each_with_index do |pair, i|
+                      record[pair.first] = value[i]
+                    end
+                  elsif key.to_s != "id" and record.respond_to?("#{key}=")  # server side methods can get included and we won't be able to write them...
+                    # for example if you have a server side method foo, that you "get" on a new record, then later that value will get sent to the server
+                    # we should track better these server side methods so this does not happen
+                    record.send("#{key}=",value)
+                  end
+                end
+                new_models << record
               end
             end
-            new_models << record
-          end
-        end
 
-        puts "!!!!!!!!!!!!!!attributes updated"
-        ActiveRecord::Base.transaction do
-          associations.each do |association|
-            parent = reactive_records[association[:parent_id]]
-            next unless parent
-            #parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true) remove this????
-            if parent.class.reflect_on_aggregation(association[:attribute].to_sym)
-              puts ">>>>>>AGGREGATE>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
-              aggregate = reactive_records[association[:child_id]]
-              dont_save_list << aggregate
-              current_attributes = parent.send(association[:attribute]).attributes
-              puts "current parent attributes = #{current_attributes}"
-              new_attributes = aggregate.attributes
-              puts "current child attributes = #{new_attributes}"
-              merged_attributes = current_attributes.merge(new_attributes) { |k, current_attr, new_attr| aggregate.send("#{k}_changed?") ? new_attr : current_attr}
-              puts "merged attributes = #{merged_attributes}"
-              aggregate.assign_attributes(merged_attributes)
-              puts "aggregate attributes after merge = #{aggregate.attributes}"
-              parent.send("#{association[:attribute]}=", aggregate)
-              puts "updated  is frozen? #{aggregate.frozen?}, parent attributes = #{parent.send(association[:attribute]).attributes}"
-            elsif parent.class.reflect_on_association(association[:attribute].to_sym).nil?
-              raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
-            elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
-              puts ">>>>>>>>>> #{parent.class.name}.send('#{association[:attribute]}') << #{reactive_records[association[:child_id]]})"
-              dont_save_list.delete(parent)
-              if false and parent.new?
-                parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]] if parent.new?
-                puts "updated"
-              else
-                puts "skipped"
-              end
-            else
-              puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
-              parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
-              dont_save_list.delete(parent)
-              puts "updated"
-            end
-          end if associations
-
-          puts "!!!!!!!!!!!!associations updated"
-
-          #if true or save
-
-  #        ActiveRecord::Base.transaction do
-
-            has_errors = false
-
-            puts "ready to start saving... dont_save_list = #{dont_save_list}"
-
-            saved_models = reactive_records.collect do |reactive_record_id, model|
-              puts "saving rr_id: #{reactive_record_id} model.object_id: #{model.object_id} frozen? <#{model.frozen?}>"
-              if model and (model.frozen? or dont_save_list.include?(model) or model.changed.include?(model.class.primary_key))
-                # the above check for changed including the private key happens if you have an aggregate that includes its own id
-                puts "validating frozen model #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
-                valid = model.valid?
-                puts "has_errors before = #{has_errors}, validate= #{validate}, !valid= #{!valid}  (validate and !valid) #{validate and !valid}"
-                has_errors ||= (validate and !valid)
-                puts "validation complete errors = <#{!valid}>, #{model.errors.messages} has_errors #{has_errors}"
-                [reactive_record_id, model.class.name, model.attributes,  (valid ? nil : model.errors.messages)]
-              elsif model and (!model.id or model.changed?)
-                puts "saving #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
-                saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save(validate: validate)
-                has_errors ||= !saved
-                messages = model.errors.messages if (validate and !saved) or (!validate and !model.valid?)
-                puts "saved complete errors = <#{!saved}>, #{messages} has_errors #{has_errors}"
-                [reactive_record_id, model.class.name, model.attributes, messages]
-              end
-            end.compact
+            #puts "!!!!!!!!!!!!!!attributes updated"
+            ActiveRecord::Base.transaction do
+              associations.each do |association|
+                parent = reactive_records[association[:parent_id]]
+                next unless parent
+                #parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true) remove this????
+                if parent.class.reflect_on_aggregation(association[:attribute].to_sym)
+                  #puts ">>>>>>AGGREGATE>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
+                  aggregate = reactive_records[association[:child_id]]
+                  dont_save_list << aggregate
+                  current_attributes = parent.send(association[:attribute]).attributes
+                  #puts "current parent attributes = #{current_attributes}"
+                  new_attributes = aggregate.attributes
+                  #puts "current child attributes = #{new_attributes}"
+                  merged_attributes = current_attributes.merge(new_attributes) { |k, current_attr, new_attr| aggregate.send("#{k}_changed?") ? new_attr : current_attr}
+                  #puts "merged attributes = #{merged_attributes}"
+                  aggregate.assign_attributes(merged_attributes)
+                  #puts "aggregate attributes after merge = #{aggregate.attributes}"
+                  parent.send("#{association[:attribute]}=", aggregate)
+                  #puts "updated  is frozen? #{aggregate.frozen?}, parent attributes = #{parent.send(association[:attribute]).attributes}"
+                elsif parent.class.reflect_on_association(association[:attribute].to_sym).nil?
+                  raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
+                elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
+                  #puts ">>>>>>>>>> #{parent.class.name}.send('#{association[:attribute]}') << #{reactive_records[association[:child_id]]})"
+                  dont_save_list.delete(parent)
+                  if false and parent.new?
+                    parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]] if parent.new?
+                    #puts "updated"
+                  else
+                    #puts "skipped"
+                  end
+                else
+                  #puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
+                  parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+                  dont_save_list.delete(parent)
+                  #puts "updated"
+                end
+              end if associations
+
+              #puts "!!!!!!!!!!!!associations updated"
+
+              has_errors = false
+
+              #puts "ready to start saving... dont_save_list = #{dont_save_list}"
+
+              saved_models = reactive_records.collect do |reactive_record_id, model|
+                #puts "saving rr_id: #{reactive_record_id} model.object_id: #{model.object_id} frozen? <#{model.frozen?}>"
+                if model and (model.frozen? or dont_save_list.include?(model) or model.changed.include?(model.class.primary_key))
+                  # the above check for changed including the private key happens if you have an aggregate that includes its own id
+                  #puts "validating frozen model #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
+                  valid = model.valid?
+                  #puts "has_errors before = #{has_errors}, validate= #{validate}, !valid= #{!valid}  (validate and !valid) #{validate and !valid}"
+                  has_errors ||= (validate and !valid)
+                  #puts "validation complete errors = <#{!valid}>, #{model.errors.messages} has_errors #{has_errors}"
+                  [reactive_record_id, model.class.name, model.attributes,  (valid ? nil : model.errors.messages)]
+                elsif model and (!model.id or model.changed?)
+                  #puts "saving #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
+                  saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save(validate: validate)
+                  has_errors ||= !saved
+                  messages = model.errors.messages if (validate and !saved) or (!validate and !model.valid?)
+                  #puts "saved complete errors = <#{!saved}>, #{messages} has_errors #{has_errors}"
+                  [reactive_record_id, model.class.name, model.attributes, messages]
+                end
+              end.compact
 
-            raise "Could not save all models" if has_errors
+              raise "Could not save all models" if has_errors
 
-#          end
-          if save
+              if save
 
-            {success: true, saved_models: saved_models }
+                {success: true, saved_models: saved_models }
 
-          else
+              else
 
-            vectors.each { |vector, model| model.reload unless model.nil? or model.new_record? or model.frozen? }
-            vectors
+                vectors.each { |vector, model| model.reload unless model.nil? or model.new_record? or model.frozen? }
+                vectors
 
-          end
+              end
 
-        end
+            end
 
-      rescue Exception => e
-        puts "exception #{e}"
-        puts e.backtrace.join("\n")
-        if save
-          {success: false, saved_models: saved_models, message: e.message}
-        else
-          {}
+          rescue Exception => e
+            ReactiveRecord::Pry.rescued(e)
+            if save
+              {success: false, saved_models: saved_models, message: e}
+            else
+              {}
+            end
+          end
         end
-
       end
 
     end
@@ -569,19 +567,26 @@ module ReactiveRecord
     else
 
       def self.destroy_record(model, id, vector, acting_user)
-        model = Object.const_get(model)
-        record = if id
-          model.find(id)
-        else
-          ServerDataCache.new(acting_user, {})[*vector]
-        end
-        record.check_permission_with_acting_user(acting_user, :destroy_permitted?).destroy
-        {success: true, attributes: {}}
 
-      rescue Exception => e
-        {success: false, record: record, message: e.message}
-      end
+        ReactiveRecord::Pry.rescue do
+          begin
+            model = Object.const_get(model)
+            record = if id
+              model.find(id)
+            else
+              ServerDataCache.new(acting_user, {})[*vector]
+            end
+
 
+            record.check_permission_with_acting_user(acting_user, :destroy_permitted?).destroy
+            {success: true, attributes: {}}
+
+          rescue Exception => e
+            ReactiveRecord::Pry.rescued(e)
+            {success: false, record: record, message: e}
+          end
+        end
+      end
     end
   end
 

data/lib/reactive_record/active_record/reactive_record/while_loading.rb

@@ -116,9 +116,7 @@ module ReactiveRecord
         end
 
         def loaded_at(loaded_at)
-          puts "loaded_at started"
           React::State.set_state(self, :loaded_at, loaded_at)
-          puts "loaded_at done"
           @is_loading = false
         end
 

data/lib/reactive_record/permissions.rb

@@ -1,55 +1,63 @@
+module ReactiveRecord
+  class AccessViolation < StandardError
+    def message
+      "ReactiveRecord::AccessViolation: #{super}"
+    end
+  end
+end
+
 class ActiveRecord::Base
-  
+
   attr_accessor :acting_user
-  
+
   def create_permitted?
     true
   end
-  
+
   def update_permitted?
     true
   end
-  
+
   def destroy_permitted?
     true
   end
-  
-  def view_permitted?(attribute) 
+
+  def view_permitted?(attribute)
     true
   end
-  
+
   def only_changed?(*attributes)
     (self.attributes.keys + self.class.reactive_record_association_keys).each do |key|
       return false if self.send("#{key}_changed?") and !attributes.include? key
     end
     true
   end
-  
+
   def none_changed?(*attributes)
     attributes.each do |key|
       return false if self.send("#{key}_changed?")
     end
     true
   end
-  
+
   def any_changed?(*attributes)
     attributes.each do |key|
       return true if self.send("#{key}_changed?")
     end
     false
-  end  
-    
+  end
+
   def all_changed?(*attributes)
     attributes.each do |key|
       return false unless self.send("#{key}_changed?")
     end
     true
   end
-  
+
   class << self
-    
+
     attr_reader :reactive_record_association_keys
-    
+
     [:has_many, :belongs_to, :composed_of].each do |macro|
       define_method "#{macro}_with_reactive_record_add_changed_method".to_sym do |attr_name, *args, &block|
         define_method "#{attr_name}_changed?".to_sym do
@@ -60,19 +68,19 @@ class ActiveRecord::Base
       end
       alias_method_chain macro, :reactive_record_add_changed_method
     end
-    
+
     def belongs_to_with_reactive_record_add_is_method(attr_name, scope = nil, options = {})
       define_method "#{attr_name}_is?".to_sym do |model|
         send(options[:foreign_key] || "#{attr_name}_id") == model.id
       end
       belongs_to_without_reactive_record_add_is_method(attr_name, scope, options)
     end
-    
+
     alias_method_chain :belongs_to, :reactive_record_add_is_method
-      
+
   end
-        
-    
+
+
   def check_permission_with_acting_user(user, permission, *args)
     old = acting_user
     self.acting_user = user
@@ -80,15 +88,15 @@ class ActiveRecord::Base
       self.acting_user = old
       self
     else
-      raise "ReactiveRecord Access Violation:  #{permission}(#{args}) returned false"
+      raise ReactiveRecord::AccessViolation, "for #{permission}(#{args})"
     end
   end
-  
+
 end
 
 class ActionController::Base
-  
+
   def acting_user
   end
-  
-end
+
+end

data/lib/reactive_record/pry.rb

@@ -0,0 +1,19 @@
+module ReactiveRecord
+
+  module Pry
+
+    def self.rescue(&block)
+      if defined? PryRescue
+        ::Pry::rescue &block
+      else
+        block.call
+      end
+    end
+
+    def self.rescued(e)
+      ::Pry::rescued(e) if defined?(PryRescue) && !e.is_a?(ReactiveRecord::AccessViolation)
+    end
+
+  end
+
+end

data/lib/reactive_record/server_data_cache.rb

@@ -186,13 +186,16 @@ module ReactiveRecord
                 elsif aggregation = cache_item.aggregation?(method)
                   cache_item.build_new_cache_item(aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }, method, method)
                 else
-                  begin
-                    cache_item.build_new_cache_item(cache_item.value.send(*method), method, method)
-                  rescue Exception => e
-                    if cache_item.value and cache_item.value != []
-                      raise "ReactiveRecord exception caught when applying #{method} to db object #{cache_item.value}: #{e}"
-                    else
-                      representative
+                  ReactiveRecord::Pry::rescue do
+                    begin
+                      cache_item.build_new_cache_item(cache_item.value.send(*method), method, method)
+                    rescue Exception => e
+                      if cache_item.value and cache_item.value != []
+                        ReactiveRecord::Pry::rescued(e)
+                        raise e, "ReactiveRecord exception caught when applying #{method} to db object #{cache_item.value}: #{e}", e.backtrace
+                      else
+                        representative
+                      end
                     end
                   end
                 end

data/lib/reactive_record/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRecord
-  VERSION = "0.7.35"
+  VERSION = "0.7.36"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-record
 version: !ruby/object:Gem::Version
-  version: 0.7.35
+  version: 0.7.36
 platform: ruby
 authors:
 - Mitch VanDuyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-31 00:00:00.000000000 Z
+date: 2016-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -164,6 +164,7 @@ files:
 - lib/reactive_record/engine.rb
 - lib/reactive_record/interval.rb
 - lib/reactive_record/permissions.rb
+- lib/reactive_record/pry.rb
 - lib/reactive_record/serializers.rb
 - lib/reactive_record/server_data_cache.rb
 - lib/reactive_record/version.rb