volt 0.8.27.beta3 → 0.8.27.beta4

data/lib/volt/models/persistors/model_store.rb

@@ -143,7 +143,7 @@ module Volt
       # Update the models based on the id/identity map.  Usually these requests
       # will come from the backend.
       def self.changed(model_id, data)
-        Model.nosave do
+        Model.no_save do
           model = @@identity_map.lookup(model_id)
 
           if model
@@ -203,7 +203,6 @@ module Volt
             end
           end
 
-          # puts "Update Collection: #{collection.inspect} - #{values.inspect} -- #{Thread.current['in_channel'].inspect}"
           QueryTasks.live_query_pool.updated_collection(collection.to_s, Thread.current['in_channel'])
           {}
         end

data/lib/volt/models/persistors/query/normalizer.rb

@@ -0,0 +1,51 @@
+module Volt
+  module Query
+    # Normalizes queries so queries that are the same have the same order and parts
+    class Normalizer
+      def self.normalize(query)
+        query = merge_finds_and_move_to_front(query)
+
+        query = reject_skip_zero(query)
+
+        query
+      end
+
+      def self.merge_finds_and_move_to_front(query)
+        # Map first parts to string
+        query = query.map {|v| v[0] = v[0].to_s ; v }
+        has_find = query.find {|v| v[0] == 'find' }
+
+        if has_find
+          # merge any finds
+          merged_find_query = {}
+          query = query.reject do |query_part|
+            if query_part[0] == 'find'
+              # on a find, merge into finds
+              find_query = query_part[1]
+              merged_find_query.merge!(find_query) if find_query
+
+              # reject
+              true
+            else
+              false
+            end
+          end
+
+          # Add finds to the front
+          query.insert(0, ['find', merged_find_query])
+        else
+          # No find was done, add it in the first position
+          query.insert(0, ['find'])
+        end
+
+        query
+      end
+
+      def self.reject_skip_zero(query)
+        query.reject do |query_part|
+          query_part[0] == 'skip' && query_part[1] == 0
+        end
+      end
+    end
+  end
+end

data/lib/volt/models/persistors/query/query_listener.rb

@@ -3,6 +3,8 @@ module Volt
   # a query have changed.  It then will make the necessary changes to any ArrayStore's
   # to get them to display the new data.
   class QueryListener
+    attr_reader :listening
+
     def initialize(query_listener_pool, tasks, collection, query)
       @query_listener_pool = query_listener_pool
       @tasks               = tasks
@@ -30,25 +32,39 @@ module Volt
             store.add(index, data)
           end
 
-          store.change_state_to(:loaded)
+          store.model.change_state_to(:loaded_state, :loaded)
+
+          # if Volt.server?
+          #   puts "BACK TO DIRTY"
+          #   store.model.change_state_to(:loaded_state, :dirty)
+          # end
         end
       end.fail do |err|
-        puts "Error adding listener: #{err.inspect}"
+        # TODO: need to make it so we can re-raise out of this promise
+        Volt.logger.error("Error adding listener: #{err.inspect}")
+        Volt.logger.error(err.backtrace)
+
+        raise err
       end
     end
 
     def add_store(store, &block)
       @stores << store
 
+      # puts "ADD STORE FOR: #{@collection.inspect}: #{@query.inspect}"
+
       if @listening
         # We are already listening and have this model somewhere else,
         # copy the data from the existing model.
         store.model.clear
-        @stores.first.model.each_with_index do |item, index|
+
+        # Get an existing store to copy data from
+        first_store_model = @stores.first.model
+        first_store_model.each_with_index do |item, index|
           store.add(index, item.to_h)
         end
 
-        store.change_state_to(:loaded)
+        store.model.change_state_to(:loaded_state, first_store_model.loaded_state)
       else
         # First time we've added a store, setup the listener and get
         # the initial data.
@@ -59,6 +75,7 @@ module Volt
     def remove_store(store)
       @stores.delete(store)
 
