livereload_rails 1.0.0

data/example/config/initializers/livereload_rails.rb

@@ -0,0 +1,5 @@
+if defined?(LivereloadRails)
+  LivereloadRails.configure do |config|
+    config.logger.level = Logger::DEBUG
+  end
+end

data/example/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  root to: "application#home"
+end

data/example/config/secrets.yml

@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key is used for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+# You can use `rake secret` to generate a secure secret key.
+
+# Make sure the secrets in this file are kept private
+# if you're sharing your code publicly.
+
+development:
+  secret_key_base: f0c7e03d29eb39c19a35c0d7d985db54d133053cd6c99db410fc0f8d6b061fd0e39d7306985fc6c0cd6b4bf2db58e018f2643658a009e3c3c2ff5d9f333da9ae

data/example/log/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

data/example/tmp/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

data/lib/livereload_rails.rb

@@ -0,0 +1,48 @@
+require "logger"
+require "livereload_rails/version"
+require "livereload_rails/watcher"
+require "livereload_rails/stream"
+require "livereload_rails/web_socket"
+require "livereload_rails/client"
+require "livereload_rails/middleware"
+require "livereload_rails/railtie" if defined?(Rails)
+
+module LivereloadRails
+  class Error < StandardError; end
+  class HijackingNotSupported < Error; end
+
+  @matchers = {}
+  @logger = Logger.new(File::NULL)
+  @paths = lambda { |paths| paths }
+
+  class << self
+    attr_accessor :matchers
+    attr_accessor :logger
+    attr_accessor :paths
+
+    def configure
+      yield self
+    end
+  end
+end
+
+LivereloadRails.configure do |config|
+  config.matchers[:stylesheets] = lambda do |file|
+    "everything.css" if file["assets/stylesheets/"]
+  end
+
+  config.matchers[:assets] = lambda do |file|
+    "everything#{File.extname(file)}" if file["assets/"]
+  end
+
+  config.matchers[:views] = lambda do |file|
+    "everything.html" if file["views/"]
+  end
+
+  config.paths = lambda do |paths|
+    [File.join(Dir.pwd, "app/views")].concat(paths)
+  end
+
+  config.logger = Logger.new($stderr)
+  config.logger.level = Logger::INFO
+end

data/lib/livereload_rails/client.rb

@@ -0,0 +1,67 @@
+module LivereloadRails
+  class Client
+    FSM = {
+      initial: {},
+      opened: { "hello" => :on_hello },
+      idle:   { "info" => nil },
+      closed: {},
+    }
+
+    def initialize(ws)
+      @state = :initial
+
+      @connection = ws
+      @connection.on(:open) { @state = :opened }
+      @connection.on(:close) { close }
+      @connection.on(:message) do |frame|
+        data = JSON.parse(frame.data)
+        command = data["command"]
+
+        if FSM[@state].has_key?(command)
+          if handler = FSM[@state][command]
+            public_send(handler, data)
+          end
+        else
+          raise "Unexpected #{data["command"].inspect} in #{@state}."
+        end
+      end
+    end
+
+    def on_hello(frame)
+      send_data({
+        command: "hello",
+        protocols: [
+          "http://livereload.com/protocols/official-7"
+        ],
+        serverName: "Elabs' LivereloadRails",
+      })
+
+      @state = :idle
+    end
+
+    def reload(path, live: true)
+      send_data(command: "reload", path: path, liveCSS: live)
+    end
+
+    def alert(message)
+      send_data(command: "alert", message: message)
+    end
+
+    def close(reason = nil)
+      if @state != :closed
+        @state = :closed
+        alert(reason) if reason
+        @connection.close
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def send_data(object)
+      @connection.write JSON.generate(object)
+    end
+  end
+end

data/lib/livereload_rails/middleware.rb

@@ -0,0 +1,56 @@
+require "monitor"
+require "set"
+require "filewatcher"
+
+module LivereloadRails
+  class Middleware
+    ASYNC_RESPONSE = [-1, {}, []]
+
+    def initialize(app, assets:, matchers: LivereloadRails.matchers)
+      @app = app
+      @clients = Set.new
+      @clients.extend(MonitorMixin)
+
+      assets.configure do |environment|
+        @watcher = Watcher.new(LivereloadRails.paths.call(environment.paths), matchers: matchers) do |file|
+          client_path = "#{assets.prefix}/#{file}"
+          clients = @clients.synchronize { @clients.dup }
+
+          LivereloadRails.logger.debug "Reloading #{clients.size} clients with #{client_path}."
+          clients.each { |client| client.reload(client_path) }
+        end
+
+        @watcher_thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          @watcher.run
+        end
+      end
+    end
+
+    def call(env)
+      if env["PATH_INFO"] == "/livereload"
+        websocket = LivereloadRails::WebSocket.from_rack(env) do |ws|
+          client = LivereloadRails::Client.new(ws)
+
+          ws.on(:open) do
+            @clients.synchronize { @clients.add(client) }
+            LivereloadRails.logger.debug "#{client} joined: #{@clients.size}."
+          end
+
+          ws.on(:close) do
+            @clients.synchronize { @clients.delete(client) }
+            LivereloadRails.logger.debug "#{client} left: #{@clients.size}."
+          end
+        end
+
+        if websocket
+          ASYNC_RESPONSE
+        else
+          @app.call(env)
+        end
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/livereload_rails/railtie.rb

@@ -0,0 +1,10 @@
+require "livereload_rails"
+require "rails/engine"
+require "rack-livereload"
+
+module LivereloadRails
+  class Railtie < ::Rails::Engine
+    config.app_middleware.use Rack::LiveReload, live_reload_port: Rails::Server.new.options[:Port]
+    config.app_middleware.use LivereloadRails::Middleware, assets: config.assets
+  end
+end

data/lib/livereload_rails/stream.rb

@@ -0,0 +1,145 @@
+require "thread"
+require "nio"
+
+module LivereloadRails
+  # A non-blocking connection.
+  class Stream
+    READ_CHUNK = 1024 * 10
+    EMPTY = "".freeze
+    SWALLOW_ERRORS = [EOFError, IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::EPROTOTYPE]
+
+    # @example
+    #   stream = Stream.new(io) do |input|
+    #     # handle input
+    #   end
+    #   stream.loop
+    #
+    # @param [#read_nonblock, #write_nonblock] io
+    #
+    # @yield [input] whenever there is input to be consumed.
+    # @yieldparam input [String] streaming input data.
+    def initialize(io)
+      @io = io
+      @io_writer = @io.dup
+
+      @read_block = Proc.new
+
+      @input_buffer = "".b
+      @output_buffer = "".b
+      @output_queue = []
+      @mutex = Mutex.new
+
+      @wakeup, @waker = IO.pipe
+    end
+
+    # Queue a message to be sent later on the stream.
+    #
+    # There is no guarantee that the message will arrive. If you want a receipt
+    # of any kind you will need to wait for a reply.
+    #
+    # @param [String] message
+    def write(message)
+      @mutex.synchronize do
+        @output_queue.push(message)
+        @waker.write("\0")
+      end
+    end
+
+    # Close the connection immediately.
+    #
+    # TODO: SO_LINGER, close before or after sending outgoing data?
+    def close
+      @io.close unless @io.closed?
+      @io_writer.close unless @io_writer.closed?
+      @waker.close unless @waker.closed?
+      @wakeup.close unless @wakeup.closed?
+    end
+
+    # @return [Boolean] true if stream is closed.
+    def closed?
+      @io.closed?
+    end
+
+    # @param [NIO::Selector] selector
+    def loop(selector = NIO::Selector.new)
+      @looping = ! closed?
+      return unless @looping
+
+      wakeup_monitor = selector.register(@wakeup, :r)
+      wakeup_monitor.value = handler_for(:wakeup_handler)
+
+      read_monitor = selector.register(@io, :r)
+      read_monitor.value = handler_for(:read_handler)
+
+      register_writer(selector)
+
+      while @looping
+        selector.select { |monitor| monitor.value.call(monitor) }
+      end
+    ensure
+      selector.deregister(@io)
+      selector.deregister(@io_writer)
+      selector.deregister(@wakeup)
+    end
+
+    private
+
+    # @note The returned string is always the same object.
+    # @return [String] the current output buffer, possibly refilled from the output queue.
+    def output_buffer
+      if @output_buffer.empty? and @output_queue.length > 0
+        message = @mutex.synchronize { @output_queue.pop }
+        @output_buffer.replace(message)
+      end
+
+      @output_buffer
+    end
+
+    def register_writer(selector)
+      return if selector.registered?(@io_writer)
+      return if output_buffer.empty?
+
+      write_monitor = selector.register(@io_writer, :w)
+      write_monitor.value = handler_for(:write_handler)
+    end
+
+    def handler_for(method_name)
+      handler_method = method(method_name)
+
+      lambda do |monitor|
+        begin
+          handler_method.call(monitor)
+        rescue IO::WaitReadable, IO::WaitWritable
+          # No op. Let monitor continue be selected.
+        rescue *SWALLOW_ERRORS
+          @looping = false
+        ensure
+          @looping = false if $!
+        end
+      end
+    end
+
+    def wakeup_handler(monitor)
+      @wakeup.read(@wakeup.stat.size)
+      register_writer(monitor.selector)
+    end
+
+    def write_handler(monitor)
+      until output_buffer.empty?
+        bytes_written = @io.write_nonblock(output_buffer)
+        output_buffer[0, bytes_written] = EMPTY
+      end
+
+      monitor.close # write_nonblock did not raise, so we have no more output.
+    end
+
+    def read_handler(monitor)
+      Kernel.loop do
+        @io.read_nonblock(READ_CHUNK, @input_buffer)
+        @read_block[@input_buffer]
+      end
+    ensure
+      @input_buffer.clear
+    end
+  end
+end

data/lib/livereload_rails/version.rb

@@ -0,0 +1,3 @@
+module LivereloadRails
+  VERSION = "1.0.0"
+end

data/lib/livereload_rails/watcher.rb

@@ -0,0 +1,40 @@
+module LivereloadRails
+  class Watcher
+    def initialize(paths, matchers:, &update)
+      LivereloadRails.logger.debug "Watching #{paths} for changes."
+      @watcher = FileWatcher.new(paths)
+      @matchers = matchers
+      @update = update
+    end
+
+    def run(timeout = 0.2)
+      @watcher.watch(timeout) do |path, event|
+        unless FileTest.file?(path)
+          LivereloadRails.logger.debug "#{path} -> not a file."
+          next
+        end
+
+        unless filename = translate(path)
+          LivereloadRails.logger.debug "#{path} -> no match."
+          next
+        end
+
+        if filename.empty?
+          LivereloadRails.logger.debug "#{path} -> ignored."
+          next
+        end
+
+        LivereloadRails.logger.debug "#{path} -> #{filename}."
+        @update[filename]
+      end
+    end
+
+    def translate(path)
+      @matchers.find do |name, matcher|
+        if value = matcher.call(path)
+          return value
+        end
+      end
+    end
+  end
+end

data/lib/livereload_rails/web_socket.rb

@@ -0,0 +1,150 @@
+require "websocket"
+require "thread"
+require "nio"
+
+# TODO: Global flag could interfere with other code.
+::WebSocket.should_raise = true
+
+module LivereloadRails
+  # Embodies a WebSocket connection as a separate thread.
+  class WebSocket
+    PING_TIMEOUT = 1
+
+    class << self
+      # Same as #initialize, but first checks if the request is a websocket upgrade.
+      #
+      # @example
+      #   WebSocket.from_rack(env) do |ws|
+      #     …
+      #     ws.on(:open)    { … }
+      #     ws.on(:message) { … }
+      #     ws.on(:close)   { … }
+      #   end
+      #
+      # @return [WebSocket, nil] a websocket instance, or nil if request was not a websocket.
+      def from_rack(env, &block)
+        new(env, &block) if env["HTTP_UPGRADE"] == "websocket"
+      end
+    end
+
+    # @param env a rack environment hash
+    def initialize(env)
+      raise ArgumentError, "no block given" unless block_given?
+
+      @env = env
+      @handlers = { open: Set.new, close: Set.new, message: Set.new }
+      @handshake = ::WebSocket::Handshake::Server.new(secure: false)
+
+      queue = Queue.new
+
+      @thread = Thread.new do
+        begin
+          finish_initialize = proc do |event|
+            finish_initialize = nil
+            queue << event
+          end
+
+          hijack do
+            yield self
+            finish_initialize[:connected]
+          end
+        ensure
+          finish_initialize[$!] if finish_initialize
+        end
+      end
+
+      message = queue.pop
+      raise message if message.is_a?(Exception)
+    end
+
+    attr_reader :thread
+
+    # Register an event handler.
+    #
+    # @example
+    #   handler = websocket.on(:open) { … }
+    #
+    # @note If an event handler raises an error, handlers after it will not run.
+    # @param [Symbol] event (one of :open, :close, :message)
+    def on(event, &handler)
+      raise ArgumentError, "no event named #{event.inspect}" unless @handlers.has_key?(event)
+
+      @handlers[event].add(handler)
+      handler
+    end
+
+    # Queues data for writing. It is not guaranteed that client will receive message.
+    #
+    # @param [#to_s] data
+    # @param [Symbol] type
+    def write(data, type: :text)
+      frame = ::WebSocket::Frame::Outgoing::Server.new(data: data, type: type, version: @handshake.version)
+      @stream.write(frame.to_s)
+    end
+
+    # Close the connection.
+    #
+    # Can safely be called multiple times.
+    def close
+      @stream.close if @stream
+    end
+
+    private
+
+    # Trigger all handlers for the given event with the given arguments.
+    #
+    # @param [Symbol] event
+    def trigger(event, *args)
+      @handlers[event].each { |handler| handler.call(*args) }
+    end
+
+    # Main loop of the WebSocket thread.
+    def hijack
+      unless @env["rack.hijack?"]
+        raise HijackingNotSupported, "server does not support hijacking"
+      end
+
+      # See http://www.rubydoc.info/github/rack/rack/file/SPEC
+      @env["rack.hijack"].call
+      @io = @env["rack.hijack_io"]
+
+      yield
+
+      @handshake.from_rack(@env)
+      raise @handshake.error unless @handshake.valid?
+
+      frame_parser = ::WebSocket::Frame::Incoming::Server.new(version: @handshake.version)
+      @stream = LivereloadRails::Stream.new(@io) do |input|
+        handle_frames(frame_parser, input)
+      end
+      @stream.write(@handshake.to_s)
+
+      trigger :open
+      handle_frames(frame_parser, @handshake.leftovers)
+
+      @stream.loop
+    ensure
+      close
+      trigger :close, *$!
+    end
+
+    def handle_frames(frame_parser, data)
+      frame_parser << data
+
+      while frame = frame_parser.next
+        case frame.type
+        when :text, :binary
+          trigger :message, frame
+        when :ping
+          write(nil, :pong)
+        when :pong
+          # TODO: reset timeout timer.
+        when :close
+          close
+        else
+          raise "unknown frame type #{frame.type}"
+        end
+      end
+    end
+  end
+end