volt 0.9.5.pre4 → 0.9.5.pre5

data/lib/volt/extra_core/array.rb

@@ -8,4 +8,26 @@ class Array
   def to_h
     Hash[self]
   end
+
+
+  # Converts an array to a sentence
+  def to_sentence(options={})
+    conjunction = options.fetch(:conjunction, 'and')
+    comma       = options.fetch(:comma, ',')
+    oxford      = options.fetch(:oxford, true) # <- true is the right value
+
+    case size
+    when 0
+      ''
+    when 1
+      self[0].to_s
+    when 2
+      self.join(" #{conjunction} ")
+    else
+      str = self[0..-2].join(comma + ' ')
+      str += comma if oxford
+      str += " #{conjunction} " + self[-1].to_s
+      str
+    end
+  end
 end

data/lib/volt/models/array_model.rb

@@ -241,6 +241,7 @@ module Volt
     def new_model(*args)
       Volt::Model.class_at_path(options[:path]).new(*args)
     end
+    alias_method :new, :new_model
 
     def new_array_model(*args)
       Volt::ArrayModel.class_at_path(options[:path]).new(*args)
@@ -306,6 +307,11 @@ module Volt
       name.pluralize
     end
 
+    alias_method :reactive_count, :count
+    def count(&block)
+      all.reactive_count(&block)
+    end
+
     private
     # called form <<, append, and create.  If a hash is passed in, it converts
     # it to a model.  Then it takes the model and inserts it into the ArrayModel
@@ -381,7 +387,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?, :present?, :blank?
+    proxy_with_load :[], :size, :length, :last, :reverse, :all, :to_a, :empty?, :present?, :blank?
 
   end
 end

data/lib/volt/models/errors.rb

@@ -26,7 +26,7 @@ module Volt
         str << "#{field} #{error}"
       end
 
-      str.join
+      str.join(', ')
     end
   end
 end

data/lib/volt/models/field_helpers.rb

@@ -22,34 +22,45 @@ module FieldHelpers
   end
 
   FIELD_CASTS = {
-    String     => :to_s.to_proc,
-    Fixnum     => lambda {|val| NUMERIC_CAST[:Integer, val] },
-    Numeric    => lambda {|val| NUMERIC_CAST[:Float, val] },
-    Float      => lambda {|val| NUMERIC_CAST[:Float, val] },
-    Time       => nil,
-    TrueClass  => nil,
-    FalseClass => nil
+    String        => :to_s.to_proc,
+    Fixnum        => lambda {|val| NUMERIC_CAST[:Integer, val] },
+    Numeric       => lambda {|val| NUMERIC_CAST[:Float, val] },
+    Float         => lambda {|val| NUMERIC_CAST[:Float, val] },
+    Time          => nil,
+    TrueClass     => nil,
+    FalseClass    => nil,
+    NilClass      => nil,
+    Volt::Boolean => nil
   }
-  VALID_FIELD_CLASSES = FIELD_CASTS.keys
 
 
   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, 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
+    def field(name, klasses = nil, options = {})
+      if klasses
+        klasses = [klasses].flatten
+
+        unless klasses.any? {|kl| FIELD_CASTS.key?(kl) }
+          klass_names = FIELD_CASTS.keys.map(&:to_s).join(', ')
+          msg = "valid field types is currently limited to #{klass_names}, you passed: #{klasses.inspect}"
+          fail FieldHelpers::InvalidFieldClass, msg
+        end
+
+        # Add NilClass as an allowed type unless allow_nil: false was passed.
+        unless options[:allow_nil] == false
+          klasses << NilClass
+        end
       end
 
       self.fields_data ||= {}
-      self.fields_data[name] = [klass, options]
+      self.fields_data[name] = [klasses, options]
 
-      if klass
-        # Add type validation, execpt for String, since anything can be a string.
-        unless klass == String
-          validate name, type: klass
+      if klasses
+        # Add type validation, execpt for String, since anything can be cast to
+        # a string.
+        unless klasses.include?(String)
+          validate name, type: klasses
         end
       end
 
@@ -59,10 +70,14 @@ module FieldHelpers
 
       define_method(:"#{name}=") do |val|
         # Check if the value assigned matches the class restriction
-        if klass
+        if klasses
           # Cast to the right type
-          if (func = FIELD_CASTS[klass])
-            val = func[val]
+          klasses.each do |kl|
+            if (func = FIELD_CASTS[kl])
+              # Cast on the first available caster
+              val = func[val]
+              break
+            end
           end
         end
 

data/lib/volt/models/model.rb

