volt 0.8.14 → 0.8.15

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

@@ -1,24 +1,26 @@
-module Persistors
-  # Implements the base persistor functionality.
-  class Base
-    def loaded(initial_state=nil)
-    end
+module Volt
+  module Persistors
+    # Implements the base persistor functionality.
+    class Base
+      def loaded(initial_state=nil)
+      end
 
-    def changed(attribute_name)
-    end
+      def changed(attribute_name)
+      end
 
-    def added(model, index)
-    end
+      def added(model, index)
+      end
 
-    # For removed, the default action is to call changed for it
-    def removed(attribute_name)
-      changed(attribute_name)
-    end
+      # For removed, the default action is to call changed for it
+      def removed(attribute_name)
+        changed(attribute_name)
+      end
 
-    def event_added(event, first, first_for_event)
-    end
+      def event_added(event, first, first_for_event)
+      end
 
-    def event_removed(event, last, last_for_event)
+      def event_removed(event, last, last_for_event)
+      end
     end
   end
 end

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

@@ -1,31 +1,33 @@
 require 'volt/models/persistors/base'
 
-module Persistors
-  class Flash < Base
-    def initialize(model)
-      @model = model
-    end
+module Volt
+  module Persistors
+    class Flash < Base
+      def initialize(model)
+        @model = model
+      end
 
-    def added(model, index)
-      if Volt.client?
-        # Setup a new timer for clearing the flash.
-        %x{
-          setTimeout(function() {
-            self.$clear_model(model);
-          }, 5000);
-        }
+      def added(model, index)
+        if Volt.client?
+          # Setup a new timer for clearing the flash.
+          %x{
+            setTimeout(function() {
+              self.$clear_model(model);
+            }, 5000);
+          }
+        end
       end
-    end
 
-    def clear_model(model)
-      @model.delete(model)
+      def clear_model(model)
+        @model.delete(model)
 
-      # Clear out the parent collection (usually the main flash)
-      # Makes it so flash.empty? reflects if there is any outstanding
-      # flashes.
-      if @model.size == 0
-        collection_name = @model.path[-1]
-        @model.parent.delete(collection_name)
+        # Clear out the parent collection (usually the main flash)
+        # Makes it so flash.empty? reflects if there is any outstanding
+        # flashes.
+        if @model.size == 0
+          collection_name = @model.path[-1]
+          @model.parent.delete(collection_name)
+        end
       end
     end
   end

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

@@ -2,64 +2,66 @@ require 'volt/models/persistors/base'
 require 'volt/utils/local_storage'
 require 'json'
 
-module Persistors
+module Volt
+  module Persistors
 
-  # Backs a collection in the local store
-  class LocalStore < Base
-    def initialize(model)
-      @model = model
-    end
+    # Backs a collection in the local store
+    class LocalStore < Base
+      def initialize(model)
+        @model = model
+      end
 
-    # Find the root for this model
-    def root_model
-      node = @model
+      # Find the root for this model
+      def root_model
+        node = @model
 
-      loop do
-        parent = node.parent
-        if parent
-          node = parent
-        else
-          break
+        loop do
+          parent = node.parent
+          if parent
+            node = parent
+          else
+            break
+          end
         end
-      end
 
-      return node
-    end
+        return node
+      end
 
-    # Called when a model is added to the collection
-    def added(model, index)
-      root_model.persistor.save_all
-    end
+      # Called when a model is added to the collection
+      def added(model, index)
+        root_model.persistor.save_all
+      end
 
-    def loaded(initial_state=nil)
-      # When the main model is first loaded, we pull in the data from the
-      # store if it exists
-      if @model.path == []
-        json_data = LocalStorage['volt-store']
-        if json_data
-          root_attributes = JSON.parse(json_data)
+      def loaded(initial_state=nil)
+        # When the main model is first loaded, we pull in the data from the
+        # store if it exists
+        if @model.path == []
+          json_data = LocalStorage['volt-store']
+          if json_data
+            root_attributes = JSON.parse(json_data)
 
-          @loading_data = true
-          root_attributes.each_pair do |key, value|
-            @model.send(:"_#{key}=", value)
+            @loading_data = true
+            root_attributes.each_pair do |key, value|
+              @model.send(:"_#{key}=", value)
+            end
+            @loading_data = nil
           end
