jstp 0.5.7 → 1.0.2

data/lib/reader/jstp/connector.rb

@@ -1,31 +0,0 @@
-module Reader
-  module JSTP
-    class Connector
-      attr_accessor :source
-
-      def initialize the_source
-        @source = the_source
-      end
-
-      # Start the server with the websocket strategy
-      def websocket
-        ::EventMachine.run &::JSTP::WebSocket.instance.event_machine
-      end
-
-      # Start the server with the TCP strategy
-      def tcp
-        @server = TCPServer.open @source.port.inbound
-        loop {
-          Thread.start(@server.accept) { |client|
-            begin 
-              ::JSTP::Engine.instance.dispatch JSON.parse client.gets
-            rescue Exception => e
-              puts "\e[31m#{e.message}\e[0m"
-              puts e.backtrace
-            end
-          }
-        }
-      end
-    end
-  end
-end

data/lib/writer/jstp/connector.rb

@@ -1,46 +0,0 @@
-module Writer
-  module JSTP
-    class Connector
-      attr_accessor :source
-
-      def initialize source
-        @source = source
-      end
-
-      # Dispatch this applying the websocket strategy
-      def websocket message
-        begin 
-          this_client = ::JSTP::WebSocket.instance
-            .client message["resource"]
-          json = message.to_json
-          this_client.callback do 
-            this_client.send_msg json
-            this_client.close_connection_after_writing
-          end
-        rescue RuntimeError => e
-          EM.run {
-            this_client = ::JSTP::WebSocket.instance
-              .client message["resource"]
-            json = message.to_json
-
-            this_client.callback do 
-              this_client.send_msg json
-              this_client.close_connection_after_writing
-            end
-
-            this_client.disconnect do 
-              EM::stop_event_loop
-            end
-          }
-        end
-      end
-
-      # Dispatch thid applying the TCP strategy
-      def tcp message
-        client = TCPSocket.open message["resource"].first, @source.port.outbound
-        client.puts message.to_json
-        client.close
-      end
-    end
-  end
-end

data/spec/jstp/api_spec.rb

@@ -1,79 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-describe JSTP::API do 
-  describe '#strategy' do 
-    it 'should set the strategy' do 
-      o = Object.new
-      o.extend JSTP::API
-
-      o.strategy inbound: :websocket, outbound: :tcp
-
-      JSTP::Connector.instance.strategy.inbound.should == :websocket
-      JSTP::Connector.instance.strategy.outbound.should == :tcp
-    end
-  end
-
-  describe '#dispatch' do 
-    before do 
-      JSTP::Connector.instance.strategy = SymbolMatrix inbound: :tcp, outbound: :websocket
-    end
-
-    context 'a block is passed' do 
-      it 'should register the block and send JSTP::Server to the EventMachine reactor' do
-        block = proc { "lalal" }
-        reader = stub 'reader'
-
-        JSTP::Connector.instance.should_receive(:block=)
-          .with block
-
-        JSTP::Connector.instance.should_receive(:from)
-          .and_return reader
-        reader.should_receive :tcp
-
-        o = Object.new
-        o.extend JSTP::API
-        o.dispatch &block
-      end
-    end
-
-    context 'an argument is passed' do 
-      it 'should dispatch the message via the Connector' do
-        message = stub 'message'
-        writer = stub 'writer'
-
-        JSTP::Connector.instance.should_receive(:to)
-          .and_return writer
-
-        writer.should_receive(:websocket)
-          .with message
-
-        o = Object.new
-        o.extend JSTP::API
-        o.dispatch message 
-      end
-    end
-
-    context 'no argument, no block' do 
-      it 'should return the JSTP::Connector.instance' do 
-        o = Object.new
-        o.extend JSTP::API
-        o.dispatch.should == JSTP::Connector.instance
-      end
-    end
-  end
-
-  describe '#port' do 
-    it 'should configure the port number' do 
-      message = {
-        "resource" => ["localhost"]
-      }
-      o = Object.new
-      o.extend JSTP::API
-      o.port inbound: 3000, outbound: 4000
-
-      JSTP::Connector.instance.port.inbound.should == 3000
-      JSTP::Connector.instance.port.outbound.should == 4000
-    end
-  end
-end

data/spec/jstp/base_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe JSTP::Base do 
-
-end

data/spec/jstp/connector_spec.rb

@@ -1,16 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'spec_helper'
-
-describe JSTP::Connector do 
-  it 'should be a singleton' do 
-    JSTP::Connector.ancestors.should include Singleton
-  end
-
-  it 'should include a discoverer for Writer' do
-    JSTP::Connector.ancestors.should include Discoverer::Writer 
-  end
-
-  it 'should include a discoverer for Reader' do 
-    JSTP::Connector.ancestors.should include Discoverer::Reader
-  end
-end

data/spec/jstp/tcp_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe JSTP::TCP do 
-  it 'should be a singleton' do 
-    JSTP::TCP.ancestors.should include Singleton
-  end
-end

