volt 0.9.6 → 0.9.7.pre2

data/lib/volt/models/root_models/root_models.rb

@@ -1,3 +1,5 @@
+require 'volt/reactive/eventable'
+
 # When you get the root of a collection (.store, .page, etc...), it gives you
 # back a unique class depending on the collection.  This allows you to add
 # things to the root easily.
@@ -8,6 +10,10 @@
 
 # Create a model that is above all of the root models.
 class BaseRootModel < Volt::Model
+  # return the name of the repo
+  def repo_name
+    self.class.name.gsub(/Root$/, '').underscore
+  end
 end
 
 
@@ -19,6 +25,8 @@ end
 
 module Volt
   class RootModels
+    extend Eventable
+
     class_attribute :model_classes
     self.model_classes = []
 
@@ -31,6 +39,17 @@ module Volt
       BaseRootModel.send(:define_method, method_name) do
         get(method_name)
       end
+
+      trigger!('model_created', klass)
+    end
+
+    # Used mostly for testing, deletes a model
+    def self.remove_model_class(klass)
+      self.model_classes.reject! {|v| v == klass }
+    end
+
+    def self.clear_temporary
+      self.model_classes.reject! {|klass| klass.is_temporary }
     end
   end
 end

data/lib/volt/models/url.rb

@@ -9,7 +9,7 @@ module Volt
 
     # TODO: we need to make it so change events only trigger on changes
     reactive_accessor :scheme, :host, :port, :path, :query, :fragment
-    attr_accessor :router
+    attr_accessor :router, :routes_loader
 
     def initialize(router = nil)
       @router = router
@@ -67,8 +67,17 @@ module Volt
     # Full url rebuilds the url from it's constituent parts.
     # The params passed in are used to generate the urls.
     def url_for(params)
-      host_with_port = host
+      host_with_port = host || location.host
       host_with_port += ":#{port}" if port && port != 80
+      scheme = scheme || location.scheme
+
+      unless RUBY_PLATFORM == 'opal'
+        # lazy load routes and views on the server
+        if !@router && @routes_loader
+          # Load the templates
+          @routes_loader.call
+        end
+      end
 
       path, params = @router.params_to_url(params)
 

data/lib/volt/models/validations/validations.rb

@@ -10,6 +10,7 @@ require 'volt/models/validators/unique_validator'
 require 'volt/models/validators/type_validator'
 
 module Volt
+
   # Include in any class to get validation logic
   module Validations
     module ClassMethods
@@ -151,8 +152,10 @@ module Volt
       end.then do
         run_custom_validations
       end.then do
-        # Return the errors object
-        errors
+        if errors.size > 0
+          # Return the errors object
+          Promise.new.reject(errors)
+        end
       end
     end
 

data/lib/volt/models/validators/type_validator.rb

@@ -16,6 +16,17 @@ module Volt
 
       valid_type = false
       type_restrictions.each do |type_rest|
+        if type_rest == Volt::Boolean
+          if RUBY_PLATFORM == 'opal'
+            type_rest = ::Boolean
+          else
+            if value == true || value == false
+              valid_type = true
+              break
+            end
+          end
+        end
+
         if value.is_a?(type_rest)
           valid_type = true
           break

data/lib/volt/models/validators/unique_validator.rb

@@ -8,11 +8,11 @@ module Volt
           query = {}
           # Check to see if any other documents have this value.
           query[field_name.to_s] = value
-          query['id'] = { '$ne' => model.id }
+          model_id = model.id
 
           # Check if the value is taken
           # TODO: need a way to handle scope for unique
-          return Volt.current_app.store.get(model.path[-2]).where(query).first.then do |item|
+          return Volt.current_app.store.get(model.path[-2]).where(query) {|m| m.id !~ model_id }.first.then do |item|
             if item
               message = (args.is_a?(Hash) && args[:message]) || 'is already taken'
 

data/lib/volt/page/bindings/attribute_binding.rb

@@ -10,7 +10,11 @@ module Volt
       @getter         = getter
       @setter         = setter
 
-      setup
+      if RUBY_PLATFORM == 'opal'
+        setup
+      else
+        setup_server
+      end
     end
 
     def setup
@@ -62,6 +66,24 @@ module Volt
 
     end
 
+    unless RUBY_PLATFORM == 'opal'
+      # Does the setup during server side rendering
+      def setup_server
+        val = begin
+          @context.instance_eval(&@getter)
+        rescue => e
+          getter_fail(e)
+          ''
+        end
+
+        node = target.find_by_tag_id(binding_name)
+
+        if node
+          node.attributes[@attribute_name] = val
+        end
+      end
+    end
+
     def changed(event = nil)
       case @attribute_name
         when 'value'

data/lib/volt/page/targets/attribute_section.rb

