volt 0.6.5 → 0.7.0

data/lib/volt/reactive/reactive_value.rb

@@ -10,7 +10,7 @@ class Object
   def cur
     self
   end
-  
+
   def reactive?
     false
   end
@@ -20,7 +20,7 @@ class ReactiveValue < BasicObject
   # methods on ReactiveValues:
   # reactive?, cur, with, on, data, trigger!
   # - everything else is forwarded to the ReactiveManager
-  
+
   # Methods we should skip wrapping the results in
   # We skip .hash because in uniq it has .to_int called on it, which needs to
   # return a Fixnum instance.
@@ -34,11 +34,11 @@ class ReactiveValue < BasicObject
   def initialize(getter, setter=nil, scope=nil)
     @reactive_manager = ::ReactiveManager.new(getter, setter, scope)
   end
-  
+
   def reactive?
     true
   end
-  
+
   # 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.
@@ -47,16 +47,16 @@ class ReactiveValue < BasicObject
       @reactive_manager.send(method_name, *args, &block)
     end
   end
-  
+
   def reactive_manager
     @reactive_manager
   end
-  alias_method :rm, :reactive_manager  
-  
+  alias_method :rm, :reactive_manager
+
   def puts(*args)
     ::Object.send(:puts, *args)
   end
-  
+
   def __is_destructive?(method_name)
     last_char = method_name[-1]
     if last_char == '=' && method_name[-2] != '='
@@ -73,7 +73,7 @@ class ReactiveValue < BasicObject
       return false
     end
   end
-  
+
   def method_missing(method_name, *args, &block)
     # Unroll send into a direct call
     if method_name == :send
@@ -85,13 +85,13 @@ class ReactiveValue < BasicObject
     # Also skip if this is a destructive method
     if SKIP_METHODS.include?(method_name) || __is_destructive?(method_name)
       current_obj = self.cur
-      
+
       # Unwrap arguments if the method doesn't want reactive values
       pass_args = reactive_manager.unwrap_if_pass_reactive(args, method_name, current_obj)
-      
+
       return current_obj.__send__(method_name, *pass_args, &block)
     end
-    
+
     result = @reactive_manager.with_and_options(args) do |val, in_args|
       # Unwrap arguments if the method doesn't want reactive values
       # TODO: Should cache the lookup on pass_reactive
@@ -100,18 +100,18 @@ class ReactiveValue < BasicObject
       # puts "GET #{method_name.inspect}"
       val.__send__(method_name, *pass_args, &block)
     end
-    
+
     manager = result.reactive_manager
-    
+
     setup_setter(manager, method_name, args)
-    
+
     manager.set_scope!([method_name, *args, block])
-    
+
     # result = result.with(block_reactives) if block
-    
+
     return result
   end
-  
+
   def setup_setter(manager, method_name, args)
     # See if we can automatically create a setter.  If we are fetching a
     # value via a read, we can probably reassign it with .name=
@@ -126,30 +126,30 @@ class ReactiveValue < BasicObject
       manager.setter! do |val|
         # Call an array setter
         self.cur.send(:"#{method_name}=", args[0], val)
-      end      
+      end
     end
   end
-  # 
+  #
   # def respond_to?(name, include_private=false)
   #   [:event_added, :event_removed].include?(name) || super
   # end
-  
+
   def respond_to_missing?(name, include_private=false)
     cur.respond_to?(name)
   end
-  
+
   def with(*args, &block)
     return @reactive_manager.with(*args, &block)
   end
-  
+
   def inspect
     "@#{cur.inspect}"
   end
-  
+
   def pretty_inspect
     inspect
   end
-  
+
   # Not 100% sure why, but we need to define this directly, it doesn't call
   # on method missing
   def ==(val)
@@ -160,11 +160,11 @@ class ReactiveValue < BasicObject
   def !
     method_missing(:!)
   end
-  
+
   def to_s
     cur.to_s
   end
-  
+
   def coerce(other)
     if other.reactive?
       return [other, self]
@@ -173,7 +173,7 @@ class ReactiveValue < BasicObject
       return [wrapped_object, self]
     end
   end
-  
+
   # Return a new reactive value that listens for changes on any
   # ReactiveValues inside of its children (hash values, array items, etc..)
   # This is useful if someone is passing in a set of options, but the main
@@ -192,7 +192,7 @@ class ReactiveGenerator
   # 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
@@ -200,11 +200,11 @@ class ReactiveGenerator
       # 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
@@ -215,7 +215,7 @@ class ReactiveGenerator
     found = []
     if object.reactive?
       found << object
-      
+
       found += find_reactives(object.cur)
     elsif object.is_a?(Array)
       object.each do |item|
@@ -227,50 +227,50 @@ class ReactiveGenerator
         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)
     @getter = getter
     @setter = setter
     @scope = scope
-    
+
     @parents = []
   end
-  
+
   def reactive?
     true
   end
-  
+
   def inspect
     "@<#{self.class.to_s}:#{reactive_object_id} #{cur.inspect}>"
   end
