volt 0.7.1 → 0.7.2

data/lib/volt/reactive/reactive_value.rb

@@ -3,8 +3,8 @@ require 'volt/reactive/reactive_tags'
 require 'volt/reactive/string_extensions'
 require 'volt/reactive/array_extensions'
 require 'volt/reactive/reactive_array'
-require 'volt/reactive/object_tracker'
 require 'volt/reactive/destructive_methods'
+require 'volt/reactive/reactive_generator'
 
 class Object
   def cur
@@ -29,10 +29,11 @@ class ReactiveValue < BasicObject
   # :methods- needs to return a straight up array to work with irb tab completion
   # :eql?   - needed for .uniq to work correctly
   # :to_ary - in some places ruby expects to get an array back from this method
-  SKIP_METHODS = [:hash, :methods, :eql?, :respond_to?, :respond_to_missing?, :to_ary, :to_int]#, :instance_of?, :kind_of?, :to_s, :to_str]
+  SKIP_METHODS = [:object_id, :hash, :methods, :eql?, :respond_to?, :respond_to_missing?, :to_ary, :to_int]#, :instance_of?, :kind_of?, :to_s, :to_str]
 
   def initialize(getter, setter=nil, scope=nil)
-    @reactive_manager = ::ReactiveManager.new(getter, setter, scope)
+    @reactive_manager = ::ReactiveManager.new(self, getter, setter, scope)
+    # @reactive_cache = {}
   end
 
   def reactive?
@@ -42,7 +43,7 @@ class ReactiveValue < BasicObject
   # Proxy methods to the ReactiveManager.  We want to have as few
   # as possible methods on reactive values, so all other methods
   # are forwarded to the object the reactive value points to.
-  [:cur, :cur=, :deep_cur, :on, :trigger!, :trigger_by_scope!].each do |method_name|
+  [:cur, :cur=, :deep_cur, :on, :trigger!, :trigger_by_scope!, :with].each do |method_name|
     define_method(method_name) do |*args, &block|
       @reactive_manager.send(method_name, *args, &block)
     end
@@ -80,6 +81,9 @@ class ReactiveValue < BasicObject
       method_name, *args = args
     end
 
+    # result = @reactive_cache[[method_name, args.map(&:object_id)]]
+    # return result if result
+
     # For some methods, we pass directly to the current object.  This
     # helps ReactiveValue's be well behaved ruby citizens.
     # Also skip if this is a destructive method
@@ -109,6 +113,11 @@ class ReactiveValue < BasicObject
 
     # result = result.with(block_reactives) if block
 
+    # if args.size == 0 || method_name == :[]
+      # puts "STORE: #{method_name} - #{args.inspect}"
+      # @reactive_cache[[method_name, args.map(&:object_id)]] = result
+    # end
+
     return result
   end
 
@@ -135,13 +144,10 @@ class ReactiveValue < BasicObject
   # end
 
   def respond_to_missing?(name, include_private=false)
+    puts "RT"
     cur.respond_to?(name)
   end
 
-  def with(*args, &block)
-    return @reactive_manager.with(*args, &block)
-  end
-
   def inspect
     "@#{cur.inspect}"
   end
@@ -187,58 +193,14 @@ class ReactiveValue < BasicObject
   end
 end
 
-class ReactiveGenerator
-  # Takes a hash and returns a ReactiveValue that depends on
-  # any ReactiveValue's inside of the hash (or children).
-  def self.from_hash(hash, skip_if_no_reactives=false)
-    reactives = find_reactives(hash)
-
-    if skip_if_no_reactives && reactives.size == 0
-      # There weren't any reactives, we can just use the hash
-      return hash
-    else
-      # Create a new reactive value that listens on all of its
-      # child reactive values.
-      value = ReactiveValue.new(hash)
-
-      reactives.each do |child|
-        value.reactive_manager.add_parent!(child)
-      end
-
-      return value
-    end
-  end
-
-  # Recursively loop through the data, returning a list of all
-  # reactive values in the hash, array, etc..
-  def self.find_reactives(object)
-    found = []
-    if object.reactive?
-      found << object
-
-      found += find_reactives(object.cur)
-    elsif object.is_a?(Array)
-      object.each do |item|
-        found += find_reactives(item)
-      end
-    elsif object.is_a?(Hash)
-      object.each_pair do |key, value|
-        found += find_reactives(key)
-        found += find_reactives(value)
-      end
-    end
-
-    return found.flatten
-  end
-end
-
 class ReactiveManager
   include ::Events
 
   attr_reader :scope, :parents
 
   # When created, ReactiveValue's get a getter (a proc)
