volt 0.8.14 → 0.8.15

data/lib/volt/models/model.rb

@@ -6,335 +6,332 @@ require 'volt/models/validations'
 require 'volt/models/model_state'
 require 'volt/reactive/reactive_hash'
 
-class NilMethodCall < NoMethodError
-end
+module Volt
 
+  class NilMethodCall < NoMethodError
+  end
 
-class Model
-  include ModelWrapper
-  include ModelHelpers
-  include ModelHashBehaviour
-  include Validations
-  include ModelState
+  class Model
+    include ModelWrapper
+    include ModelHelpers
+    include ModelHashBehaviour
+    include Validations
+    include ModelState
 
-  attr_reader :attributes
-  attr_reader :parent, :path, :persistor, :options
+    attr_reader :attributes
+    attr_reader :parent, :path, :persistor, :options
 
-  def initialize(attributes={}, options={}, initial_state=nil)
-    @deps = HashDependency.new
-    self.options = options
+    def initialize(attributes = {}, options = {}, initial_state = nil)
+      @deps        = HashDependency.new
+      self.options = options
 
-    self.send(:attributes=, attributes, true)
+      send(:attributes=, attributes, true)
 
-    # Models start in a loaded state since they are normally setup from an
-    # ArrayModel, which will have the data when they get added.
-    @state = :loaded
+      # Models start in a loaded state since they are normally setup from an
+      # ArrayModel, which will have the data when they get added.
+      @state = :loaded
 
-    @persistor.loaded(initial_state) if @persistor
-  end
+      @persistor.loaded(initial_state) if @persistor
+    end
 
-  # the id is stored in a field named _id, so we setup _id to proxy to this
-  def _id
-    @attributes && @attributes[:_id]
-  end
+    # the id is stored in a field named _id, so we setup _id to proxy to this
+    def _id
+      @attributes && @attributes[:_id]
+    end
 
-  def _id=(val)
-    self.__id = val
-  end
+    def _id=(val)
+      self.__id = val
+    end
 
-  # Update the options
-  def options=(options)
-    @options = options
-    @parent = options[:parent]
-    @path = options[:path] || []
-    @class_paths = options[:class_paths]
-    @persistor = setup_persistor(options[:persistor])
-  end
+    # Update the options
+    def options=(options)
+      @options     = options
+      @parent      = options[:parent]
+      @path        = options[:path] || []
+      @class_paths = options[:class_paths]
+      @persistor   = setup_persistor(options[:persistor])
+    end
 
-  # Assign multiple attributes as a hash, directly.
-  def attributes=(attrs, initial_setup=false)
-    @attributes = {}
+    # Assign multiple attributes as a hash, directly.
+    def attributes=(attrs, initial_setup = false)
+      @attributes = {}
 
-    attrs = wrap_values(attrs)
+      attrs = wrap_values(attrs)
+
+      if attrs
+        # Assign id first
+        id       = attrs.delete(:_id)
+        self._id = id if id
+
+        # Assign each attribute using setters
+        attrs.each_pair do |key, value|
+          if self.respond_to?(:"#{key}=")
+            # If a method without an underscore is defined, call that.
+            send(:"#{key}=", value)
+          else
+            # Otherwise, use the _ version
+            send(:"_#{key}=", value)
+          end
+        end
+      else
+        @attributes = attrs
+      end
 
-    if attrs
-      # Assign id first
-      id = attrs.delete(:_id)
-      self._id = id if id
+      # Trigger and change all
+      @deps.changed_all!
+      @deps = HashDependency.new
 
-      # Assign each attribute using setters
-      attrs.each_pair do |key, value|
-        if self.respond_to?(:"#{key}=")
-          # If a method without an underscore is defined, call that.
-          self.send(:"#{key}=", value)
-        else
-          # Otherwise, use the _ version
-          self.send(:"_#{key}=", value)
+      unless initial_setup
+
+        # Let the persistor know something changed
+        if @persistor
+          # the changed method on a persistor should return a promise that will
+          # be resolved when the save is complete, or fail with a hash of errors.
+          return @persistor.changed
         end
       end
-    else
-      @attributes = attrs
     end
 
-    # Trigger and change all
-    @deps.changed_all!
-    @deps = HashDependency.new
-
-    unless initial_setup
+    alias_method :assign_attributes, :attributes=
 
