volt 0.8.14 → 0.8.15

data/lib/volt/models/model_hash_behaviour.rb

@@ -1,62 +1,62 @@
-# Contains all of the methods on a model that make it behave like a hash.
-# Moving this into a module cleans up the main Model class for things that
-# make it behave like a model.
-module ModelHashBehaviour
+module Volt
+  # Contains all of the methods on a model that make it behave like a hash.
+  # Moving this into a module cleans up the main Model class for things that
+  # make it behave like a model.
+  module ModelHashBehaviour
 
-  def delete(name)
-    name = name.to_sym
+    def delete(name)
+      name = name.to_sym
 
-    value = attributes.delete(name)
-    @deps.delete(name)
+      value = attributes.delete(name)
+      @deps.delete(name)
 
-    @persistor.removed(name) if @persistor
+      @persistor.removed(name) if @persistor
 
-    return value
-  end
-
-  def nil?
-    attributes.nil?
-  end
+      value
+    end
 
-  def empty?
-    !attributes || attributes.size == 0
-  end
+    def nil?
+      attributes.nil?
+    end
 
-  def false?
-    attributes.false?
-  end
+    def empty?
+      !attributes || attributes.size == 0
+    end
 
-  def true?
-    attributes.true?
-  end
+    def false?
+      attributes.false?
+    end
 
-  def clear
-    attributes.each_pair do |key,value|
-      @deps.changed!(key)
+    def true?
+      attributes.true?
     end
 
-    attributes.clear
+    def clear
+      attributes.each_pair do |key, value|
+        @deps.changed!(key)
+      end
 
-    @persistor.removed(nil) if @persistor
-  end
+      attributes.clear
 
-  def each_with_object(*args, &block)
-    return (@attributes || {}).each_with_object(*args, &block)
-  end
+      @persistor.removed(nil) if @persistor
+    end
 
+    def each_with_object(*args, &block)
+      (@attributes || {}).each_with_object(*args, &block)
+    end
 
-  # Convert the model to a hash all of the way down.
-  def to_h
-    hash = {}
-    if empty?
-      return nil
-    else
-      attributes.each_pair do |key, value|
-        hash[key] = deep_unwrap(value)
-      end
 
-      return hash
+    # Convert the model to a hash all of the way down.
+    def to_h
+      if empty?
+        nil
+      else
+        hash = {}
+        attributes.each_pair do |key, value|
+          hash[key] = deep_unwrap(value)
+        end
+        hash
+      end
     end
   end
-
 end

data/lib/volt/models/model_helpers.rb

@@ -1,47 +1,49 @@
-# A place for things shared between an ArrayModel and a Model
-module ModelHelpers
-  def deep_unwrap(value)
-    if value.is_a?(Model)
-      value = value.to_h
-    elsif value.is_a?(ArrayModel)
-      value = value.to_a
+module Volt
+  # A place for things shared between an ArrayModel and a Model
+  module ModelHelpers
+    def deep_unwrap(value)
+      if value.is_a?(Model)
+        value.to_h
+      elsif value.is_a?(ArrayModel)
+        value.to_a
+      else
+        value
+      end
     end
 
-    return value
-  end
-
-  # Pass to the persisotr
-  def event_added(event, first, first_for_event)
-    @persistor.event_added(event, first, first_for_event) if @persistor
-  end
+    # Pass to the persisotr
+    def event_added(event, first, first_for_event)
+      @persistor.event_added(event, first, first_for_event) if @persistor
+    end
 
-  # Pass to the persistor
-  def event_removed(event, last, last_for_event)
-    @persistor.event_removed(event, last, last_for_event) if @persistor
-  end
+    # Pass to the persistor
+    def event_removed(event, last, last_for_event)
+      @persistor.event_removed(event, last, last_for_event) if @persistor
+    end
 
-  # Gets the class for a model at the specified path.
-  def class_at_path(path)
-    if path
-      begin
-        # remove the _ and then singularize
-        if path.last == :[]
-          index = -2
-        else
-          index = -1
-        end
+    # Gets the class for a model at the specified path.
+    def class_at_path(path)
+      if path
+        begin
+          # remove the _ and then singularize
+          if path.last == :[]
+            index = -2
+          else
+            index = -1
+          end
 
