volt 0.9.5.pre3 → 0.9.5.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 552337e005627aa06bff5950bcd94cbb5ab58684
-  data.tar.gz: cf7e89e6862c51796186c9034a62e378e27abcfc
+  metadata.gz: 237e158164bd2f394e80998fa3314f52024fbebc
+  data.tar.gz: abd1d018ffd679afba929518326f0139cce4deb0
 SHA512:
-  metadata.gz: 9c42d896c2c9cb881778a8a90dee2c2ff398213540bbaa4183f13c748106b7f8d0724cf50327ce090e7e1c30dcb7336d758f4a5d5ec61521420b53a33478593d
-  data.tar.gz: ea0d96fa24038a6d45d99a3adb3ee59cd072adef219a48aa7c5543e63de9f52f7abf16fd6564aa4ed740e7cc137fcbd2c65220e38a76cf1e8ea7a664fb7ac868
+  metadata.gz: 48b5fa1a075beab16bbe901532b11e46e6ee4aa065d21db169bc425efc9def807d2d286f5ea4a2f6b569458b05fcb7052721ceb3df26aa7d585990a1d4fe6ffb
+  data.tar.gz: d18c325ef1f789d19a6ceaf2327452fd5b06dcefda74d0eeeca8e66b070599544ebf5176779d465a67bf641987f9af40de34a3eb7bbcffcd4b8d469910b17aea

data/CHANGELOG.md

@@ -5,6 +5,8 @@
 - You can now disable auto-import of JS/CSS with ```disable_auto_import``` in a dependencies.rb file
 - Opal was upgraded to 0.8, which brings sourcemaps back (yah!)
 - Page load performance was improved, and more of sprockets was used for component loading.
+- You can now return promises in permissions blocks.  Also, can_read?, can_create?, and .can_delete?
+- Anything in /public is now served via Rack::Static in the default middleware stack.  (So you can put user uploaded images in there)
 
 ## 0.9.4
 ### Lingo Change

data/app/volt/models/active_volt_instance.rb

@@ -0,0 +1,6 @@
+class ActiveVoltInstance < Volt::Model
+  field :server_id, String
+  field :ips, String
+  field :port, Fixnum
+  field :time, Time
+end

data/app/volt/tasks/live_query/live_query.rb

@@ -37,7 +37,7 @@ class LiveQuery
     notify! do |channel|
       filtered_data = nil
       Volt.as_user(channel.user_id) do
-        filtered_data = model.filtered_attributes
+        filtered_data = model.filtered_attributes.sync
       end
 
       channel.send_message('added', nil, @collection, @query, index, filtered_data)
@@ -57,7 +57,7 @@ class LiveQuery
     notify!(skip_channel) do |channel|
       filtered_data = nil
       Volt.as_user(channel.user_id) do
-        filtered_data = model.filtered_attributes
+        filtered_data = model.filtered_attributes.sync
       end
       # puts "Changed: #{id}, #{data} to #{channel.inspect}"
       channel.send_message('changed', nil, @collection, @query, id, filtered_data)

data/app/volt/tasks/query_tasks.rb

@@ -26,7 +26,7 @@ class QueryTasks < Volt::Task
     if initial_data
       # Only send the filtered attributes for this user
       initial_data.map! do |data|
-        [data[0], live_query.model_for_filter(data[1]).filtered_attributes]
+        [data[0], live_query.model_for_filter(data[1]).filtered_attributes.sync]
       end
     end
 

data/lib/volt/models.rb

@@ -12,16 +12,14 @@ require 'volt/models/persistors/local_store'
 require 'volt/models/root_models/root_models'
 # require 'volt/models/root_models/store_root'
 
-# Fow now, we're keeping a volt copy of the promise library from opal 0.8,
-# since opal 0.7.x's version has some bugs.
-# if RUBY_PLATFORM == 'opal'
-#   require 'promise'
-# else
-#   # Opal doesn't expose its promise library directly
-#   require 'opal'
+# Requrie in opal's promise library
+if RUBY_PLATFORM == 'opal'
+  require 'promise'
+else
+  # Opal doesn't expose its promise library directly
+  require 'opal'
 