data/spec/jstp/web_socket_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe JSTP::WebSocket do 
-  it 'should be a singleton' do 
-    JSTP::WebSocket.ancestors.should include Singleton
-  end
-
-  describe '#event_machine' do 
-    before do 
-      JSTP::Connector.instance.port = SymbolMatrix inbound: 33333, outbound: 44444 
-    end
-
-    it 'should start a websocket server in 33333' do 
-      JSTP::WebSocket.instance.server_setup
-        .should_receive :call
-
-      EventMachine::WebSocket.should_receive(:start)
-        .with({ host: '0.0.0.0', port: JSTP::Connector.instance.port.inbound }, 
-          &JSTP::WebSocket.instance.server_setup)
-
-      JSTP::WebSocket.instance.event_machine.call
-    end
-  end
-
-  describe '#server_setup' do 
-    it 'should set #event_on_message to onmessage' do
-      pending 'Outdated example'
-      
-      server = stub 'server'
-      JSTP::WebSocket.instance.event_on_message.should_receive :call
-
-      server.should_receive(:onmessage)
-        .with &JSTP::WebSocket.instance.event_on_message
-
-      JSTP::WebSocket.instance.server_setup.call server
-    end
-  end
-
-  describe '#event_on_message' do 
-    it 'should call the registered block with the parsed message' do 
-      pending 'Outdated example'
-
-      @the_proc = stub 'the proc'
-      @message = stub 'message'
-      @parsed_message = stub 'parsed message'
-
-      JSON.should_receive(:parse).with(@message)
-        .and_return @parsed_message
-
-      JSTP::Connector.instance.should_receive(:block)
-        .and_return @the_proc
-
-      @the_proc.should_receive(:call)
-        .with @parsed_message
-
-      JSTP::WebSocket.instance.event_on_message.call @message
-    end
-  end
-
-  describe '#client' do 
-    context 'there is no connection for that address' do 
-      before do
-        @web_socket_client = stub 'web socket client'
-        @resource = ["localhost", "hola", "quetal"]
-      end
-
-      it 'should initialize the websocket client' do 
-        EventMachine::WebSocketClient.should_receive(:connect)
-          .with("ws://#{@resource.first}:#{JSTP::Connector.instance.port.outbound}/#{@resource[1..-1].join('/')}")
-          .and_return @web_socket_client
-
-        JSTP::WebSocket.instance
-          .client(@resource)
-          .should == @web_socket_client
-      end
-    end
-  end
-end

data/spec/reader/jstp/connector_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Reader::JSTP::Connector do 
-  describe '#websocket' do 
-    it 'should run EventMachine with the JSTP::EventMachine proc' do 
-      JSTP::WebSocket.instance.event_machine.should_receive :call
-
-      EventMachine.should_receive(:run)
-        .with &JSTP::WebSocket.instance.event_machine
-
-      reader = Reader::JSTP::Connector.new stub 'connector'
-      reader.websocket
-    end    
-  end
-
-  describe '#tcp' do 
-    it 'should create the server and start it' do 
-      pending 'I still can test infinite loops'
-      
-      tcp_server = stub 'tcp server'
-
-      TCPServer.should_receive(:open)
-        .with(JSTP::Connector.instance.port.inbound)
-        .and_return tcp_server
-
-      tcp_server.should_receive(:accept)
-
-      reader = Reader::JSTP::Connector.new stub 'connector'
-      reader.tcp
-    end
-  end
-end

data/spec/writer/jstp/connector_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-describe Writer::JSTP::Connector do 
-  describe '#websocket' do 
-    before do 
-      @connector = stub 'connector'
-      @message = { "resource" => ["lala"] }
-      @message_json = stub 'message_json'
-      @web_socket_client = stub 'web socket client'
-    end
-
-    it 'should get the client from the pool and set the callback' do
-      @writer = Writer::JSTP::Connector.new @connector
-
-      JSTP::WebSocket.instance.should_receive(:client)
-        .with(@message["resource"])
-        .and_return @web_socket_client
-
-      @web_socket_client.should_receive(:callback)
-
-      @message.should_receive(:to_json).and_return @message_json
-
-      @writer.websocket @message      
-    end
-
-    it 'should send the message from the callback' do 
-      pending "I'm unable to test this properly since providing a Proc will make me lose scope for the client"
-      @writer = Writer::JSTP::Connector.new @connector
-
-      JSTP::WebSocket.should_receive(:client)
-        .with(@message["resource"])
-        .and_return @web_socket_client
-
-      @web_socket_client.should_receive(:callback)
-
-      @message.should_receive(:to_json).and_return @message_json
-      @web_socket_client.should_receive(:send_msg)
-        .with(@message_json)
-
-      @writer.websocket @message      
-    end
-  end
-
-  describe '#tcp' do 
-    it 'should get the resource and use it as host, then send the dispatch in JSON' do
-      message = stub 'message'
-      message_json = stub 'message json'
-      resource = stub 'resource'
-      hostname = stub 'hostname'
-      socket = stub 'socket'
-
-      message.should_receive(:[]).with("resource")
-        .and_return resource
-
-      resource.should_receive(:first).and_return hostname
-
-      JSTP::Connector.instance.port = SymbolMatrix inbound: 4444, outbound: 3333
-
-      TCPSocket.should_receive(:open).with(hostname, JSTP::Connector.instance.port.outbound)
-        .and_return socket
-
-      message.should_receive(:to_json).and_return message_json
-
-      socket.should_receive(:puts).with message_json
-      socket.should_receive(:close)
-
-      writer = Writer::JSTP::Connector.new ::JSTP::Connector.instance
-      writer.tcp message
-    end
-  end
-end