-        klass_name = path[index].singularize.camelize
+          klass_name = path[index].singularize.camelize
 
-        klass = $page.model_classes[klass_name] || Model
-      rescue NameError => e
-        # Ignore exception, just means the model isn't defined
+          klass = $page.model_classes[klass_name] || Model
+        rescue NameError => e
+          # Ignore exception, just means the model isn't defined
+          klass = Model
+        end
+      else
         klass = Model
       end
-    else
-      klass = Model
-    end
 
-    return klass
+      klass
+    end
   end
 end

data/lib/volt/models/model_state.rb

@@ -1,22 +1,21 @@
-# All models have a state that has to do with it being loaded, in process of
-# being loaded, or not yet loading.
-module ModelState
-
-  def state
-    if @persistor && @persistor.respond_to?(:state)
-      @persistor.state
-    else
-      @state || :loaded
+module Volt
+  # All models have a state that has to do with it being loaded, in process of
+  # being loaded, or not yet loading.
+  module ModelState
+    def state
+      if @persistor && @persistor.respond_to?(:state)
+        @persistor.state
+      else
+        @state || :loaded
+      end
     end
-  end
 
-  def change_state_to(state)
-    @state = state
-  end
+    def change_state_to(state)
+      @state = state
+    end
 
-  def loaded?
-    self.state == :loaded
+    def loaded?
+      self.state == :loaded
+    end
   end
-
-
 end

data/lib/volt/models/model_wrapper.rb

@@ -1,31 +1,32 @@
-module ModelWrapper
-  # For cretain values, we wrap them to make the behave as a
-  # model.
-  def wrap_value(value, lookup)
-    if value.is_a?(Array)
-      value = new_array_model(value, @options.merge(parent: self, path: path + lookup))
-    elsif value.is_a?(Hash)
-      value = new_model(value, @options.merge(parent: self, path: path + lookup))
+module Volt
+  module ModelWrapper
+    # For cretain values, we wrap them to make the behave as a
+    # model.
+    def wrap_value(value, lookup)
+      if value.is_a?(Array)
+        new_array_model(value, @options.merge(parent: self, path: path + lookup))
+      elsif value.is_a?(Hash)
+        new_model(value, @options.merge(parent: self, path: path + lookup))
+      else
+        value
+      end
     end
 
-    return value
-  end
-
-  def wrap_values(values, lookup=[])
-    if values.is_a?(Array)
-      # Coming from an array
-      values = values.map {|v| wrap_value(v,lookup + [:[]]) }
-    elsif values.is_a?(Hash)
-      pairs = values.map do |k,v|
-        # TODO: We should be able to move wrapping into the method_missing on model
-        path = lookup + [k.to_sym]
+    def wrap_values(values, lookup=[])
+      if values.is_a?(Array)
+        # Coming from an array
+        values.map { |v| wrap_value(v, lookup + [:[]]) }
+      elsif values.is_a?(Hash)
+        pairs = values.map do |k, v|
+          # TODO: We should be able to move wrapping into the method_missing on model
+          path = lookup + [k.to_sym]
 
-        [k, wrap_value(v,path)]
+          [k, wrap_value(v, path)]
+        end
+        Hash[pairs]
+      else
+        values
       end
-
-      values = Hash[pairs]
     end
-
-    return values
   end
 end

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

@@ -2,203 +2,205 @@ require 'volt/models/persistors/store'
 require 'volt/models/persistors/query/query_listener_pool'
 require 'volt/models/persistors/store_state'
 
-module Persistors
-  class ArrayStore < Store
-    include StoreState
+module Volt
+  module Persistors
+    class ArrayStore < Store
+      include StoreState
 
-    @@query_pool = QueryListenerPool.new
+      @@query_pool = QueryListenerPool.new
 
-    attr_reader :model
+      attr_reader :model
 
-    def self.query_pool
-      @@query_pool
-    end
+      def self.query_pool
+        @@query_pool
+      end
 
-    def initialize(model, tasks=nil)
-      super
+      def initialize(model, tasks=nil)
+        super
 
-      @query = @model.options[:query]
-    end
+        @query = @model.options[:query]
+      end
 