-          @loading_data = nil
         end
       end
-    end
 
-    # Callled when an item is changed (or removed)
-    def changed(attribute_name)
-      root_model.persistor.save_all
-    end
+      # Callled when an item is changed (or removed)
+      def changed(attribute_name)
+        root_model.persistor.save_all
+      end
 
-    # Called on the root
-    def save_all
-      return if @loading_data
+      # Called on the root
+      def save_all
+        return if @loading_data
 
-      json_data = JSON.dump(@model.to_h)
+        json_data = JSON.dump(@model.to_h)
 
-      LocalStorage['volt-store'] = json_data
+        LocalStorage['volt-store'] = json_data
+      end
     end
   end
-end
+end

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

@@ -1,12 +1,14 @@
 require 'volt/utils/generic_counting_pool'
 
-# The identity map ensures that there is only one copy of a model
-# used on the front end at a time.
-class ModelIdentityMap < GenericCountingPool
-  # add extends GenericCountingPool so it can add in a model without
-  # a direct lookup.  We use this when we create a model (without an id)
-  # then save it and it gets assigned an id.
-  def add(id, model)
-    @pool[id] = [1, model]
+module Volt
+  # The identity map ensures that there is only one copy of a model
+  # used on the front end at a time.
+  class ModelIdentityMap < GenericCountingPool
+    # add extends GenericCountingPool so it can add in a model without
+    # a direct lookup.  We use this when we create a model (without an id)
+    # then save it and it gets assigned an id.
+    def add(id, model)
+      @pool[id] = [1, model]
+    end
   end
 end

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

@@ -1,121 +1,121 @@
 require 'volt/models/persistors/store'
 require 'volt/models/persistors/store_state'
 
-module Persistors
-  class ModelStore < Store
-    include StoreState
+module Volt
+  module Persistors
+    class ModelStore < Store
+      include StoreState
 
-    ID_CHARS = [('a'..'f'), ('0'..'9')].map {|v| v.to_a }.flatten
+      ID_CHARS = [('a'..'f'), ('0'..'9')].map { |v| v.to_a }.flatten
 
-    attr_reader :model
-    attr_accessor :in_identity_map
+      attr_reader :model
+      attr_accessor :in_identity_map
 
-    def initialize(model, tasks)
-      super
+      def initialize(model, tasks)
+        super
 
-      @in_identity_map = false
-    end
+        @in_identity_map = false
+      end
 
-    def add_to_collection
-      @in_collection = true
-      ensure_setup
-      changed
-    end
+      def add_to_collection
+        @in_collection = true
+        ensure_setup
+        changed
+      end
 
-    def remove_from_collection
-      @in_collection = false
-    end
+      def remove_from_collection
+        @in_collection = false
+      end
 
-    # Called the first time a value is assigned into this model
-    def ensure_setup
-      if @model.attributes
-        @model.attributes[:_id] ||= generate_id
+      # Called the first time a value is assigned into this model
+      def ensure_setup
+        if @model.attributes
+          @model.attributes[:_id] ||= generate_id
 
-        add_to_identity_map
+          add_to_identity_map
+        end
       end
-    end
 
-    def add_to_identity_map
-      unless @in_identity_map
-        @@identity_map.add(@model._id, @model)
+      def add_to_identity_map
+        unless @in_identity_map
+          @@identity_map.add(@model._id, @model)
 
-        @in_identity_map = true
+          @in_identity_map = true
+        end
       end
-    end
 
-    # Create a random unique id that can be used as the mongo id as well
-    def generate_id
-      id = []
-      24.times { id << ID_CHARS.sample }
+      # Create a random unique id that can be used as the mongo id as well
+      def generate_id
+        id = []
+        24.times { id << ID_CHARS.sample }
 
-      return id.join
-    end
+        return id.join
+      end
 
-    # Called when the model changes
-    def changed(attribute_name=nil)
-      path = @model.path
+      # Called when the model changes
+      def changed(attribute_name=nil)
+        path = @model.path
 
-      promise = Promise.new
+        promise = Promise.new
 
-      ensure_setup
+        ensure_setup
 
