volt 0.8.18 → 0.8.19

data/lib/volt/controllers/model_controller.rb

@@ -43,7 +43,8 @@ module Volt
 
       inst.model = @default_model if @default_model
 
-      inst.initialize(*args, &block)
+      # In MRI initialize is private for some reason, so call it with send
+      inst.send(:initialize, *args, &block)
 
       inst
     end
@@ -87,6 +88,10 @@ module Volt
       $page.local_store
     end
 
+    def cookies
+      $page.cookies
+    end
+
     def url
       $page.url
     end

data/lib/volt/data_stores/mongo_driver.rb

@@ -4,9 +4,13 @@ module Volt
   class DataStore
     class MongoDriver
       def self.fetch
-        @@mongo_db ||= Mongo::MongoClient.new(Volt.config.db_host, Volt.config.db_path)
-        @@db ||= @@mongo_db.db(Volt.config.db_name)
-
+        if Volt.config.db_uri.present?
+          @@mongo_db ||= Mongo::MongoClient.from_uri(Volt.config.db_uri)
+          @@db ||= @@mongo_db.db(Volt.config.db_uri.split('/').last || Volt.config.db_name)
+        else
+          @@mongo_db ||= Mongo::MongoClient.new(Volt.config.db_host, Volt.config.db_path)
+          @@db ||= @@mongo_db.db(Volt.config.db_name)
+        end
         @@db
       end
     end

data/lib/volt/models.rb

@@ -5,6 +5,9 @@ require 'volt/models/persistors/store_factory'
 require 'volt/models/persistors/array_store'
 require 'volt/models/persistors/model_store'
 require 'volt/models/persistors/params'
+if RUBY_PLATFORM == 'opal'
+  require 'volt/models/persistors/cookies'
+end
 require 'volt/models/persistors/flash'
 require 'volt/models/persistors/local_store'
 if RUBY_PLATFORM == 'opal'

data/lib/volt/models/array_model.rb

@@ -66,12 +66,30 @@ module Volt
 
       super(model)
 
-      @persistor.added(model, @array.size - 1) if @persistor
+      if @persistor
+        @persistor.added(model, @array.size - 1)
+      else
+        nil
+      end
+    end
 
-      model
+    # Works like << except it returns a promise
+    def append(model)
+      promise, model = self.send(:<<, model)
+
+      # Return a promise if one doesn't exist
+      promise ||= Promise.new.resolve(model)
+
+      promise
     end
 
-    alias_method :append, :<<
+
+    # Find one does a query, but only returns the first item or
+    # nil if there is no match.  Unlike #find, #find_one does not
+    # return another cursor that you can call .then on.
+    def find_one(*args, &block)
+      find(*args, &block).limit(1)[0]
+    end
 
     # Make sure it gets wrapped
     def inject(*args)

data/lib/volt/models/model.rb

@@ -22,6 +22,7 @@ module Volt
 
     def initialize(attributes = {}, options = {}, initial_state = nil)
       @deps        = HashDependency.new
+      @size_dep    = Dependency.new
       self.options = options
 
       send(:attributes=, attributes, true)
@@ -60,16 +61,20 @@ module Volt
       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)
+        # When doing a mass-assign, we don't save until the end.
+        Model.nosave do
+          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
         end
       else
@@ -111,9 +116,12 @@ module Volt
 
     def method_missing(method_name, *args, &block)
       if method_name[0] == '_'
+
+        # Remove underscore
+        method_name = method_name[1..-1]
         if method_name[-1] == '='
-          # Assigning an attribute with =
-          assign_attribute(method_name, *args, &block)
+          # Assigning an attribute without the =
+          assign_attribute(method_name[0..-2], *args, &block)
         else
           read_attribute(method_name)
         end
@@ -127,47 +135,71 @@ module Volt
     def assign_attribute(method_name, *args, &block)
       self.expand!
       # Assign, without the =
-      attribute_name = method_name[1..-2].to_sym
+      attribute_name = method_name.to_sym
 
       value = args[0]
 
-      @attributes[attribute_name] = wrap_value(value, [attribute_name])
+      old_value = @attributes[attribute_name]
+      new_value = wrap_value(value, [attribute_name])
+
+      if old_value != new_value
+        @attributes[attribute_name] = new_value
+
+        @deps.changed!(attribute_name)
 