-      # Let the persistor know something changed
-      if @persistor
-        # the changed method on a persistor should return a promise that will
-        # be resolved when the save is complete, or fail with a hash of errors.
-        return @persistor.changed
+    # Pass the comparison through
+    def ==(val)
+      if val.is_a?(Model)
+        # Use normal comparison for a model
+        super
+      else
+        # Compare to attributes otherwise
+        attributes == val
       end
     end
-  end
-  alias_method :assign_attributes, :attributes=
-
-  # Pass the comparison through
-  def ==(val)
-    if val.is_a?(Model)
-      # Use normal comparison for a model
-      return super
-    else
-      # Compare to attributes otherwise
-      return attributes == val
-    end
-  end
 
-  # Pass through needed
-  def !
-    !attributes
-  end
+    # Pass through needed
+    def !
+      !attributes
+    end
 
 
-  def method_missing(method_name, *args, &block)
-    if method_name[0] == '_'
-      if method_name[-1] == '='
-        # Assigning an attribute with =
-        assign_attribute(method_name, *args, &block)
+    def method_missing(method_name, *args, &block)
+      if method_name[0] == '_'
+        if method_name[-1] == '='
+          # Assigning an attribute with =
+          assign_attribute(method_name, *args, &block)
+        else
+          read_attribute(method_name)
+        end
       else
-        read_attribute(method_name)
+        # Call on parent
+        super
       end
-    else
-      # Call on parent
-      super
     end
-  end
 
-  # Do the assignment to a model and trigger a changed event
-  def assign_attribute(method_name, *args, &block)
-    self.expand!
-    # Assign, without the =
-    attribute_name = method_name[1..-2].to_sym
+    # Do the assignment to a model and trigger a changed event
+    def assign_attribute(method_name, *args, &block)
+      self.expand!
+      # Assign, without the =
+      attribute_name = method_name[1..-2].to_sym
 
-    value = args[0]
+      value = args[0]
 
-    @attributes[attribute_name] = wrap_value(value, [attribute_name])
+      @attributes[attribute_name] = wrap_value(value, [attribute_name])
 
-    @deps.changed!(attribute_name)
+      @deps.changed!(attribute_name)
 
-    # Let the persistor know something changed
-    @persistor.changed(attribute_name) if @persistor
-  end
+      # Let the persistor know something changed
+      @persistor.changed(attribute_name) if @persistor
+    end
 
-  # When reading an attribute, we need to handle reading on:
-  # 1) a nil model, which returns a wrapped error
-  # 2) reading directly from attributes
-  # 3) trying to read a key that doesn't exist.
-  def read_attribute(method_name)
-    # Reading an attribute, we may get back a nil model.
-    method_name = method_name.to_sym
-
-    if method_name[0] != '_' && @attributes == nil
-      # The method we are calling is on a nil model, return a wrapped
-      # exception.
-      return return_undefined_method(method_name)
-    else
-      attr_name = method_name[1..-1].to_sym
-      # See if the value is in attributes
-      value = (@attributes && @attributes[attr_name])
-
-      # Track dependency
-      @deps.depend(attr_name)
-
-      if value
-        # key was in attributes or cache
-        return value
+    # When reading an attribute, we need to handle reading on:
+    # 1) a nil model, which returns a wrapped error
+    # 2) reading directly from attributes
+    # 3) trying to read a key that doesn't exist.
+    def read_attribute(method_name)
+      # Reading an attribute, we may get back a nil model.
+      method_name = method_name.to_sym
+
+      if method_name[0] != '_' && @attributes == nil
+        # The method we are calling is on a nil model, return a wrapped
+        # exception.
+        return_undefined_method(method_name)
       else
-        # TODO: implement a timed out cache flusing
-        new_model = read_new_model(attr_name)
-        @attributes ||= {}
-        @attributes[attr_name] = new_model
+        attr_name = method_name[1..-1].to_sym
+        # See if the value is in attributes
+        value     = (@attributes && @attributes[attr_name])
 
-        return new_model
+        # Track dependency
+        @deps.depend(attr_name)
+
+        if value
+          # key was in attributes or cache
+          value
+        else
+          new_model              = read_new_model(attr_name)
+          @attributes            ||= {}
+          @attributes[attr_name] = new_model
+          new_model
+        end
       end
     end