-      path_size = path.size
-      if !(defined?($loading_models) && $loading_models) && @tasks && path_size > 0 && !@model.nil?
-        if path_size > 3 && (parent = @model.parent) && source = parent.parent
-          @model.attributes[:"#{path[-4].singularize}_id"] = source._id
-        end
+        path_size = path.size
+        if !(defined?($loading_models) && $loading_models) && @tasks && path_size > 0 && !@model.nil?
+          if path_size > 3 && (parent = @model.parent) && (source = parent.parent)
+            @model.attributes[:"#{path[-4].singularize}_id"] = source._id
+          end
 
-        if !collection
-          puts "Attempting to save model directly on store."
-          raise "Attempting to save model directly on store."
-        else
-          StoreTasks.save(collection, self_attributes).then do |errors|
-            if errors.size == 0
-              promise.resolve(nil)
-            else
-              promise.reject(errors)
+          if !collection
+            puts "Attempting to save model directly on store."
+            raise "Attempting to save model directly on store."
+          else
+            StoreTasks.save(collection, self_attributes).then do |errors|
+              if errors.size == 0
+                promise.resolve(nil)
+              else
+                promise.reject(errors)
+              end
             end
           end
         end
+        promise
       end
 
-      return promise
-    end
-
-    def event_added(event, first, first_for_event)
-      if first_for_event && event == :changed
-        ensure_setup
+      def event_added(event, first, first_for_event)
+        if first_for_event && event == :changed
+          ensure_setup
+        end
       end
-    end
 
-    # Update the models based on the id/identity map.  Usually these requests
-    # will come from the backend.
-    def self.changed(model_id, data)
-      model = @@identity_map.lookup(model_id)
+      # Update the models based on the id/identity map.  Usually these requests
+      # will come from the backend.
+      def self.changed(model_id, data)
+        model = @@identity_map.lookup(model_id)
 
-      if model
-        data.each_pair do |key, value|
-          if key != :_id
-            model.send(:"_#{key}=", value)
+        if model
+          data.each_pair do |key, value|
+            if key != :_id
+              model.send(:"_#{key}=", value)
+            end
           end
         end
       end
-    end
 
-    def [](val)
-      raise "Models do not support hash style lookup.  Hashes inserted into other models are converted to models, see https://github.com/voltrb/volt#automatic-model-conversion"
-    end
+      def [](val)
+        raise "Models do not support hash style lookup.  Hashes inserted into other models are converted to models, see https://github.com/voltrb/volt#automatic-model-conversion"
+      end
 
-    private
+      private
       # Return the attributes that are only for this store, not any sub-associations.
       def self_attributes
         # Don't store any sub-stores, those will do their own saving.
-        @model.attributes.reject {|k,v| v.is_a?(Model) || v.is_a?(ArrayModel) }
+        @model.attributes.reject { |k, v| v.is_a?(Model) || v.is_a?(ArrayModel) }
       end
 
       def collection
         @model.path[-2]
       end
-
+    end
   end
 end

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

@@ -1,27 +1,29 @@
 require 'volt/models/persistors/base'
 
-module Persistors
-  class Params < Base
-    def initialize(model)
-      @model = model
-    end
+module Volt
+  module Persistors
+    class Params < Base
+      def initialize(model)
+        @model = model
+      end
 