-  
+
   def reactive_object_id
     @reactive_object_id ||= rand(100000)
   end
-  
-  
+
+
   def event_added(event, scope, first)
     # 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
   end
-  
+
   def event_removed(event, last)
     # 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)
   end
@@ -284,7 +284,7 @@ class ReactiveManager
     # if ObjectTracker.cache_version == @cached_version
     #   return @cached_obj
     # end
-    
+
     if @getter.class == ::Proc
       # Get the current value, capture any errors
       begin
@@ -296,33 +296,33 @@ class ReactiveManager
       # getter is just an object, return it
       result = @getter
     end
-    
+
     if result.reactive?
       # Unwrap any stored reactive values
       result = result.cur
     end
-    
+
     # if ObjectTracker.cache_enabled
     #   @cached_obj = result
     #   @cached_version = ObjectTracker.cache_version
     # end
-    
+
     return result
   end
-  
+
   def cur=(val)
     if @setter
       @setter.call(val)
     elsif @scope == nil
       @getter = val
       @setter = nil
-      
+
       trigger!('changed')
     else
       raise "Value can not be updated"
     end
   end
-  
+
   # Returns a copy of the object with where all ReactiveValue's are replaced
   # with their current value.
   # NOTE: Classes need to implement their own deep_cur method for this to work,
@@ -330,28 +330,28 @@ class ReactiveManager
   def deep_cur
     self.cur.deep_cur
   end
-  
+
   # Method calls can be tagged so the reactive value knows
   # how to handle them.  This lets you check the state of
   # the tags.
   def check_tag(method_name, tag_name, current_obj)
     if current_obj.respond_to?(:reactive_method_tag)
       tag = current_obj.reactive_method_tag(method_name, tag_name)
-      
+
       unless tag
         # Get the tag from the all methods if its not directly specified
         tag = current_obj.reactive_method_tag(:__all_methods, tag_name)
       end
-      
+
       # Evaluate now if its a proc
       tag = tag.call(method_name) if tag.class == ::Proc
-      
+
       return tag
     end
-    
+
     return nil
   end
-  
+
   def unwrap_if_pass_reactive(args, method_name, current_obj)
     # Check to see if the method we're calling wants to receive reactive values.
     pass_reactive = check_tag(method_name, :pass_reactive, current_obj)
@@ -359,33 +359,33 @@ class ReactiveManager
     # Unwrap arguments if the method doesn't want reactive values
     return pass_reactive ? args : args.map{|v| v.cur }
   end
-  
+
   # With returns a new reactive value dependent on any arguments passed in.
   # If a block is passed in, the getter is the block its self, which will
   # be passed the .cur and the .cur of any reactive arguments.
   def with(*args, &block)
     return with_and_options(args, &block)
   end
-  
+
   def with_and_options(args, &block)
     getter = @getter
     setter = @setter
     scope = @scope
-     
+
     if block
       # If a block was passed in, the getter now becomes a proc that calls
       # the passed in block with the right arguments.
-      getter = ::Proc.new do        
+      getter = ::Proc.new do
         # TODO: Calling cur every time
         current_val = self.cur
-        
+
         if current_val.is_a?(Exception)
           current_val
         else
           block.call(current_val, args)
         end
       end
-      
+
       # TODO: Make this work with custom setters
       setter = nil
 
@@ -393,9 +393,9 @@ class ReactiveManager
       # method because we don't know enough about what methods its calling.
       scope = nil
     end
-    
+
     new_val = ReactiveValue.new(getter, setter, scope)
-    
+
     # Add the ReactiveValue we're building from
     new_val.reactive_manager.add_parent!(self)
 
@@ -403,34 +403,34 @@ class ReactiveManager
     args.select(&:reactive?).each do |arg|
       new_val.reactive_manager.add_parent!(arg.reactive_manager)
     end
-    
+
     return new_val
   end
-  
+
   def add_parent!(parent)
     @parents << parent
     event_chain.add_object(parent)
   end
-  
+
   def remove_parent!(parent)
     @parents.delete(parent)
     event_chain.remove_object(parent)
   end
 
-  
+
   def set_scope!(new_scope)
     @scope = new_scope
-    
+
     self
   end
-  
+
   def set_scope(new_scope)
     dup.scope!(new_scope)
   end
-  
+
   # Sets the setter
   def setter!(setter=nil, &block)
     @setter = setter || block
   end
 
-end
+end

data/lib/volt/reactive/string_extensions.rb

@@ -1,6 +1,6 @@
 class String
   include ReactiveTags
-  
+
   alias :__old_plus :+
   if RUBY_PLATFORM != 'opal'
     alias :__old_concat :<<
@@ -14,7 +14,7 @@ class String
     if val.reactive? && !result.reactive?
       result = ReactiveValue.new(result)
     end
-  
+
     return result
   end
 
@@ -24,7 +24,7 @@ class String
         raise "Cannot append a reactive string to non-reactive string.  Use + instead"
       end
       result = __old_concat(val)
