volt 0.9.3.pre2 → 0.9.3.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 424f310e39b6096bf3372ff3dd5b90e6936718ef
-  data.tar.gz: fa76365d2cc587f7985e39008f13825f02c6515d
+  metadata.gz: f07b58ba0668779997cda13fafd289b7c91451b6
+  data.tar.gz: b5b4d4a31d7b2ea898c6c1ce57ad6fa39373b03a
 SHA512:
-  metadata.gz: c6371586b5afc5278951bf89478153b6e854edb444503ca8ea312071f74d350c2807aa67eede9f8d64a97bc8c8208649dafd46ae723f58c1cb4308566b3a0ce5
-  data.tar.gz: 86c5ef5a2b1da23d537103884ee7cdd840be23dae4a59ae22e0c2be0b3ac56652541fcbd5dd808b79c474cda6846e4847ef2839c9a91c5009da931952937c563
+  metadata.gz: f8a220c588390c7c6a1f37199b8be4a56129339e8d6450ab18fd142bb9ff7b892465290e6efdd79524c538af793e3f5ef80226fbd1e009704fe656585c8722bf
+  data.tar.gz: 5e89589d70e40122664207102c1e4abafb33fe58fcb6aa26827c2ef706a302ce83a1bca8d75f4e8989208d67a0690f2a2f3a4eac6d45cb73afbe1763e88e6a0f

data/CHANGELOG.md

@@ -7,8 +7,19 @@
 - models without an assigned persistor now use the page persistor (which now can provide basic querying)
 - Volt now pushes updates between mulitple app instances.  Updates are pushed between any servers, clients, runners, etc.. that are connected to the same database via the MessageBus (see next)
 - Volt now comes with a "MessageBus" built in.  The message bus provides a pub/sub interface for the app "cluster".  Volt provides a default message bus implementation using peer to peer sockets that are automatically managed via the database.