-  def initialize(getter, setter=nil, scope=nil)
+  def initialize(reactive_value, getter, setter=nil, scope=nil)
+    @reactive_value = reactive_value
     @getter = getter
     @setter = setter
     @scope = scope
@@ -246,6 +208,10 @@ class ReactiveManager
     @parents = []
   end
 
+  def reactive_value
+    @reactive_value
+  end
+
   def reactive?
     true
   end
@@ -259,31 +225,28 @@ class ReactiveManager
   end
 
 
-  def event_added(event, scope, first)
+  def event_added(event, scope, first, first_for_event)
     # When the first event is registered, we need to start listening on our current object
     # for it to publish events.
-    object_tracker.enable! if first
+
+    update_followers if first
   end
 
-  def event_removed(event, last)
+  def event_removed(event, last, last_for_event)
     # If no one is listening on the reactive value, then we don't need to listen on our
     # current object for events, because no one cares.
-    object_tracker.disable! if @listeners.size == 0
-  end
 
-  def object_tracker
-    @object_tracker ||= ::ObjectTracker.new(self)
+    remove_followers if last
   end
 
 
   # Fetch the current value
-  def cur
-    # @@cur_count ||= 0
-    # @@cur_count += 1
-    # puts "Cur: #{@@cur_count}"# if @@cur_count % 100 == 0
-    # if ObjectTracker.cache_version == @cached_version
-    #   return @cached_obj
-    # end
+  def cur(shallow=false, ignore_cache=false)
+    # Return from cache if it is cached
+    if @cur_cache && !shallow && !ignore_cache
+      # puts "From Cache: #{@cur_cache.inspect}"
+      return @cur_cache
+    end
 
     if @getter.class == ::Proc
       # Get the current value, capture any errors
@@ -297,30 +260,67 @@ class ReactiveManager
       result = @getter
     end
 
-    if result.reactive?
+    if !shallow && result.reactive?
       # Unwrap any stored reactive values
       result = result.cur
     end
 
-    # if ObjectTracker.cache_enabled
-    #   @cached_obj = result
-    #   @cached_version = ObjectTracker.cache_version
-    # end
+    # puts "CUR FOR: #{result.inspect}"
 
     return result
   end
 
+
+  def update_followers
+    if has_listeners?
+      current_obj = cur(false, true)
+      should_attach = current_obj.respond_to?(:on)
+      # puts "SA #{should_attach} - #{current_obj.inspect}"
+
+      if should_attach
+        if !@cur_cache || current_obj.object_id != @cur_cache.object_id
+          # puts "CHANGED FROM: #{@cur_cache.inspect} to #{current_obj.inspect} - #{current_obj.object_id} vs #{@cur_cache.object_id}"
+          remove_followers
+
+          # puts "SET TO: #{current_obj.inspect} on #{self.inspect}"
+          @cur_cache_chain_listener = self.event_chain.add_object(current_obj)
+        end
+      else
+        remove_followers
+      end
+
+      # Store current if we have listeners
+      @cur_cache = current_obj
+    end
+  end
+
+  def remove_followers
+    # puts "REMOVE FOLLOWERS: #{@cur_cache.inspect} on #{self.inspect}"
+    # Remove from previous
+    if @cur_cache
+      @cur_cache = nil
+    end
+
+    if @cur_cache_chain_listener
+      @cur_cache_chain_listener.remove
+      @cur_cache_chain_listener = nil
+    end
+  end
+
   def cur=(val)
     if @setter
       @setter.call(val)