-  
+
       return result
     end
   end

data/lib/volt/router/routes.rb

@@ -5,18 +5,18 @@ class Routes
 
   def initialize
     @routes = []
-    
+
     if Volt.server?
       @path_matchers = []
     end
   end
-  
+
   def define(&block)
     instance_eval(&block)
-    
+
     return self
   end
-  
+
   def get(path, options={})
     if path.index('{') && path.index('}')
       # The path contains bindings.
@@ -24,10 +24,10 @@ class Routes
     else
       add_path_matcher([path]) if Volt.server?
     end
-    
+
     @routes << [path, options]
   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.
@@ -35,15 +35,15 @@ class Routes
   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
       end
     end
-    
+
     add_path_matcher(sections) if Volt.server?
-    
+
     # 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|
@@ -55,7 +55,7 @@ class Routes
         end
       end.join('')
     end
-    
+
     return path
   end
 
@@ -69,19 +69,19 @@ class Routes
         match_path = match_path + section
       end
     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)    
+  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])
       end
     end
-    
+
     return '/', params
   end
 
@@ -92,30 +92,29 @@ class Routes
       # 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]
       end
     end
-    
+
     return {}
   end
-  
+
   private
     def path_and_params(params, path, options)
       params = params.attributes.dup
-      puts params.inspect if path.class == Proc
       path = path.call(params) if path.class == Proc
-    
+
       options.keys.each do |key|
         params.delete(key)
       end
-      
+
       return path, params
     end
-  
+
     # Match one route against the current params.
     def params_match_options?(params, options)
       options.each_pair do |key, value|
@@ -136,7 +135,7 @@ class Routes
           return false
         end
       end
-    
+
       return true
     end
-end
+end

data/lib/volt/server/component_handler.rb

@@ -1,6 +1,6 @@
 require 'stringio'
 require 'volt'
-require 'volt/server/template_parser'
+require 'volt/server/html_parser/view_parser'
 require 'volt/server/component_templates'
 require 'volt/server/rack/asset_files'
 
@@ -8,7 +8,7 @@ class ComponentHandler
   def initialize(component_paths)
     @component_paths = component_paths
   end
-  
+
   def call(env)
     req = Rack::Request.new(env)
 
@@ -16,13 +16,13 @@ class ComponentHandler
     component_name = req.path.strip.gsub(/^\/components\//, '').gsub(/[.]js$/, '')
 
     code = ''
-  
+
     asset_files = AssetFiles.new(component_name, @component_paths)
     asset_files.component_paths.each do |component_path, component_name|
       code << ComponentTemplates.new(component_path, component_name).code
       code << "\n\n"
     end
-  
+
     javascript_code = Opal.compile(code)
 
     # puts "ENV: #{env.inspect}"
@@ -30,4 +30,4 @@ class ComponentHandler
   end
 
 
-end
+end

data/lib/volt/server/component_templates.rb

@@ -5,11 +5,11 @@ class ComponentTemplates
     @component_path = component_path
     @component_name = component_name
   end
-  
+
   def code
     return generate_controller_code + generate_view_code + generate_model_code + generate_routes_code
   end
-  
+
   def generate_view_code
     code = ''
     views_path = "#{@component_path}/views/"
@@ -20,14 +20,17 @@ class ComponentTemplates
       template_path = view_path[views_path.size..((-1 * ('.html'.size + 1)))]
       template_path = "#{@component_name}/#{template_path}"
 
-      all_templates = TemplateParser.new(File.read(view_path), template_path)
+      # all_templates = TemplateParser.new(File.read(view_path), template_path)
+      all_templates = ViewParser.new(File.read(view_path), template_path)
 
       binding_initializers = []
       all_templates.templates.each_pair do |name, template|
         binding_code = []
 
-        template['bindings'].each_pair do |key,value|
-          binding_code << "#{key.inspect} => [#{value.join(', ')}]"
+        if template['bindings']
+          template['bindings'].each_pair do |key,value|
+            binding_code << "#{key.inspect} => [#{value.join(', ')}]"
+          end
         end
 
         binding_code = "{#{binding_code.join(', ')}}"
@@ -51,26 +54,26 @@ class ComponentTemplates
 
     return code
   end
-  
+
   def generate_model_code
     code = ''
     models_path = "#{@component_path}/models/"
 
     Dir["#{models_path}*.rb"].sort.each do |model_path|
       code << File.read(model_path) + "\n\n"
-      
+
       model_name = model_path.match(/([^\/]+)[.]rb$/)[1]
-      
+
       code << "$page.add_model(#{model_name.inspect})\n\n"
     end
 
     return code
   end
-  
+
   def generate_routes_code
     code = ''
     routes_path = "#{@component_path}/config/routes.rb"
-    
+
     if File.exists?(routes_path)
       code << "$page.add_routes do\n"
       code << "\n" + File.read(routes_path) + "\n"
@@ -79,4 +82,4 @@ class ComponentTemplates
 
     return code
   end
-end
+end