reactive-record 0.7.6 → 0.7.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8548152ff489f1a0eb74a6eb0acbe08bcf94acb0
-  data.tar.gz: 2f6578db7396a607c8b3e61bea163fb55c5699c9
+  metadata.gz: e925fd65899df1cb77f96d9f3ccd69ec217c84b0
+  data.tar.gz: 758b5f711b45aa013975580fb6e35efe0e84d1b5
 SHA512:
-  metadata.gz: daab93265cb69a09597a46ed12cafda5975abdba0ac6eddb82b74123448ced47ee3d39b889d9ad7fc28ddf85bc7999ff73db8fd69b7fe76b9ce540571b51132a
-  data.tar.gz: e5ea4f5e44394b9103636a3b0081b7671caea1b90ab8627a5ba9b66976bcaaab212819da3e56aa3739a7903ef5cc1b98ddfb5fbbb7c1904ab6d9693241bef628
+  metadata.gz: 0488d3001210b59a6e041807c4766b9110986b9f66e6327eb06214252d874d5b8c6873e96897c92c8f7c7c0a24a1dacc56f64d947a09f883eaae4a338e2d1494
+  data.tar.gz: 6a37ddf21f528087ee68fea326eead883c740b7b61697106593a2089a58783173b9d8e0ecdfd263cce86d4987a9b6f7a76800afe9fa35857244b249a062c1d20

data/app/controllers/reactive_record/reactive_record_controller.rb

@@ -2,19 +2,19 @@ require 'reactive_record/server_data_cache'
 
 module ReactiveRecord
 
-  class ReactiveRecordController < ApplicationController
+  class ReactiveRecordController < ::ApplicationController
     
     def fetch
-      render :json => ReactiveRecord::ServerDataCache[params[:pending_fetches]]
+      render :json => ReactiveRecord::ServerDataCache[params[:pending_fetches], acting_user]
     end
         
 
     def save
-      render :json => ReactiveRecord::Base.save_records(params[:models], params[:associations])
+      render :json => ReactiveRecord::Base.save_records(params[:models], params[:associations], acting_user)
     end
       
     def destroy
-      render :json => ReactiveRecord::Base.destroy_record(params[:model], params[:id], params[:vector])
+      render :json => ReactiveRecord::Base.destroy_record(params[:model], params[:id], params[:vector], acting_user)
     end
 
   end

data/lib/reactive-record.rb

@@ -17,6 +17,7 @@ else
   
   require "opal"
   require "reactive_record/version"
+  require "reactive_record/permissions"
   require "reactive_record/engine"
   require "reactive_record/server_data_cache"
   require "reactive_record/active_record/reactive_record/isomorphic_base"

data/lib/reactive_record/active_record/associations.rb

@@ -36,7 +36,9 @@ module ActiveRecord
       
       def inverse_of
         unless @options[:through] or @inverse_of
-          inverse_association = klass.reflect_on_all_associations.detect { | association | association.association_foreign_key == @association_foreign_key }
+          inverse_association = klass.reflect_on_all_associations.detect do | association | 
+            association.association_foreign_key == @association_foreign_key and association.klass.base_class == @owner_class.base_class
+          end
           raise "Association #{@owner_class}.#{attribute} (foreign_key: #{@association_foreign_key}) has no inverse in #{@klass_name}" unless inverse_association
           @inverse_of = inverse_association.attribute
         end

data/lib/reactive_record/active_record/class_methods.rb

@@ -79,7 +79,9 @@ module ActiveRecord
     end
         
     [:belongs_to, :has_many, :has_one].each do |macro| 
-      define_method(macro) do |name, opts = {}| 
+      define_method(macro) do |*args| # is this a bug in opal?  saying name, scope=nil, opts={} does not work!
+        name = args.first
+        opts = args.last
         Associations::AssociationReflection.new(base_class, macro, name, opts)
       end
     end

data/lib/reactive_record/active_record/instance_methods.rb