+      # update_followers
     elsif @scope == nil
       @getter = val
       @setter = nil
 
+      # update_followers
       trigger!('changed')
     else
       raise "Value can not be updated"
     end
+
   end
 
   # Returns a copy of the object with where all ReactiveValue's are replaced

data/lib/volt/reactive/string_extensions.rb

@@ -1,5 +1,5 @@
 class String
-  include ReactiveTags
+  # include ReactiveTags
 
   alias :__old_plus :+
   if RUBY_PLATFORM != 'opal'

data/lib/volt/router/routes.rb

@@ -1,14 +1,53 @@
 require 'volt'
 
-class Routes
-  attr_reader :routes, :path_matchers
+# The Routes class takes a set of routes and sets up methods to go from
+# a url to params, and params to url.
+# routes do
+#   get "/about", _view: 'about'
+#   get "/blog/{_id}/edit", _view: 'blog/edit', _action: 'edit'
+#   get "/blog/{_id}", _view: 'blog/show', _action: 'show'
+#   get "/blog", _view: 'blog'
+#   get "/blog/new", _view: 'blog/new', _action: 'new'
+#   get "/cool/{_name}", _view: 'cool'
+# end
+#
+# Using the routes above, we would generate the following:
+#
+# @direct_routes = {
+#   '/about' => {_view: 'about'},
+#   '/blog' => {_view: 'blog'}
+#   '/blog/new' => {_view: 'blog/new', _action: 'new'}
+# }
+#
+# -- nil represents a terminal
+# -- * represents any match
+# -- a number for a parameter means use the value in that number section
+#
+# @indirect_routes = {
+#     '*' => {
+#       'edit' => {
+#         nil => {_id: 1, _view: 'blog/edit', _action: 'edit'}
+#       }
+#       nil => {_id: 1, _view: 'blog/show', _action: 'show'}
+#     }
+#   }
+# }
+#
+# Match for params
+# @param_matches = [
+#   {_id: nil, _view: 'blog/edit', _action: 'edit'} => Proc.new {|params| "/blog/#{params.id}/edit", params.reject {|k,v| k == :id }}
+# ]
 
+class Routes
   def initialize
-    @routes = []
+    # Paths where there are no bindings (an optimization)
+    @direct_routes = {}
 
-    if Volt.server?
-      @path_matchers = []
-    end
+    # Paths with bindings
+    @indirect_routes = {}
+
+    # Matcher for going from params to url
+    @param_matches = []
   end
 
   def define(&block)
@@ -17,125 +56,203 @@ class Routes
     return self
   end
 
-  def get(path, options={})
-    if path.index('{') && path.index('}')
-      # The path contains bindings.
-      path = build_path_matcher(path, options)
+  # Add a route
+  def get(path, params={})
+    params = params.symbolize_keys
+    if has_binding?(path)
+      add_indirect_path(path, params)
     else
-      add_path_matcher([path]) if Volt.server?
+      @direct_routes[path] = params
     end
 
-    @routes << [path, options]
+    add_param_matcher(path, params)
   end
 
-  # Takes the path and splits it up into sections around any
-  # bindings in the path.  Those are then used to create a proc
-  # that will return the path with the current params in it.
-  # If it matches it will be used.
-  def build_path_matcher(path, options)
-    sections = path.split(/(\{[^\}]+\})/)
-    sections = sections.reject {|v| v == '' }
-
-    sections.each do |section|
-      if section[0] == '{' && section[-1] == '}'
-        options[section[1..-2]] = nil
+  # Takes in params and generates a path and the remaining params
+  # that should be shown in the url.  The extra "unused" params
+  # will be tacked onto the end of the url ?param1=value1, etc...
+  #
+  # returns the url and new params, or nil, nil if no match is found.
+  def params_to_url(test_params)
+    @param_matches.each do |param_matcher|
+      # TODO: Maybe a deep dup?
+      result, new_params = check_params_match(test_params.dup, param_matcher[0])
+
+      if result
+        return param_matcher[1].call(new_params)
       end
     end
 
