volt 0.4.14 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 905771711030eddcecc7a47be637a9a32d935718
-  data.tar.gz: cb0e6dcf3ba7a19bcc1544069d209a3f8508a023
+  metadata.gz: a1b1635ef6a0d61f2fd334870249bffd6a032a55
+  data.tar.gz: 761fe764d63b32d5ce1e65b482b4094d4a4f12fa
 SHA512:
-  metadata.gz: 8ffded87588ef61e162316878a4ef29d26c0d61d1d85f480cc48ab169c16e5ee938cf8f80ffd8cdb1171679376cb2f423d5389eacd47919660e5e4bfb8879669
-  data.tar.gz: 99d9f82057294e409f44bc061a848caf780ecaf3967e4b211265837d11c1cc4bdc66afbc5505c4a74c054af7b2805756cde8f6a56040fd2d7a265dfead1454f7
+  metadata.gz: a8c3e07939e8f5f22104bb0e16f30fa4dfb5270741341d31239aa0d4c746089134545a6cfc4214da7915fd6581d191113a8c0560bfee5f3b10c225242a9db17f
+  data.tar.gz: 6fcd81d3d469133e8552869c03a86ca1be4902608e5f825ce580c98716e5a4e8d72be35afafb0aad99097195abf16f6a73e49f03fa94bc08190a91d3377a8696

data/Readme.md