@@ -11,8 +11,11 @@ module ActiveRecord
         @backing_record = hash
       else
         # standard active_record new -> creates a new instance, primary key is ignored if present
-        hash[primary_key] = nil
-        @backing_record = ReactiveRecord::Base.new(self.class, hash, self)
+        # we have to build the backing record first then initialize it so associations work correctly
+        @backing_record = ReactiveRecord::Base.new(self.class, {}, self)
+        @backing_record.instance_eval do
+          self.class.load_data { hash.each { |attribute, value| reactive_set!(attribute, value) unless attribute == primary_key } }
+        end
       end
     end
     

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

@@ -43,10 +43,14 @@ module ReactiveRecord
       self.class.data_loading?
     end
     
+    def self.load_data(&block)
+      current_data_loading, @data_loading = [@data_loading, true]
+      yield
+      @data_loading = current_data_loading
+    end
+    
     def self.load_from_json(json, target = nil)
-      @data_loading = true
-      ServerDataCache.load_from_json(json, target)
-      @data_loading = false
+      load_data { ServerDataCache.load_from_json(json, target) }
     end
     
     def self.class_scopes(model)
@@ -100,9 +104,9 @@ module ReactiveRecord
     
     def initialize(model, hash = {}, ar_instance = nil)
       @model = model
-      @synced_attributes = {}
-      @attributes = hash
       @ar_instance = ar_instance
+      @synced_attributes = {}
+      @attributes = {}
       records[model] << self
     end
   
@@ -203,7 +207,7 @@ module ReactiveRecord
     def sync!(hash = {})
       @attributes.merge! hash
       @synced_attributes = @attributes.dup
-      @synced_attributes.each { |key, value| @synced_attributes[key] = value.dup if value.is_a? Collection }
+      @synced_attributes.each { |key, value| @synced_attributes[key] = value.dup_for_sync if value.is_a? Collection }
       @saving = false
       React::State.set_state(self, self, :synced) unless data_loading?
       self

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

@@ -13,6 +13,14 @@ module ReactiveRecord
       end
       @scopes = {}
     end
+    
+    def dup_for_sync
+      self.dup.instance_eval do
+        @collection = @collection.dup if @collection
+        @scopes = @scopes.dup
+        self
+      end
+    end
 
     def all
       @dummy_collection.notify if @dummy_collection
@@ -55,10 +63,10 @@ module ReactiveRecord
 
 
     def <<(item)
-      if @owner and @association and inverse_of = @association.inverse_of
+      backing_record = item.instance_variable_get(:@backing_record)
+      if backing_record and @owner and @association and inverse_of = @association.inverse_of
         item.attributes[inverse_of].attributes[@association.attribute].delete(item) if item.attributes[inverse_of] and item.attributes[inverse_of].attributes[@association.attribute]
         item.attributes[inverse_of] = @owner
-        backing_record = item.instance_variable_get(:@backing_record)
         React::State.set_state(backing_record, inverse_of, @owner) unless backing_record.data_loading?
       end
       all << item unless all.include? item

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

@@ -6,10 +6,11 @@ module ReactiveRecord
     
     include React::IsomorphicHelpers
         
-    before_first_mount do
+    before_first_mount do |context|
       if RUBY_ENGINE != 'opal'
-        @server_data_cache = ReactiveRecord::ServerDataCache.new
+        @server_data_cache = ReactiveRecord::ServerDataCache.new(context.controller.acting_user)
       else
+        @fetch_scheduled = nil
         @records = Hash.new { |hash, key| hash[key] = [] }
         @class_scopes = Hash.new { |hash, key| hash[key] = {} }
         if on_opal_client? 
@@ -150,26 +151,31 @@ module ReactiveRecord
 
     def self.schedule_fetch
       @fetch_scheduled ||= after(0.001) do