-  end
 
-  # Get a new model, make it easy to override
-  def read_new_model(method_name)
-    if @persistor && @persistor.respond_to?(:read_new_model)
-      return @persistor.read_new_model(method_name)
-    else
-      opts = @options.merge(parent: self, path: path + [method_name])
-      if method_name.plural?
-        return new_array_model([], opts)
+    # Get a new model, make it easy to override
+    def read_new_model(method_name)
+      if @persistor && @persistor.respond_to?(:read_new_model)
+        return @persistor.read_new_model(method_name)
       else
-        return new_model(nil, opts)
+        opts = @options.merge(parent: self, path: path + [method_name])
+        if method_name.plural?
+          return new_array_model([], opts)
+        else
+          return new_model(nil, opts)
+        end
       end
     end
-  end
 
-  def return_undefined_method(method_name)
-    # Methods called on nil capture an error so the user can know where
-    # their nil calls are.  This error can be re-raised at a later point.
-    begin
-      raise NilMethodCall.new("undefined method `#{method_name}' for #{self.to_s}")
-    rescue => e
-      result = e
-
-      # Cleanup backtrace
-      # TODO: this could be better
-      result.backtrace.reject! {|line| line['lib/models/model.rb'] || line['lib/models/live_value.rb'] }
+    def return_undefined_method(method_name)
+      # Methods called on nil capture an error so the user can know where
+      # their nil calls are.  This error can be re-raised at a later point.
+      begin
+        raise NilMethodCall.new("undefined method `#{method_name}' for #{self.to_s}")
+      rescue => e
+        result = e
+
+        # Cleanup backtrace
+        # TODO: this could be better
+        result.backtrace.reject! { |line| line['lib/models/model.rb'] || line['lib/models/live_value.rb'] }
+      end
     end
-  end
 
-  def new_model(attributes, options)
-    class_at_path(options[:path]).new(attributes, options)
-  end
+    def new_model(attributes, options)
+      class_at_path(options[:path]).new(attributes, options)
+    end
 
-  def new_array_model(attributes, options)
-    # Start with an empty query
-    options = options.dup
-    options[:query] = {}
+    def new_array_model(attributes, options)
+      # Start with an empty query
+      options         = options.dup
+      options[:query] = {}
 
-    ArrayModel.new(attributes, options)
-  end
+      ArrayModel.new(attributes, options)
+    end
 
-  def trigger_by_attribute!(event_name, attribute, *passed_args)
-    trigger_by_scope!(event_name, *passed_args) do |scope|
-      method_name, *args, block = scope
+    def trigger_by_attribute!(event_name, attribute, *passed_args)
+      trigger_by_scope!(event_name, *passed_args) do |scope|
+        method_name, *args, block = scope
 
-      # TODO: Opal bug
-      args ||= []
+        # TODO: Opal bug
+        args                      ||= []
 
-      # Any methods without _ are not directly related to one attribute, so
-      # they should all trigger
-      !method_name || method_name[0] != '_' || (method_name == attribute.to_sym && args.size == 0)
+        # Any methods without _ are not directly related to one attribute, so
+        # they should all trigger
+        !method_name || method_name[0] != '_' || (method_name == attribute.to_sym && args.size == 0)
+      end
     end
-  end
 
-  # If this model is nil, it makes it into a hash model, then
-  # sets it up to track from the parent.
-  def expand!
-    if attributes.nil?
-      @attributes = {}
-      if @parent
-        @parent.expand!
+    # If this model is nil, it makes it into a hash model, then
+    # sets it up to track from the parent.
+    def expand!
+      if attributes.nil?
+        @attributes = {}
+        if @parent
+          @parent.expand!
 
-        @parent.send(:"_#{@path.last}=", self)
+          @parent.send(:"_#{@path.last}=", self)
+        end
       end
     end
-  end
-
-  # Initialize an empty array and append to it
-  def <<(value)
-    if @parent
-      @parent.expand!
-    else
-      raise "Model data should be stored in sub collections."
-    end
 
-    # Grab the last section of the path, so we can do the assign on the parent
-    path = @path.last
-    result = @parent.send(path)
+    # Initialize an empty array and append to it
+    def <<(value)
+      if @parent
+        @parent.expand!
+      else
+        raise "Model data should be stored in sub collections."
+      end
 
