first

Author: Ari Russo

LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -0,0 +1,6 @@
+# browser-repl
+    
+
+
+Licensed under Apache 2.0, See the file LICENSE
+Copyright (c) 2014 [Ari Russo](http://arirusso.com) 

Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+task :default => [:test]

bin/repl

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "browser-repl"
+
+EM.run { BrowserRepl::REPL.new(:host => "localhost", :port => 9007) }

gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+group :test do 
+  gem "mocha"
+  gem "shoulda-context"
+end
+
+gem "colorize"
+gem "em-websocket"

lib/browser-repl.rb

@@ -0,0 +1,16 @@
+# libs
+require "colorize"
+require "em-websocket"
+require "json"
+require "readline"
+require "socket"
+
+# classes
+require "browser-repl/messager"
+require "browser-repl/repl"
+
+module BrowserRepl
+
+  VERSION = "0.1"
+
+end

lib/browser-repl/messager.rb

@@ -0,0 +1,48 @@
+module BrowserRepl
+
+  # Handles sending and receiving messages to/from the socket
+  class Messager
+ 
+    # @param [EventMachine::WebSocket] socket
+    # @param [Hash] options
+    # @option options [Boolean] :debug
+    def initialize(socket, options = {})
+      @socket = socket
+      @debug = options[:debug]
+    end
+
+    # Handle an inputted message
+    # @param [String] raw_message A raw inputted JSON message
+    # @return [Hash]
+    def in(raw_message, &block)
+      hash = JSON.parse(raw_message, :symbolize_names => true)
+      hash[:timestamp] = Time.at(hash[:timestamp].to_i / 1000) if !hash[:timestamp].nil?
+      yield(hash) if block_given?
+      hash
+    end
+
+    # Generate a new timestamp in js format
+    # @return [Fixnum]
+    def new_timestamp
+      Time.now.to_i * 1000 # javascript time int format
+    end
+
+    # Send a message over the socket
+    # @param [Hash] message A message to send
+    # @return [String, nil] If a message was sent, its JSON string; otherwise nil
+    def out(message)
+      if !@socket.nil?
+        message[:timestamp] ||= new_timestamp
+        json = message.to_json
+        @debug.puts "Sending message: #{json}" if @debug
+        @socket.send(json)
+        json
+      else
+        @debug.puts "Warning: No connection" if @debug
+        nil
+      end
+    end
+
+  end
+
+end

lib/browser-repl/repl.rb

@@ -0,0 +1,87 @@
+# Patch EventMachine::WebSocket so that we can initialize EM on demand
+module EventMachine
+  module WebSocket
+    def self.start(options, &blk)
+      EM.epoll
+      #EM.run {
+        trap("TERM") { stop }
+        trap("INT")  { stop }
+
+        run(options, &blk)
+      #}
+    end
+
+    def self.run(options)
+      host, port = options.values_at(:host, :port)
+      EM.start_server(host, port, Connection, options) do |c|
+        yield c
+      end
+    end
+  end
+end
+
+module BrowserRepl
+
+  class REPL
+
+    attr_reader :messager
+
+    def initialize(config)
+      @config = config
+      @socket = nil
+      @messager = nil
+      start
+    end
+
+    private
+
+    def get_input
+      line = Readline.readline('> ', true)
+      return nil if line.nil?
+      if line =~ /^\s*$/ or Readline::HISTORY.to_a[-2] == line
+        Readline::HISTORY.pop
+      end      
+      statement = line.strip
+      if statement == "exit"
+        exit
+      else
+        @messager.out({ :statement => statement })
+      end
+    end
+
+    def start
+      EM::WebSocket.run(@config) do |ws|
+        @socket = ws
+        @messager = Messager.new(@socket)
+        configure
+      end
+    end
+
+    def configure
+      @socket.onopen do |handshake|
+        puts "b-r: Connection open"
+        @active = true
+        get_input
+      end
+
+      @socket.onclose do 
+        puts "b-r: Connection closed"
+        @active = false
+      end
+
+      @socket.onmessage do |raw_message|
+        @messager.in(raw_message) do |message|
+          output = if !message[:value].nil?
+            message[:value]
+          elsif !message[:error].nil?
+            message[:error].red
+          end
+          puts(output)
+        end
+        get_input
+      end
+
+    end
+
+  end
+end

test/helper.rb

@@ -0,0 +1,8 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require "mocha/test_unit"
+require "shoulda-context"
+
+require "browser-repl"

test/messager_test.rb

@@ -0,0 +1,88 @@
+require "helper"
+
+class BrowserRepl::MessagerTest < Test::Unit::TestCase
+
+  include BrowserRepl
+
+  context "Messager" do
+
+    setup do
+      @socket = Object.new
+      @messager = Messager.new(@socket)
+    end
+
+    context "#in" do
+
+      setup do
+        @message = { :value => "blah", :timestamp => 1396406728702 }.to_json
+        @result = @messager.in(@message)
+      end
+
+      should "convert from String to Hash" do
+        assert_not_nil @result
+        assert_equal Hash, @result.class
+        assert_equal "blah", @result[:value]
+      end
+
+      should "convert timestamp from js time to ruby" do
+        timestamp = @result[:timestamp]
+        assert_not_nil timestamp
+        assert_equal Time, timestamp.class
+        assert_equal 2014, timestamp.year
+        assert_equal 4, timestamp.month
+        assert_equal 22, timestamp.hour
+      end
+      
+    end
+
+    context "#new_timestamp" do
+
+      should "be js int time format" do
+        result = @messager.new_timestamp
+        assert_not_nil result
+        assert_equal Fixnum, result.class
+        assert result.to_s.size > Time.new.to_i.to_s.size
+        assert_equal (result / 1000).to_s.size, Time.new.to_i.to_s.size
+      end
+
+    end
+
+    context "#out" do
+
+      setup do
+        @message = { :statement => "something" }
+      end
+
+      should "not overwrite timestamp" do
+        @socket.expects(:send).once
+        ts = Time.now.to_i / 1000
+        @message[:timestamp] = ts
+        @messager.out(@message)
+        assert_equal ts, @message[:timestamp]
+      end
+
+      should "generate new timestamp" do
+        @socket.expects(:send).once
+        @messager.out(@message)
+        assert_not_nil @message[:timestamp]
+        assert_equal Fixnum, @message[:timestamp].class
+      end
+
+      should "return nil if fails" do
+        messager = Messager.new(nil)
+        result = messager.out(@message)
+        assert_nil result
+      end
+
+      should "return json string if success" do
+        @socket.expects(:send).once
+        result = @messager.out(@message)
+        assert_not_nil result
+        assert_equal String, result.class
+      end
+
+    end
+
+  end
+
+end