roadrunner-live-reload 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 119f7e23b76f8359cbaac564919f5fe5f320fafb
+  data.tar.gz: e55cdb91290439dcb508c99af0fe7b5ebdec067a
+SHA512:
+  metadata.gz: e90d3a5e6f7095e9c553bca1d309acedcc8aeba6e057e0bf21b0a56e3ac143c11efcbdbf372d23585bb5921938f8278628a22076f9095a3d2956454c86f6f05b
+  data.tar.gz: 0ac4a3891149bf9c0ef284c3122aa753f86f0ec16daea93b09d1f356194afc3433f107ab3f0e3162b3decaa4808994c44ac11691fb3443abeda0c6aae175da4a

data/.gitignore

@@ -0,0 +1,2 @@
+roadrunner*.gem
+.yardoc/*

data/.rspec

@@ -0,0 +1 @@
+-f d -c

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.2)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Alcides Queiroz (alcidesqueiroz@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+RoadRunner
+=====
+
+What is?
+--------
+
+RoadRunner is a simple, but powerful, live reload tool totally written in Ruby. Though RoadRunner was made in Ruby, it is language-agnostic, in simple words: you can use RoadRunner with ANY language or platform (or operating system) in your back-end. You just need ruby installed.
+
+
+Usage
+--------------------
+1) Run:
+```ruby
+sudo gem install roadrunner-live-reload
+``` 
+
+2) Create a roadrunner.yml file in the root folder of your project by running the command `roadrunner setup`.
+
+Your file structure will look like this:
+```yaml
+config:
+  polling_interval: 0.1
+  change_check_strategy: modification_time #You also can use 'checksum'
+  live_reload_port: 9876
+  web_server_port: 9875
+  files: [
+           ["/relative/path/to/some/css-file.css", "/relative/path/in/your/web-server.css"],
+           "/equivalent/path.css"
+         ]
+
+```
+If the relative path for a file to be monitored in your project folder structure is equal to its URL in web server, you just have to add this path (relative to the root folder) to the "files" collection. 
+
+```yaml
+  files: [
+           "/same/path.css",
+           ...
+         ]
+```
+
+But if the paths are different, you can map it easily:
+```yaml
+  files: [
+           ["/relative/path/to/some/css-file.css", "/relative/path/in/your/web-server.css"],
+           ...
+         ]
+```
+3) RoadRunner also starts a tiny web server to serve the roadrunner.js script file. So, add a reference to this file in your application layout/template/master page.
+```javascript
+<script src="http://localhost:9875/roadrunner.js"></script>
+```
+4) Open a terminal, "cd" to your project root folder (where roadrunner.yml is located) and run: 
+```
+roadrunner
+```
+5) Open your application in your browser
+
+License
+-------
+This code is free to use under the terms of the MIT license

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require 'rubygems'
+require 'bundler/gem_tasks'
+
+Dir.glob(File.join(File.join(File.dirname(__FILE__), 'lib/tasks/*.rake'))).each {|rt| import rt}
+task :default => :register_roadrunner

data/distr/roadrunner

@@ -0,0 +1,29 @@
+#!{RUBY_PATH}
+require '{ROADRUNNER_ROOT_PATH}/src/roadrunner.rb'
+require 'fileutils'
+
+roadrunner_root_path = "{ROADRUNNER_ROOT_PATH}"
+
+case ARGV[0]
+when "--help", "-h"
+  puts "Description:"
+  puts "\tStarts the RoadRunner server, a live reload tool which notifies listeners (ie: a web application) \n\tthat your CSS, JS, HTML files (or any file type you want) has changed.\n\n"
+  puts "Options:"
+  puts "%15s - The same as just \"compass\"" % "watch"
+  puts "%15s - Creates a new roadrunner.yml config file in the current folder" % "setup"
+  puts "%15s - Show this message" % "--help, -h"
+  puts "%15s - Print out version information" % "--version, -v"
+
+when "--version", "-v"
+	puts "Roadrunner Version #{RoadRunner::VERSION}\nCopyright (c) Alcides Queiroz"
+
+when "setup"
+  FileUtils.cp("#{roadrunner_root_path}/roadrunner.sample.yml", File.join(Dir.pwd, "roadrunner.yml"))
+  puts "Sample config file created successfully!"
+  
+when "watch"
+  RoadRunner.init_server
+
+else
+  RoadRunner.init_server
+end

data/distr/roadrunner.bat

@@ -0,0 +1,6 @@
+@ECHO OFF
+IF NOT "%~f0" == "~f0" GOTO :WinNT
+@"ruby.exe" "{ROADRUNNER_LOADER}" %1 %2 %3 %4 %5 %6 %7 %8 %9
+GOTO :EOF
+:WinNT
+@"ruby.exe" "%~dpn0" %*

data/lib/os.rb

@@ -0,0 +1,17 @@
+module OS
+  def OS.windows?
+    (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+  end
+
+  def OS.mac?
+   (/darwin/ =~ RUBY_PLATFORM) != nil
+  end
+
+  def OS.unix?
+    !OS.windows?
+  end
+
+  def OS.linux?
+    OS.unix? and not OS.mac?
+  end
+end

data/lib/tasks/register.rake

@@ -0,0 +1,24 @@
+task :register_roadrunner do 
+	ruby_path = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
+	ruby_dir = File.dirname(ruby_path)
+	distr_files_dir = File.expand_path(File.join(File.dirname(__FILE__), "../../distr" ))
+	roadrunner_root_path = File.expand_path(File.join(File.dirname(__FILE__), "../.." ))
+
+	FileUtils.cp(File.join(distr_files_dir, "roadrunner"), ruby_dir)
+	FileUtils.cp(File.join(distr_files_dir, "roadrunner.bat"), ruby_dir)
+
+	compass_loader_path = File.join(ruby_dir, "roadrunner")
+	compass_bat_path = File.join(ruby_dir, "roadrunner.bat")
+
+	compass_loader_file_text = File.read(compass_loader_path)
+							   .gsub(/{RUBY_PATH}/, ruby_path)
+							   .gsub(/{ROADRUNNER_ROOT_PATH}/, roadrunner_root_path)
+
+	compass_bat_file_text = File.read(compass_bat_path)
+							.gsub(/{ROADRUNNER_LOADER}/, compass_loader_path)
+
+	File.open(compass_loader_path, "w") { |file| file << compass_loader_file_text }
+	File.open(compass_bat_path, "w") { |file| file << compass_bat_file_text }
+
+	#`echo #{File.dirname(__FILE__)} >> d:\\projects\\roadrunner\\teste`
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module RoadRunner
+  VERSION = "0.3.1".freeze
+end

data/lib/websocket.rb

@@ -0,0 +1,588 @@
+# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+# Lincense: New BSD Lincense
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07
+# Reference: http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10
+
+require "base64"
+require "socket"
+require "uri"
+require "digest/md5"
+require "digest/sha1"
+require "openssl"
+require "stringio"
+
+
+class WebSocket
+
+    class << self
+
+        attr_accessor(:debug)
+
+    end
+
+    class Error < RuntimeError
+
+    end
+    
+    WEB_SOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    OPCODE_CONTINUATION = 0x00
+    OPCODE_TEXT = 0x01
+    OPCODE_BINARY = 0x02
+    OPCODE_CLOSE = 0x08
+    OPCODE_PING = 0x09
+    OPCODE_PONG = 0x0a
+
+    def initialize(arg, params = {})
+      if params[:server] # server
+
+        @server = params[:server]
+        @socket = arg
+        line = gets()
+        if !line
+          raise(WebSocket::Error, "Client disconnected without sending anything.")
+        end
+        line = line.chomp()
+        if !(line =~ /\AGET (\S+) HTTP\/1.1\z/n)
+          raise(WebSocket::Error, "Invalid request: #{line}")
+        end
+        @path = $1
+        read_header()
+        if @header["sec-websocket-version"]
+          @web_socket_version = @header["sec-websocket-version"]
+          @key3 = nil
+        elsif @header["sec-websocket-key1"] && @header["sec-websocket-key2"]
+          @web_socket_version = "hixie-76"
+          @key3 = read(8)
+        else
+          @web_socket_version = "hixie-75"
+          @key3 = nil
+        end
+        if !@server.accepted_origin?(self.origin)
+          raise(WebSocket::Error,
+            ("Unaccepted origin: %s (server.accepted_domains = %p)\n\n" +
+              "To accept this origin, write e.g. \n" +
+              "  WebSocketServer.new(..., :accepted_domains => [%p]), or\n" +
+              "  WebSocketServer.new(..., :accepted_domains => [\"*\"])\n") %
+            [self.origin, @server.accepted_domains, @server.origin_to_domain(self.origin)])
+        end
+        @handshaked = false
+
+      else # client
+        
+        @web_socket_version = "hixie-76"
+        uri = arg.is_a?(String) ? URI.parse(arg) : arg
+
+        if uri.scheme == "ws"
+          default_port = 80
+        elsif uri.scheme = "wss"
+          default_port = 443
+        else
+          raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
+        end
+
+        @path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
+        host = uri.host + ((!uri.port || uri.port == default_port) ? "" : ":#{uri.port}")
+        origin = params[:origin] || "http://#{uri.host}"
+        key1 = generate_key()
+        key2 = generate_key()
+        key3 = generate_key3()
+
+        socket = TCPSocket.new(uri.host, uri.port || default_port)
+
+        if uri.scheme == "ws"
+          @socket = socket
+        else
+          @socket = ssl_handshake(socket)
+        end
+
+        write(
+          "GET #{@path} HTTP/1.1\r\n" +
+          "Upgrade: WebSocket\r\n" +
+          "Connection: Upgrade\r\n" +
+          "Host: #{host}\r\n" +
+          "Origin: #{origin}\r\n" +
+          "Sec-WebSocket-Key1: #{key1}\r\n" +
+          "Sec-WebSocket-Key2: #{key2}\r\n" +
+          "\r\n" +
+          "#{key3}")
+        flush()
+
+        line = gets().chomp()
+        raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
+        read_header()
+        if (@header["sec-websocket-origin"] || "").downcase() != origin.downcase()
+          raise(WebSocket::Error,
+            "origin doesn't match: '#{@header["sec-websocket-origin"]}' != '#{origin}'")
+        end
+        reply_digest = read(16)
+        expected_digest = hixie_76_security_digest(key1, key2, key3)
+        if reply_digest != expected_digest
+          raise(WebSocket::Error,
+            "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
+        end
+        @handshaked = true
+
+      end
+      @received = []
+      @buffer = ""
+      @closing_started = false
+    end
+
+    attr_reader(:server, :header, :path)
+
+    def handshake(status = nil, header = {})
+      if @handshaked
+        raise(WebSocket::Error, "handshake has already been done")
+      end
+      status ||= "101 Switching Protocols"
+      def_header = {}
+      case @web_socket_version
+        when "hixie-75"
+          def_header["WebSocket-Origin"] = self.origin
+          def_header["WebSocket-Location"] = self.location
+          extra_bytes = ""
+        when "hixie-76"
+          def_header["Sec-WebSocket-Origin"] = self.origin
+          def_header["Sec-WebSocket-Location"] = self.location
+          extra_bytes = hixie_76_security_digest(
+            @header["Sec-WebSocket-Key1"], @header["Sec-WebSocket-Key2"], @key3)
+        else
+          def_header["Sec-WebSocket-Accept"] = security_digest(@header["sec-websocket-key"])
+          extra_bytes = ""
+      end
+      header = def_header.merge(header)
+      header_str = header.map(){ |k, v| "#{k}: #{v}\r\n" }.join("")
+      # Note that Upgrade and Connection must appear in this order.
+      write(
+        "HTTP/1.1 #{status}\r\n" +
+        "Upgrade: websocket\r\n" +
+        "Connection: Upgrade\r\n" +
+        "#{header_str}\r\n#{extra_bytes}")
+      flush()
+      @handshaked = true
+    end
+
+    def send(data)
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      case @web_socket_version
+        when "hixie-75", "hixie-76"
+          data = force_encoding(data.dup(), "ASCII-8BIT")
+          write("\x00#{data}\xff")
+          flush()
+        else
+          send_frame(OPCODE_TEXT, data, !@server)
+      end
+    end
+    
+    def receive()
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      case @web_socket_version
+        
+        when "hixie-75", "hixie-76"
+          packet = gets("\xff")
+          return nil if !packet
+          if packet =~ /\A\x00(.*)\xff\z/nm
+            return force_encoding($1, "UTF-8")
+          elsif packet == "\xff" && read(1) == "\x00" # closing
+            close(1005, "", :peer)
+            return nil
+          else
+            raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
+          end
+        
+        else
+          begin
+            bytes = read(2).unpack("C*")
+            fin = (bytes[0] & 0x80) != 0
+            opcode = bytes[0] & 0x0f
+            mask = (bytes[1] & 0x80) != 0
+            plength = bytes[1] & 0x7f
+            if plength == 126
+              bytes = read(2)
+              plength = bytes.unpack("n")[0]
+            elsif plength == 127
+              bytes = read(8)
+              (high, low) = bytes.unpack("NN")
+              plength = high * (2 ** 32) + low
+            end
+            if @server && !mask
+              # Masking is required.
+              @socket.close()
+              raise(WebSocket::Error, "received unmasked data")
+            end
+            mask_key = mask ? read(4).unpack("C*") : nil
+            payload = read(plength)
+            payload = apply_mask(payload, mask_key) if mask
+            case opcode
+              when OPCODE_TEXT
+                return force_encoding(payload, "UTF-8")
+              when OPCODE_BINARY
+                raise(WebSocket::Error, "received binary data, which is not supported")
+              when OPCODE_CLOSE
+                close(1005, "", :peer)
+                return nil
+              when OPCODE_PING
+                raise(WebSocket::Error, "received ping, which is not supported")
+              when OPCODE_PONG
+              else
+                raise(WebSocket::Error, "received unknown opcode: %d" % opcode)
+            end
+          rescue EOFError
+            return nil
+          end
+        
+      end
+    end
+    
+    def tcp_socket
+      return @socket
+    end
+
+    def host
+      return @header["host"]
+    end
+
+    def origin
+      case @web_socket_version
+        when "7", "8"
+          name = "sec-websocket-origin"
+        else
+          name = "origin"
+      end
+      if @header[name]
+        return @header[name]
+      else
+        raise(WebSocket::Error, "%s header is missing" % name)
+      end
+    end
+
+    def location
+      return "ws://#{self.host}#{@path}"
+    end
+    
+    # Does closing handshake.
+    def close(code = 1005, reason = "", origin = :self)
+      if !@closing_started
+        case @web_socket_version
+          when "hixie-75", "hixie-76"
+            write("\xff\x00")
+          else
+            if code == 1005
+              payload = ""
+            else
+              payload = [code].pack("n") + force_encoding(reason.dup(), "ASCII-8BIT")
+            end
+            send_frame(OPCODE_CLOSE, payload, false)
+        end
+      end
+      @socket.close() if origin == :peer
+      @closing_started = true
+    end
+    
+    def close_socket()
+      @socket.close()
+    end
+
+  private
+
+    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+
+    def read_header()
+      @header = {}
+      while line = gets()
+        line = line.chomp()
+        break if line.empty?
+        if !(line =~ /\A(\S+): (.*)\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @header[$1] = $2
+        @header[$1.downcase()] = $2
+      end
+      if !@header["upgrade"]
+        raise(WebSocket::Error, "Upgrade header is missing")
+      end
+      if !(@header["upgrade"] =~ /\AWebSocket\z/i)
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
+      end
+      if !@header["connection"]
+        raise(WebSocket::Error, "Connection header is missing")
+      end
+      if @header["connection"].split(/,/).grep(/\A\s*Upgrade\s*\z/i).empty?
+        raise(WebSocket::Error, "invalid Connection: " + @header["connection"])
+      end
+    end
+
+    def send_frame(opcode, payload, mask)
+      payload = force_encoding(payload.dup(), "ASCII-8BIT")
+      # Setting StringIO's encoding to ASCII-8BIT.
+      buffer = StringIO.new(force_encoding("", "ASCII-8BIT"))
+      write_byte(buffer, 0x80 | opcode)
+      masked_byte = mask ? 0x80 : 0x00
+      if payload.bytesize <= 125
+        write_byte(buffer, masked_byte | payload.bytesize)
+      elsif payload.bytesize < 2 ** 16
+        write_byte(buffer, masked_byte | 126)
+        buffer.write([payload.bytesize].pack("n"))
+      else
+        write_byte(buffer, masked_byte | 127)
+        buffer.write([payload.bytesize / (2 ** 32), payload.bytesize % (2 ** 32)].pack("NN"))
+      end
+      if mask
+        mask_key = Array.new(4){ rand(256) }
+        buffer.write(mask_key.pack("C*"))
+        payload = apply_mask(payload, mask_key)
+      end
+      buffer.write(payload)
+      write(buffer.string)
+    end
+
+    def gets(rs = $/)
+      line = @socket.gets(rs)
+      $stderr.printf("recv> %p\n", line) if WebSocket.debug
+      return line
+    end
+
+    def read(num_bytes)
+      str = @socket.read(num_bytes)
+      $stderr.printf("recv> %p\n", str) if WebSocket.debug
+      if str && str.bytesize == num_bytes
+        return str
+      else
+        raise(EOFError)
+      end
+    end
+
+    def write(data)
+      if WebSocket.debug
+        data.scan(/\G(.*?(\n|\z))/n) do
+          $stderr.printf("send> %p\n", $&) if !$&.empty?
+        end
+      end
+      @socket.write(data)
+    end
+
+    def flush()
+      @socket.flush()
+    end
+    
+    def write_byte(buffer, byte)
+      buffer.write([byte].pack("C"))
+    end
+    
+    def security_digest(key)
+      return Base64.encode64(Digest::SHA1.digest(key + WEB_SOCKET_GUID)).gsub(/\n/, "")
+    end
+
+    def hixie_76_security_digest(key1, key2, key3)
+      bytes1 = websocket_key_to_bytes(key1)
+      bytes2 = websocket_key_to_bytes(key2)
+      return Digest::MD5.digest(bytes1 + bytes2 + key3)
+    end
+
+    def apply_mask(payload, mask_key)
+      orig_bytes = payload.unpack("C*")
+      new_bytes = []
+      orig_bytes.each_with_index() do |b, i|
+        new_bytes.push(b ^ mask_key[i % 4])
+      end
+      return new_bytes.pack("C*")
+    end
+
+    def generate_key()
+      spaces = 1 + rand(12)
+      max = 0xffffffff / spaces
+      number = rand(max + 1)
+      key = (number * spaces).to_s()
+      (1 + rand(12)).times() do
+        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
+        pos = rand(key.size + 1)
+        key[pos...pos] = char
+      end
+      spaces.times() do
+        pos = 1 + rand(key.size - 1)
+        key[pos...pos] = " "
+      end
+      return key
+    end
+
+    def generate_key3()
+      return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+    end
+
+    def websocket_key_to_bytes(key)
+      num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
+      return [num].pack("N")
+    end
+
+    def force_encoding(str, encoding)
+      if str.respond_to?(:force_encoding)
+        return str.force_encoding(encoding)
+      else
+        return str
+      end
+    end
+
+    def ssl_handshake(socket)
+      ssl_context = OpenSSL::SSL::SSLContext.new()
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.sync_close = true
+      ssl_socket.connect()
+      return ssl_socket
+    end
+
+end
+
+
+class WebSocketServer
+
+    def initialize(params_or_uri, params = nil)
+      if params
+        uri = params_or_uri.is_a?(String) ? URI.parse(params_or_uri) : params_or_uri
+        params[:port] ||= uri.port
+        params[:accepted_domains] ||= [uri.host]
+      else
+        params = params_or_uri
+      end
+      @port = params[:port] || 80
+      @accepted_domains = params[:accepted_domains]
+      if !@accepted_domains
+        raise(ArgumentError, "params[:accepted_domains] is required")
+      end
+      if params[:host]
+        @tcp_server = TCPServer.open(params[:host], @port)
+      else
+        @tcp_server = TCPServer.open(@port)
+      end
+    end
+
+    attr_reader(:tcp_server, :port, :accepted_domains)
+
+    def run(&block)
+      while true
+        Thread.start(accept()) do |s|
+          begin
+            ws = create_web_socket(s)
+            yield(ws) if ws
+          rescue => ex
+            print_backtrace(ex)
+          ensure
+            begin
+              ws.close_socket() if ws
+            rescue
+            end
+          end
+        end
+      end
+    end
+
+    def accept()
+      return @tcp_server.accept()
+    end
+
+    def accepted_origin?(origin)
+      domain = origin_to_domain(origin)
+      return @accepted_domains.any?(){ |d| File.fnmatch(d, domain) }
+    end
+
+    def origin_to_domain(origin)
+      if origin == "null" || origin == "file://"  # local file
+        return "null"
+      else
+        return URI.parse(origin).host
+      end
+    end
+
+    def create_web_socket(socket)
+      ch = socket.getc()
+      if ch == ?<
+        # This is Flash socket policy file request, not an actual Web Socket connection.
+        send_flash_socket_policy_file(socket)
+        return nil
+      else
+        socket.ungetc(ch) if ch
+        return WebSocket.new(socket, :server => self)
+      end
+    end
+
+  private
+
+    def print_backtrace(ex)
+      $stderr.printf("%s: %s (%p)\n", ex.backtrace[0], ex.message, ex.class)
+      for s in ex.backtrace[1..-1]
+        $stderr.printf("        %s\n", s)
+      end
+    end
+
+    # Handles Flash socket policy file request sent when web-socket-js is used:
+    # http://github.com/gimite/web-socket-js/tree/master
+    def send_flash_socket_policy_file(socket)
+      socket.puts('<?xml version="1.0"?>')
+      socket.puts('<!DOCTYPE cross-domain-policy SYSTEM ' +
+        '"http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">')
+      socket.puts('<cross-domain-policy>')
+      for domain in @accepted_domains
+        next if domain == "file://"
+        socket.puts("<allow-access-from domain=\"#{domain}\" to-ports=\"#{@port}\"/>")
+      end
+      socket.puts('</cross-domain-policy>')
+      socket.close()
+    end
+
+end
+
+
+if __FILE__ == $0
+  Thread.abort_on_exception = true
+
+  if ARGV[0] == "server" && ARGV.size == 3
+
+    server = WebSocketServer.new(
+      :accepted_domains => [ARGV[1]],
+      :port => ARGV[2].to_i())
+    puts("Server is running at port %d" % server.port)
+    server.run() do |ws|
+      puts("Connection accepted")
+      puts("Path: #{ws.path}, Origin: #{ws.origin}")
+      if ws.path == "/"
+        ws.handshake()
+        while data = ws.receive()
+          printf("Received: %p\n", data)
+          ws.send(data)
+          printf("Sent: %p\n", data)
+        end
+      else
+        ws.handshake("404 Not Found")
+      end
+      puts("Connection closed")
+    end
+
+  elsif ARGV[0] == "client" && ARGV.size == 2
+
+    client = WebSocket.new(ARGV[1])
+    puts("Connected")
+    Thread.new() do
+      while data = client.receive()
+        printf("Received: %p\n", data)
+      end
+    end
+    $stdin.each_line() do |line|
+      data = line.chomp()
+      client.send(data)
+      printf("Sent: %p\n", data)
+    end
+
+  else
+
+    $stderr.puts("Usage:")
+    $stderr.puts("  ruby web_socket.rb server ACCEPTED_DOMAIN PORT")
+    $stderr.puts("  ruby web_socket.rb client ws://HOST:PORT/")
+    exit(1)
+
+  end
+end

data/roadrunner-0.3.1.debug.js

@@ -0,0 +1,126 @@
+;(function(global){
+  
+  /**
+   * @class RoadRunner
+   * @static
+   */
+  var RoadRunner = {};
+
+  var host = location.hostname || "localhost";
+  var port = 9876;
+  
+  /**
+   * Creates a WebSocket client and listen to the RoadRunner server
+   * @method listen
+   * @static
+   */
+  RoadRunner.listen = function(){
+    var socket = new WebSocket("ws://" + host + ":" + port);
+    var rr = this;
+    socket.onmessage = function(msg){  
+      var msgJSON = JSON.parse(msg["data"]);
+      rr.resolveChange(msgJSON)
+    } 
+  }
+
+  /**
+   * Split a file path in path, file and extension 
+   * @method _getPathParts
+   * @param url {String} URL to split
+   * @return {Object} the Hash containing the URL parts
+   * @private
+   */
+  var _getPathParts = function(url) {
+    if(!url.match(/[\/\\]/)) url = "/" + url;
+
+    var m = url.match(/(.*)[\/\\]([^\/\\]+)\.(\w+)$/);
+    
+    return {
+        fullPath: url,
+        path: m[1],
+        file: m[2],
+        ext: m[3]
+    };
+  };
+
+  /**
+   * Shows a warning in console
+   * @method _warn
+   * @param url {String} Message to be shown
+   * @private
+   */
+  var _warn = function(msg){
+    console.warn("RoadRunner:", msg);
+  }
+
+  /**
+   * Resolve changes depending on file type
+   * @method resolveChange
+   * @param msg {Object} The JSON message with info about the change
+   * @static
+   */
+  RoadRunner.resolveChange = function(msg){
+    var URLparts = _getPathParts(msg.filepath);
+    var resolver;
+    switch(URLparts.ext.toLowerCase()){
+      case "css":
+        resolver = CSSResolver;
+        break;
+
+      case "js":
+        resolver = GenericResolver;
+        break;
+
+      case "png":
+      case "gif":
+      case "svg":
+      case "jpg":
+      case "jpeg":
+        //ToDo: Create a resolver for images to update img tags and backgrounds without reloading the page
+        resolver = GenericResolver;
+        break;
+
+      case "html":
+      case "htm":
+        resolver = GenericResolver;
+
+      default:
+        resolver = GenericResolver;
+    }
+    resolver.resolve(URLparts);
+    _warn("The file \"" + URLparts.fullPath + "\" has changed at " + msg.modified_at + ".");
+  }
+
+  /**
+   * Generic strategy to resolve static files changes, 
+   * its behaviour is to refresh the page forcing to not use the local cache
+   * @class GenericResolver
+   * @static
+   */
+  var GenericResolver = {};
+  GenericResolver.resolve = function(URLparts){
+    location.reload(true);
+  }
+
+  /**
+   * Strategy to resolve CSS files changes, 
+   * its behaviour is update link tags' href references and force the browser to not using the cache
+   * @class CSSResolver
+   * @static
+   */
+  var CSSResolver = {};
+  CSSResolver.resolve = function(URLparts){
+    var path = URLparts.fullPath;
+    var stylesheets = global.document.querySelectorAll("link[href*=\"" + path + "\"]");
+
+    if(stylesheets.length > 0){
+      for(var i = 0; i < stylesheets.length; i++){
+        var stylesheet = stylesheets[i];
+        stylesheet.setAttribute("href", path + "?rand=" + Math.floor(Math.random() * 9999));
+
+      }
+    }
+  }
+      
+  RoadRunner.listen();
+})(window);