+      # puts "REMOVE STORE: #{@collection.inspect}: #{@query.inspect} - #{@stores.size}"
       # When there are no stores left, remove the query listener from
       # the pool, it can get created again later.
       if @stores.size == 0
@@ -86,7 +103,6 @@ module Volt
 
     def changed(model_id, data)
       $loading_models = true
-      puts "new data: #{data.inspect}"
       Persistors::ModelStore.changed(model_id, data)
       $loading_models = false
     end

data/lib/volt/models/persistors/query/query_listener_pool.rb

@@ -7,14 +7,5 @@ module Volt
   # query in different places.  This makes it so we only need to track a
   # single query at once.  Data updates will only be sent once as well.
   class QueryListenerPool < GenericPool
-    def print
-      puts '--- Running Queries ---'
-
-      @pool.each_pair do |table, query_hash|
-        query_hash.each_key do |query|
-          puts "#{table}: #{query.inspect}"
-        end
-      end
-    end
   end
 end

data/lib/volt/models/persistors/store.rb

@@ -34,6 +34,14 @@ module Volt
         end
         model
       end
+
+      def clear_identity_map
+        @@identity_map.clear
+      end
+
+      def inspect
+        "<#{self.class.to_s}:#{object_id}>"
+      end
     end
   end
 end

data/lib/volt/models/persistors/store_state.rb

@@ -4,33 +4,10 @@ module Volt
     module StoreState
       # Called when a collection loads
       def loaded(initial_state = nil)
-        change_state_to(initial_state || :not_loaded)
-      end
-
-      def state
-        @state_dep ||= Dependency.new
-        @state_dep.depend
-
-        @state
-      end
-
-      # Called from the QueryListener when the data is loaded
-      def change_state_to(new_state)
-        old_state = @state
-        @state    = new_state
-
-        # Trigger changed on the 'state' method
-        if old_state != @state
-          @state_dep.changed! if @state_dep
-        end
-
-        if @state == :loaded && @fetch_promises
-          # Trigger each waiting fetch
-          @fetch_promises.compact.each { |fp| fp.resolve(@model) }
-          @fetch_promises = nil
-
-          # puts "STOP LIST---------"
-          stop_listening
+        if initial_state
+          @model.change_state_to(:loaded_state, initial_state)
+        elsif !@loaded_state
+          @model.change_state_to(:loaded_state, :not_loaded)
         end
       end
     end

data/lib/volt/models/state_helpers.rb

@@ -0,0 +1,11 @@
+module Volt
+  module StateHelpers
+    def loaded_state
+      state_for(:loaded_state)
+    end
+
+    def loaded?
+      loaded_state == :loaded
+    end
+  end
+end

data/lib/volt/models/state_manager.rb

@@ -0,0 +1,43 @@
+module Volt
+  module StateManager
+    def state_for(state_name)
+      ivar_name = :"@#{state_name}"
+
+      # Depend on the dep
+      state_dep_for(state_name).depend
+
+      instance_variable_get(ivar_name)
+    end
+
+    # Called from the QueryListener when the data is loaded
+    def change_state_to(state_name, new_state, trigger=true)
+      # use an instance variable for the state storage
+      ivar_name = :"@#{state_name}"
+
+      old_state = instance_variable_get(ivar_name)
+      instance_variable_set(ivar_name, new_state)
+
+      # Trigger changed on the 'state' method
+      if old_state != new_state && trigger
+        dep = state_dep_for(state_name, false)
+        dep.changed! if dep
+      end
+    end
+
+    private
+    # Get a state ivar for state_name
+    # @params [String] the name of the state variable
+    # @params [Boolean] if true, one will be created if it does not exist
+    def state_dep_for(state_name, create=true)
+      dep_ivar_name = :"@#{state_name}_dep"
+      dep = instance_variable_get(dep_ivar_name)
+      if !dep && create
+        dep = Dependency.new
+        instance_variable_set(dep_ivar_name, dep)
+      end
+
+      dep
+    end
+
+  end
+end