+- You can now nest models on store.  Previously store was limited to only storing either values or ArrayModels (associations).  You can now store directly, in mongo this will be stored as a nested value.
+- Promises got more awesome.  Promises in volt can now proxy methods to their future resolved value.  Something like: ```promise.then {|v| v.name }``` can now be written simply as: ```promise.name```  It will still return a promise, but to make life easier:
+- All bindings now support promises directly.
+- You can now set/get properties directly on ```store``` and they will be saved to a ```root_stores_models``` table.
+- All code in config/initializers is now run on app startup.
+- All code in any components config/initializers (app/main/config/initializers/*.rb) is now run on the server during app startup.  On the client, only the included components initializers will be run.
+- all initializers folders now support a ```client``` and ```server``` folder.
+- has_one is now supported.
+- You can now use .create to make a new item on a collection.
 
 ### Changed
+- All methods on ArrayModel's under the store collection now return a Promise.
+- A #create method was added to ArrayModel.
 - All logic associated with mongo has been moved into the volt-mongo gem.  If you are migrating from a previous version, be sure to add ```gem 'volt-mongo'``` to the Gemfile.
 - models using the page or store persistor now auto-generate an id when created.  This simplifies things since models always have an id.  It makes association easier as well. (internally that is)
 - models now use ```.id``` instead of ```._id```  Queries and saves are mapped to _id in the volt-mongo gem
@@ -18,6 +29,7 @@
     - controllers now take a Volt::App when created directly.
 - You can now use .each in attribute bindings.
 - We moved to csso as the css compressor because it does not require libv8, only an execjs runtime.
+- Each bindings now support promises.
 
 ## 0.9.2
 ### Changed

data/app/volt/tasks/query_tasks.rb

@@ -1,11 +1,4 @@
 class QueryTasks < Volt::Task
-  # The dispatcher passes its self in
-  def initialize(volt_app, channel, dispatcher = nil)
-    @volt_app = volt_app
-    @channel = channel
-    @dispatcher = dispatcher
-  end
-
   def add_listener(collection, query)
     live_query = @volt_app.live_query_pool.lookup(collection, query)
     track_channel_in_live_query(live_query)

data/app/volt/tasks/store_tasks.rb

@@ -2,12 +2,6 @@ require 'mongo'
 require 'volt/models'
 
 class StoreTasks < Volt::Task
-  def initialize(volt_app, channel = nil, dispatcher = nil)
-    @volt_app = volt_app
-    @channel = channel
-    @dispatcher = dispatcher
-  end
-
   def db
     @@db ||= Volt::DataStore.fetch
   end

data/docs/UPGRADE_GUIDE.md

@@ -11,4 +11,6 @@ gem 'rbnacl-libsodium', require: false
 # Asset compilation gems, they will be required when needed.
 gem 'csso-rails', '~> 0.3.4', require: false
 gem 'uglifier', '>= 2.4.0', require: false
+
+gem 'volt-mongo'
 ```

data/lib/volt/cli/asset_compile.rb

@@ -22,7 +22,7 @@ module Volt
       @root_path ||= Dir.pwd
       Volt.root  = @root_path
 
-      Volt.boot(@root_path)
+      volt_app = Volt.boot(@root_path)
 
       require 'volt/server/rack/component_paths'
       require 'volt/server/rack/component_code'
@@ -35,7 +35,7 @@ module Volt
       @component_paths   = ComponentPaths.new(@root_path)
       @app               = Rack::Builder.new
       @opal_files        = OpalFiles.new(@app, @app_path, @component_paths)
-      @index_files       = IndexFiles.new(@app, @component_paths, @opal_files)
+      @index_files       = IndexFiles.new(@app, volt_app, @component_paths, @opal_files)
       @component_handler = ComponentHandler.new(@component_paths)
 
       puts 'Compile Opal for components'

data/lib/volt/cli/console.rb

@@ -25,6 +25,27 @@ class Pry
       end
     end
   end
+
+  # The following causes promises in the console to auto-resolve, making it
+  # easier to see your data, but harder to follow along.  Currently off by
+  # default.
+  if ENV['AUTO_RESOLVE']
+    def evaluate_ruby(code)
+      inject_sticky_locals!
+      exec_hook :before_eval, code, self
+
+      result = current_binding.eval(code, Pry.eval_path, Pry.current_line)
+
+      if result.is_a?(Promise)
+        result = result.sync
+      end
+
+      set_last_result(result, code)
+    ensure
+      update_input_history(code)
+      exec_hook :after_eval, result, self
+    end
+  end
 end
 
 module Volt

data/lib/volt/config.rb

@@ -71,16 +71,6 @@ else
         end
       end
 
-      # Load in all .rb files in the config folder
-      def run_app_and_initializers
-        files = ["#{Volt.root}/config/app.rb"]
-        files += Dir[Volt.root + '/config/initializers/*.rb']
-
-        files.each do |config_file|
-          require(config_file)
-        end
-      end
-
       alias_method :setup,  :configure
       alias_method :config, :configuration
     end

data/lib/volt/controllers/collection_helpers.rb

@@ -0,0 +1,18 @@
+# Collection helpers provide methods to access methods of page directly.
+# @page is expected to be defined and a Volt::Page
+module Volt
+  module CollectionHelpers
+
+    def url_for(params)
+      @page.url.url_for(params)
+    end
+
+    def url_with(params)
+      @page.url.url_with(params)
+    end
+
+    def store
+      @page.store
+    end
+  end
+end

data/lib/volt/controllers/model_controller.rb

@@ -1,11 +1,13 @@
 require 'volt/reactive/reactive_accessors'
 require 'volt/controllers/actions'
 require 'volt/controllers/template_helpers'
+require 'volt/controllers/collection_helpers'
 
 module Volt
   class ModelController
     include ReactiveAccessors
     include Actions
+    include CollectionHelpers
 
     # A model controller will have its
     # class VoltTemplates
@@ -149,10 +151,6 @@ module Volt
       @page.page
     end
 
-    def store
-      @page.store
-    end
-
     def flash
       @page.flash
     end
@@ -185,14 +183,6 @@ module Volt
       @controller ||= Model.new
     end
 
-    def url_for(params)
-      @page.url.url_for(params)
-    end
-
-    def url_with(params)
-      @page.url.url_with(params)
-    end
-
     # loaded? is a quick way to see if the model for the controller is loaded
     # yet.  If the model is there, it asks the model if its loaded.  If the model
     # was set to a promise, it waits for the promise to resolve.

data/lib/volt/extra_core/object.rb

@@ -19,6 +19,16 @@ class Object
     end
   end
 
+  # Convert a non-promise value into a resolved promise.  Resolve the block if
+  # it takes one.
+  def then(&block)
+    promisify_and_run_method(:then, &block)
+  end
+
+  # def fail(&block)
+  #   promisify_and_run_method(:fail, &block)
+  # end
+
   def try(*a, &b)
     if a.empty? && block_given?
       yield self
@@ -26,4 +36,13 @@ class Object
       public_send(*a, &b) if respond_to?(a.first)
     end
   end
+
+  private
+  def promisify_and_run_method(method_name, &block)
+    promise = Promise.new.resolve(self)
+
+    promise = promise.send(method_name, &block) if block
+
+    promise
+  end
 end

data/lib/volt/models.rb

@@ -9,14 +9,19 @@ require 'volt/models/persistors/params'
 require 'volt/models/persistors/cookies' if RUBY_PLATFORM == 'opal'
 require 'volt/models/persistors/flash'
 require 'volt/models/persistors/local_store'
-if RUBY_PLATFORM == 'opal'
-  require 'promise'
-else
-  # Opal doesn't expose its promise library directly
-  require 'opal'
+require 'volt/models/root_models/root_models'
+require 'volt/models/root_models/store_root'
 
-  gem_dir = File.join(Opal.gem_dir, '..')
-  require(gem_dir + '/stdlib/promise')
-end
+# Fow now, we're keeping a volt copy of the promise library from opal 0.8,
+# since opal 0.7.x's version has some bugs.
+# if RUBY_PLATFORM == 'opal'
+#   require 'promise'
+# else
+#   # Opal doesn't expose its promise library directly
+#   require 'opal'
+
+#   gem_dir = File.join(Opal.gem_dir, '..')
+#   require(gem_dir + '/stdlib/promise')
+# end
 # TODO: remove once https://github.com/opal/opal/pull/725 is released.
-require 'volt/utils/promise_patch'
+require 'volt/utils/promise_extensions'

data/lib/volt/models/array_model.rb

@@ -14,15 +14,28 @@ module Volt
 
     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_root_dep(*method_names)
+    # For many methods, we want to register a dependency on the root_dep as soon
+    # as the method is called, so it can begin loading.  Also, some persistors
+    # need to have special loading logic (such as returning a promise instead
+    # of immediately returning).  To accomplish this, we call the
+    # #run_once_loaded method on the persistor.
+    def self.proxy_with_load(*method_names)
       method_names.each do |method_name|
-        define_method(method_name) do |*args|
+        old_method_name = :"__old_#{method_name}"
+        alias_method(old_method_name, method_name)
+
+        define_method(method_name) do |*args, &block|
           # track on the root dep
           persistor.try(:root_dep).try(:depend)
 
-          super(*args)
+          if persistor.respond_to?(:run_once_loaded) &&
+              !Volt.in_mode?(:no_model_promises)
+            persistor.run_once_loaded(block) do
+              send(old_method_name, *args)
+            end
+          else
+            send(old_method_name, *args)
+          end
         end
       end
     end
@@ -40,7 +53,6 @@ module Volt
       end
     end
 
-    proxy_with_root_dep :[], :size, :first, :last, :state_for, :reverse
     proxy_to_persistor :then, :fetch, :fetch_first, :fetch_each
 
     def initialize(array = [], options = {})
@@ -64,6 +76,13 @@ module Volt
       self
     end
 
+    def state_for(*args)
+      # Track on root dep
+      persistor.try(:root_dep).try(:depend)
+
+      super
+    end
+
     # Make sure it gets wrapped
     def <<(model)
       if model.is_a?(Model)
@@ -119,6 +138,11 @@ module Volt
       end
     end
 
+    # Create does append with a default empty model
+    def create(model={})
+      append(model)
+    end
+
     def delete(val)
       # Check to make sure the models are allowed to be deleted
       if !val.is_a?(Model) || val.can_delete?
@@ -129,17 +153,36 @@ module Volt
       end
     end
 
-    # 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
-
     def first
       self[0]
     end
 
+    # Return the first item in the collection, or create one if one does not
+    # exist yet.
+    def first_or_create
+      first.then do |item|
+        if item
+          item
+        else
+          create
+        end
+      end
+    end
+
+    def last
+      self[-1]
+    end
+
+    def reverse
+      super
+    end
+
+    # Return the model, on store, .all is proxied to wait for load and return
+    # a promise.
+    def all
+      self
+    end
+
     # returns a promise to fetch the first instance
     def fetch_first(&block)
       persistor = self.persistor
@@ -186,8 +229,10 @@ module Volt
     def to_a
       @size_dep.depend
       array = []
-      attributes.size.times do |index|
-        array << deep_unwrap(self[index])
+      Volt.run_in_mode(:no_model_promises) do
+        attributes.size.times do |index|
+          array << deep_unwrap(self[index])
+        end
       end
       array
     end
@@ -216,13 +261,8 @@ module Volt
       model
     end
 
-    private
+    # We need to setup the proxy methods below where they are defined.
+    proxy_with_load :first, :[], :size, :last, :reverse, :all, :to_a
 
-    # Takes the persistor if there is one and
-    def setup_persistor(persistor)
-      # Use page as the default persistor
-      persistor ||= Persistors::Page
-      @persistor = persistor.new(self)
-    end
   end
 end

data/lib/volt/models/associations.rb

@@ -13,7 +13,7 @@ module Volt
             lookup_key = get(key_name)
 
             # Return a promise for the belongs_to
-            root.get(method_name.pluralize).where(id: lookup_key).fetch_first
+            root.get(method_name.pluralize).where(id: lookup_key).first
           end
         end
       end
@@ -23,6 +23,21 @@ module Volt
           get(method_name.pluralize, true)
         end
       end
+
+      # has_one creates a method on the Volt::Model that returns a promise
+      # to get the associated model.
+      def has_one(method_name)
+        if method_name.plural?
+          raise NameError, "has_one takes a singluar association name"
+        end
+
+        define_method(method_name) do
+          association_with_root_model('has_one') do |root|
+            key = self.class.to_s.underscore + '_id'
+            root.send(method_name.pluralize).where(key => id).first
+          end
+        end
+      end
     end
 
     def self.included(base)

data/lib/volt/models/model.rb

@@ -59,6 +59,9 @@ module Volt
     }
 
     def initialize(attributes = {}, options = {}, initial_state = nil)
+      # Start off with empty attributes
+      @attributes = {}
+
       # The listener event counter keeps track of how many computations are listening on this model
       @listener_event_counter = EventCounter.new(
         -> { parent.try(:persistor).try(:listener_added) },
@@ -132,8 +135,6 @@ module Volt
 
     # Assign multiple attributes as a hash, directly.
     def assign_attributes(attrs, initial_setup = false, skip_changes = false)
-      @attributes ||= {}
-
       attrs = wrap_values(attrs)
 
       if attrs
@@ -146,8 +147,8 @@ module Volt
           assign_all_attributes(attrs)
         end
       else
-        # Assign to nil
-        @attributes = attrs
+        # Assign to empty
+        @attributes = {}
       end
 
       # Trigger and change all
@@ -291,8 +292,10 @@ module Volt
       end
     end
 
-    def new_model(*args)
-      Volt::Model.class_at_path(options[:path]).new(*args)
+    def new_model(attributes = {}, new_options = {}, initial_state = nil)
+      new_options = new_options.merge(persistor: @persistor)
+
+      Volt::Model.class_at_path(new_options[:path]).new(attributes, new_options, initial_state)
     end
 
     def new_array_model(attributes, options)
@@ -314,9 +317,18 @@ module Volt
         # loaded_state = self.loaded_state
         # str += " state:#{loaded_state}" if loaded_state
 
-        persistor = self.persistor
+        # persistor = self.persistor
         # str += " persistor:#{persistor.inspect}" if persistor
-        str += " #{attributes.inspect}>"
+
+        # Show the :id first, then sort the rest of the attributes
+        attrs = attributes.dup
+
+        id = attrs.delete(:id)
+
+        attrs = attrs.sort
+        attrs.insert(0, [:id, id])
+
+        str += " #{attrs.to_h.inspect}>"
 
         str
       end
@@ -372,13 +384,6 @@ module Volt
       end
     end
 
-    # Takes the persistor if there is one and
-    def setup_persistor(persistor)
-      # Use page as the default persistor
-      persistor ||= Persistors::Page
-      @persistor = persistor.new(self)
-    end
-
     # Used internally from other methods that assign all attributes
     def assign_all_attributes(attrs, track_changes = false)
       # Assign each attribute using setters
@@ -403,5 +408,12 @@ module Volt
         self.id = generate_id
       end
     end
+
+    def self.inherited(subclass)
+      if defined?(RootModels)
+        RootModels.add_model_class(subclass)
+      end
+    end
+
   end
 end