-      @deps.changed!(attribute_name)
+        if old_value == nil || new_value == nil
+          @size_dep.changed!
+        end
+
+        # TODO: Can we make this so it doesn't need to be handled for non store collections
+        # (maybe move it to persistor, though thats weird since buffers don't have a persistor)
+        clear_server_errors(attribute_name) if @server_errors
 
-      # Let the persistor know something changed
-      @persistor.changed(attribute_name) if @persistor
+
+        # Don't save right now if we're in a nosave block
+        if !defined?(Thread) || !Thread.current['nosave']
+          # Let the persistor know something changed
+          @persistor.changed(attribute_name) if @persistor
+        end
+      end
     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)
+    def read_attribute(attr_name)
       # Reading an attribute, we may get back a nil model.
-      method_name = method_name.to_sym
+      attr_name = attr_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
-        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)
 
+      # See if the value is in attributes
+      if @attributes && @attributes.key?(attr_name)
         # Track dependency
         @deps.depend(attr_name)
 
-        if value
-          # key was in attributes or cache
-          value
+        return @attributes[attr_name]
+      else
+        new_model              = read_new_model(attr_name)
+        @attributes            ||= {}
+        @attributes[attr_name] = new_model
+
+        # Trigger size change
+        # TODO: We can probably improve Computations to just make this work
+        # without the delay
+        if Volt.in_browser?
+          `setImmediate(function() {`
+            @size_dep.changed!
+          `});`
         else
-          new_model              = read_new_model(attr_name)
-          @attributes            ||= {}
-          @attributes[attr_name] = new_model
-          new_model
+          @size_dep.changed!
         end
+
+        # Depend on attribute
+        @deps.depend(attr_name)
+        return new_model
       end
     end
 
@@ -261,32 +293,43 @@ module Volt
         if save_to
           if save_to.is_a?(ArrayModel)
             # Add to the collection
-            new_model             = save_to << attributes
-
-            # Set the buffer's id to track the main model's id
-            attributes[:_id] = new_model._id
-            options[:save_to]     = new_model
-
-            # TODO: return a promise that resolves if the append works
+            promise = save_to.append(attributes)
           else
             # We have a saved model
-            return save_to.assign_attributes(attributes)
+            promise = save_to.assign_attributes(attributes)
+          end
+
+          return promise.then do |new_model|
+            if new_model
+              # Set the buffer's id to track the main model's id
+              attributes[:_id] = new_model._id
+              options[:save_to]     = new_model
+            end
+
+            nil
+          end.fail do |errors|
+            if errors.is_a?(Hash)
+              server_errors.replace(errors)
+            end
+
+            promise_for_errors(errors)
           end
         else
           fail 'Model is not a buffer, can not be saved, modifications should be persisted as they are made.'
         end
-
-        Promise.new.resolve({})
       else
         # Some errors, mark all fields
-        self.class.validations.keys.each do |key|
-          mark_field!(key.to_sym)
-        end
-
-        Promise.new.reject(errors)
+        promise_for_errors(errors)
       end
     end
 
+    # When errors come in, we mark all fields and return a rejected promise.
+    def promise_for_errors(errors)
+      mark_all_fields!
+
+      Promise.new.reject(errors)
+    end
+
     # Returns a buffered version of the model
     def buffer
       model_path = options[:path]
@@ -312,6 +355,24 @@ module Volt
       model
     end
 
+    # Takes a block that when run, changes to models will not save inside of
+    if RUBY_PLATFORM == 'opal'
+      # Temporary stub for no save on client
+      def self.nosave
+        yield
+      end
+    else
+      def self.nosave
+        previous = Thread.current['nosave']
+        Thread.current['nosave'] = true
+        begin
+          yield
+        ensure
+          Thread.current['nosave'] = previous
+        end
+      end
+    end
+
     private
 
     def setup_buffer(model)

data/lib/volt/models/model_hash_behaviour.rb

@@ -6,7 +6,9 @@ module Volt
     def delete(name)
       name = name.to_sym
 
-      value = attributes.delete(name)
+      value = @attributes.delete(name)
+
+      @size_dep.changed!
       @deps.delete(name)
 
       @persistor.removed(name) if @persistor
@@ -14,28 +16,40 @@ module Volt
       value
     end
 
+    def size
+      @size_dep.depend
+      @attributes.size
+    end
+
+    def keys
+      @size_dep.depend
+      @attributes.keys
+    end
+
     def nil?
-      attributes.nil?
+      @attributes.nil?
     end
 
     def empty?