data/lib/volt/models/url.rb

@@ -74,7 +74,7 @@ module Volt
         nested_params_hash(params).each_pair do |key, value|
           # remove the _ from the front
           value = `encodeURI(value)`
-          query_parts << "#{key[1..-1]}=#{value}"
+          query_parts << "#{key}=#{value}"
         end
 
         if query_parts.size > 0
@@ -176,7 +176,7 @@ module Volt
         else
           # assign value
           if old_val != new_val
-            params.send(:"#{name}=", new_val)
+            params.set(name, new_val)
           end
           new_params.delete(name)
         end
@@ -189,10 +189,10 @@ module Volt
     def assign_new(params, new_params)
       new_params.each_pair do |name, value|
         if value.is_a?(Hash)
-          assign_new(params.send(name), value)
+          assign_new(params.get(name), value)
         else
           # assign
-          params.send(:"#{name}=", value)
+          params.set(name, value)
         end
       end
     end
@@ -230,7 +230,7 @@ module Volt
     # Example:
     # user[name]=Ryan would parse as [:_user, :_name]
     def query_key_sections(key)
-      key.split(/\[([^\]]+)\]/).reject(&:empty?).map { |v| :"_#{v}" }
+      key.split(/\[([^\]]+)\]/).reject(&:empty?)
     end
 
     # Generate the key for a nested param attribute

data/lib/volt/models/validations.rb

@@ -1,6 +1,6 @@
-# require 'volt/models/validations/errors'
-require 'volt/models/validators/email_validator'
+require 'volt/models/errors'
 require 'volt/models/validators/format_validator'
+require 'volt/models/validators/email_validator'
 require 'volt/models/validators/length_validator'
 require 'volt/models/validators/numericality_validator'
 require 'volt/models/validators/phone_number_validator'
@@ -66,57 +66,64 @@ module Volt
       @server_errors.delete(key)
     end
 
-    # TODO: Errors is being called for any validation change.  We should have errors return a
-    # hash like object that only calls the validation for each one.
-    def errors(marked_only = false)
-      errors = {}
-
-      # Merge into errors, combining any error arrays
-      merge = proc do |new_errors|
-        errors.merge!(new_errors) do |key, new_val, old_val|
-          new_val + old_val
-        end
-      end
+    def errors(marked_only=false)
+      @errors ||= Errors.new
 
-      # Get the previous model from the buffer
-      save_to = options[:save_to]
-      if save_to && save_to.is_a?(Volt::Model)
-        old_model = save_to
+      if marked_only
+        # Only return the fields that have been marked
+        @errors.to_h.select {|key,_| marked_fields[key] }
       else
-        old_model = nil
+        @errors
       end
+    end
+
+    # TODO: Errors is being called for any validation change.  We should have errors return a
+    # hash like object that only calls the validation for each one.
+    def validate!
+      errors.clear
 
-      errors = run_validations(errors, merge, marked_only, old_model)
+      run_validations
 
       # See if any server errors are in place and merge them in if they are
       if Volt.client?
-        errors = merge.call(server_errors.to_h)
+        errors.merge!(server_errors.to_h)
       end
 
-      errors = run_custom_validations(errors, merge, old_model)
+      run_custom_validations
 
       errors
     end
 
+    # Returns true if any of the changed fields now has an error
+    # @return [Boolean] true if one of the changed fields has an error.
+    def error_in_changed_attributes?
+      errs = errors
+      changed_attributes.each_pair do |key, _|
+        # If any of the fields with errors are also the ones that were
+        return true if errs[key]
+      end
+
+      return false
+    end
+
+
     private
 
     # Runs through each of the normal validations.
-    def run_validations(errors, merge, marked_only, old_model)
+    def run_validations
       validations = self.class.validations
       if validations
 
         # Run through each validation
         validations.each_pair do |field_name, options|