-#   gem_dir = File.join(Opal.gem_dir, '..')
-#   require(gem_dir + '/stdlib/promise')
-# end
-# TODO: remove once https://github.com/opal/opal/pull/725 is released.
+  gem_dir = File.join(Opal.gem_dir, '..')
+  require(gem_dir + '/stdlib/promise')
+end
 require 'volt/utils/promise_extensions'

data/lib/volt/models/array_model.rb

@@ -22,21 +22,50 @@ module Volt
     # of immediately returning).  To accomplish this, we call the
     # #run_once_loaded method on the persistor.
     def self.proxy_with_load(*method_names)
+      imethods = instance_methods(false)
       method_names.each do |method_name|
-        old_method_name = :"__old_#{method_name}"
-        alias_method(old_method_name, method_name)
+        # Sometimes we want to alias a method_missing method, so we use super
+        # instead to call it, if its not defined locally.
+        if imethods.include?(method_name)
+          imethod = true
+          old_method_name = :"__old_#{method_name}"
+          alias_method(old_method_name, method_name)
+        else
+          imethod = false
+        end
 
         define_method(method_name) do |*args, &block|
+          if imethod
+            call_orig = proc do |*args|
+              send(old_method_name, *args)
+            end
+          else
+            call_orig = proc do |*args|
+              super(*args)
+            end
+          end
+
           # track on the root dep
           persistor.try(:root_dep).try(:depend)
 
           if persistor.respond_to?(:run_once_loaded) &&
               !Volt.in_mode?(:no_model_promises)
-            persistor.run_once_loaded(block) do
-              send(old_method_name, *args)
+            promise = persistor.run_once_loaded.then do
+              # We are already loaded and the result is going to be wrapped
+              Volt.run_in_mode(:no_model_promises) do
+                call_orig.call(*args)
+              end
+            end
+
+            if block
+              promise = promise.then do |val|
+                block.call(val)
+              end
             end
+
+            promise
           else
-            send(old_method_name, *args)
+            call_orig.call(*args)
           end
         end
       end
@@ -119,11 +148,17 @@ module Volt
 
     def delete(val)
       # Check to make sure the models are allowed to be deleted
-      if !val.is_a?(Model) || val.can_delete?
-        result = super
-        Promise.new.resolve(result)
+      if !val.is_a?(Model)
+        # Not a model, return as a Promise
+        super(val).then
       else
-        Promise.new.reject("permissions did not allow delete for #{val.inspect}.")
+        val.can_delete?.then do |can_delete|
+          if can_delete
+            super(val)
+          else
+           Promise.new.reject("permissions did not allow delete for #{val.inspect}.")
+          end
+        end
       end
     end
 
@@ -199,6 +234,10 @@ module Volt
       super(*args)
     end
 
+    def flatten(*args)
+      wrap_values(to_a.flatten(*args))
+    end
+
     def new_model(*args)
       Volt::Model.class_at_path(options[:path]).new(*args)
     end
@@ -285,34 +324,39 @@ module Volt
 
 
       if model.is_a?(Model)
-        if !model.can_create?
-          fail "permissions did not allow create for #{model.inspect}"
-        end
-
-        # Add it to the array and trigger any watches or on events.
-        reactive_array_append(model)
-
-        @persistor.added(model, @array.size - 1)
-
-        # Validate and save
-        promise = model.run_changed.then do
-          # Mark the model as not new
-          model.instance_variable_set('@new', false)
-
-          # Mark the model as loaded
-          model.change_state_to(:loaded_state, :loaded)
-
-        end.fail do |err|
-          # remove from the collection because it failed to save on the server
-          # we don't need to call delete on the server.
-          index = @array.index(model)
-          delete_at(index, true)
+        promise = model.can_create?.then do |can_create|
+          unless can_create
+            fail "permissions did not allow create for #{model.inspect}"
+          end
+        end.then do
 
-          # remove from the id list
-          @persistor.try(:remove_tracking_id, model)
+          # Add it to the array and trigger any watches or on events.
+          reactive_array_append(model)
 
