volt 0.8.4 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a84884c1b8515b231b4dabcbe6757cb7d18f6744
-  data.tar.gz: b9e66a5548bc014e1759280520516094362d7ab4
+  metadata.gz: 3c7f9c10d1c4c9b36bbf686d224d63b7efac606d
+  data.tar.gz: 3d5734b9bf49bd4bc385442fcafe8fa52a083d6c
 SHA512:
-  metadata.gz: c1c7d2b1280226777aa301457c8a6f61dc09c2a43ff9e0a000035308a7712447dd0d4423e5d4e5536778b3b47edea464ee8f7881d4bae32d06b1470d31ff7437
-  data.tar.gz: 6e76d4a9a137a9eb1d7691f1dc56e0f80002bc6afdd200a606ca5ade4cb5dd4c31e86649006df493e5d8b18aa07201851dabe9848352be366576db53ce9b590f
+  metadata.gz: ea67b035043177a2f63d14906b25a9b71e12f6bb2737b471c749947971bc170680d83d61df1a20c7a9b13a009d1bb43c3e5610a71374d79a763c7af7158431a1
+  data.tar.gz: 9aed66c68f300dc644f38ff84802152f3e2c4cd37780306c2a142247b6d6d71d70a89c49b307117e07b04e89db05165d1f1c86ed7472f28218d80a0078f76608

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-# 0.0.8 - Oct 3, 2014
+# 0.8.4 - Oct 4, 2014
+
+  - Added configuration for databases.
+
+# 0.8.0 - Oct 3, 2014
 
   - Major change: After a bunch of research and effort, we have decided to change the way the reactive core works.  Previously, all objects that maybe changed would be wrapped in a ReactiveValue object that could be updated using ```.cur=``` and accessed using ```.cur```  This had many advantages, but resulted in very complex framework code.  It also had a few problems, mainly that reactive value's (sometimes) needed to be unwrapped when passed to code that wasn't aware of reactivity.  Our goal is transparent reactivity.  Taking infuence from meteor.js, we have switched to a simpler reactive model.  See the Readme for details of the new reactive system.  The new system has a few advantages.  Mainly, you can for the most part write code that is reactive and it will just work.
   - Radio button support has been added, see README.md

data/Readme.md