data/roadrunner-live-reload.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "roadrunner-live-reload"
+  s.version     = RoadRunner::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alcides Queiroz Aguiar"]
+  s.email       = ["alcidesqueiroz@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/roadrunner"
+  s.extra_rdoc_files = ["README.md"]
+  s.summary     = "A live reload command line tool written in ruby."
+  s.description = s.summary
+  s.extensions = ["Rakefile"]
+
+  #s.files         = `git ls-files`.split($\)
+  s.files         = [ ".gitignore", ".rspec",  
+                      "Gemfile", "Gemfile.lock", 
+                      "LICENSE", "README.md", "Rakefile", 
+                      "lib/version.rb", "lib/websocket.rb", "src/webserver.rb", 
+                      "lib/tasks/register.rake", "lib/os.rb", 
+                      "roadrunner-0.3.1.debug.js", "roadrunner-live-reload.gemspec", 
+                      "roadrunner.sample.yml", "spec/comingsoon.gitkeep", 
+                      "src/roadrunner.rb", "distr/roadrunner", "distr/roadrunner.bat"]
+
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rake", "~> 0.9.2"
+end

data/roadrunner.sample.yml

@@ -0,0 +1,9 @@
+config:
+  polling_interval: 0.1
+  change_check_strategy: modification_time #You also can use 'checksum'
+  live_reload_port: 9876
+  web_server_port: 9875
+  files: [
+           ["/relative/path/to/some/css-file.css", "/relative/path/in/your/web-server.css"],
+           "/equivalent/path.css"
+         ]

data/spec/comingsoon.gitkeep

@@ -0,0 +1,13 @@
+APOLOGY
+=======
+
+Roadrunner is being succesfully used for a few months, since its very first version there have been almost no changes.
+Recently (since I'm completely outta time) I made an effort to transform the existing code in a gem, to make it easier to use.
+I confess, once I didn't wrote tests in the very beginning of the development process for this tool (totally my fault), it became harder and harder to have enough time to retroactively cover the code with tests (I know there's not so much code to test, but it doesn't make any difference, due to time availability).
+
+Last, but not least: I really promise, when I have enough time I'll do my homework and cover this tool with tests.
+
+I Hope Roadrunner is useful for you.
+
+Sincerely yours
+Alcides Queiroz - alcidesqueiroz (at) gmail (dot) com

data/src/roadrunner.rb

@@ -0,0 +1,162 @@
+require 'socket'
+require 'yaml'
+require_relative '../lib/websocket'
+require_relative '../lib/version'
+require_relative 'webserver'
+
+module RoadRunner
+  def self.root_dir
+     Dir.pwd
+  end
+
+  def self.config_file
+    File.join(root_dir, "roadrunner.yml")
+  end
+
+  def self.config key=nil
+    unless defined? @@config
+      begin
+        @@config = YAML.load_file(config_file)["config"]
+        parse_config_key key
+      rescue
+        puts "Could not found the roadrunner.yml configuration file."
+        puts "To create a new configuration file run 'roadrunner setup', then edit the generated file."
+        puts "Finishing a little early =("
+        abort
+      end
+    end
+    @@config
+  end
+
+  def self.parse_config_key key
+    return @@config if key.nil?
+    key_parts = key.split(/[\.,>]/)
+    
+    ret = @@config
+    key_parts.each do |part|
+      ret = ret[part];
+    end
+
+    ret
+  end
+
+  def self.load_files_to_monitor
+    files = config("files")
+    @@files_to_monitor = []
+    files.each do |path|
+      if path.is_a? Array
+        relative_path = path[0]
+        url_relative_path = path[1]
+      else
+        relative_path = path
+        url_relative_path = path
+      end
+      
+      absolute_path = File.join(root_dir, relative_path)
+      file = File.open(absolute_path)
+      @@files_to_monitor << {
+        :relative_path => relative_path,
+        :absolute_path => absolute_path,
+        :url_relative_path => url_relative_path,
+        :mtime => file.mtime,
+        :checksum => calculate_checksum(file)
+      }
+      file.close
+    end
+  end
+
+  def self.monitor_files
+    load_files_to_monitor
+    polling_interval = config("polling_interval")
+
+    strategy = config("change_check_strategy")
+    checksum_checker = Proc.new do |file, file_hash| 
+      checksum = calculate_checksum(file)
+
+      if checksum != file_hash[:checksum]
+        file_hash[:mtime] = Time.now
+        file_hash[:checksum] = checksum
+        notify_change file, file_hash[:relative_path], file_hash[:url_relative_path]
+      end
+    end
+
+    mtime_checker = Proc.new do |file, file_hash|
+      if file.mtime != file_hash[:mtime]
+        file_hash[:mtime] = file.mtime
+        notify_change file, file_hash[:relative_path], file_hash[:url_relative_path]
+      end
+    end
+
+    if strategy == "checksum"
+      checker = checksum_checker
+    elsif strategy == "modification_time"
+      checker = mtime_checker
+    else
+      raise "Invalid change_check_strategy"
+    end
+
+    loop do
+      sleep polling_interval
+      @@files_to_monitor.each do |file_hash|
+        begin
+          file = File.open(file_hash[:absolute_path])
+          checker.call file, file_hash
+          file.close
+        rescue
+          puts "/!\\ Could not found the file #{file_hash[:absolute_path]} "
+        end
+      end
+    end
+  end
+
+  def self.notify_change file, relative_path, url_relative_path
+    puts "!!! File '#{file.path}' changed at #{file.mtime}. \nNotification sent to listeners."
+    lost_connection = []
+    @@sockets.each do |socket|
+      begin
+        socket.send "{ \"filepath\": \"#{url_relative_path.gsub("\\", "/")}\", \"modified_at\": \"#{file.mtime}\" }"
+      rescue 
+        lost_connection << socket 
+      end
+    end
+    
+    lost_connection.each do |socket|
+      @@sockets.delete socket
+    end
+  end
+
+  def self.init_server
+    initialization_message
+    @@sockets = []
+    Thread.new { RoadRunner::WebServer.init_server }
+    Thread.new { monitor_files }
+    Thread.abort_on_exception = true
+
+    server = WebSocketServer.new(
+              :accepted_domains => ["*"],
+              :port => config("live_reload_port"))
+    loop do
+      server.run do |ws|
+        @@sockets << ws
+        puts "New connection at #{Time.now.to_s}"
+        ws.handshake()
+        while data = ws.receive()
+          sleep 0.1
+        end
+      end
+    end
+  end
+
+  def self.initialization_message
+    puts "Starting Roadrunner #{RoadRunner::VERSION} (ctrl-c to exit)"
+    puts "RoadRunner Live Reload Server is running on port #{config("live_reload_port")}"
+    puts "RoadRunner Simple Web Server is running on port #{config("web_server_port")}"
+    puts "Polling for changes..."
+  end
+
+  private 
+
+  def self.calculate_checksum file
+    Digest::SHA2.file(file).hexdigest
+  end 
+end

data/src/webserver.rb

@@ -0,0 +1,53 @@
+require 'socket'
+require 'uri'
+
+module RoadRunner::WebServer
+  @@server = nil
+
+  def self.web_root
+    File.expand_path(File.join(File.dirname(__FILE__), ".."))
+  end
+
+  def self.requested_file(request_line)
+    request_uri = request_line.split(" ")[1]
+    path = URI.unescape(URI(request_uri).path)    
+  end
+
+  def self.server
+    @@server ||= TCPServer.new('localhost', RoadRunner::config("web_server_port"))
+  end
+
+  def self.init_server
+    loop do
+      socket = server.accept
+      request_line = socket.gets
+
+      unless request_line.nil?
+        file_name = requested_file(request_line)
+        
+        if file_name == "/roadrunner.js"
+          File.open(File.join(web_root, "roadrunner-#{RoadRunner::VERSION}.debug.js"), "rb") do |file|
+            socket.print "HTTP/1.1 200 OK\r\n" +
+                         "Content-Type: text/javascript\r\n" +
+                         "Content-Length: #{file.size}\r\n" +
+                         "Connection: close\r\n"
+
+            socket.print "\r\n"
+            IO.copy_stream(file, socket)
+          end
+        else
+          message = "File not found\n"
+
+          socket.print "HTTP/1.1 404 Not Found\r\n" +
+                       "Content-Type: text/plain\r\n" +
+                       "Content-Length: #{message.size}\r\n" +
+                       "Connection: close\r\n"
+
+          socket.print "\r\n"
+          socket.print message
+        end
+        socket.close
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: roadrunner-live-reload
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Alcides Queiroz Aguiar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+description: A live reload command line tool written in ruby.
+email:
+- alcidesqueiroz@gmail.com
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/version.rb
+- lib/websocket.rb
+- src/webserver.rb
+- lib/tasks/register.rake
+- lib/os.rb
+- roadrunner-0.3.1.debug.js
+- roadrunner-live-reload.gemspec
+- roadrunner.sample.yml
+- spec/comingsoon.gitkeep
+- src/roadrunner.rb
+- distr/roadrunner
+- distr/roadrunner.bat
+homepage: http://rubygems.org/gems/roadrunner
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A live reload command line tool written in ruby.
+test_files: []