-          # re-raise, err might not be an Error object, so we use a rejected promise to re-raise
-          Promise.new.reject(err)
+          @persistor.added(model, @array.size - 1)
+        end.then do
+          nil.then do
+            # Validate and save
+            model.run_changed
+          end.then do
+            # Mark the model as not new
+            model.instance_variable_set('@new', false)
+
+            # Mark the model as loaded
+            model.change_state_to(:loaded_state, :loaded)
+
+          end.fail do |err|
+            # remove from the collection because it failed to save on the server
+            # we don't need to call delete on the server.
+            index = @array.index(model)
+            delete_at(index, true)
+
+            # remove from the id list
+            @persistor.try(:remove_tracking_id, model)
+
+            # re-raise, err might not be an Error object, so we use a rejected promise to re-raise
+            Promise.new.reject(err)
+          end
         end
       else
         promise = nil.then do
@@ -337,7 +381,7 @@ module Volt
     end
 
     # We need to setup the proxy methods below where they are defined.
-    proxy_with_load :[], :size, :last, :reverse, :all, :to_a, :empty?
+    proxy_with_load :[], :size, :last, :reverse, :all, :to_a, :empty?, :present?, :blank?
 
   end
 end

data/lib/volt/models/field_helpers.rb

@@ -36,13 +36,16 @@ module FieldHelpers
   module ClassMethods
     # field lets you declare your fields instead of using the underscore syntax.
     # An optional class restriction can be passed in.
-    def field(name, klass = nil, auto_cast = true)
+    def field(name, klass = nil, options = {})
       if klass && !VALID_FIELD_CLASSES.include?(klass)
         klass_names = VALID_FIELD_CLASSES.map(&:to_s).join(', ')
         msg = "valid field types is currently limited to #{klass_names}"
         fail FieldHelpers::InvalidFieldClass, msg
       end
 
+      self.fields_data ||= {}
+      self.fields_data[name] = [klass, options]
+
       if klass
         # Add type validation, execpt for String, since anything can be a string.
         unless klass == String
@@ -69,6 +72,7 @@ module FieldHelpers
   end
 
   def self.included(base)
+    base.class_attribute :fields_data
     base.send :extend, ClassMethods
   end
 end

data/lib/volt/models/permissions.rb

@@ -106,41 +106,37 @@ module Volt
         !owner_id.nil? && owner_id == Volt.current_user_id
       end
 
-      # Returns boolean if the model can be deleted
-      def can_delete?
-        action_allowed?(:delete)
-      end
-
-      # Checks the read permissions
-      def can_read?
-        action_allowed?(:read)
-      end
-
-      def can_create?
-        action_allowed?(:create)
+      [:create, :update, :read, :delete].each do |action|
+        # Each can_action? (can_delete? for example) returns a promise that
+        # resolves to true or false if the user
+        define_method(:"can_#{action}?") do
+          action_allowed?(action)
+        end
       end
 
       # Checks if any denies are in place for an action (read or delete)
       def action_allowed?(action_name)
         # TODO: this does some unnecessary work
-        compute_allow_and_deny(action_name)
+        compute_allow_and_deny(action_name).then do
 
-        deny = @__deny_fields == true || (@__deny_fields && @__deny_fields.size > 0)
+          deny = @__deny_fields == true || (@__deny_fields && @__deny_fields.size > 0)
 
-        clear_allow_and_deny
+          clear_allow_and_deny
 
-        !deny
+          !deny
+        end
       end
 
       # Return the list of allowed fields
       def allow_and_deny_fields(action_name)
-        compute_allow_and_deny(action_name)
+        compute_allow_and_deny(action_name).then do
 
-        result = [@__allow_fields, @__deny_fields]
+          result = [@__allow_fields, @__deny_fields]
 
-        clear_allow_and_deny
+          clear_allow_and_deny
 
-        result
+          result
+        end
       end
 
       # Filter fields returns the attributes with any denied or not allowed fields