-    def changed(attribute_name)
-      if RUBY_PLATFORM == 'opal'
-        %x{
-          if (window.setTimeout && this.$run_update.bind) {
-            if (window.paramsUpdateTimer) {
-              clearTimeout(window.paramsUpdateTimer);
+      def changed(attribute_name)
+        if RUBY_PLATFORM == 'opal'
+          %x{
+            if (window.setTimeout && this.$run_update.bind) {
+              if (window.paramsUpdateTimer) {
+                clearTimeout(window.paramsUpdateTimer);
+              }
+              window.paramsUpdateTimer = setTimeout(this.$run_update.bind(this), 0);
             }
-            window.paramsUpdateTimer = setTimeout(this.$run_update.bind(this), 0);
           }
-        }
+        end
       end
-    end
 
-    def run_update
-      if Volt.client?
-        $page.url.update!
+      def run_update
+        if Volt.client?
+          $page.url.update!
+        end
       end
     end
   end

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

@@ -1,87 +1,89 @@
-# The query listener is what gets notified on the backend when the results from
-# 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
-  def initialize(query_listener_pool, tasks, collection, query)
-    @query_listener_pool = query_listener_pool
-    @tasks = tasks
-    @stores = []
+module Volt
+  # The query listener is what gets notified on the backend when the results from
+  # 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
+    def initialize(query_listener_pool, tasks, collection, query)
+      @query_listener_pool = query_listener_pool
+      @tasks               = tasks
+      @stores              = []
 
-    @collection = collection
-    @query = query
+      @collection = collection
+      @query      = query
 
-    @listening = false
-  end
+      @listening = false
+    end
 
-  def add_listener
-    @listening = true
-    QueryTasks.add_listener(@collection, @query).then do |ret|
-      results, errors = ret
+    def add_listener
+      @listening = true
+      QueryTasks.add_listener(@collection, @query).then do |ret|
+        results, errors = ret
 
-      # When the initial data comes back, add it into the stores.
-      @stores.dup.each do |store|
-        # Clear if there are existing items
-        store.model.clear if store.model.size > 0
+        # When the initial data comes back, add it into the stores.
+        @stores.dup.each do |store|
+          # Clear if there are existing items
+          store.model.clear if store.model.size > 0
 
-        results.each do |index, data|
-          store.add(index, data)
-        end
+          results.each do |index, data|
+            store.add(index, data)
+          end
 
-        store.change_state_to(:loaded)
+          store.change_state_to(:loaded)
+        end
+      end.fail do |err|
+        puts "Err: #{err.inspect}"
       end
-    end.fail do |err|
-      puts "Err: #{err.inspect}"
     end
-  end
 
-  def add_store(store, &block)
-    @stores << store
+    def add_store(store, &block)
+      @stores << store
 
-    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|
-        store.add(index, item.to_h)
+      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|
+          store.add(index, item.to_h)
+        end
+      else
+        # First time we've added a store, setup the listener and get
+        # the initial data.
+        add_listener
       end
-    else
-      # First time we've added a store, setup the listener and get
-      # the initial data.
-      add_listener
     end
-  end
 
-  def remove_store(store)
-    @stores.delete(store)
+    def remove_store(store)
+      @stores.delete(store)
 
-    # When there are no stores left, remove the query listener from
-    # the pool, it can get created again later.
-    if @stores.size == 0
-      @query_listener_pool.remove(@collection, @query)
+      # When there are no stores left, remove the query listener from
+      # the pool, it can get created again later.
+      if @stores.size == 0
+        @query_listener_pool.remove(@collection, @query)
 
-      # Stop listening
-      if @listening
-        @listening = false
-        QueryTasks.remove_listener(@collection, @query)
+        # Stop listening
+        if @listening
+          @listening = false
+          QueryTasks.remove_listener(@collection, @query)
+        end
       end
     end
-  end
 
-  def added(index, data)
-    @stores.each do |store|
-      store.add(index, data)
+    def added(index, data)
+      @stores.each do |store|
+        store.add(index, data)
+      end
     end
-  end
 
-  def removed(ids)
-    @stores.each do |store|
-      store.remove(ids)
+    def removed(ids)
+      @stores.each do |store|
+        store.remove(ids)
+      end
     end
-  end
 
-  def changed(model_id, data)
-    $loading_models = true
-    Persistors::ModelStore.changed(model_id, data)
-    $loading_models = false
+    def changed(model_id, data)
+      $loading_models = true
+      Persistors::ModelStore.changed(model_id, data)
+      $loading_models = false
+    end
   end
 end

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

@@ -1,17 +1,19 @@
 require 'volt/utils/generic_pool'
 require 'volt/models/persistors/query/query_listener'
 
-# Keeps track of all query listeners, so they can be reused in different
-# places.  Dynamically generated queries may end up producing the same
-# 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 ---"
+module Volt
+  # Keeps track of all query listeners, so they can be reused in different
+  # places.  Dynamically generated queries may end up producing the same
+  # 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.keys.each do |query|
-        puts "#{table}: #{query.inspect}"
+      @pool.each_pair do |table, query_hash|
+        query_hash.keys.each do |query|
+          puts "#{table}: #{query.inspect}"
+        end
       end
     end
   end