volt 0.8.27.beta6 → 0.8.27.beta7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 664d87e842c6c03b483345d4771a71d72ad1567e
-  data.tar.gz: 8e82d85deddbc176c6cda90317b5a005f63f918d
+  metadata.gz: a8f7ccdc9801cf342901b77cf83b2091af34975f
+  data.tar.gz: a4f0dd2b28f09f2423fa602eb45c9935d422840c
 SHA512:
-  metadata.gz: a8e1ffac496bf1ead1564de04a4dac9a48ccbc68776d5db3fa0b9bb8ed2fcb7b10a31c9e5869f1f521f6b0d0796c37937a041a4efbe398d674e0884cbf93e3c2
-  data.tar.gz: 5e54e036809c3d61f75de5a80f01658d46ef572aacc0193c45498a97b92c41dc665e2b761dcc848f7206a21240b18698557cc2df90be43cdf36b39b4594cce9c
+  metadata.gz: 94607eb5080e4809be8a505e2a6e0c2602a887346de86c335e7177b1230ed75048091a9d1751d1b3d30e1960bb242b385966c58eb1b13bd52f03a05b253f3069
+  data.tar.gz: bb4d64bc6781e697e646f53054c305499fcd4434e10c8bfde661c46fb0fef31a3a0bda791818c783bc5631aacfadd156486baddb0537a4868dd597056f91708c

data/CHANGELOG.md

@@ -2,11 +2,11 @@
 
 ## 0.8.27 - WIP
 ### Added
-- _'s are no longer required for route constraints (so just use ```controller: 'main', action: 'index'``` now)
+- added has_many and belongs_to on models.  See docs.
+- you can now serve http/rest from Volt.  Thanks to @jfahrer for his great work.  Docs coming soon.
 - fixed generated component code
 - added .order for sorting on the data store (since .sort is a ruby Enum method)