@@ -60,6 +60,13 @@ module Volt
         end
       end
 
+      # Also copy the attribute bindings
+      bindings.each_pair do |name, binding|
+        if name.is_a?(String) && name[0..1] == 'id'
+          new_bindings[name] = binding
+        end
+      end
+
       return new_html.join(''), new_bindings
     end
 

data/lib/volt/page/targets/binding_document/component_node.rb

@@ -1,10 +1,11 @@
 require 'volt/page/targets/binding_document/html_node'
+require 'volt/page/targets/binding_document/tag_node'
 require 'volt/reactive/eventable'
 
 module Volt
-  # Component nodes contain an array of both HtmlNodes and ComponentNodes.
+  # Component nodes contain an array of HtmlNodes, TagNodes and ComponentNodes.
   # Instead of providing a full DOM API, component nodes are the branch
-  # nodes and html nodes are the leafs.  This is all we need to produce
+  # nodes and html/tag nodes are the leafs.  This is all we need to produce
   # the html from templates outside of a normal dom.
   class ComponentNode < BaseNode
     include Eventable
@@ -31,7 +32,8 @@ module Volt
     end
 
     def html=(html)
-      parts  = html.split(/(\<\!\-\- \$\/?[0-9]+ \-\-\>)/).reject { |v| v == '' }
+      tag_regex = /(\<[^\>]+\>)/
+      parts  = html.split(tag_regex).reject { |v| v == '' }
 
       # Clear current nodes
       @nodes = []
@@ -40,21 +42,27 @@ module Volt
 
       parts.each do |part|
         case part
-          when /\<\!\-\- \$[0-9]+ \-\-\>/
-            # Open
-            binding_id = part.match(/\<\!\-\- \$([0-9]+) \-\-\>/)[1].to_i
-
-            sub_node = ComponentNode.new(binding_id, current_node, @root || self)
-            current_node << sub_node
-            current_node = sub_node
-          when /\<\!\-\- \$\/[0-9]+ \-\-\>/
-            # Close
-            # binding_id = part.match(/\<\!\-\- \$\/([0-9]+) \-\-\>/)[1].to_i
-
-            current_node = current_node.parent
-          else
-            # html string
-            current_node << HtmlNode.new(part)
+        when /\<\!\-\- \$[0-9]+ \-\-\>/
+          # Open
+          binding_id = part.match(/\<\!\-\- \$([0-9]+) \-\-\>/)[1].to_i
+
+          sub_node = ComponentNode.new(binding_id, current_node, @root || self)
+          current_node << sub_node
+          current_node = sub_node
+        when /\<\!\-\- \$\/[0-9]+ \-\-\>/
+          # Close
+          # binding_id = part.match(/\<\!\-\- \$\/([0-9]+) \-\-\>/)[1].to_i
+
+          current_node = current_node.parent
+        when /^<\/[-!\:A-Za-z0-9_]+[^>]*>/
+          # end tag, just store it as html for performance
+          current_node << HtmlNode.new(part)
+        when /\<[^\>]+\>/
+          # start tag or unary
+          current_node << TagNode.new(part)
+        else
+          # html string
+          current_node << HtmlNode.new(part)
         end
       end
 
@@ -92,6 +100,24 @@ module Volt
       nil
     end
 
+    # TODO: This is an inefficient implementation since it has to walk the tree,
+    # we should make it so it caches nodes after the first walk (similar to
+    # how browsers handle getElementById)
+    def find_by_tag_id(tag_id)
+      @nodes.each do |node|
+        if node.is_a?(ComponentNode)
+          # Walk down nodes
+          val = node.find_by_tag_id(tag_id)
+          return val if val
+        elsif node.is_a?(TagNode)
+          # Found a matching tag
+          return node if node.tag_id == tag_id
+        end
+      end
+
+      nil
+    end
+
     def remove
       @nodes = []
 

data/lib/volt/page/targets/binding_document/tag_node.rb