@@ -149,70 +145,80 @@ module Volt
       # Run with Volt.as_user(...) to change the user
       def filtered_attributes
         # Run the read permission check
-        allow, deny = allow_and_deny_fields(:read)
-
-        result = nil
-
-        if allow && allow != true && allow.size > 0
-          # always keep id
-          allow << :id
-
-          # Only keep fields in the allow list
-          result = @attributes.select { |key| allow.include?(key) }
-        elsif deny == true
-          # Only keep id
-          # TODO: Should this be a full reject?
-          result = @attributes.reject { |key| key != :id }
-        elsif deny && deny.size > 0
-          # Reject any in the deny list
-          result = @attributes.reject { |key| deny.include?(key) }
-        else
-          result = @attributes
-        end
-
-        # Deeply filter any nested models
-        return result.map do |key, value|
-          if value.is_a?(Model)
-            value = value.filtered_attributes
+        allow_and_deny_fields(:read).then do |allow, deny|
+
+          result = nil
+
+          if allow && allow != true && allow.size > 0
+            # always keep id
+            allow << :id
+
+            # Only keep fields in the allow list
+            result = @attributes.select { |key| allow.include?(key) }
+          elsif deny == true
+            # Only keep id
+            # TODO: Should this be a full reject?
+            result = @attributes.reject { |key| key != :id }
+          elsif deny && deny.size > 0
+            # Reject any in the deny list
+            result = @attributes.reject { |key| deny.include?(key) }
+          else
+            result = @attributes
           end
 
-          [key, value]
-        end.to_h
+          # Deeply filter any nested models
+          result.then do |res|
+            keys = []
+            values = []
+            res.each do |key, value|
+              if value.is_a?(Model)
+                value = value.filtered_attributes
+              end
+              keys << key
+              values << value
+            end
+
+            Promise.when(*values).then do |values|
+              keys.zip(values).to_h
+            end
+          end
+        end
       end
 
       private
 
       def run_permissions(action_name = nil)
-        compute_allow_and_deny(action_name)
-
-        errors = {}
-
-        if @__allow_fields == true
-          # Allow all fields
-        elsif @__allow_fields && @__allow_fields.size > 0
-          # Deny all not specified in the allow list
-          changed_attributes.keys.each do |field_name|
-            unless @__allow_fields.include?(field_name)
-              add_error_if_changed(errors, field_name)
+        compute_allow_and_deny(action_name).then do
+
+          errors = {}
+
+          if @__allow_fields == true
+            # Allow all fields
+          elsif @__allow_fields && @__allow_fields.size > 0
+            # Deny all not specified in the allow list
+            changed_attributes.keys.each do |field_name|
+              unless @__allow_fields.include?(field_name)
+                add_error_if_changed(errors, field_name)
+              end
             end
           end
-        end
 
-        if @__deny_fields == true
-          # Don't allow any field changes
-          changed_attributes.keys.each do |field_name|
-            add_error_if_changed(errors, field_name)
-          end
-        elsif @__deny_fields
-          # Allow all except the denied
-          @__deny_fields.each do |field_name|
-            add_error_if_changed(errors, field_name) if changed?(field_name)
+          if @__deny_fields == true
+            # Don't allow any field changes
+            changed_attributes.keys.each do |field_name|
+              add_error_if_changed(errors, field_name)
+            end
+          elsif @__deny_fields
+            # Allow all except the denied
+            @__deny_fields.each do |field_name|
+              add_error_if_changed(errors, field_name) if changed?(field_name)
+            end
           end
-        end
 
-        clear_allow_and_deny
+          clear_allow_and_deny
 
-        errors
+          errors
+        end
       end
 
       def clear_allow_and_deny
@@ -235,10 +241,13 @@ module Volt
         # Run each of the permission blocks for this action
         permissions = self.class.__permissions__
         if permissions && (blocks = permissions[action_name])
-          blocks.each do |block|
+          results = blocks.map do |block|
             # Call the block, pass the action name
             instance_exec(action_name, &block)
           end
+
+          # Wait for any promises returned
+          Promise.when(*results)
         end
       end