-        last_fetch_at = @last_fetch_at
-        pending_fetches = @pending_fetches.uniq
-        log(["Server Fetching: %o", pending_fetches.to_n])
-        start_time = Time.now
-        HTTP.post(`window.ReactiveRecordEnginePath`, payload: {pending_fetches: pending_fetches}).then do |response|
-          fetch_time = Time.now
-          log("       Fetched in:   #{(fetch_time-start_time).to_i}s")
-          begin
-            ReactiveRecord::Base.load_from_json(response.json)
-          rescue Exception => e
-            log("Exception raised while loading json from server: #{e}", :error)
+        if @pending_fetches.count > 0  # during testing we might reset the context while there are pending fetches
+          last_fetch_at = @last_fetch_at
+          pending_fetches = @pending_fetches.uniq
+          log(["Server Fetching: %o", pending_fetches.to_n])
+          start_time = Time.now
+          HTTP.post(`window.ReactiveRecordEnginePath`, payload: {pending_fetches: pending_fetches}).then do |response|
+            fetch_time = Time.now
+            log("       Fetched in:   #{(fetch_time-start_time).to_i}s")
+            begin
+              ReactiveRecord::Base.load_from_json(response.json)
+            rescue Exception => e
+              log("Exception raised while loading json from server: #{e}", :error)
+            end
+            log("       Processed in: #{(Time.now-fetch_time).to_i}s")
+            log(["       Returned: %o", response.json.to_n])
+            ReactiveRecord.run_blocks_to_load
+            ReactiveRecord::WhileLoading.loaded_at last_fetch_at
+          end.fail do |response|
+            log("Fetch failed", :error)
+            ReactiveRecord.run_blocks_to_load(response.body)
           end
-          log("       Processed in: #{(Time.now-fetch_time).to_i}s")
-          log(["       Returned: %o", response.json.to_n])
-          ReactiveRecord.run_blocks_to_load
-          ReactiveRecord::WhileLoading.loaded_at last_fetch_at
-        end if @pending_fetches.count > 0
-        @pending_fetches = []
-        @last_fetch_at = Time.now
-        @fetch_scheduled = nil
+          @pending_fetches = []
+          @last_fetch_at = Time.now
+          @fetch_scheduled = nil
+        end
       end
     end
     
@@ -182,7 +188,7 @@ module ReactiveRecord
     if RUBY_ENGINE == 'opal'
       
       def save(&block) 
-
+        
         if data_loading?
 
           sync!
@@ -241,18 +247,29 @@ module ReactiveRecord
               internal_id, klass, attributes = item
               backing_records[internal_id].sync!(attributes)
             end
-            yield response.json[:success], response.json[:message] if block
-            promise.resolve response.json[:success], response.json[:message]
+            log("Reactive Record Save Failed: #{response.json[:message]}", :error) unless response.json[:success]
+            response.json[:saved_models].each do |model|
+              log("  Model: #{model[1]}  Attributes: #{model[2]}  Errors: #{model[3]}", :error) if model[3]
+            end
+            yield response.json[:success], response.json[:message], response.json[:saved_models]  if block
+            promise.resolve response.json
           end
           promise
+        else
+          promise = Promise.new
+          yield true, nil if block
+          promise.resolve({success: true})
+          promise
         end
       end
       
     else
       
-      def self.save_records(models, associations)
+      def self.save_records(models, associations, acting_user)
         
         reactive_records = {}
+        new_models = []
+        saved_models = []
 
         models.each do |model_to_save|
           attributes = model_to_save[:attributes]
@@ -262,43 +279,61 @@ module ReactiveRecord
             record = model.find(id)
             keys = record.attributes.keys
             attributes.each do |key, value|
-              record[key] = value if keys.include? key
+              if keys.include? key 
+                record[key] = value
+              else
+                record.send("#{key}=",value)
+              end
             end
             record
           else
             record = model.new
             keys = record.attributes.keys
             attributes.each do |key, value|
-              record[key] = value if keys.include? key
+              if keys.include? key 
+                record[key] = value
+              else
+                record.send("#{key}=",value)
+              end
             end