@@ -72,19 +72,28 @@ You can access the Volt console with:
 1. [Getting Help](#getting-help)
 2. [Rendering](#rendering)
   1. [States and Computations](#state-and-computations)
-  1. [Computations](#computations)
+    1. [Computations](#computations)
+  2. [Dependencies](#dependencies)
 3. [Views](#views)
   1. [Bindings](#bindings)
     1. [Content Binding](#content-binding)
     2. [If Binding](#if-binding)
     3. [Each Binding](#each-binding)
     4. [Attribute Bindings](#attribute-bindings)
-    5. [Escaping](#escaping)
+  2. [Escaping](#escaping)
 4. [Models](#models)
-  1. [Provided Collections](#provided-collections)
-  2. [ArrayModel Events](#arraymodel-events)
-  3. [Automatic Model Conversion](#automatic-model-conversion)
+  1. [Nil Models](#nil-models)
+  2. [Provided Collections](#provided-collections)
+  3. [Store Collection](#store-collection)
+  4. [Sub Collections](#sub-collections)
+  5. [Model Classes](#model-classes)
+  6. [Buffers](#buffers)
+  7. [Validations](#validations)
+  8. [Model State](#model-state)
+  9. [ArrayModel Events](#arraymodel-events)
+  10. [Automatic Model Conversion](#automatic-model-conversion)
 5. [Controllers](#controllers)
+  1. [Reactive Accessors](#reactive-accessors)
 6. [Tasks](#tasks)
 7. [Components](#components)
   1. [Dependencies](#dependencies)
@@ -97,9 +106,11 @@ You can access the Volt console with:
 9. [Routes](#routes)
   1. [Routes file](#routes-file)
 10. [Testing](#testing)
-11. [Volt Helpers](#volt-helpers)
+11. [Debugging](#debugging)
+12. [Volt Helpers](#volt-helpers)
   1. [Logging](#logging)
   2. [App Configuration](#app-configuration)
+13. [Contributing](#contributing)
 
 # Getting Help
 
@@ -270,7 +281,7 @@ You can do {index + 1} to correct the zero offset.
 
 When items are removed or added to the array, the #each binding automatically and intelligently adds or removes the items from/to the DOM.
 
-## Attribute Bindings
+### Attribute Bindings
 
 Bindings can also be placed inside of attributes.
 
@@ -327,17 +338,19 @@ When you need to use { and } outside of bindings, anything in a triple mustache
 
 # Models
 
-Volt's concept of a model is slightly different from many frameworks where a model is the name for the ORM to the database.  In Volt a model is a class where you can store data easily.  Models can be created with a "Persistor", which is responsible for storing the data in the model.  Models created without a persistor, simply store the data in the classes instance.  Lets first see how to use a model.
+Volt's concept of a model is slightly different from many frameworks where a model is the name for the ORM to the database.  In Volt a model is a class where you can store data easily.  Models can be created with a "Persistor", which is responsible for storing the data in the model somewhere.  Models created without a persistor, simply store the data in the classes instance.  Lets first see how to use a model.
 
-Volt comes with many built-in models; one is called `page`.  If you call `#page` on a controller, you will get access to the model.  Models provided by Volt are automatically wrapped in a ReactiveValue so update events can be tracked.
+Volt comes with many built-in models; one is called `page`.  If you call `#page` on a controller, you will get access to the model.
 
 ```ruby
     page._name = 'Ryan'
     page._name
-    # => @'Ryan'
+    # => 'Ryan'
 ```
 
-Models act like a hash that you can access with getters and setters that start with an _ .  If an underscore method is called that hasn't yet been assigned, you will get back a "nil model".  Prefixing with an underscore makes sure we don't accidentally try to call a method that doesn't exist and get back nil model instead of raising an exception.  There is no need to define which fields a model has. Fields behave similarly to a hash, but with a different access and assignment syntax.
+Models act like a hash that you can access with getters and setters that start with an underscore.  If an attribute is accessed that hasn't yet been assigned, you will get back a "nil model".  Prefixing with an underscore makes sure we don't accidentally try to call a method that doesn't exist and get back nil model instead of raising an exception. Fields behave similarly to a hash, but with a different access and assignment syntax.
+
+  # TODO: Add docs on fields in classes
 
 Models also let you nest data without creating the intermediate models:
 
@@ -350,23 +363,28 @@ Models also let you nest data without creating the intermediate models:
     # => @#<Model:_settings {:_color=>"blue"}>
 ```
 
-Nested data is automatically setup when assigned.  In this case, page._settings is a model that is part of the page model.
+Nested data is automatically setup when assigned.  In this case, page._settings is a model that is part of the page model.  This allows nested models to be bound to a binding without the need to setup the model before use.
 
-You can also append to a model if it's not defined yet.  In Volt models, plural properties are assumed to contain arrays (or more specifically, ArrayModels).
+In Volt models, plural properties return an ArrayModel instance.  ArrayModels behave the same way as normal arrays.  You can add/remove items to the array with normal array methods (#<<, push, append, delete, delete_at, etc...)
 
 ```ruby
-    page._items << 'item 1'
     page._items
-    # => @#<ArrayModel ["item 1", "item 2"]>
+    # #<ArrayModel:70303686333720 []>
+
+    page._items << {_name: 'Item 1'}
+
+    page._items
+    # #<ArrayModel:70303686333720 [<Model:70303682055800 {:_name=>"Item 1"}>]>
+
+    page._items.size
+    # => 1
 
     page._items[0]
-    # => @"item 1"
+    # => <Model:70303682055800 {:_name=>"Item 1"}>
 ```
 
-ArrayModels can be appended to and accessed just like regular arrays.
-
 
-### Nil Models
+## Nil Models
 
 As a convience, calling something like ```page._info``` returns what's called a NilModel (assuming it isn't already initialized).  NilModels are place holders for future possible Models.  NilModels allow us to bind deeply nested values without initializing any intermediate values.
 
@@ -417,6 +435,160 @@ Above, I mentioned that Volt comes with many default collection models accessibl
 
 **more storage locations are planned**
 
+## Store Collection
+
+The store collection backs data in the data store.  Currently the only supported data store is Mongo. (More coming soon, RethinkDb will probably be next)  You can use store very similar to the other collections.
+
+In Volt you can access ```store``` on the front-end and the back-end.  Data will automatically be synced between the front-end and the backend.  Any changes to the data in store will be reflected on any clients using the data (unless a [buffer](#buffer) is in use - see below).
+
+```ruby
+    store._items << {_name: 'Item 1'}
+
+    store._items[0]
+    # => <Model:70303681865560 {:_name=>"Item 1", :_id=>"e6029396916ed3a4fde84605"}>
+```
+
+Inserting into ```store._items``` will create a ```_items``` table and insert the model into it.  An pseudo-unique _id will be automatically generated.
+
+Currently one difference between ```store``` and other collections is ```store``` does not store properties directly.  Only ArrayModels are allowed directly on ```store```
+
+```ruby
+    store._something = 'yes'
+    # => won't be saved at the moment
+```
+
+Note: We're planning to add support for direct ```store``` properties.
+
+## Sub Collections
+
+Models can be nested on ```store```
+
+```ruby
+    store._states << {_name: 'Montana'}
+    montana = store._states[0]
+
+    montana._cities << {_name: 'Bozeman'}
+    montana._cities << {_name: 'Helena'}
+
+    store._states << {_name: 'Idaho'}
+    idaho = store._states[1]
+
+    idaho._cities << {_name: 'Boise'}
+    idaho._cities << {_name: 'Twin Falls'}
+
+    store._states
+    # #<ArrayModel:70129010999880 [<Model:70129010999460 {:_name=>"Montana", :_id=>"e3aa44651ff2e705b8f8319e"}>, <Model:70128997554160 {:_name=>"Montana", :_id=>"9aaf6d2519d654878c6e60c9"}>, <Model:70128997073860 {:_name=>"Idaho", :_id=>"5238883482985760e4cb2341"}>, <Model:70128997554160 {:_name=>"Montana", :_id=>"9aaf6d2519d654878c6e60c9"}>, <Model:70128997073860 {:_name=>"Idaho", :_id=>"5238883482985760e4cb2341"}>]>
+```
+
+You can also create a Model first and then insert it.
+
+```ruby
+    montana = Model.new({_name: 'Montana'})
+
+    montana._cities << {_name: 'Bozeman'}
+    montana._cities << {_name: 'Helena'}
+
+    store._states << montana
+```
+
+## Model Classes
+
+By default all collections use the Model class by default.
+
+```ruby
+    page._info.class
+    # => Model
+```
+
+You can provide classes that will be loaded in place of the standard model class.  You can place these in any app/{component}/models folder.  For example, you could add ```app/main/info.rb```  Model classes should inherit from ```Model```
+
+```ruby
+    class Info < Model
+    end
+```
+
+Now when you access any sub-collection called ```_info```, it will load as an instance of ```Info```
+
+```ruby
+    page._info.class
+    # => Info
+```
+
+This lets you set custom methods and validations within collections.
+
+## Buffers
+
+Because the store collection is automatically synced to the backend, any change to a model's property will result in all other clients seeing the change immediately.  Often this is not the desired behavior.  To facilitate building [CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete) apps, Volt provides the concept of a "buffer".  A buffer can be created from one model and will not save data back to its backing model until .save! is called on it.  This lets you create a form thats not saved until a submit button is pressed.
+
+```ruby
+    store._items << {_name: 'Item 1'}
+
+    item1 = store._items[0]
+
+    item1_buffer = item1.buffer
+
+    item1_buffer._name = 'Updated Item 1'
+    item1_buffer._name
+    # => 'Updated Item 1'
+
+    item1._name
+    # => 'Item 1'
+
+    item1_buffer.save!
+
+    item1_buffer._name
+    # => 'Updated Item 1'
+
+    item1._name
+    # => 'Updated Item 1'
+```
+
+```#save!``` on buffer also returns a [promise](http://opalrb.org/blog/2014/05/07/promises-in-opal/) that will resolve when the data has been saved back to the server.
+
+```ruby
+    item1_buffer.save!.then do
+      puts "Item 1 saved"
+    end.fail do |err|
+      puts "Unable to save because #{err}"
+    end
+```
+
+Calling .buffer on an existing model will return a buffer for that model instance.  If you call .buffer on an ArrayModel (plural sub-collection), you will get a buffer for a new item in that collection.  Calling .save! will then add the item to that sub-collection as if you had done << to push the item into the collection.
+
+## Validations
+
+Within a model class, you can setup validations.  Validations let you restrict the types of data that can be stored in a model.  Validations are mostly useful for the ```store``` collection, though they can be used elsewhere.
+
+At the moment we only have two validations implemented (length and presence).  Though a lot more will be coming.
+
+```ruby
+    class Info < Model
+      validate :_name, length: 5
+      validate :_state, presence: true
+    end
+```
+
+When calling save on a model with validations, the following occurs:
+
+1. Client side validations are run; if they fail, the promise from ```save!``` is rejected with the error object.
+2. The data is sent to the server and client and server side validations are run on the server; any failures are returned and the promise is rejected on the front-end (with the error object)
+    - re-running the validations on the server side makes sure that no data can be saved that doesn't pass the validations
+3. If all validations pass, the data is saved to the database and the promise resolved on the client.
+4. The data is synced to all other clients.
+
+
+## Model State
+
+**Work in progress**
+
+| state       | events bound | description                                                  |
+|-------------|--------------|--------------------------------------------------------------|
+| not_loaded  | no           | no events and no one has accessed the data in the model      |
+| loading     | maybe        | someone either accessed the data or bound an event           |
+| loaded      | yes          | data is loaded and there is an event bound                   |
+| dirty       | no           | data was either accessed without binding an event, or an event was bound, but later unbound. |
+
+
 ## ArrayModel Events
 
 Models trigger events when their data is updated.  Currently, models emit two events: added and removed.  For example:
@@ -781,16 +953,7 @@ If ```params._view``` were 'todos' and ```params._index``` were not nil, the rou
 
 Routes are matched top to bottom in a routes file.
 
-## Debugging
-
-An in browser irb is in the works.  We also have source maps support, but they are currently disabled by default.  To enable them run:
-
-    MAPS=true volt s
-
-This feature is disabled by default because (due to the volume of pages rendered) it slows down page rendering. We're working with the opal and sprockets teams to make it so everything is still served in one big source maps file (which would show the files as they originated on disk)
-
-
-## Channel
+# Channel
 
 Controllers provide a `#channel` method, that you can use to get the status of the connection to the backend.  Channel is provided in a ReactiveValue, and when the status changes, the changed events are triggered.  It provides the following:
 
@@ -822,6 +985,14 @@ To run Capybara tests, you need to specify a driver.  The following drivers are
 
 Chrome is not supported due to [this issue](https://code.google.com/p/chromedriver/issues/detail?id=887#makechanges) with ChromeDriver.  Feel free to go [here](https://code.google.com/p/chromedriver/issues/detail?id=887#makechanges) and pester the chromedriver team to fix it.
 
+# Debugging
+
+An in browser irb is in the works.  We also have source maps support, but they are currently disabled by default.  To enable them run:
+
+    MAPS=true volt s
+
+This feature is disabled by default because (due to the volume of pages rendered) it slows down page rendering. We're working with the opal and sprockets teams to make it so everything is still served in one big source maps file (which would show the files as they originated on disk)
+
 # Volt Helpers
 
 ## Logging
@@ -859,24 +1030,6 @@ Volt does its best to start with useful defaults.  You can configure things like
 
 TODO
 
-
-# Data Store
-
-Volt provides a data store collection on the front-end and the back-end.  In store, all plural names are assumed to be collections (like an array), and all singular are assumed to be a model (like a hash).
-
-```ruby
-store._things
-```
-
-**Work in progress**
-
-| state       | events bound | description                                                  |
-|-------------|--------------|--------------------------------------------------------------|
-| not_loaded  | no           | no events and no one has accessed the data in the model      |
-| loading     | maybe        | someone either accessed the data or bound an event           |
-| loaded      | yes          | data is loaded and there is an event bound                   |
-| dirty       | no           | data was either accessed without binding an event, or an event was bound, but later unbound. |
-
 # Contributing
 
 You want to contribute?  Great!  Thanks for being awesome!  At the moment, we have a big internal todo list, hop on https://gitter.im/voltrb/volt so we don't duplicate work.  Pull requests are always welcome, but asking about helping on gitter should save some duplication.

data/VERSION

@@ -1 +1 @@
-0.8.4
+0.8.5

data/app/volt/tasks/live_query/data_store.rb

@@ -2,7 +2,10 @@ require 'mongo'
 
 class DataStore
   def initialize
-    @@db = Volt::DataStore.fetch
+  end
+
+  def db
+    @@db ||= Volt::DataStore.fetch
   end
 
   def query(collection, query)
@@ -13,6 +16,6 @@ class DataStore
       end
     end
 
-    @@db[collection].find(query).to_a
+    db[collection].find(query).to_a
   end
 end

data/app/volt/tasks/store_tasks.rb

@@ -3,14 +3,12 @@ require 'query_tasks'
 
 class StoreTasks
   def initialize(channel=nil, dispatcher=nil)
-    @@db = Volt::DataStore.fetch
-
     @channel = channel
     @dispatcher = dispatcher
   end
 
   def db
-    @@db
+    @@db ||= Volt::DataStore.fetch
   end
 
   def model_errors(collection, data)
@@ -43,14 +41,14 @@ class StoreTasks
       # TODO: Seems mongo is dumb and doesn't let you upsert with custom id's
       begin
         # data['_id'] = BSON::ObjectId('_id') if data['_id']
-        @@db[collection].insert(data)
+        db[collection].insert(data)
       rescue Mongo::OperationFailure => error
         # Really mongo client?
         if error.message[/^11000[:]/]
           # Update because the id already exists
           update_data = data.dup
           update_data.delete(:_id)
-          @@db[collection].update({:_id => id}, update_data)
+          db[collection].update({:_id => id}, update_data)
         else
           return {:error => error.message}
         end
@@ -64,7 +62,7 @@ class StoreTasks
   end
 
   def delete(collection, id)
-    @@db[collection].remove('_id' => id)
+    db[collection].remove('_id' => id)
 
     QueryTasks.live_query_pool.updated_collection(collection, @channel)
   end

data/lib/volt/models/model_helpers.rb

@@ -1,5 +1,4 @@
 # A place for things shared between an ArrayModel and a Model
-
 module ModelHelpers
   def deep_unwrap(value)
     if value.is_a?(Model)
@@ -23,16 +22,16 @@ module ModelHelpers
 
   # Gets the class for a model at the specified path.
   def class_at_path(path)
-    if path && path.last == :[]
+    if path
       begin
-        # TODO: SECURITY on the back-end we need to check that the model class we're loading
-        # is coming from the models folder.
-
         # remove the _ and then singularize
-        klass_name = path[-2][1..-1].singularize.camelize
+        if path.last == :[]
+          klass_name = path[-2][1..-1].singularize.camelize
+        else
+          klass_name = path[-1][1..-1].singularize.camelize
+        end
 
-        klass_name = klass_name.camelize
-        klass = Object.send(:const_get, klass_name.to_sym)
+        klass = $page.model_classes[klass_name] || Model
       rescue NameError => e
         # Ignore exception, just means the model isn't defined
         klass = Model

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

@@ -31,7 +31,7 @@ module Persistors
       root_model.persistor.save_all
     end
 
-    def loaded
+    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 == []

data/lib/volt/page/page.rb

@@ -31,7 +31,7 @@ require 'volt/page/tasks'
 
 
 class Page
-  attr_reader :url, :params, :page, :templates, :routes, :events
+  attr_reader :url, :params, :page, :templates, :routes, :events, :model_classes
 
   def initialize
     @model_classes = {}
@@ -138,7 +138,7 @@ class Page
   end
 
   def add_model(model_name)
-    @model_classes[["*", "_#{model_name}"]] = Object.const_get(model_name.camelize)
+    @model_classes[model_name] = Object.const_get(model_name.camelize)
   end
 
   def add_template(name, template, bindings)

data/lib/volt/tasks/dispatcher.rb

@@ -19,7 +19,7 @@ class Dispatcher
         error = nil
       rescue => e
         # TODO: Log these errors better
-        puts "ERROR: #{e.inspect}"
+        puts e.inspect
         puts e.backtrace
         result = nil
         error = e

data/spec/models/model_spec.rb

@@ -1,12 +1,14 @@
+require 'spec_helper'
 require 'volt/models'
-require 'volt/reactive/dependency'
-require 'volt/reactive/computation'
 
 
 class TestItem < Model
+end
 
+class Item < Model
 end
 
+
 describe Model do
 
   it "should allow _ methods to be used to store values without predefining them" do
@@ -413,4 +415,22 @@ describe Model do
       @model = Model.new(nil, persistor: persistor)
     end
   end
+
+  if RUBY_PLATFORM != 'opal'
+    describe "class loading" do
+      it 'should load classes for models' do
+        $page = Page.new
+        $page.add_model('Item')
+
+        @model = Model.new
+
+        # Should return a buffer of the right type
+        expect(@model._items.buffer.class).to eq(Item)
+
+        # Should insert as the right type
+        @model._items << {_name: 'Item 1'}
+        expect(@model._items[0].class).to eq(Item)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: volt
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
 platform: ruby
 authors:
 - Ryan Stout
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-04 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor