volt 0.2.3

data/lib/volt/reactive/string_extensions.rb

@@ -0,0 +1,34 @@
+class String
+  include ReactiveTags
+  
+  alias :__old_plus :+
+  if RUBY_PLATFORM != 'opal'
+    alias :__old_concat :<<
+  end
+  # alias :concat :__old_concat
+
+  # In volt, we want a value + reactive strings to return a reactive string.  So we
+  # over-ride + to check for when we are adding a reactive string to a string.
+  def +(val)
+    result = __old_plus(val.cur)
+    if val.reactive? && !result.reactive?
+      result = ReactiveValue.new(result)
+    end
+  
+    return result
+  end
+
+  if RUBY_PLATFORM != 'opal'
+    tag_method(:<<) do
+      destructive!
+    end
+    def <<(val)
+      if val.reactive?
+        raise "Cannot append a reactive string to non-reactive string.  Use + instead"
+      end
+      result = __old_concat(val)
+  
+      return result
+    end
+  end
+end

data/lib/volt/router/routes.rb

@@ -0,0 +1,83 @@
+class Routes
+  attr_reader :routes
+
+  def initialize
+    @routes = []
+  end
+  
+  def define(&block)
+    instance_eval(&block)
+    
+    return self
+  end
+  
+  def get(path, options)
+    if path.index(':')
+      sections = path.split(/([:][^:\/]+)/)
+      
+      sections.each do |section|
+        if section[0] == ':'
+          options[section[1..-1]] = nil
+        end
+      end
+      path = Proc.new do |params|
+        # Create a path using the params in the path
+        sections.map do |section|
+          if section[0] == ':'
+            params[section[1..-1]]
+          else
+            section
+          end
+        end.join('')
+      end
+    end
+    
+    @routes << [path, options]
+  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])
+      end
+    end
+    
+    return '/', params
+  end
+
+  # Takes in a path and returns the matching params.
+  def params_for_path(path)
+    routes.each do |route|
+      if 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
+      path = path.call(params) if path.class == Proc
+    
+      options.keys.each do |key|
+        params.delete(key)
+      end
+      
+      return path, params
+    end
+  
+    def params_match_options?(params, options)
+      options.each_pair do |key, value|
+        if value == nil || value != params.send(key)
+          return false
+        end
+      end
+    
+      return true
+    end
+end

data/lib/volt/server.rb

@@ -0,0 +1,121 @@
+require 'opal'
+require "rack"
+if RUBY_PLATFORM != 'java'
+  require "rack/sockjs"
+  require "eventmachine"
+end
+require "sprockets-sass"
+require "sass"
+
+require 'volt/extra_core/extra_core'
+require 'volt/server/request_handler'
+require 'volt/server/component_handler'
+if RUBY_PLATFORM != 'java'
+  require 'volt/server/channel_handler'
+end
+require 'volt/server/source_map_server'
+
+class Index
+
+  def initialize(app, files)
+    @app = app
+    @files = files
+  end
+
+  def call(env)
+    if %w[/ /demo /blog /todos /page3 /page4].include?(env['PATH_INFO']) || env['PATH_INFO'][0..5] == '/todos'
+      [200, { 'Content-Type' => 'text/html' }, [html]]
+    else
+      @app.call env
+    end
+  end
+  
+  def html
+    index_path = File.expand_path(File.join(Dir.pwd, "public/index.html"))
+    html = File.read(index_path)
+    
+    ERB.new(html).result(binding)
+  end
+end
+
+
+
+SOURCE_MAPS = !!ENV['MAPS']
+
+Opal::Processor.source_map_enabled = SOURCE_MAPS
+# Opal::Processor.arity_check_enabled = true
+# Opal::Processor.dynamic_require_severity = :raise
+
+
+
+class Server
+  def self.app
+
+    builder = Rack::Builder.new do
+      use Rack::CommonLogger
+      # run RequestHandler.new
+
+      use Rack::ShowExceptions
+
+      map '/components' do
+        run ComponentHandler.new
+      end
+
+      environment = Opal::Environment.new
+      
+      app_path = File.expand_path(File.join(Dir.pwd, "app"))
+      environment.append_path(app_path)
+      
+      volt_gem_lib_path = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+      environment.append_path(volt_gem_lib_path)
+  
+      # Add the opal load paths
+      Opal.paths.each do |path|
+        environment.append_path(path)
+      end
+  
+      # opal-jquery gem
+      spec = Gem::Specification.find_by_name("opal-jquery")
+      environment.append_path(spec.gem_dir + "/opal")
+
+  
+      map '/assets' do
+        run environment
+      end
+  
+      if SOURCE_MAPS
+        source_maps = SourceMapServer.new(environment)
+  
+        map(source_maps.prefix) do
+          run source_maps
+        end
+      end
+
+      if RUBY_PLATFORM != 'java'
+        map "/channel" do
+          run Rack::SockJS.new(ChannelHandler)#, :websocket => false
+        end
+      end
+
+      if SOURCE_MAPS
+        files = environment['volt/templates/page'].to_a.map {|v| v.logical_path }
+      else
+        files = []
+      end
+
+      use Index, files
+
+      use Rack::Static,
+        :urls => ["/"],
+        :root => "public",
+        :index => "",
+        :header_rules => [
+          [:all, {'Cache-Control' => 'public, max-age=86400'}]
+        ]
+  
+      run lambda{ |env| [ 404, { 'Content-Type'  => 'text/html' }, ['404 - page not found'] ] }
+    end
+    
+    return builder
+  end
+end

data/lib/volt/server/binding_setup.rb

@@ -0,0 +1,2 @@
+class BindingSetup
+end

data/lib/volt/server/channel_handler.rb

@@ -0,0 +1,31 @@
+require 'json'
+require 'sockjs/session'
+
+class ChannelHandler < SockJS::Session
+  def self.message_all
+    @@channels.each do |channel|
+      channel.send(message)
+    end
+    
+  end
+  
+  def initialize(session, *args)
+    @session = session
+
+    @@channels ||= []
+    @@channels << self
+    
+    super
+  end
+  
+  def process_message(message)
+    puts "Process: #{message}"
+    self.class.message_all(message)
+  end
+  
+  def closed    
+    # Remove ourself from the available channels
+    @@channels.delete(self)
+  end
+
+end

data/lib/volt/server/component_handler.rb

@@ -0,0 +1,88 @@
+require 'stringio'
+require 'volt'
+require 'volt/server/template_parser'
+
+class ComponentHandler
+  def call(env)
+    req = Rack::Request.new(env)
+
+    # TODO: Sanatize template path
+    @component_path = req.path.strip.gsub(/^\/components\//, '').gsub(/[.]js$/, '')
+
+    code = generate_controller_code + generate_view_code + generate_model_code + generate_routes_code
+
+    javascript_code = Opal.compile(code)
+
+    # puts "ENV: #{env.inspect}"
+    [200, {"Content-Type" => "text/html"}, StringIO.new(javascript_code)]
+  end
+
+  def generate_view_code
+    code = ''
+    views_path = Volt.root + "/app/#{@component_path}/views/"
+
+    # Load all templates in the folder
+    Dir["#{views_path}*/*.html"].each do |view_path|
+      # Get the path for the template, supports templates in folders
+      template_path = view_path[views_path.size..((-1 * ('.html'.size + 1)))]
+      template_path = "#{@component_path}/#{template_path}"
+      # puts "Template Path: #{template_path.inspect}"
+
+      all_templates = TemplateParser.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(', ')}]"
+        end
+
+        binding_code = "{#{binding_code.join(', ')}}"
+
+        code << "$page.add_template(#{name.inspect}, #{template['html'].inspect}, #{binding_code})\n"
+      end
+    end
+    # puts "--------------"
+    # puts "CODE: #{code}"
+
+    return code
+  end
+
+  def generate_controller_code
+    code = ''
+    controllers_path = Volt.root + "/app/#{@component_path}/controllers/"
+
+    Dir["#{controllers_path}*_controller.rb"].each do |controller_path|
+      code << File.read(controller_path) + "\n\n"
+    end
+
+    return code
+  end
+  
+  def generate_model_code
+    code = ''
+    models_path = Volt.root + "/app/#{@component_path}/models/"
+
+    Dir["#{models_path}*.rb"].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 = Volt.root + "/app/#{@component_path}/config/routes.rb"
+    
+    code << "$page.add_routes do\n"
+    code << "\n" + File.read(routes_path) + "\n"
+    code << "end\n\n"
+
+    return code
+  end
+end

data/lib/volt/server/if_binding_setup.rb

@@ -0,0 +1,29 @@
+# With if bindings, we need to track each branch, which is on the
+# same scope level as the original if statement.  We use this class
+# to track each branch.
+
+require 'volt/server/binding_setup'
+class IfBindingSetup < BindingSetup
+  def initialize
+    @branches = []
+  end
+  
+  def add_branch(content, template_name)
+    @branches << [content, template_name]
+  end
+  
+  def to_setup_code
+    branches = @branches.map do |branch|
+      content = branch[0]
+      if content == nil
+        content = nil.inspect
+      else
+        content = "Proc.new { #{branch[0]} }"
+      end
+      
+      "[#{content}, #{branch[1].inspect}]"
+    end.join(', ')
+    
+    "lambda { |target, context, id| IfBinding.new(target, context, id, [#{branches}]) }"
+  end
+end

data/lib/volt/server/request_handler.rb

@@ -0,0 +1,16 @@
+require 'stringio'
+
+class RequestHandler
+  def call(env)
+    req = Rack::Request.new(env)
+    # puts env.inspect
+    # puts req.inspect
+
+    puts req.path
+    req.post?
+    puts req.params["data"]
+
+    # puts "ENV: #{env.inspect}"
+    [200, {"Content-Type" => "text/html"}, StringIO.new("Hello Rack!")]
+  end
+end

data/lib/volt/server/scope.rb

@@ -0,0 +1,43 @@
+# Template parsing is fairly simple at the moment.  Basically we walk the dom and
+# do two types of replacements.
+# 1) replacement in text nodes
+# 2) attribute replacements
+
+class Scope
+  attr_accessor :bindings, :outer_binding_number, :closed_block_scopes, :last_if_binding
+
+  def initialize(outer_binding_number=nil)
+    # For block bindings, the outer binding number lets us know what the name
+    # of the comments are that go before/after this scope block.
+    @outer_binding_number = outer_binding_number
+    @bindings = {}
+  end
+
+  def add_closed_child_scope(scope)
+    @closed_block_scopes ||= []
+    @closed_block_scopes << scope
+  end
+
+  def add_binding(binding_name, setup_code)
+    @bindings[binding_name] ||= []
+    @bindings[binding_name] << setup_code
+  end
+  
+  def start_if_binding(binding_name, if_binding_setup)
+    @last_if_binding = [binding_name, if_binding_setup]
+  end
+  
+  def current_if_binding
+    @last_if_binding
+  end
+  
+  def close_if_binding!
+    if @last_if_binding
+      binding_name, if_binding_setup = @last_if_binding
+      @last_if_binding = nil
+      
+      add_binding(binding_name, if_binding_setup.to_setup_code)
+    end
+  end
+  
+end