@@ -62,6 +62,7 @@ You can access the volt console with:
 
 1. [Rendering](#rendering)
   1. [Reactive Values](#reactive-values)
+    1. [ReactiveValue Gotchyas](#reactivevalue-gotchyas)
   2. [Bindings](#bindings)
     1. [Content Binding](#content-binding)
     2. [If Binding](#if-binding)
@@ -70,6 +71,7 @@ You can access the volt console with:
 2. [Models](#models)
   1. [Reactive Models](#reactive-models)
   2. [Model Events](#model-events)
+  3. [Provided Collections](#provided-collections)
 3. [Components](#components)
   1. [Assets](#assets)
   2. [Component Generator](#component-generator)
@@ -166,6 +168,20 @@ Lastly, we can also pass in other reactive value's as arguments to methods on a
     # => C changed
 ```
 
+### ReactiveValue Gotchya's
+
+There are a few simple things to keep in mind with ReactiveValue's.  In order to make them mostly compatible with other ruby objects, a two methods do not return another ReactiveValue.
+
+    to_s and inspect
+
+If you want these to be used reactively, see the section on [with](#with)
+
+Also, due to a small limitation in ruby, ReactiveValue's always are truthy.  See the [truthy checks](#truthy-checks-true-false-or-and-and) section on how to check for truth.
+
+### Current Status
+
+NOTE: currently ReactiveValue's are not complete.  At the moment, they do not handle methods that are passed blocks (or procs, lambda's).  This is planned, but not complete.  At the moment you can use [with](#with) to accomplish similar things.
+
 ### Truthy Checks: .true?, .false?, .or, and .and
 
 Because a method on a reactive value always returns another reactive value, and because only nil and false are false in ruby, we need a way to check if a ReactiveValue is truthy in our code.  The easiest way to do this is by calling .true? on it.  It will return a non-wrapped boolean.  .nil? and .false? do as you would expect.
@@ -189,7 +205,16 @@ Simply use:
 
 ### With
 
-... TODO: ...
+Normally when you want to have some a value that depends on another value, but transforms it somehow, you simply call your transform method on the ReactiveValue.  However sometimes the transform is not directly on the ReactiveValue's object.
+
+You can call .with on any ReactiveValue.  .with will return a new ReactiveValue that depends on the current ReactiveValue.  .with takes a block, the first argument to the block will be the cur value of the ReactiveValue you called with on.  Any additional arguments to with will be passed in after the first one.  If you pass another ReactiveValue as an argument to .with, the returned ReactiveValue will depend on the argument ReactiveValue as well, and the block will receive the arguments cur value.
+
+```ruby
+    a = ReactiveValue.new(5)
+    b = a.with {|v| v + 10 }
+    b.cur
+    # => 15
+```
 
 ## Bindings
 
@@ -311,7 +336,9 @@ You can also append to a model if its not defined yet.
 
 An array model will automatically be setup to contain the items appended.
 
-Above I mentioned that Volt comes with many different models accessable from a controller.  Each stores in a different location.
+## Provided Collections
+
+Above I mentioned that Volt comes with many default collection models accessable from a controller.  Each stores in a different location.
 
 | Name      | Storage Location                                                          |
 |-----------|---------------------------------------------------------------------------|
@@ -331,6 +358,7 @@ Because all models provided by Volt are wrapped in a ReactiveValue, you can regi
 
 Models trigger events when their data is updated.  Currently models emit three events: changed, added, and removed.  For example:
 
+```ruby
     model = Model.new
     
     model._name.on('changed') { puts 'name changed' }
@@ -344,7 +372,7 @@ Models trigger events when their data is updated.  Currently models emit three e
     model._items.on('removed') { puts 'item removed' }
     model._items.delete_at(0)
     # => item removed
-
+```
 
 ## Automatic Model Conversion
 
@@ -352,6 +380,7 @@ Models trigger events when their data is updated.  Currently models emit three e
 
 For convience, when placing a hash inside of another model, it is automatically converted into a model.  Models are similar to hashes, but provide support for things like persistance and triggering reactive events.
 
+```ruby
     user = Model.new
     user._name = 'Ryan'
     user._profiles = {
@@ -365,7 +394,7 @@ For convience, when placing a hash inside of another model, it is automatically
     # => "http://www.twitter.com/ryanstout"
     user._profiles.class
     # => Model
-    
+```  
     
 Models are accessed differently from hashes.  Instead of using model[:symbol] to access, you call a method model.method_name.  This provides a dynamic unified store where setters and getters can be added without changing any access code.
 
@@ -373,6 +402,7 @@ Models are accessed differently from hashes.  Instead of using model[:symbol] to
 
 Arrays inside of models are automatically converted to an instance of ArrayModel.  ArrayModels behave the same as a normal Array except that they can handle things like being bound to backend data and triggering reactive events.
 
+```ruby
     model = Model.new
     model._items << {_name: 'item 1'}
     model._items.class
@@ -381,11 +411,12 @@ Arrays inside of models are automatically converted to an instance of ArrayModel
     model._items[0].class
     # => Model
     model._items[0]
-    
+```    
 
 
 To convert a Model or an ArrayModel back to a normal hash, call .to_h or .to_a respectively.  To convert them to a JavaScript Object (for passing to some JavaScript code), call .to_n (to native).
 
+```ruby
     user = Model.new
     user._name = 'Ryan'
     user._profiles = {
@@ -398,26 +429,47 @@ To convert a Model or an ArrayModel back to a normal hash, call .to_h or .to_a r
     
     items = ArrayModel.new([1,2,3,4])
     items
+```
 
 # Controllers
 
-A controller can be any class in Volt, however it is common to have that class inherit from ModelController.  A model controller lets you specify a model that the controller works off of.  This is a common pattern in Volt.  To assign the current model, simply set @model to one of the provided models in the initializer.
+A controller can be any class in Volt, however it is common to have that class inherit from ModelController.  A model controller lets you specify a model that the controller works off of.  This is a common pattern in Volt.  To assign the current model for a controller, simply call the model method passing in one of the following:
 
+1. A symbol representing the name of a provided collection model:
+
+```ruby
+    class TodosController < ModelController
+      model :page
+  
+      # ...
+    end
+```
+
+This can also be done at anytime on the controller instance:
+    
+```ruby
     class TodosController < ModelController
       def initialize
-        @model = page
+        model :page
       end
     end
+```
+    
+See the [provided collections](#provided-collections) section for a list of the available collection models.
+
+You can also provide your own object to model.
 
-Now any methods not defined on the TodosController will fall through to the @model.  All views in views/{controller_name} will have this controller as the target for any ruby run in their bindings.  This means that calls on self (implicit or with self.) will have the model as their target (after calling through the controller).  This lets you add methods to the controller to control how the model is handled.
+Now any methods not defined on the TodosController will fall through to the provided model.  All views in views/{controller_name} will have this controller as the target for any ruby run in their bindings.  This means that calls on self (implicit or with self.) will have the model as their target (after calling through the controller).  This lets you add methods to the controller to control how the model is handled.
 
 Controllers in the app/home component do not need to be namespaced, all other components should namespace controllers like so:
 
+```ruby
     module Auth
       class LoginController < ModelController
         # ...
       end
     end
+```
 
 Here "auth" would be the component name.
 
@@ -428,7 +480,7 @@ Apps are made up of Components.  Each folder under app/ is a component.  When yo
 You can also use controls (see below) from one component in another.  To do this, you must require the component from the component you wish to use them.  This can be done in the ```config/dependencies.rb``` file.  Just put
 
 ```ruby
-component 'component_name'
+    component 'component_name'
 ```
 
 in the file.
@@ -437,8 +489,10 @@ Dependencies act just like require in ruby, but for whole components.
 
 Sometimes you may need to include an externally hosted JS file from a component.  To do this, simply do the following in the dependencies.rb file:
 
+```ruby
     javascript_file 'http://code.jquery.com/jquery-2.0.3.min.js'
     css_file '//netdna.bootstrapcdn.com/bootstrap/3.0.3/css/bootstrap.min.css'
+```
     
 Note above though that jquery and bootstrap are currently included by default.  Using javascript_file and css_file will be mixed in with your component assets at the correct locations according to the order they occur in the dependencies.rb files.
 
@@ -456,7 +510,9 @@ Components can easily be shared as a gem.  Volt provides a scaffold for componen
 
 While developing, you can use the component by placing the following in your Gemfile:
 
-    gem 'volt-{component_name}', path: '/path/to/folder/with/component'
+```ruby
+gem 'volt-{component_name}', path: '/path/to/folder/with/component'
+```
 
 Once the gem is ready, you can release it to ruby gems with:
 
@@ -537,7 +593,9 @@ This means that routes in volt have to go both from url to params and params to
 
 Routes are specified on a per-component basis in the config/routes.rb file.  Routes simply map from url to params.
 
+```ruby
     get "/todos", _controller: 'todos'
+```
 
 Routes take two arguments, a path, and a params hash.  When a new url is loaded and the path is matched on a route, the params will be set to the params provided for that route.
 
@@ -547,7 +605,9 @@ When the params are changed, the url will be set to the path for the route that'
 
 Route path's can also contain variables similar to bindings.
 
+```ruby
     get "/todos/{_index}", _controller: 'todos'
+```
     
 In the case above, if any url matches /todos/*, (where * is anything but a slash), it will be the active route. params._controller would be set to 'todos', and params._index would be set to the value in the path.
 

data/VERSION

@@ -1 +1 @@
-0.4.14
+0.4.15

data/lib/volt/controllers/model_controller.rb

@@ -1,14 +1,10 @@
-class ModelController
-  def initialize
-    self.model = @@default_model
-  end
-  
+class ModelController  
   def self.model(val)
     @@default_model = val
   end
   
   # Sets the current model on this controller
-  def model=(val)
+  def model(val)
     if val.is_a?(Symbol) || val.is_a?(String)
       collections = [:page, :store, :params]
       if collections.include?(val.to_sym)
@@ -16,9 +12,22 @@ class ModelController
       else
         raise "#{val} is not the name of a valid model, choose from: #{collections.join(', ')}"
       end
-    else
+    elsif model
       @model = model
+    else
+      raise "model can not be #{model.inspect}"
+    end
+  end
+  
+  def self.new(*args, &block)
+    inst = self.allocate
+    if @@default_model
+      inst.model(@@default_model || :page)
     end
+    
+    inst.initialize(*args, &block)
+    
+    return inst
   end
   
   def page

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: volt
 version: !ruby/object:Gem::Version
-  version: 0.4.14
+  version: 0.4.15
 platform: ruby
 authors:
 - Ryan Stout
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2014-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor