volt 0.9.1.pre1 → 0.9.1.pre2

data/lib/volt/server/component_handler.rb

@@ -11,24 +11,32 @@ module Volt
     def call(env)
       req            = Rack::Request.new(env)
 
+      path = req.path.strip
+
+      request_source_map = (File.extname(path) == '.map')
+
       # TODO: Sanatize template path
-      component_name = req.path.strip.gsub(/^\/components\//, '').gsub(/[.]js$/, '')
+      component_name = path.gsub(/^\/components\//, '').gsub(/[.](js|map)$/, '')
 
-      javascript_code = compile_for_component(component_name)
+      javascript_code = compile_for_component(component_name, request_source_map)
 
       [200, { 'Content-Type' => 'application/javascript; charset=utf-8' }, StringIO.new(javascript_code)]
     end
 
-    def compile_for_component(component_name)
+    def compile_for_component(component_name, map=false)
       code = ComponentCode.new(component_name, @component_paths).code
 
-      # Add the lib directory to the load path
-      Opal.append_path(Volt.root + '/lib')
-
       # Compile the code
-      javascript_code = Opal.compile(code)
+      # javascript_code = Opal.compile(code)
+      builder = Opal::Builder.new.build_str(code, 'app.rb')
+
+      if map
+        js_code = builder.source_map
+      else
+        js_code = builder.to_s + "\n//# sourceMappingURL=#{component_name}.map"
+      end
 
-      javascript_code
+      js_code
     end
   end
 end

data/lib/volt/server/forking_server.rb

@@ -0,0 +1,176 @@
+#
+
+require 'drb'
+require 'stringio'
+require 'listen'
+
+module Volt
+  class ForkingServer
+    def initialize(server)
+      # A read write lock for accessing and creating the lock
+      @child_lock = ReadWriteLock.new
+
+      # Trap exit
+      at_exit do
+        # Only run on parent
+        if @child_id
+          puts "Exiting..."
+          @exiting = true
+          stop_child
+        end
+      end
+
+      @server = server
+
+      start_child
+    end
+
+    # Start child forks off a child process and sets up a DRb connection to the
+    # child.  #start_child should be called from within the write lock.
+    def start_child
+      # Aquire the write lock, so we prevent anyone from using the child until
+      # its setup or recreated.
+      unless @drb_object
+        # Get the id of the parent process, so we can wait for exit in the child
+        # so the child can exit if the parent closes.
+        @parent_id = Process.pid
+
+        @reader, @writer = IO.pipe
+
+        if @child_id = fork
+          # running as parent
+          @writer.close
+
+          # Read the url from the child
+          uri = @reader.gets.strip
+
+          # Setup a drb object to the child
+          DRb.start_service
+
+          @drb_object = DRbObject.new_with_uri(uri)
+          @server_proxy = @drb_object[0]
+          @dispatcher_proxy = @drb_object[1]
+
+          SocketConnectionHandler.dispatcher = @dispatcher_proxy
+
+          start_change_listener
+        else
+          # Running as child
+          @reader.close
+
+          @server.boot_volt
+          @rack_app = @server.new_server
+
+          # Set the drb object locally
+          @dispatcher = Dispatcher.new
+          drb_object = DRb.start_service(nil, [self, @dispatcher])
+
+          @writer.puts(drb_object.uri)
+
+          watch_for_parent_exit
+
+          begin
+            DRb.thread.join
+          rescue Interrupt => e
+            # Ignore interrupt
+            exit
+          end
+        end
+      end
+    end
+
+    # In the even the parent gets killed without at_exit running,
+    # we watch the pipe and close if the pipe gets closed.
+    def watch_for_parent_exit
+      Thread.new do
+        loop do
+          if @writer.closed?
+            puts "Parent process died"
+            exit
+          end
+
+          sleep 3
+        end
+      end
+    end
+
+    def call_on_child(env)
+      status, headers, body = @rack_app.call(env)
+
+      # Extract the body to pass as a string.  We need to do this
+      # because after the call, the objects will be GC'ed, so we want
+      # them to be able to be marshaled to be send over DRb.
+      if body.respond_to?(:to_str)
+        body_str = body
+      else
+        extracted_body = []
+
+        # Read the
+        body.each do |str|
+          extracted_body << str
+        end
+
+        body.close if body.respond_to?(:close)
+        body_str = extracted_body.join
+      end
+
+      [status, headers, body_str]
+    end
+
+    def call(env)
+      @child_lock.with_read_lock do
+        if @exiting
+          [500, {}, 'Server Exiting']
+        else
+          @server_proxy.call_on_child(env)
+        end
+      end
+    end
+
+    def stop_child
+      # clear the drb object and kill the child process.
+      if @drb_object
+        begin
+          @drb_object = nil
+          DRb.stop_service
+          @reader.close
+          stop_change_listener
+          Process.kill(9, @child_id)
+        rescue => e
+          puts "Stop Child Error: #{e.inspect}"
+        end
+      end
+    end
+
+    def reload
+      Volt.logger.log_with_color('file changed, sending reload', :light_blue)
+      begin
+        SocketConnectionHandler.send_message_all(nil, 'reload')
+      rescue => e
+        Volt.logger.error("Reload dispatch error: ")
+        Volt.logger.error(e)
+      end
+
+      @child_lock.with_write_lock do
+        stop_child
+        start_child
+      end
+    end
+
+    def start_change_listener
+      # Setup the listeners for file changes
+      @listener = Listen.to("#{@server.app_path}/") do |modified, added, removed|
+        Thread.new do
+          # Run the reload in a new thread
+          reload
+        end
+      end
+      @listener.start
+    end
+
+    def stop_change_listener
+      @listener.stop
+    end
+
+  end
+end

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

@@ -113,7 +113,7 @@ module Volt
 
       string_template_renderer_path = add_string_template_renderer(content)
 
-      save_binding(id, "lambda { |__p, __t, __c, __id| Volt::AttributeBinding.new(__p, __t, __c, __id, #{attribute_name.inspect}, Proc.new { Volt::StringTemplateRender.new(__p, __c, #{string_template_renderer_path.inspect}) }) }")
+      save_binding(id, "lambda { |__p, __t, __c, __id| Volt::AttributeBinding.new(__p, __t, __c, __id, #{attribute_name.inspect}, Proc.new { Volt::StringTemplateRenderer.new(__p, __c, #{string_template_renderer_path.inspect}) }) }")
     end
 
     def add_string_template_renderer(content)

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

@@ -142,7 +142,11 @@ module Volt
     def start_tag(tag, tag_name, rest, unary)
       section_tag = tag_name[0] == ':' && tag_name[1] =~ /[A-Z]/
 
-      tag_name = tag_name.downcase
+      if section_tag
+        tag_name = tag_name.underscore
+      else
+        tag_name = tag_name.downcase
+      end
 
       # handle doctype so we get it output exactly the same way
       if tag_name == '!doctype'
@@ -150,13 +154,6 @@ module Volt
         return
       end
 
-      # Auto-close the last inline tag if we started a new block
-      if BLOCK[tag_name]
-        if last && INLINE[last]
-          end_tag(nil, last)
-        end
-      end
-
       # Some tags close themselves when a new one of themselves is reached.
       # ex, a tr will close the previous tr
       if CLOSE_SELF[tag_name] && last == tag_name

data/lib/volt/server/rack/http_request.rb

@@ -1,5 +1,7 @@
 require 'volt'
-require 'rack'
+if RUBY_PLATFORM != 'opal'
+  require 'rack'
+end
 
 module Volt
   # A request object for a HttpController. See Rack::Request for more details

data/lib/volt/server/rack/http_resource.rb

@@ -1,4 +1,6 @@
-require 'rack'
+if RUBY_PLATFORM != 'opal'
+  require 'rack'
+end
 require 'volt'
 require 'volt/router/routes'
 require 'volt/server/rack/http_request'

data/lib/volt/server/rack/opal_files.rb

@@ -13,6 +13,20 @@ module Volt
       Opal::Processor.source_map_enabled = Volt.source_maps?
       Opal::Processor.const_missing_enabled = true
 
+      # Setup Opal paths
+
+      # Add the lib directory to the load path
+      Opal.append_path(Volt.root + '/app')
+      Opal.append_path(Volt.root + '/lib')
+
+      Gem.loaded_specs.values.each do |gem|
+        path = gem.full_gem_path + '/app'
+
+        if Dir.exists?(path)
+          Opal.append_path(path)
+        end
+      end
+
       # Don't run arity checks in production
       # Opal::Processor.arity_check_enabled = !Volt.env.production?
       # Opal::Processor.dynamic_require_severity = :raise

data/lib/volt/server/socket_connection_handler.rb

@@ -1,9 +1,8 @@
 require 'json'
-require 'sockjs/session'
 require File.join(File.dirname(__FILE__), '../../../app/volt/tasks/query_tasks')
 
 module Volt
-  class SocketConnectionHandler < SockJS::Session
+  class SocketConnectionHandler
     # Create one instance of the dispatcher
 
     # We track the connected user_id with the channel for use with permissions.
@@ -20,6 +19,7 @@ module Volt
 
     # Sends a message to all, optionally skipping a users channel
     def self.send_message_all(skip_channel = nil, *args)
+      return unless defined?(@@channels)
       @@channels.each do |channel|
         if skip_channel && channel == skip_channel
           next
@@ -33,8 +33,6 @@ module Volt
 
       @@channels ||= []
       @@channels << self
-
-      super
     end
 
     def process_message(message)
@@ -48,21 +46,19 @@ module Volt
     def send_message(*args)
       str = JSON.dump([*args])
 
-      begin
-        send(str)
-      rescue MetaState::WrongStateError => e
-        puts "Tried to send to closed connection: #{e.inspect}"
-
-        # Mark this channel as closed
-        closed
-      end
+      @session.send(str)
     end
 
     def closed
-      # Remove ourself from the available channels
-      @@channels.delete(self)
-
-      QueryTasks.new(self).close!
+      unless @closed
+        @closed = true
+        # Remove ourself from the available channels
+        @@channels.delete(self)
+
+        QueryTasks.new(self).close!
+      else
+        Volt.logger.error("Socket Error: Connection already closed\n#{inspect}")
+      end
     end
 
     def inspect

data/lib/volt/server/websocket/rack_server_adaptor.rb

@@ -0,0 +1,19 @@
+begin
+  require 'puma'
+  RUNNING_SERVER = 'puma'
+rescue LoadError => e
+  begin
+    require 'thin'
+    RUNNING_SERVER = 'thin'
+  rescue LoadError => e
+    Volt.logger.error('Unable to find a compatible rack server, please make sure your Gemfile includes one of the following: thin or puma')
+  end
+end
+
+module Volt
+  class RackServerAdaptor
+    def self.load
+      Faye::WebSocket.load_adapter(RUNNING_SERVER)
+    end
+  end
+end

data/lib/volt/server/websocket/websocket_handler.rb

@@ -0,0 +1,42 @@
+require 'faye/websocket'
+require 'volt/server/socket_connection_handler'
+require 'volt/server/websocket/rack_server_adaptor'
+
+
+module Volt
+  # Setup the dispatcher for the socket connection handler.
+  # SocketConnectionHandler.dispatcher = Dispatcher.new
+
+  class WebsocketHandler
+    def initialize(app)
+      # Setup the rack server and adaptor
+      RackServerAdaptor.load
+
+      @app = app
+    end
+
+    def call(env)
+      if Faye::WebSocket.websocket?(env)
+        ws = Faye::WebSocket.new(env)
+
+        socket_connection_handler = SocketConnectionHandler.new(ws)
+
+        ws.on :message do |event|
+          socket_connection_handler.process_message(event.data)
+        end
+
+        ws.on :close do |event|
+          socket_connection_handler.closed
+
+          ws = nil
+        end
+
+        # Return async Rack response
+        ws.rack_response
+      else
+        # Call down to the app
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/volt/spec/capybara.rb

@@ -2,11 +2,11 @@ require 'volt/spec/sauce_labs'
 
 module Volt
   class << self
-    def setup_capybara(app_path)
+    def setup_capybara(app_path, volt_app=nil)
       browser = ENV['BROWSER']
 
       if browser
-        setup_capybara_app(app_path)
+        setup_capybara_app(app_path, volt_app)
 
         case browser
         when 'phantom'
@@ -27,19 +27,30 @@ module Volt
       end
     end
 
-    def setup_capybara_app(app_path)
+    def setup_capybara_app(app_path, volt_app)
       require 'capybara'
       require 'capybara/dsl'
       require 'capybara/rspec'
       require 'capybara/poltergeist'
+      require 'selenium-webdriver'
       require 'volt/server'
 
-      Capybara.server do |app, port|
-        require 'rack/handler/thin'
-        Rack::Handler::Thin.run(app, Port: port)
+      case RUNNING_SERVER
+      when 'thin'
+        Capybara.server do |app, port|
+          require 'rack/handler/thin'
+          Rack::Handler::Thin.run(app, Port: port)
+        end
+      when 'puma'
+        Capybara.server do |app, port|
+          Puma::Server.new(app).tap do |s|
+            s.add_tcp_listener Capybara.server_host, port
+          end.run.join
+        end
       end
 
-      Capybara.app = Server.new(app_path).app
+      # Setup server, use existing booted app
+      Capybara.app = Server.new(app_path, volt_app).app
     end
   end
 end