-    def event_added(event, first, first_for_event)
-      # First event, we load the data.
-      if first
-        @has_events = true
-        load_data
+      def event_added(event, first, first_for_event)
+        # First event, we load the data.
+        if first
+          @has_events = true
+          load_data
+        end
       end
-    end
 
-    def event_removed(event, last, last_for_event)
-      # Remove listener where there are no more events on this model
-      if last
-        @has_events = false
-        stop_listening
+      def event_removed(event, last, last_for_event)
+        # Remove listener where there are no more events on this model
+        if last
+          @has_events = false
+          stop_listening
+        end
       end
-    end
 
-    # Called when an event is removed and we no longer want to keep in
-    # sync with the database.
-    def stop_listening(stop_watching_query=true)
-      return if @has_events
-      return if @fetch_promises && @fetch_promises.size > 0
+      # Called when an event is removed and we no longer want to keep in
+      # sync with the database.
+      def stop_listening(stop_watching_query=true)
+        return if @has_events
+        return if @fetch_promises && @fetch_promises.size > 0
 
-      @query_computation.stop if @query_computation && stop_watching_query
+        @query_computation.stop if @query_computation && stop_watching_query
 
-      if @query_listener
-        @query_listener.remove_store(self)
-        @query_listener = nil
-      end
+        if @query_listener
+          @query_listener.remove_store(self)
+          @query_listener = nil
+        end
 
-      @state = :dirty
-    end
+        @state = :dirty
+      end
 
-    # Called the first time data is requested from this collection
-    def load_data
-      # Don't load data from any queried
-      if @state == :not_loaded || @state == :dirty
-        # puts "Load Data at #{@model.path.inspect} - query: #{@query.inspect} on #{self.inspect}"
-        change_state_to :loading
+      # Called the first time data is requested from this collection
+      def load_data
+        # Don't load data from any queried
+        if @state == :not_loaded || @state == :dirty
+          # puts "Load Data at #{@model.path.inspect} - query: #{@query.inspect} on #{self.inspect}"
+          change_state_to :loading
 
-        if @query.is_a?(Proc)
-          @query_computation = -> do
-            stop_listening(false)
+          if @query.is_a?(Proc)
+            @query_computation = -> do
+              stop_listening(false)
 
-            change_state_to :loading
+              change_state_to :loading
 
-            new_query = @query.call
+              new_query = @query.call
 
-            run_query(@model, @query.call)
-          end.watch!
-        else
-          run_query(@model, @query)
+              run_query(@model, @query.call)
+            end.watch!
+          else
+            run_query(@model, @query)
+          end
         end
       end
-    end
 
-    # Clear out the models data, since we're not listening anymore.
-    def unload_data
-      change_state_to :not_loaded
-      @model.clear
-    end
+      # Clear out the models data, since we're not listening anymore.
+      def unload_data
+        change_state_to :not_loaded
+        @model.clear
+      end
 
-    def run_query(model, query={})
-      @model.clear
+      def run_query(model, query={})
+        @model.clear
 
-      collection = model.path.last
-      # Scope to the parent
-      if model.path.size > 1
-        parent = model.parent
+        collection = model.path.last
+        # Scope to the parent
+        if model.path.size > 1
+          parent = model.parent
 
-        parent.persistor.ensure_setup if parent.persistor
+          parent.persistor.ensure_setup if parent.persistor
 
-        if parent && (attrs = parent.attributes) && attrs[:_id].true?
-          query[:"#{model.path[-3].singularize}_id"] = attrs[:_id]
+          if parent && (attrs = parent.attributes) && attrs[:_id].true?
+            query[:"#{model.path[-3].singularize}_id"] = attrs[:_id]
+          end
         end
-      end
 
-      @query_listener = @@query_pool.lookup(collection, query) do
-        # Create if it does not exist
-        QueryListener.new(@@query_pool, @tasks, collection, query)
-      end
+        @query_listener = @@query_pool.lookup(collection, query) do
+          # Create if it does not exist
+          QueryListener.new(@@query_pool, @tasks, collection, query)
+        end
 
-      @query_listener.add_store(self)
-    end
+        @query_listener.add_store(self)
+      end
 
-    # Find can take either a query object, or a block that returns a query object.  Use
-    # the block style if you need reactive updating queries
-    def find(query=nil, &block)
-      # Set a default query if there is no block
-      if block
-        if query
-          raise "Query should not be passed in to a find if a block is specified"
+      # Find can take either a query object, or a block that returns a query object.  Use
+      # the block style if you need reactive updating queries
+      def find(query=nil, &block)
+        # Set a default query if there is no block
+        if block
+          if query
+            raise "Query should not be passed in to a find if a block is specified"
+          end
+          query = block
+        else
+          query ||= {}
         end
-        query = block
-      else
-        query ||= {}
+
+        return Cursor.new([], @model.options.merge(:query => query))
       end
 
-      return Cursor.new([], @model.options.merge(:query => query))
-    end
+      # Returns a promise that is resolved/rejected when the query is complete.  Any
+      # passed block will be passed to the promises then.  Then will be passed the model.
+      def then(&block)
+        promise = Promise.new
 
-    # Returns a promise that is resolved/rejected when the query is complete.  Any
-    # passed block will be passed to the promises then.  Then will be passed the model.
-    def then(&block)
-      promise = Promise.new
+        promise = promise.then(&block) if block
 
-      promise = promise.then(&block) if block
+        if @state == :loaded
+          promise.resolve(@model)
+        else
+          @fetch_promises ||= []
+          @fetch_promises << promise
 
-      if @state == :loaded
-        promise.resolve(@model)
-      else
-        @fetch_promises ||= []
-        @fetch_promises << promise
+          load_data
+        end
 
-        load_data
+        return promise
       end
 
-      return promise
-    end
+      # Called from backend
+      def add(index, data)
+        $loading_models = true
 
-    # Called from backend
-    def add(index, data)
-      $loading_models = true
+        data_id = data[:_id]
 
-      data_id = data[:_id]
+        # Don't add if the model is already in the ArrayModel
+        if !@model.array.find { |v| v._id == data_id }
+          # Find the existing model, or create one
+          new_model = @@identity_map.find(data_id) do
+            new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
+            @model.new_model(data, new_options, :loaded)
+          end
 
-      # Don't add if the model is already in the ArrayModel
-      if !@model.array.find {|v| v._id == data_id }
-        # Find the existing model, or create one
-        new_model = @@identity_map.find(data_id) do
-          new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
-          @model.new_model(data, new_options, :loaded)
+          @model.insert(index, new_model)
         end
 
-        @model.insert(index, new_model)
+        $loading_models = false
       end
 
-      $loading_models = false
-    end
-
-    def remove(ids)
-      $loading_models = true
-      ids.each do |id|
-        # TODO: optimize this delete so we don't need to loop
-        @model.each_with_index do |model, index|
-          if model._id == id
-            del = @model.delete_at(index)
-            break
+      def remove(ids)
+        $loading_models = true
+        ids.each do |id|
+          # TODO: optimize this delete so we don't need to loop
+          @model.each_with_index do |model, index|
+            if model._id == id
+              del = @model.delete_at(index)
+              break
+            end
           end
         end
-      end
 
-      $loading_models = false
-    end
-
-    def channel_name
-      @model.path[-1]
-    end
+        $loading_models = false
+      end
 
-    # When a model is added to this collection, we call its "changed"
-    # method.  This should trigger a save.
-    def added(model, index)
-      if model.persistor
-        # Tell the persistor it was added
-        model.persistor.add_to_collection
+      def channel_name
+        @model.path[-1]
       end
-    end
 
-    def removed(model)
-      if model.persistor
-        # Tell the persistor it was removed
-        model.persistor.remove_from_collection
+      # When a model is added to this collection, we call its "changed"
+      # method.  This should trigger a save.
+      def added(model, index)
+        if model.persistor
+          # Tell the persistor it was added
+          model.persistor.add_to_collection
+        end
       end
 
-      if defined?($loading_models) && $loading_models
-        return
-      else
-        StoreTasks.delete(channel_name, model.attributes[:_id])
+      def removed(model)
+        if model.persistor
+          # Tell the persistor it was removed
+          model.persistor.remove_from_collection
+        end
+
+        if defined?($loading_models) && $loading_models
+          return
+        else
+          StoreTasks.delete(channel_name, model.attributes[:_id])
+        end
       end
-    end
 
+    end
   end
 end