-    add_path_matcher(sections) if Volt.server?
+    return nil, nil
+  end
+
+  # Takes in a path and returns the matching params.
+  # returns params as a hash
+  def url_to_params(path)
+    # First try a direct match
+    result = @direct_routes[path]
+    return result if result
+
+    # Next, split the url and walk the sections
+    parts = url_parts(path)
+
+    return match_path(parts, parts, @indirect_routes)
+  end
+
+  private
+    # Recursively walk the @indirect_routes hash, return the params for a route, return
+    # false for non-matches.
+    def match_path(original_parts, remaining_parts, node)
+      # Take off the top part and get the rest into a new array
+      # part will be nil if we are out of parts (fancy how that works out, now
+      # stand in wonder about how much someone thought this through, though
+      # really I just got lucky)
+      part, *parts = remaining_parts
 
-    # Create a path that takes in the params and returns the main
-    # part of the url with the params filled in.
-    path = Proc.new do |params|
-      sections.map do |section|
-        if section[0] == '{' && section[-1] == '}'
-          params[section[1..-2]]
+      if part == nil
+        if node[part]
+          # We found a match, replace the bindings and return
+          # TODO: Handvle nested
+          return setup_bindings_in_params(original_parts, node[part])
         else
-          section
+          return false
         end
-      end.join('')
+      elsif (new_node = node[part])
+        # Direct match for section, continue
+        return match_path(original_parts, parts, new_node)
+      elsif (new_node = node['*'])
+        # Match on binding section
+        return match_path(original_parts, parts, new_node)
+      end
     end
 
-    return path
-  end
+    # The params out of match_path will have integers in the params that came from bindings
+    # in the url.  This replaces those with the values from the url.
+    def setup_bindings_in_params(original_parts, params)
+      # Create a copy of the params we can modify and return
+      params = params.dup
 
-  # TODO: This is slow, optimize with a DFA or NFA
-  def add_path_matcher(sections)
-    match_path = ''
-    sections.each do |section|
-      if section[0] == '{' && section[-1] == '}'
-        match_path = match_path + "[^\\/]+"
-      else
-        match_path = match_path + section
+      params.each_pair do |key, value|
+        if value.is_a?(Fixnum)
+          # Lookup the param's value in the original url parts
+          params[key] = original_parts[value]
+        end
       end
+
+      return params
     end
 