-- changed .find to .where to not conflict with ruby Enum's .find
-- added .fetch and .fetch_first for waiting on store model loads
+- calling .then on ArrayModels has been changed to calling .fetch and .fetch_first.  These both return a promise, and take an optional block
 - added .sync for synchronusly waiting on promises on the server only
 - added the ability to pass content into tags: (https://github.com/voltrb/docs/blob/master/en/docs/yield_binding.md)
 - the {action}_remove method had been changed to before_{action}_remove and after_{action}_remove to provide more hooks and a clearer understanding of when it is happening.
@@ -18,9 +18,22 @@
 - refactored TemplateBinding, moved code into ViewLookupForPath (SRP)
 - reserved fields now get a warning in models
 - bindings will now resolve any values that are promises. (currently only content and attribute, if, each, and template coming soon)
+- ```store``` is now available inside of specs.  If it is accessed in a spec, the database will be cleaned after the spec.
+- ```the_page``` is a shortcut to the page collection inside of specs.  (Unfortunately, ```page``` is used by capybara, so for now we're using ```the_page```, we'll find a better solution in the future.)
 
 ### Changed
+- model attributes no longer return NilModels.  Instead they just return nil.  You can however add an ! to the end to "expand" the model to an empty model.
+
+```page._new_todo # => now returns nil```
+
+```page._new_todo! # => returns an empty model```
+
+So if you wanted to use a property on ```_new_todo``` without initializing ```_new_todo```, you could add the ! to the lookup.
+- Volt.user has been renamed to Volt.current_user so its clearer what it returns
+- _'s are no longer required for route constraints (so just use ```controller: 'main', action: 'index'``` now)
 - the underlying way queries are normalized and passed to the server has changed (no external api changes)
+- changed .find to .where to not conflict with ruby Enum's .find
+- Volt::TaskHandler is now Volt::Task
 
 ## 0.8.24 - 2014-12-05
 ### Added

data/VERSION

@@ -1 +1 @@
-0.8.27.beta6
+0.8.27.beta7

data/app/volt/models/user.rb

@@ -21,7 +21,7 @@ module Volt
       deny :hashed_password
 
       # Deny all if this isn't the owner
-      deny if !_id == Volt.user_id && !new?
+      deny if !_id == Volt.current_user_id && !new?
     end
 
     if RUBY_PLATFORM == 'opal'

data/app/volt/tasks/query_tasks.rb

@@ -1,7 +1,7 @@
 require_relative 'live_query/data_store'
 require_relative 'live_query/live_query_pool'
 
-class QueryTasks < Volt::TaskHandler
+class QueryTasks < Volt::Task
   @@live_query_pool = LiveQueryPool.new(DataStore.new)
   @@channel_live_queries = {}
 
@@ -23,7 +23,7 @@ class QueryTasks < Volt::TaskHandler
       # For requests from the client (with @channel), we track the channel
       # so we can send the results back.  Server side requests don't stay live,
       # they simply return to :dirty once the query is issued.
-      @channel.user_id = Volt.user_id
+      @channel.user_id = Volt.current_user_id
 
       live_query.add_channel(@channel)
     end

data/app/volt/tasks/store_tasks.rb

@@ -1,7 +1,7 @@
 require 'mongo'
 require 'volt/models'
 
-class StoreTasks < Volt::TaskHandler
+class StoreTasks < Volt::Task
   def initialize(channel = nil, dispatcher = nil)
     @channel = channel
     @dispatcher = dispatcher
@@ -35,8 +35,12 @@ class StoreTasks < Volt::TaskHandler
   def save(collection, path, data)
     data = data.symbolize_keys
     promise = nil
-    Volt::Model.no_validate do
-      promise = load_model(collection, path, data)
+
+    # Don't check the permissions when we load the model, since we want all fields
+    Volt.skip_permissions do
+      Volt::Model.no_validate do
+        promise = load_model(collection, path, data)
+      end
     end
 
     # On the backend, the promise is resolved before its returned, so we can
@@ -61,7 +65,13 @@ class StoreTasks < Volt::TaskHandler
 
   def delete(collection, id)
     # Load the model, then call .destroy on it
-    store.send(:"_#{collection}").where(_id: id).fetch_first do |model|
+    query = nil
+
+    Volt.skip_permissions do
+      query = store.send(:"_#{collection}").where(_id: id)
+    end
+
+    query.fetch_first do |model|
       if model
         if model.can_delete?
           db[collection].remove('_id' => id)

data/app/volt/tasks/user_tasks.rb

@@ -1,4 +1,4 @@
-class UserTasks < Volt::TaskHandler
+class UserTasks < Volt::Task
   # Login a user, takes a login and password.  Login can be either a username
   # or an e-mail based on Volt.config.public.auth.use_username
   def login(login, password)

data/lib/volt/controllers/http_controller.rb

@@ -0,0 +1,60 @@
+require 'volt/server/rack/http_response_header'
+require 'volt/server/rack/http_response_renderer'
+
+module Volt
+  # Allow you to create controllers that act as http endpoints
+  class HttpController
+    attr_accessor :response_body
+    attr_reader :params, :response_headers, :request
+
+    # Initialzed with the params parsed from the route and the HttpRequest
+    def initialize(params, request)
+      @response_headers = HttpResponseHeader.new
+      @response_body = []
+      @request = request
+      @params = params.symbolize_keys.merge(request.params)
+    end
+
+    def perform(action)
+      # TODO: before actions
+      send(action.to_sym)
+      # TODO: after actions / around actions
+      respond
+    end
+
+    private
+
+    def store
+      $page.store
+    end
+
+    def head(status, additional_headers = {})
+      @response_status = status
+      response_headers.merge!(additional_headers)
+    end
+
+    def redirect_to(target, status = :found)
+      head(status, location: target)
+    end
+
+    def render(content)
+      status = content.delete(:status) || :ok
+      body, additional_headers = HttpResponseRenderer.new.render(content)
+      head(status, additional_headers)
+      response_body << body
+    end
+
+    def respond
+      Rack::Response.new(response_body, response_status, response_headers)
+    end
+
+    # Get the http status code as integer
+    def response_status
+      if @response_status.is_a?(Symbol)
+        Rack::Utils::SYMBOL_TO_STATUS_CODE[@response_status]
+      else
+        @response_status.try(:to_i) || 200
+      end
+    end
+  end
+end

data/lib/volt/controllers/model_controller.rb

@@ -108,7 +108,11 @@ module Volt
 
     # Change the url params, similar to redirecting to a new url
     def go(url)
-      self.url.parse(url)
+      # We might be in the rendering loop, so wait until the next tick before
+      # we change the url
+      Timers.next_tick do
+        self.url.parse(url)
+      end
     end
 
     def page

data/lib/volt/extra_core/string.rb

@@ -35,6 +35,12 @@ class String
     gsub('_', ' ').split(' ').map(&:capitalize).join(' ')
   end
 
+  def headerize
+    split(/[_-]/)
+      .map { |new_str| new_str[0].capitalize + new_str[1..-1] }
+      .join('-')
+  end
+
   def plural?
     # TODO: Temp implementation
     pluralize == self

data/lib/volt/models/array_model.rb

@@ -82,7 +82,10 @@ module Volt
       if @persistor
         promise = @persistor.added(model, @array.size - 1)
         if promise && promise.is_a?(Promise)
-          return promise.fail do |err|
+          return promise.then do
+            # return the model
+            model
+          end.fail do |err|
             # remove from the collection because it failed to save on the server
             @array.delete(model)
 
@@ -95,7 +98,8 @@ module Volt
           end
         end
       else
-        nil
+        # Return this model
+        model
       end
     end
 

data/lib/volt/models/associations.rb

@@ -21,7 +21,7 @@ module Volt
             # The key will be "{this class name}_id"
             remote_key_name ||= :"#{path[-2].singularize}_id"
 
-            root.send(:"_#{method_name.pluralize}").where(remote_key_name => id)
+            root.send(:"_#{method_name.pluralize}!").where(remote_key_name => id)
           end
         end
       end

data/lib/volt/models/buffer.rb

@@ -1,6 +1,10 @@
 module Volt
   module Buffer
-    def save!
+    # Save saves the contents of a buffer to the save_to location.  If the buffer is new, it will create a new
+    # model to save to.  Otherwise it will be an existing model.  Save returns a promise that may fail with
+    # validation errors from the server (or the client).  You can also pass a block as a shortcut to calling
+    # ```.save!.then do```
+    def save!(&block)
       # TODO: this shouldn't need to be run, but if no attributes are assigned, then
       # if needs to be run.  Maybe there's a better way to handle it.
       validate!
@@ -8,6 +12,8 @@ module Volt
       # Get errors from validate
       errors = self.errors.to_h
 
+      result = nil
+
       if errors.size == 0
         save_to = options[:save_to]
         if save_to
@@ -19,7 +25,7 @@ module Volt
             promise = save_to.assign_attributes(attributes)
           end
 
-          return promise.then do |new_model|
+          result = promise.then do |new_model|
             # The main model saved, so mark the buffer as not new
             @new = false
 
@@ -42,8 +48,13 @@ module Volt
         end
       else
         # Some errors, mark all fields
-        promise_for_errors(errors)
+        result = promise_for_errors(errors)
       end
+
+      # If passed a block, call then on it with the block.
+      result = result.then(&block) if block
+
+      return result
     end
 
     # When errors come in, we mark all fields and return a rejected promise.

data/lib/volt/models/model.rb

@@ -188,7 +188,12 @@ module Volt
           # Assigning an attribute without the =
           set(method_name[0..-2], args[0], &block)
         else
-          get(method_name)
+          # If the method has an ! on the end, then we assign an empty
+          # collection if no result exists already.
+          expand = (method_name[-1] == '!')
+          method_name = method_name[0..-2] if expand
+
+          get(method_name, expand)
         end
       else
         # Call on parent
@@ -198,7 +203,6 @@ module Volt
 
     # Do the assignment to a model and trigger a changed event
     def set(attribute_name, value, &block)
-      self.expand!
       # Assign, without the =
       attribute_name = attribute_name.to_sym
 
@@ -227,13 +231,15 @@ module Volt
         # Save the changes
         run_changed(attribute_name) unless Volt.in_mode?(:no_change_tracking)
       end
+
+      new_value
     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 get(attr_name)
+    def get(attr_name, expand=false)
       # Reading an attribute, we may get back a nil model.
       attr_name = attr_name.to_sym
 
@@ -242,31 +248,29 @@ module Volt
       # Track that something is listening
       @root_dep.depend
 
+      # 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)
-
         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!
-          `});`
+        # If we're expanding, or the get is for a collection, in which
+        # case we always expand.
+        if expand || attr_name.plural?
+          new_value = read_new_model(attr_name)
+
+          # A value was generated, store it
+          if new_value
+            # Assign directly.  Since this is the first time
+            # we're loading, we can just assign.
+            set(attr_name, new_value)
+          end
+
+          return new_value
         else
-          @size_dep.changed!
+          return nil
         end
-
-        # Depend on attribute
-        @deps.depend(attr_name)
-        return new_model
       end
     end
 
@@ -280,10 +284,11 @@ module Volt
         return @persistor.read_new_model(method_name)
       else
         opts = @options.merge(parent: self, path: path + [method_name])
+
         if method_name.plural?
           return new_array_model([], opts)
         else
-          return new_model(nil, opts)
+          return new_model({}, opts)
         end
       end
     end
@@ -300,43 +305,6 @@ module Volt
       ArrayModel.new(attributes, options)
     end
 
-    # If this model is nil, it makes it into a hash model, then
-    # sets it up to track from the parent.
-    def expand!
-      if attributes.nil?
-        @attributes = {}
-        if @parent
-          @parent.expand!
-
-          @parent.send(:"_#{@path.last}=", self)
-        end
-      end
-    end
-
-    # Initialize an empty array and append to it
-    def <<(value)
-      if @parent
-        @parent.expand!
-      else
-        fail 'Model data should be stored in sub collections.'
-      end
-
-      # Grab the last section of the path, so we can do the assign on the parent
-      path   = @path.last
-      result = @parent.send(path)
-
-      if result.nil?
-        # If this isn't a model yet, instantiate it
-        @parent.send(:"#{path}=", new_array_model([], @options))
-        result = @parent.send(path)
-      end
-
-      # Add the new item
-      result << value
-
-      nil
-    end
-
     def inspect
       Computation.run_without_tracking do
         str = "<#{self.class}:#{object_id}"

data/lib/volt/models/permissions.rb

@@ -4,7 +4,7 @@ module Volt
     # The permissions module provides helpers for working with Volt permissions.
     module Permissions
       module ClassMethods
-        # Own by user requires a logged in user (Volt.user) to save a model.  If
+        # Own by user requires a logged in user (Volt.current_user) to save a model.  If
         # the user is not logged in, an validation error will occur.  Once created
         # the user can not be changed.
         #
@@ -13,7 +13,7 @@ module Volt
           # When the model is created, assign it the user_id (if the user is logged in)
           on(:new) do
             # Only assign the user_id if there isn't already one and the user is logged in.
-            if _user_id.nil? && !(user_id = Volt.user_id).nil?
+            if _user_id.nil? && !(user_id = Volt.current_user_id).nil?
               send(:"_#{key}=", user_id)
             end
           end
@@ -102,13 +102,13 @@ module Volt
       end
 
       # owner? can be called on a model to check if the currently logged
-      # in user (```Volt.user```) is the owner of this instance.
+      # in user (```Volt.current_user```) is the owner of this instance.
       #
       # @param key [Symbol] the name of the attribute where the user_id is stored
       def owner?(key=:user_id)
         # Lookup the original user_id
         owner_id = was(key) || send(:"_#{key}")
-        owner_id != nil && owner_id == Volt.user_id
+        owner_id != nil && owner_id == Volt.current_user_id
       end
 
       # Returns boolean if the model can be deleted