@@ -0,0 +1,41 @@
+# The tag node represents an html tag with a binding id in it.  It provides an
+# api to change attribute values.
+
+require 'volt/page/targets/binding_document/base_node'
+
+module Volt
+  class TagNode < BaseNode
+    # We use some of the same parts from the sandlebars parser, but since this
+    # has to ship to the client, we only take the parts we need.
+    START_TAG  = /^<([-!\:A-Za-z0-9_]+)((?:\s+[\w\-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/
+    ATTRIBUTES = /([-\:A-Za-z0-9_]+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/
+
+    attr_reader :tag_id
+    attr_reader :attributes
+
+    def initialize(html)
+      tag = html.scan(START_TAG).first
+      @start_tag = tag[0]
+      @attributes = tag[1].scan(ATTRIBUTES).map do |match|
+        name = match[0]
+        value = match[1] || match[2] || match[3]
+
+        # Store the tag's id for quick lookup
+        if name == 'id'
+          @tag_id = value
+        end
+
+        [name, value]
+      end.to_h
+      @end_tag = tag[2]
+    end
+
+    def to_html
+      attr_str = @attributes.map do |key, value|
+        "#{key}=\"#{value}\""
+      end.join(' ')
+
+      "<" + [@start_tag, attr_str, @end_tag].reject(&:blank?).join(' ') + ">"
+    end
+  end
+end

data/lib/volt/page/tasks.rb

@@ -30,12 +30,12 @@ module Volt
 
     def received_message(name, promise_id, *args)
       case name
-        when 'added', 'removed', 'updated', 'changed'
-          notify_query(name, *args)
-        when 'response'
-          response(promise_id, *args)
-        when 'reload'
-          reload
+      when 'updated'
+        notify_updated(*args)
+      when 'response'
+        response(promise_id, *args)
+      when 'reload'
+        reload
       end
     end
 
@@ -57,6 +57,14 @@ module Volt
           Volt.logger.error('Task Response:')
           Volt.logger.error(error)
 
+          if error.is_a?(String)
+            klass, error = error.split(':', 2)
+
+            if (klass = Object.const_get(klass))
+              error = klass.new(error)
+            end
+          end
+
           promise.reject(error)
         else
           promise.resolve(result)
@@ -66,9 +74,9 @@ module Volt
 
     # Called when the backend sends a notification to change the results of
     # a query.
-    def notify_query(method_name, collection, query, *args)
+    def notify_updated(collection, query, *args)
       query_obj = Persistors::ArrayStore.query_pool.lookup(collection, query)
-      query_obj.send(method_name, *args)
+      query_obj.updated(*args)
     end
 
     def reload

data/lib/volt/queries/live_query.rb

@@ -0,0 +1,109 @@
+# Tracks a channel and a query on a collection.  Alerts
+# the listener when the data in the query changes.
+#
+# has_many QuerySubscriptions
+
+require 'volt/queries/query_diff'
+require 'volt/queries/query_runner'
+
+module Volt
+  class LiveQuery
+    attr_reader :volt_app, :pool, :collection, :query, :last_data
+
+    def initialize(volt_app, pool, data_store, collection, query)
+      @volt_app = volt_app
+      @pool = pool
+      @collection = collection
+      @query = query
+
+      @query_runner = QueryRunner.new(data_store, collection, query)
+      # Grab the associations from the query runner
+      @associations = @query_runner.associations
+
+      @query_subscriptions = {}
+      @data_store = data_store
+
+      # initial run
+      @last_data = run
+    end
+
+    # Decrements the count on the LiveQueryPool.  This is called when a
+    # QuerySubscrption no longer is using this LiveQuery.
+    def remove_reference
+      @pool.remove(@collection, @query)
+    end
+
+    def query_subscription_for_channel(channel)
+      @query_subscriptions[channel] ||= begin
+        QuerySubscription.new(self, channel)
+      end
+    end
+
+    def remove_query_subscription(channel)
+      @query_subscriptions.delete(channel)
+
+      if @query_subscriptions.empty?
+        # No more query_subscriptions, this means no one is using this query,
+        # remove it from the pool
+
+        # Reduce the count on the live query
+        begin
+          remove_reference
+        rescue Volt::GenericPoolDeleteException => e
+          # ignore
+          Volt.logger.error e.inspect
+        end
+      end
+    end
+
+    def run
+      @query_runner.run
+    end
+
+
+    def update(skip_channel=nil)
+      new_data = run
+
+      if new_data.is_a?(Array)
+        # Diff the new data
+        diff = QueryDiff.new(@last_data, @associations).run(new_data)
+
+        notify_updated(skip_channel, diff)
+      else
+        # When working with queries that return a value, we don't diff, we just
+        # push an update operation
+        notify_updated(skip_channel, {'u' => new_data})
+      end
+
+      @last_data = new_data
+    end
+
+    def notify_updated(skip_channel, diff)
+      # TODO: We should be able to mostly skip our own channel
+      # notify!(skip_channel) do |query_subscription|
+      notify! do |query_subscription|
+        query_subscription.notify_updated(diff)
+      end
+    end
+
+    # Runs through each query subscription, yielding all except the optional
+    # one with skip_channel.
+
+    def notify!(skip_channel = nil)
+      query_subs = @query_subscriptions
+      if skip_channel
+        query_subs = query_subs.reject { |channel, query_sub| channel == skip_channel }
+      end
+
+      query_subs.values.each do |query_sub|
+        yield(query_sub)
+      end
+    end
+
+
+    def inspect
+      "<#{self.class} #{@collection}: #{@query.inspect}>"
+    end
+
+  end
+end