volt 0.8.14 → 0.8.15

data/lib/volt/models/array_model.rb

@@ -3,127 +3,128 @@ require 'volt/models/model_wrapper'
 require 'volt/models/model_helpers'
 require 'volt/models/model_state'
 
-class ArrayModel < ReactiveArray
-  include ModelWrapper
-  include ModelHelpers
-  include ModelState
-
-  attr_reader :parent, :path, :persistor, :options, :array
-
-  # For many methods, we want to call load data as soon as the model is interacted
-  # with, so we proxy the method, then call super.
-  def self.proxy_with_load_data(*method_names)
-    method_names.each do |method_name|
-      define_method(method_name) do |*args|
-        load_data
-        super(*args)
+module Volt
+  class ArrayModel < ReactiveArray
+    include ModelWrapper
+    include ModelHelpers
+    include ModelState
+
+    attr_reader :parent, :path, :persistor, :options, :array
+
+    # For many methods, we want to call load data as soon as the model is interacted
+    # with, so we proxy the method, then call super.
+    def self.proxy_with_load_data(*method_names)
+      method_names.each do |method_name|
+        define_method(method_name) do |*args|
+          load_data
+          super(*args)
+        end
       end
     end
-  end
-
-  proxy_with_load_data :[], :size, :first, :last
 
-  def initialize(array=[], options={})
-    @options = options
-    @parent = options[:parent]
-    @path = options[:path] || []
-    @persistor = setup_persistor(options[:persistor])
+    proxy_with_load_data :[], :size, :first, :last
 
-    array = wrap_values(array)
+    def initialize(array=[], options={})
+      @options   = options
+      @parent    = options[:parent]
+      @path      = options[:path] || []
+      @persistor = setup_persistor(options[:persistor])
 
-    super(array)
+      array = wrap_values(array)
 
-    @persistor.loaded if @persistor
-  end
+      super(array)
 
-  def find(*args, &block)
-    if @persistor
-      return @persistor.find(*args, &block)
-    else
-      raise "this model's persistance layer does not support find, try using store"
+      @persistor.loaded if @persistor
     end
-  end
 
-  def then(*args, &block)
-    if @persistor
-      return @persistor.then(*args, &block)
-    else
-      raise "this model's persistance layer does not support then, try using store"
+    def find(*args, &block)
+      if @persistor
+        return @persistor.find(*args, &block)
+      else
+        raise "this model's persistance layer does not support find, try using store"
+      end
     end
-  end
 
-  def attributes
-    self
-  end
+    def then(*args, &block)
+      if @persistor
+        @persistor.then(*args, &block)
+      else
+        raise "this model's persistance layer does not support then, try using store"
+      end
+    end
 
-  # Make sure it gets wrapped
-  def <<(model)
-    if model.is_a?(Model)
-      # Set the new path
-      model.options = @options.merge(path: @options[:path] + [:[]])
-    else
-      model = wrap_values([model]).first
+    def attributes
+      self
     end
 
-    super(model)
+    # Make sure it gets wrapped
+    def <<(model)
+      if model.is_a?(Model)
+        # Set the new path
+        model.options = @options.merge(path: @options[:path] + [:[]])
+      else
+        model = wrap_values([model]).first
+      end
 
-    @persistor.added(model, @array.size-1) if @persistor
+      super(model)
 
-    return model
-  end
-  alias_method :append, :<<
+      @persistor.added(model, @array.size-1) if @persistor
 
-  # Make sure it gets wrapped
-  def inject(*args)
-    args = wrap_values(args)
-    super(*args)
-  end
+      model
+    end
 
-  # Make sure it gets wrapped
-  def +(*args)
-    args = wrap_values(args)
-    super(*args)
-  end
+    alias_method :append, :<<
 
-  def new_model(*args)
-    class_at_path(options[:path]).new(*args)
-  end
+    # Make sure it gets wrapped
+    def inject(*args)
+      args = wrap_values(args)
+      super(*args)
+    end
 
-  def new_array_model(*args)
-    ArrayModel.new(*args)
-  end
+    # Make sure it gets wrapped
+    def +(*args)
+      args = wrap_values(args)
+      super(*args)
+    end
 
-  # Convert the model to an array all of the way down
-  def to_a
-    array = []
-    attributes.each do |value|
-      array << deep_unwrap(value)
+    def new_model(*args)
+      class_at_path(options[:path]).new(*args)
     end
 
-    return array
-  end
+    def new_array_model(*args)
+      ArrayModel.new(*args)
+    end
 
-  def inspect
-    if @persistor && @persistor.is_a?(Persistors::ArrayStore) && state == :not_loaded
-      # Show a special message letting users know it is not loaded yet.
-      return "#<#{self.class.to_s}:not loaded, access with [] or size to load>"
+    # Convert the model to an array all of the way down
+    def to_a
+      array = []
+      attributes.each do |value|
+        array << deep_unwrap(value)
+      end
+      array
     end
 
-    # Otherwise inspect normally
-    return super
-  end
+    def inspect
+      if @persistor && @persistor.is_a?(Persistors::ArrayStore) && state == :not_loaded
+        # Show a special message letting users know it is not loaded yet.
+        "#<#{self.class.to_s}:not loaded, access with [] or size to load>"
+      else
+        # Otherwise inspect normally
+        super
+      end
+    end
 
-  def buffer
-    model_path = options[:path] + [:[]]
-    model_klass = class_at_path(model_path)
+    def buffer
+      model_path  = options[:path] + [:[]]
+      model_klass = class_at_path(model_path)
 
-    new_options = options.merge(path: model_path, save_to: self).reject {|k,_| k.to_sym == :persistor }
-    model = model_klass.new({}, new_options)
+      new_options = options.merge(path: model_path, save_to: self).reject { |k, _| k.to_sym == :persistor }
+      model       = model_klass.new({}, new_options)
 
-    return model
-  end
+      model
+    end
 
-  private
+    private
     # Takes the persistor if there is one and
     def setup_persistor(persistor)
       if persistor
@@ -137,5 +138,5 @@ class ArrayModel < ReactiveArray
         @persistor.load_data
       end
     end
-
+  end
 end

data/lib/volt/models/cursor.rb

@@ -1,6 +1,7 @@
 require 'volt/models/array_model'
 
-class Cursor < ArrayModel
-
+module Volt
+  class Cursor < ArrayModel
 
+  end
 end