@@ -354,6 +354,22 @@ module Volt
       to_h.to_json
     end
 
+    # Update tries to update the model and returns
+    def update(attrs)
+      old_attrs = @attributes.dup
+      Model.no_change_tracking do
+        assign_all_attributes(attrs, false)
+
+        validate!.then do |errs|
+          if errs && errs.present?
+            # Revert wholesale
+            @attributes = old_attrs
+            Promise.new.resolve(errs)
+          end
+        end
+      end
+    end
+
     private
     def run_initial_setup(initial_setup)
       # Save the changes

data/lib/volt/models/validations/validations.rb

@@ -42,12 +42,15 @@ module Volt
 
           if run_in_actions.size == 0 || run_in_actions.include?(action)
             @instance_validations = {}
+            @instance_custom_validations = []
 
             instance_exec(action, &block)
 
             result = run_validations(@instance_validations)
+            result.merge!(run_custom_validations(@instance_custom_validations))
 
             @instance_validations = nil
+            @instance_custom_validations = nil
 
             result
           end
@@ -55,9 +58,19 @@ module Volt
       end
     end
 
-    def validate(field_name = nil, options = nil)
-      @instance_validations[field_name] ||= {}
-      @instance_validations[field_name].merge!(options)
+    # Called on the model inside of a validations block.  Allows the user to
+    # control if validations should be run.
+    def validate(field_name = nil, options = nil, &block)
+      if block
+        # Setup a custom validation inside of the current validations block.
+        if field_name || options
+          fail 'validate should be passed a field name and options or a block, not both.'
+        end
+        @instance_custom_validations << block
+      else
+        @instance_validations[field_name] ||= {}
+        @instance_validations[field_name].merge!(options)
+      end
     end
 
     def self.included(base)
@@ -200,10 +213,12 @@ module Volt
       promise
     end
 
-    def run_custom_validations
+    def run_custom_validations(custom_validations = nil)
+      # Default to running the class level custom validations
+      custom_validations ||= self.class.custom_validations
+
       promise = Promise.new.resolve(nil)
-      # Call all of the custom validations
-      custom_validations = self.class.custom_validations
+
       if custom_validations
         custom_validations.each do |custom_validation|
           # Add to the promise chain

data/lib/volt/models/validators/type_validator.rb

@@ -1,17 +1,49 @@
 # Enforces a type on a field.  Typically setup from ```field :name, Type```
 module Volt
+  # Volt::Boolean can be used if you want a boolean type
+  class Boolean
+  end
+
   class TypeValidator
     def self.validate(model, field_name, args)
       errors = {}
       value  = model.get(field_name)
 
-      type_restriction = args.is_a?(Hash) ? args[:type] : args
+      type_restriction = args.is_a?(Hash) ? (args[:type] || args[:types]) : args
 
-      unless value.is_a?(type_restriction)
+      # Make into an array of 1 if its not already an array.
+      type_restrictions = [type_restriction].flatten
+
+      valid_type = false
+      type_restrictions.each do |type_rest|
+        if value.is_a?(type_rest)
+          valid_type = true
+          break
+        end
+      end
+
+      unless valid_type
         if args.is_a?(Hash) && args[:message]
           message = args[:message]
         else
-          message = "must be of type #{type_restriction.to_s}"
+          type_msgs = type_restrictions.map do |type_rest|
+            if [Fixnum, Float, Numeric].include?(type_rest)
+              "a number"
+            elsif type_rest == NilClass
+              # we don't mention the nil restriction
+              nil
+            elsif type_rest == Volt::Boolean
+              ['true', 'false']
+            elsif type_rest == TrueClass
+              'true'
+            elsif type_rest == FalseClass
+              'false'
+            else
+              "a #{type_rest.to_s}"
+            end
+          end.flatten
+
+          message = "must be #{type_msgs.compact.to_sentence(conjunction: 'or')}"
         end
 
         errors[field_name] = [message]

data/lib/volt/page/bindings/content_binding.rb

@@ -50,7 +50,7 @@ module Volt
       # https://github.com/opal/opal/issues/798
       str.gsub(HTML_ESCAPE_REGEXP) do |char|
         HTML_ESCAPE[char]
-      end
+      end.gsub('  ', " \u00A0").gsub("\n ", "\n\u00A0")
     end
 
     def remove

data/lib/volt/page/bindings/event_binding.rb

@@ -5,6 +5,9 @@ module Volt
   class JSEvent
     attr_reader :js_event
 
+    # The Volt controller that dispatched the event.
+    attr_accessor :controller
+
     def initialize(js_event)
       @js_event = js_event
     end