-          # When marked only, skip any validations on non-marked fields
-          next if marked_only && !marked_fields[field_name]
-
           options.each_pair do |validation, args|
             # Call the specific validator, then merge the results back
             # into one large errors hash.
             klass = validation_class(validation, args)
 
             if klass
-              validate_with(merge, klass, old_model, field_name, args)
+              result = klass.validate(self, field_name, args)
+              errors.merge!(result)
             else
               fail "validation type #{validation} is not specified."
             end
@@ -127,27 +134,16 @@ module Volt
       errors
     end
 
-    def run_custom_validations(errors, merge, old_model)
+    def run_custom_validations
       # Call all of the custom validations
       custom_validations = self.class.custom_validations
       if custom_validations
         custom_validations.each do |custom_validation|
-          # Run the validator in the context of the model, passes in
-          # the old_model as an argument
-          result = instance_exec(old_model, &custom_validation)
-
-          if result
-            errors = merge.call(result)
-          end
+          # Run the validator in the context of the model
+          result = instance_exec(&custom_validation)
+          errors.merge!(result)
         end
       end
-
-      errors
-    end
-
-    # calls the validate method on the class, passing the right arguments.
-    def validate_with(merge, klass, old_model, field_name, args)
-      merge.call(klass.validate(self, old_model, field_name, args))
     end
 
     def validation_class(validation, args)
@@ -155,5 +151,6 @@ module Volt
     rescue NameError => e
       puts "Unable to find #{validation} validator"
     end
+
   end
 end

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

@@ -1,19 +1,14 @@
 module Volt
-  class EmailValidator
+  class EmailValidator < FormatValidator
     DEFAULT_OPTIONS = {
       with: /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i,
       message: 'must be an email address'
     }
 
-    def self.validate(model, old_model, field_name, options)
-      new(model, field_name, options).errors
-    end
-
-    def self.new(model, field_name, options)
-      options = DEFAULT_OPTIONS if options == true
-      options = DEFAULT_OPTIONS.merge options
+    private
 
-      FormatValidator.new(model, field_name).apply options
+    def default_options
+      DEFAULT_OPTIONS
     end
   end
 end

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

@@ -1,14 +1,13 @@
 module Volt
+  # Validates the format of a field against any number of block or regex
+  # criteria
   class FormatValidator
     # Creates a new instance with the provided options and returns it's errors
     #
-    # @note the second param +old_model+ is unused and will soon be removed,
-    #   you can pass nil in the mean time
-    #
     # @example
     #   options = { with: /.+@.+/, message: 'must include an @ symobl' }
     #
-    #   FormatValidator.validate(user, nil, 'email', options)
+    #   FormatValidator.validate(user, 'email', options)
     #
     # @example
     #   numbers_only = /^\d+$/
@@ -19,17 +18,16 @@ module Volt
     #     { with: sum_equals_ten, message: 'must add up to 10' }
     #   ]
     #
-    #   FormatValidator.validate(user, nil, 'email', options)
+    #   FormatValidator.validate(user, 'email', options)
     #
     # @param model [Volt::Model] the model being validated
-    # @param old_model [NilClass] no longer used, will be removed
     # @param field_name [String] the name of the field being validated
     #
     # @param options (see #apply)
     # @option options (see #apply)
     #
     # @return (see #errors)
-    def self.validate(model, old_model, field_name, options)
+    def self.validate(model, field_name, options)
       new(model, field_name).apply(options).errors
     end
 
@@ -37,7 +35,8 @@ module Volt
     # @param field_name [String] the name of the field being validated
     def initialize(model, field_name)
       @name = field_name
-      @value = model.read_attribute field_name
+      @value = model.get field_name
+
       @criteria = []
     end
 
@@ -57,6 +56,18 @@ module Volt
     # @return [self] returns itself for chaining
     def apply(options)
       return apply_list options if options.is_a? Array