-    if result.nil?
-      # If this isn't a model yet, instantiate it
-      @parent.send(:"#{path}=", new_array_model([], @options))
+      # Grab the last section of the path, so we can do the assign on the parent
+      path   = @path.last
       result = @parent.send(path)
-    end
 
-    # Add the new item
-    result << value
+      if result.nil?
+        # If this isn't a model yet, instantiate it
+        @parent.send(:"#{path}=", new_array_model([], @options))
+        result = @parent.send(path)
+      end
 
-    return nil
-  end
+      # Add the new item
+      result << value
 
-  def inspect
-    str = nil
-    Computation.run_without_tracking do
-      str = "<#{self.class.to_s}:#{object_id} #{attributes.inspect}>"
+      nil
     end
 
-    return str
-  end
-
-  def save!
-    # Compute the erros once
-    errors = self.errors
-
-    if errors.size == 0
-      save_to = options[:save_to]
-      if save_to
-        if save_to.is_a?(ArrayModel)
-          # Add to the collection
-          new_model = save_to << self.attributes
-
-          # Set the buffer's id to track the main model's id
-          self.attributes[:_id] = new_model._id
-          options[:save_to] = new_model
+    def inspect
+      Computation.run_without_tracking do
+        "<#{self.class.to_s}:#{object_id} #{attributes.inspect}>"
+      end
+    end
 
-          # TODO: return a promise that resolves if the append works
+    def save!
+      # Compute the erros once
+      errors = self.errors
+
+      if errors.size == 0
+        save_to = options[:save_to]
+        if save_to
+          if save_to.is_a?(ArrayModel)
+            # Add to the collection
+            new_model             = save_to << self.attributes
+
+            # Set the buffer's id to track the main model's id
+            self.attributes[:_id] = new_model._id
+            options[:save_to]     = new_model
+
+            # TODO: return a promise that resolves if the append works
+          else
+            # We have a saved model
+            return save_to.assign_attributes(self.attributes)
+          end
         else
-          # We have a saved model
-          return save_to.assign_attributes(self.attributes)
+          raise "Model is not a buffer, can not be saved, modifications should be persisted as they are made."
         end
+
+        Promise.new.resolve({})
       else
-        raise "Model is not a buffer, can not be saved, modifications should be persisted as they are made."
-      end
+        # Some errors, mark all fields
+        self.class.validations.keys.each do |key|
+          mark_field!(key.to_sym)
+        end
 
-      return Promise.new.resolve({})
-    else
-      # Some errors, mark all fields
-      self.class.validations.keys.each do |key|
-        mark_field!(key.to_sym)
+        Promise.new.reject(errors)
       end
-
-      return Promise.new.reject(errors)
     end
-  end
 
 
-  # Returns a buffered version of the model
-  def buffer
-    model_path = options[:path]
+    # Returns a buffered version of the model
+    def buffer
+      model_path = options[:path]
 
-    # When we grab a buffer off of a plual class (subcollection), we get it as a model.
-    if model_path.last.plural? && model_path[-1] != :[]
-      model_klass = class_at_path(model_path + [:[]])
-    else
-      model_klass = class_at_path(model_path)
-    end
+      # When we grab a buffer off of a plual class (subcollection), we get it as a model.
+      if model_path.last.plural? && model_path[-1] != :[]
+        model_klass = class_at_path(model_path + [:[]])
+      else
+        model_klass = class_at_path(model_path)
+      end
 
-    new_options = options.merge(path: model_path, save_to: self).reject {|k,_| k.to_sym == :persistor }
-    model = model_klass.new({}, new_options, :loading)
+      new_options = options.merge(path: model_path, save_to: self).reject { |k, _| k.to_sym == :persistor }
+      model       = model_klass.new({}, new_options, :loading)
 
-    if state == :loaded
-      setup_buffer(model)
-    else
-      self.parent.then do
+      if state == :loaded
         setup_buffer(model)
+      else
+        self.parent.then do
+          setup_buffer(model)
+        end
       end
-    end
 
-    return model
-  end
+      model
+    end
 
 
-  private
+    private
     def setup_buffer(model)
       model.attributes = self.attributes
       model.change_state_to(:loaded)
@@ -346,5 +343,5 @@ class Model
         @persistor = persistor.new(self)
       end
     end
-
+  end
 end