+            new_models << record
             record
           end
         end
         
-        associations.each do |association|
-          begin
-            if reactive_records[association[:parent_id]].class.reflect_on_aggregation(association[:attribute].to_sym)
-              reactive_records[association[:parent_id]].send("#{association[:attribute]}=", reactive_records[association[:child_id]])
-            elsif reactive_records[association[:parent_id]].class.reflect_on_association(association[:attribute].to_sym).collection?
-              reactive_records[association[:parent_id]].send("#{association[:attribute]}") << reactive_records[association[:child_id]]
+        ActiveRecord::Base.transaction do
+          
+          associations.each do |association|
+            parent = reactive_records[association[:parent_id]]
+            parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true)
+            if parent.class.reflect_on_aggregation(association[:attribute].to_sym)
+              parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+            elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
+              parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
             else
-              reactive_records[association[:parent_id]].send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+              parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
             end
-          end
-        end if associations 
+          end if associations 
+          
+          has_errors = false
 
-        saved_models = reactive_records.collect do |reactive_record_id, model|
-          unless model.frozen? 
-            saved = model.save
-            [reactive_record_id, model.class.name, model.attributes, saved]
-          end
-        end.compact
-      
-        {success: true, saved_models: saved_models || []}
+          saved_models = reactive_records.collect do |reactive_record_id, model|
+            unless model.frozen? 
+              saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save
+              has_errors ||= !saved
+              [reactive_record_id, model.class.name, model.attributes, (saved ? nil : model.errors.full_messages)]
+            end
+          end.compact
+          
+          raise "Could not save all models" if has_errors
+        
+        end
+        
+        {success: true, saved_models: saved_models }
       
       rescue Exception => e
         
-        {success: false, saved_models: saved_models || [], message: e.message}
+        {success: false, saved_models: saved_models, message: e.message}
         
       end
       
@@ -325,11 +360,11 @@ module ReactiveRecord
         if id or vector
           HTTP.post(`window.ReactiveRecordEnginePath`+"/destroy", payload: {model: ar_instance.model_name, id: id, vector: vector}).then do |response|
             yield response.json[:success], response.json[:message] if block
-            promise.resolve response.json[:success], response.json[:message]
+            promise.resolve response.json
           end
         else
           yield true, nil if block
-          promise.resolve true, nil
+          promise.resolve({success: true})
         end
         
         @attributes = {}
@@ -341,15 +376,16 @@ module ReactiveRecord
       
     else
       
-      def self.destroy_record(model, id, vector)
+      def self.destroy_record(model, id, vector, acting_user)
         model = Object.const_get(model)
         record = if id 
           model.find(id)
         else
-          ServerDataCache.new[*vector]
+          ServerDataCache.new(acting_user)[*vector]
         end
-        record.destroy
+        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

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

@@ -23,14 +23,14 @@ module ReactiveRecord
     @loads_pending = true
   end
 
-  def self.run_blocks_to_load
+  def self.run_blocks_to_load(failure = nil)
     if @blocks_to_load
       blocks_to_load = @blocks_to_load
       @blocks_to_load = []
       blocks_to_load.each do |promise_and_block|
         @loads_pending = nil
-        result = promise_and_block.last.call
-        if @loads_pending
+        result = promise_and_block.last.call(failure)
+        if @loads_pending and !failure
           @blocks_to_load << promise_and_block
         else
           promise_and_block.first.resolve result

data/lib/reactive_record/permissions.rb

@@ -0,0 +1,94 @@
+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) 
+    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  
+    
+  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
+          instance_variable_get "@reactive_record_#{attr_name}_changed".to_sym
+        end
+        (@reactive_record_association_keys ||= []) << attr_name
+        send "#{macro}_without_reactive_record_add_changed_method".to_sym, attr_name, *args, &block
+      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
+    if self.send(permission, *args)
+      self.acting_user = old
+      self
+    else
+      raise "ReactiveRecord Access Violation:  #{permission}(#{args}) returned false"
+    end
+  end
+  
+end
+
+class ActionController::Base
+  
+  def acting_user
+  end
+  
+end