-      !attributes || attributes.size == 0
+      @size_dep.depend
+      !@attributes || @attributes.size == 0
     end
 
     def false?
-      attributes.false?
+      @attributes.false?
     end
 
     def true?
-      attributes.true?
+      @attributes.true?
     end
 
     def clear
-      attributes.each_pair do |key, value|
+      @attributes.each_pair do |key, value|
         @deps.changed!(key)
       end
 
-      attributes.clear
+      @attributes.clear
+      @size_dep.changed!
 
       @persistor.removed(nil) if @persistor
     end
@@ -46,15 +60,18 @@ module Volt
 
     # Convert the model to a hash all of the way down.
     def to_h
+      @size_dep.depend
+
       if @attributes.nil?
         nil
       else
         hash = {}
-        attributes.each_pair do |key, value|
+        @attributes.each_pair do |key, value|
           hash[key] = deep_unwrap(value)
         end
         hash
       end
     end
+
   end
 end

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

@@ -2,6 +2,7 @@ require 'volt/models/persistors/store'
 require 'volt/models/persistors/query/query_listener_pool'
 require 'volt/models/persistors/store_state'
 
+
 module Volt
   module Persistors
     class ArrayStore < Store
@@ -82,6 +83,7 @@ module Volt
 
       # Clear out the models data, since we're not listening anymore.
       def unload_data
+        puts "Unload Data"
         change_state_to :not_loaded
         @model.clear
       end
@@ -138,9 +140,10 @@ module Volt
       # 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)
+        raise "then must pass a block" unless block
         promise = Promise.new
 
-        promise = promise.then(&block) if block
+        promise = promise.then(&block)
 
         if @state == :loaded
           promise.resolve(@model)
@@ -197,7 +200,7 @@ module Volt
       # method.  This should trigger a save.
       def added(model, index)
         if model.persistor
-          # Tell the persistor it was added
+          # Tell the persistor it was added, return the promise
           model.persistor.add_to_collection
         end
       end

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

@@ -0,0 +1,91 @@
+# Use a volt model to persist to cookies.
+# Some code borrowed from: https://github.com/opal/opal-browser/blob/master/opal/browser/cookies.rb
+
+require 'volt/models/persistors/base'
+
+module Volt
+  module Persistors
+    # Backs a collection in the local store
+    class Cookies < Base
+      def read_cookies
+        cookies = `document.cookie`
+        Hash[cookies.split(';').map do |v|
+          parts = v.split('=').map { |p| p = p.strip ; `decodeURIComponent(p)` }
+
+          # Default to empty if no value
+          parts << '' if parts.size == 1
+
+          parts
+        end]
+      end
+
+      def write_cookie(key, value, options={})
+        parts = []
+
+        parts << `encodeURIComponent(key)`
+        parts << '='
+        parts << `encodeURIComponent(value)`
+        parts << '; '
+
+        parts << 'max-age=' << options[:max_age] << '; '        if options[:max_age]
+        if options[:expires]
+          expires = options[:expires]
+          parts << 'expires=' << `expires.toGMTString()` << '; '
+        end
+        parts << 'path='    << options[:path] << '; '           if options[:path]
+        parts << 'domain='  << options[:domain] << '; '         if options[:domain]
+        parts << 'secure'                                       if options[:secure]
+
+        cookie_val = parts.join
+
+        `document.cookie = cookie_val`
+      end
+
+      def initialize(model)
+        @model = model
+      end
+
+      # Called when a model is added to the collection
+      def added(model, index)
+        # Save an added cookie
+      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 !@loaded && @model.path == []
+          @loaded = true
+
+          writing_cookies do
+            read_cookies.each_pair do |key, value|
+              @model.assign_attribute(key, value)
+            end
+          end
+        end
+      end
+
+      # Callled when an cookies value is changed
+      def changed(attribute_name)
+        # TODO: Make sure we're only assigning directly, not sub models
+        unless $writing_cookies
+          value = @model.read_attribute(attribute_name)
+
+          # Temp, expire in 1 year, going to expand this api
+          write_cookie(attribute_name, value.to_s, expires: Time.now + (356 * 24 * 60 * 60))
+        end
+      end
+
+      def removed(attribute_name)
+        writing_cookies do
+          write_cookie(attribute_name, '', expires: Time.now)
+        end
+      end
+
+      def writing_cookies
+        $writing_cookies = true
+        yield
+        $writing_cookies = false
+      end
+    end
+  end
+end