-    @path_matchers << (/^#{match_path}$/)
-  end
 
-  # Takes in params and generates a path and the remaining params
-  # that should be shown in the url.
-  def url_for_params(params)
-    routes.each do |route|
-      if params_match_options?(params, route[1])
-        return path_and_params(params, route[0], route[1])
+    # Build up the @indirect_routes data structure.
+    # '*' means wildcard match anything
+    # nil means a terminal, who's value will be the params.
+    #
+    # In the params, an integer vaule means the index of the wildcard
+    def add_indirect_path(path, params)
+      node = @indirect_routes
+
+      parts = url_parts(path)
+
+      parts.each_with_index do |part, index|
+        if has_binding?(part)
+          params[part[1..-2].to_sym] = index
+
+          # Set the part to be '*' (anything matcher)
+          part = '*'
+        end
+
+        node = (node[part] ||= {})
       end
+
+      node[nil] = params
     end
 
-    return '/', params
-  end
 
-  # Takes in a path and returns the matching params.
-  # TODO: Slow, need dfa
-  def params_for_path(path)
-    routes.each do |route|
-      # TODO: Finish nested routes
-      if false && route[0].class == Proc
-        # puts route[0].call(params).inspect
-
-        return false
-      elsif route[0] == path
-        # Found the matching route
-        return route[1]
+    def add_param_matcher(path, params)
+      params = params.dup
+      parts = url_parts(path)
+
+      parts.each_with_index do |part, index|
+        if has_binding?(part)
+          # Setup a nil param that can match anything, but gets
+          # assigned into the url
+          params[part[1..-2].to_sym] = nil
+        end
       end
+
+      path_transformer = create_path_transformer(parts)
+
+      @param_matches << [params, path_transformer]
     end
 
-    return {}
-  end
+    # Takes in url parts and returns a proc that takes in params and returns
+    # a url with the bindings filled in, and params with the binding params
+    # removed.  (So the remaining can be added onto the end of the url ?params1=...)
+    def create_path_transformer(parts)
+      return lambda do |input_params|
+        input_params = input_params.dup
 
-  private
-    def path_and_params(params, path, options)
-      params = params.attributes.dup
-      path = path.call(params) if path.class == Proc
+        url = parts.map do |part|
+          val = if has_binding?(part)
+            # Get the
+            binding = part[1..-2].to_sym
+            input_params.delete(binding)
+          else
+            part
+          end
 
-      options.keys.each do |key|
-        params.delete(key)
-      end
+          val
+        end.join('/')
 
-      return path, params
+        return '/' + url, input_params
+      end
     end
 
-    # Match one route against the current params.
-    def params_match_options?(params, options)
-      options.each_pair do |key, value|
-        # If the value is a hash, we have a nested route.  Get the
-        # matching section in the parameter and loop down to check
-        # the values down.
+    # Takes in a hash of params and checks to make sure keys in param_matcher
+    # are in test_params.  Checks for equal value unless value in param_matcher
+    # is nil.
+    #
+    # returns false or true, new_params - where the new params are a the params not
+    # used in the basic match.  Later some of these may be inserted into the url.
+    def check_params_match(test_params, param_matcher)
+      param_matcher.each_pair do |key, value|
         if value.is_a?(Hash)
-          sub_params = params.send(key)
+          if test_params[key]
+            result = check_params_match(test_params[key], value)
 
-          if sub_params
-            return params_match_options?(sub_params, value)
+            if result == false
+              return false
+            else
+              test_params.delete(key)
+            end
+          else
+            # test_params did not have matching key
+            return false
+          end
+        elsif value == nil
+          unless test_params.has_key?(key)
+            return false
+          end
+        else
+          if test_params[key] == value
+            test_params.delete(key)
           else
             return false
           end
-        elsif value != nil && value != params.send(key)
-          # A nil value means it can match anything, so we don't want to
-          # fail on nil.
-          return false
         end
       end
 
-      return true
+      return true, test_params
     end
+
+    def url_parts(path)
+      return path.split('/').reject(&:blank?)
+    end
+
+
+    # Check if a string has a binding in it
+    def has_binding?(string)
+      string.index('{') && string.index('}')
+    end
+
 end

data/lib/volt/server/component_handler.rb

@@ -15,10 +15,12 @@ class ComponentHandler
 
     code = ComponentCode.new(component_name, @component_paths).code
 
+    # puts "CODE: #{code}"
+
     javascript_code = Opal.compile(code)
 
     # puts "ENV: #{env.inspect}"
-    [200, {"Content-Type" => "text/html"}, StringIO.new(javascript_code)]
+    [200, {"Content-Type" => "text/html; charset=utf-8"}, StringIO.new(javascript_code)]
   end
 
 

data/lib/volt/server/html_parser/view_parser.rb

@@ -7,17 +7,33 @@ require 'volt/server/html_parser/textarea_scope'
 
 class ViewParser
   attr_reader :templates
-  
+
   def initialize(html, template_path)
     @template_path = template_path
 
     handler = ViewHandler.new(template_path)
-    
+
     SandlebarsParser.new(html, handler)
-    
+
     # Close out the last scope
     handler.scope.last.close_scope
-    
+
     @templates = handler.templates
   end
+
+  # Returns a parsed version of the data (useful for backend rendering
+  # and testing)
+  def data
+    templates = @templates.deep_clone
+
+    templates.each_pair do |name, value|
+      if value['bindings']
+        value['bindings'].each_pair do |number, binding|
+          value['bindings'][number] = binding.map {|code| eval(code) }
+        end
+      end
+    end
+
+    return templates
+  end
 end