data/lib/reactive_record/server_data_cache.rb

@@ -86,8 +86,9 @@ module ReactiveRecord
   
 
     class ServerDataCache
-      
-      def initialize
+            
+      def initialize(acting_user)
+        @acting_user = acting_user
         @cache = []
         @requested_cache_items = []
       end
@@ -95,7 +96,7 @@ module ReactiveRecord
       if RUBY_ENGINE != 'opal'
       
         def [](*vector)
-          root = CacheItem.new(@cache, vector[0])
+          root = CacheItem.new(@cache, @acting_user, vector[0])
           vector[1..-1].inject(root) { |cache_item, method| cache_item.apply_method method if cache_item }
           vector[0] = vector[0].constantize
           new_items = @cache.select { | cache_item | cache_item.root == root}
@@ -103,8 +104,8 @@ module ReactiveRecord
           new_items.last.value if new_items.last
         end
       
-        def self.[](vectors)
-          cache = new
+        def self.[](vectors, acting_user)
+          cache = new(acting_user)
           vectors.each { |vector| cache[*vector] }
           cache.as_json
         end
@@ -130,6 +131,7 @@ module ReactiveRecord
           attr_reader :vector
           attr_reader :record_chain
           attr_reader :root
+          attr_reader :acting_user
 
           def value 
             @ar_object
@@ -139,7 +141,7 @@ module ReactiveRecord
             vector.last
           end
           
-          def self.new(db_cache, klass)
+          def self.new(db_cache, acting_user, klass)
             klass_constant = klass.constantize
             if existing = db_cache.detect { |cached_item| cached_item.vector == [klass_constant] }
               return existing
@@ -147,9 +149,10 @@ module ReactiveRecord
             super
           end
 
-          def initialize(db_cache, klass)
+          def initialize(db_cache, acting_user, klass)
             klass = klass.constantize
             @db_cache = db_cache
+            @acting_user = acting_user
             @vector = [klass]
             @ar_object = klass
             @record_chain = []
@@ -161,6 +164,9 @@ module ReactiveRecord
           def apply_method_to_cache(method, &block)
             @db_cache.inject(nil) do | representative, cache_item |
               if cache_item.vector == vector
+                if @ar_object.class < ActiveRecord::Base and @ar_object.attributes.has_key?(method)
+                  @ar_object.check_permission_with_acting_user(acting_user, :view_permitted?, method)
+                end
                 begin
                   new_ar_object = yield cache_item
                   cache_item.clone.instance_eval do
@@ -197,13 +203,8 @@ module ReactiveRecord
               else
                 apply_method_to_cache(method) {[]}
               end
-            else # @ar_object.respond_to? [*method].first 
-              puts "apply #{method} to #{@vector}" 
-              r = apply_method_to_cache(method) { |cache_item| cache_item.value.send(*method) }# rescue nil } # rescue in case we are on a nil association
-              puts "representative method = #{r}"
-              r
-            #else
-             # self
+            else 
+              apply_method_to_cache(method) { |cache_item| cache_item.value.send(*method) }
             end
           end
           

data/lib/reactive_record/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRecord
-  VERSION = "0.7.6"
+  VERSION = "0.7.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-record
 version: !ruby/object:Gem::Version
-  version: 0.7.6
+  version: 0.7.7
 platform: ruby
 authors:
 - Mitch VanDuyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-28 00:00:00.000000000 Z
+date: 2015-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -162,6 +162,7 @@ files:
 - lib/reactive_record/active_record/reactive_record/while_loading.rb
 - lib/reactive_record/engine.rb
 - lib/reactive_record/interval.rb
+- lib/reactive_record/permissions.rb
 - lib/reactive_record/serializers.rb
 - lib/reactive_record/server_data_cache.rb
 - lib/reactive_record/version.rb