+
+      options = case options
+                when true
+                  default_options
+                when Hash
+                  if default_options.is_a? Hash
+                    default_options.merge options
+                  else
+                    options
+                  end
+                end
+
       with options[:with], options[:message]
       self
     end
@@ -107,6 +118,10 @@ module Volt
       self
     end
 
+    def default_options
+      {}
+    end
+
     def test(criterion)
       return false unless @value.respond_to? :match
 

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

@@ -1,8 +1,8 @@
 module Volt
   class LengthValidator
-    def self.validate(model, old_model, field_name, args)
+    def self.validate(model, field_name, args)
       errors = {}
-      value  = model.read_attribute(field_name)
+      value  = model.get(field_name)
 
       if args.is_a?(Fixnum)
         min     = args

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

@@ -1,6 +1,6 @@
 module Volt
   class NumericalityValidator
-    def self.validate(model, old_model, field_name, args)
+    def self.validate(model, field_name, args)
       # Construct the class and return the errors
       new(model, field_name, args).errors
     end
@@ -12,10 +12,14 @@ module Volt
       @args = args
       @errors = {}
 
-      @value = model.read_attribute(field_name)
+      @value = model.get(field_name)
 
       # Convert to float if it is a string for a float
-      @value = Kernel.Float(@value) rescue nil
+      # The nil check and the nan? check are only require for opal 0.6
+      unless @value.nil?
+        @value = Kernel.Float(@value) rescue nil
+        @value = nil if RUBY_PLATFORM == 'opal' && @value.nan?
+      end
 
       check_errors
     end

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

@@ -1,19 +1,14 @@
 module Volt
-  class PhoneNumberValidator
+  class PhoneNumberValidator < FormatValidator
     DEFAULT_OPTIONS = {
       with: /^(\+?\d{1,2}[\.\-\ ]?\d{3}|\(\d{3}\)|\d{3})[\.\-\ ]?\d{3,4}[\.\-\ ]?\d{4}$/,
       message: 'must be a phone number with area or country code'
     }
 
-    def self.validate(model, old_model, field_name, options)
-      new(model, field_name, options).errors
-    end
-
-    def self.new(model, field_name, options)
-      options = DEFAULT_OPTIONS if options == true
-      options = DEFAULT_OPTIONS.merge options
+    private
 
-      FormatValidator.new(model, field_name).apply options
+    def default_options
+      DEFAULT_OPTIONS
     end
   end
 end

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

@@ -1,8 +1,8 @@
 module Volt
   class PresenceValidator
-    def self.validate(model, old_model, field_name, args)
+    def self.validate(model, field_name, args)
       errors = {}
-      value  = model.read_attribute(field_name)
+      value  = model.get(field_name)
       if !value || value.blank?
         if args.is_a?(Hash) && args[:message]
           message = args[:message]

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

@@ -1,11 +1,11 @@
 module Volt
   class UniqueValidator
-    def self.validate(model, old_model, field_name, args)
+    def self.validate(model, field_name, args)
       errors = {}
 
       if RUBY_PLATFORM != 'opal'
         if args
-          value  = model.read_attribute(field_name)
+          value  = model.get(field_name)
 
           query = {}
           # Check to see if any other documents have this value.

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

@@ -0,0 +1,6 @@
+module Volt
+  # Provide methods on the model class to more easily setup user validations
+  module UserValidatorHelpers
+
+  end
+end

data/lib/volt/models.rb

@@ -11,9 +11,14 @@ end
 require 'volt/models/persistors/flash'
 require 'volt/models/persistors/local_store'
 if RUBY_PLATFORM == 'opal'
-  require 'promise.rb'
+  require 'promise'
 else
   # Opal doesn't expose its promise library directly
-  spec = Gem::Specification.find_by_name('opal')
-  require(spec.gem_dir + '/stdlib/promise')
+  # gem_dir = Gem::Specification.find_by_name('opal').gem_dir
+  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.
+require 'volt/utils/promise_patch'