@@ -43,31 +46,52 @@ module Volt
       end
 
 
-      handler = proc do |js_event|
+      handler = proc do |js_event, *args|
         event = JSEvent.new(js_event)
         event.prevent_default! if event_name == 'submit'
 
-        # Call the proc the user setup for the event in context,
-        # pass in the wrapper for the JS event
-        result = @context.instance_exec(event, &call_proc)
-
-        # The following doesn't work due to the promise already chained issue.
-        # # Ignore native objects.
-        # result = nil unless BasicObject === result
+        # When the event is triggered via ```trigger(..)``` in a controller,
+        # it will pass its self as the first argument.  We set that to
+        # ```controller``` on the event, so it can be easily accessed.
+        if args[0].is_a?(Volt::ModelController)
+          args = args.dup
+          event.controller = args.shift
+        end
 
-        # # if the result is a promise, log an exception if it failed and wasn't
-        # # handled
-        # if result.is_a?(Promise) && !result.next
-        #   result.fail do |err|
-        #     Volt.logger.error("EventBinding Error: promise returned from event binding #{@event_name} was rejected")
-        #     Volt.logger.error(err)
-        #   end
-        # end
+        args << event
 
+        self.class.call_handler_proc(@context, call_proc, event, args)
       end
+
       @listener = browser.events.add(@event_name, self, handler)
     end
 
+    def self.call_handler_proc(context, call_proc, event, args)
+      # When the EventBinding is compiled, it converts a passed in string to
+      # get a Method:
+      #
+      # Example:
+      #   <a e-awesome="some_method">...</a>
+      #
+      # The call_proc will be passed in as:  Proc.new { method(:some_method) }
+      #
+      # So first we call the call_proc, then that returns a method (or proc),
+      # which we call passing in the arguments based on the arity.
+      #
+      # If the e- binding has arguments passed to it, we just use those.
+      result = context.instance_exec(event, &call_proc)
+      # Trim args to match arity
+
+      # The proc returned a
+      if result && result.is_a?(Method)
+        args = args[0...result.arity]
+
+        result.call(*args)
+      end
+
+      result
+    end
+
     # Remove the event binding
     def remove
       browser.events.remove(@event_name, self)

data/lib/volt/page/document_events.rb

@@ -14,10 +14,12 @@ module Volt
 
         that = self
 
+        document_handler = proc do |*args|
+          handle(event, *args)
+        end
+
         `
-        $('body').on(event, function(e) {
-          that.$handle(event, e, e.target || e.originalEvent.target);
-        });
+        $('body').on(event, #{document_handler});
       `
 
       end
@@ -26,8 +28,8 @@ module Volt
       @events[event][binding.binding_name][binding.object_id] = handler
     end
 
-    def handle(event_name, event, target)
-      element = `$(#{target})`
+    def handle(event_name, event, *args)
+      element = `$(event.target || event.originalEvent.target)`
 
       loop do
         # Lookup the handler, make sure to not assume the group
@@ -43,7 +45,7 @@ module Volt
         if handlers
           handlers.values.each do |handler|
             # Call each handler for this object
-            handler.call(event)
+            handler.call(event, *args)
           end
         end
 

data/lib/volt/reactive/reactive_array.rb

@@ -93,10 +93,27 @@ module Volt
       end
     end
 
+    def last
+      self[-1]
+    end
+
     # TODO: Handle a range
     def [](index)
       # Handle a negative index, depend on size
-      index = @array.size + index if index < 0
+      if index < 0
+        # Depend on size by calling .size, since we are looking up reverse
+        # indexes
+
+        # cache size lookup
+        size = self.size
+
+        index = size + index
+
+        # In this case, we're looking back past 0 (going backwards), so we get
+        # nil.  Since we're depending on @size_dep (because we called .size),
+        # it will invalidate when the size changes.
+        return nil if index < 0
+      end
 
       # Get or create the dependency
       dep   = (@array_deps[index] ||= Dependency.new)

data/lib/volt/server/forking_server.rb

@@ -257,8 +257,14 @@ module Volt
 
     def start_change_listener
       sync_mod_time
+
+      options = {}
+      if ENV['POLL_FS']
+        options[:force_polling] = true
+      end
+
       # Setup the listeners for file changes
-      @listener = Listen.to("#{@server.app_path}/") do |modified, added, removed|
+      @listener = Listen.to("#{@server.app_path}/", options) do |modified, added, removed|
         Thread.new do
           # Run the reload in a new thread
           reload(modified + added + removed)