noam_lemma 0.2.1

data/lib/noam_lemma/player.rb

@@ -0,0 +1,78 @@
+require 'thread' 
+
+module Noam
+  class NoamPlayerException < Exception; end
+
+  class Player
+    def initialize(remote_host, remote_port)
+      begin
+        @socket = TCPSocket.new(remote_host, remote_port)
+      rescue Errno::ECONNREFUSED
+        raise NoamPlayerException.new("Unable to connect to the Noam server at #{remote_host}:#{remote_port}. Is it running?")
+      end
+
+      @queue = Queue.new
+      manage_queue_on_thread
+    end
+
+    def put(message)
+      @queue.push(message)
+    end
+
+    def stop
+      put(:soft_exit)
+      @thread.join
+    end
+
+    def stop!
+      put(:hard_exit)
+      @thread.join
+    end
+
+    private
+
+    def manage_queue_on_thread
+      @thread = Thread.new do |t|
+        begin
+          loop do
+            message = @queue.pop
+            break if exit?(message)
+            process(message)
+          end
+        ensure
+          @socket.close
+        end
+      end
+    end
+
+    def process(message)
+      case message
+      when :soft_exit
+        finish_queue
+      when :hard_exit
+      else
+        @socket.print(message.noam_encode)
+        @socket.flush
+      end
+    end
+
+    def exit?(message)
+      message == :hard_exit || message == :soft_exit
+    end
+
+    def finish_queue
+      queue_to_array.each do |message|
+        @socket.print(message.noam_encode)
+        @socket.flush
+      end
+    end
+
+    def queue_to_array
+      result = []
+      while(@queue.size > 0) do
+        result << @queue.pop
+      end
+      result
+    end
+  end
+end

data/lib/noam_lemma/version.rb

@@ -0,0 +1,3 @@
+module NoamLemma
+  VERSION = "0.2.1"
+end

data/lib/noam_lemma.rb

@@ -0,0 +1,16 @@
+Thread.abort_on_exception = true
+
+module Noam
+  BEACON_PORT = 1030
+
+  VERSION = '0.2.1'
+  DEVICE_TYPE = 'ruby-script'
+
+  class NoamThreadCancelled < Exception; end
+end
+
+require 'noam_lemma/beacon'
+require 'noam_lemma/lemma'
+require 'noam_lemma/listener'
+require 'noam_lemma/message'
+require 'noam_lemma/player'

data/noam_lemma.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'noam_lemma/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "noam_lemma"
+  spec.version       = NoamLemma::VERSION
+  spec.authors       = ["John Van Enk"]
+  spec.email         = ["vanenkj@gmail.com"]
+  spec.description   = %q{A lemma factory for the Noam pub-sub system.}
+  spec.summary       = %q{A lemma factory for the Noam pub-sub system.}
+  spec.homepage      = "https://github.com/noam-io/lemma-ruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "require_all"
+  spec.add_development_dependency "bundler", "~>  1.3"
+  spec.add_development_dependency "rake",    "~> 10.3"
+  spec.add_development_dependency "rspec",   "~>  2.14"
+  spec.add_development_dependency "mocha",   "~>  1.1"
+end

data/spec/noam_lemma/beacon_spec.rb

@@ -0,0 +1,26 @@
+describe Noam::Beacon do
+  describe "#new" do
+    it "creates a new beacon" do
+      beacon = Noam::Beacon.new(:name, :host, :noam)
+      beacon.name.should == :name
+      beacon.host.should == :host
+      beacon.port.should == :noam
+    end
+  end
+
+  describe "::discover" do
+    before do
+      FakeManager.start
+    end
+
+    after do
+      FakeManager.stop
+    end
+
+    it "creates a Beacon based on server beacons" do
+      beacon = Noam::Beacon.discover
+      beacon.should be_a(Noam::Beacon)
+      beacon.port.should == NoamTest::FakeServer::PORT
+    end
+  end
+end

data/spec/noam_lemma/lemma_spec.rb

@@ -0,0 +1,88 @@
+describe Noam::Lemma do
+  SERVER_DELAY = 0.05
+
+  before(:each) do
+    FakeManager.start
+    @server = FakeManager.server
+    @lemma = Noam::Lemma.new("Example Lemma", ["event1"], ["event1"])
+    @lemma.discover
+    sleep(SERVER_DELAY)
+  end
+
+  after do
+    @lemma.stop
+    FakeManager.stop
+  end
+
+  describe "#new" do
+    context "with provided arguments" do
+      let(:lemma) { Noam::Lemma.new("Example Lemma", ["event1"], ["event1"]) }
+
+      it "sets #name to the given name" do
+        lemma.name.should  == "Example Lemma"
+      end
+
+      it "sets #hears to the given hears" do
+        lemma.hears.should == ["event1"]
+      end
+
+      it "sets #speaks to the given speaks" do
+        lemma.speaks.should == ["event1"]
+      end
+    end
+
+    context "with default arguments" do
+      let(:lemma) { Noam::Lemma.new("Example Lemma") }
+
+      it "sets #hears to an empty array" do
+        lemma.hears.should == []
+      end
+
+      it "sets #speaks to an empty array" do
+        lemma.speaks.should == []
+      end
+    end
+  end
+
+  describe "#hears" do
+    let(:lemma) { Noam::Lemma.new("Example Lemma", ["example_event"]) }
+
+    it "delegates to the MessageFilter when set" do
+      message_filter = Noam::MessageFilter.new
+      message_filter.hear("sample_event") {}
+      lemma.set_message_filter(message_filter)
+      lemma.hears.should == message_filter.hears
+    end
+  end
+
+  describe "#discover" do
+    it "sends a registration message" do
+      @server.clients.length.should == 1
+      @server.clients.first.port.should be_an(Integer)
+      @server.clients.first.port.should_not == 0
+    end
+
+    it "initializes listener and player" do
+      @lemma.listener.should_not be_nil
+      @lemma.player.should_not be_nil
+    end
+  end
+
+  describe "#speak" do
+    it "sends an event to the server" do
+      @lemma.speak("an event", "some value")
+      sleep(SERVER_DELAY)
+      @server.messages.map{|m| m[2]}.include?("an event").should be_true
+    end
+  end
+
+  describe "#listen" do
+    it "returns a message from the server" do
+      @server.send_message(["event", "test-server", "event1", "noam event"])
+      message = @lemma.listen
+      message.source.should == "test-server"
+      message.event.should  == "event1"
+      message.value.should  == "noam event"
+    end
+  end
+end

data/spec/noam_lemma/message/heard_spec.rb

@@ -0,0 +1,19 @@
+describe Noam::Message::Heard do
+  describe "#new" do
+    it "creates a new Heard message" do
+      h = Noam::Message::Heard.new("source", "event", "value")
+      h.source.should == "source"
+      h.event.should == "event"
+      h.value.should == "value"
+    end
+  end
+
+  describe "::from_noam" do
+    it "ceates a new Heard message from the noam event structure" do
+      h = Noam::Message::Heard.from_noam(["event", "source", "event", "value"].to_json)
+      h.source.should == "source"
+      h.event.should == "event"
+      h.value.should == "value"
+    end
+  end
+end

data/spec/noam_lemma/message/playable_spec.rb

@@ -0,0 +1,17 @@
+describe Noam::Message::Playable do
+  describe "#new" do
+    it "can be built" do
+      Noam::Message::Playable.new(
+        :host, :event, :value
+      ).class.should == Noam::Message::Playable
+    end
+  end
+
+  describe "#noam_encode" do
+    it "encodes the Playable" do
+      Noam::Message::Playable.new(
+        "host", "event", "value"
+      ).noam_encode.should == '000032["event","host","event","value"]'
+    end
+  end
+end

data/spec/noam_lemma/message/register_spec.rb

@@ -0,0 +1,17 @@
+describe Noam::Message::Register do
+  describe "#new" do
+    it "creates a new Register object" do
+      message = Noam::Message::Register.new(:devid, :port, :hears, :speaks)
+      message.should be_a(Noam::Message::Register)
+    end
+  end
+
+  describe "#noam_encode" do
+    it "encodes the Register message" do
+      message = Noam::Message::Register.new("an_id", 1234, ["e1"], ["e2", "e3"]).noam_encode
+      expected = '000066["register","an_id",1234,["e1"],["e2","e3"],"' +
+        Noam::DEVICE_TYPE + '","' + Noam::VERSION + '"]'
+      message.should == expected
+    end
+  end
+end

data/spec/noam_lemma/message_filter_spec.rb

@@ -0,0 +1,68 @@
+describe Noam::MessageFilter do
+  let(:filter)  { Noam::MessageFilter.new }
+  let(:message) { stub_message("example_event") }
+
+  describe "#hear" do
+    it "registers event names with the filter" do
+      filter.hear("example_event") {}
+      filter.hear("sample_event") {}
+      filter.hears.should == ["example_event", "sample_event"]
+    end
+  end
+
+  describe "#hears" do
+    it "includes single entries for event names registered multiple times" do
+      filter.hear("example_event") {}
+      filter.hear("example_event") {}
+      filter.hears.should == ["example_event"]
+    end
+  end
+
+  describe "#receive" do
+    it "calls blocks associated with the given event name" do
+      messages_received = 0
+      filter.hear("example_event") {|message| messages_received += 1}
+      filter.receive(message)
+      messages_received.should == 1
+    end
+
+    it "calls multiple blocks associated with the given event name" do
+      message_one = nil, message_two = nil
+      filter.hear("example_event") {|message| message_one = message}
+      filter.hear("example_event") {|message| message_two = message}
+      filter.receive(message)
+      message_one.should be(message)
+      message_two.should be(message)
+    end
+
+    it "ignores blocks associated with other event names" do
+      example_received = nil, sample_received = nil
+      filter.hear("example_event") {|message| example_received = true}
+      filter.hear("sample_event") {|message| sample_received = true}
+      filter.receive(stub_message("example_event"))
+      example_received.should be_true
+      sample_received.should be_false
+    end
+
+    it "returns the given message" do
+      message = stub_message("example_event")
+      result = filter.receive(message)
+      result.should be(message)
+    end
+
+    it "ignores event names with no associations" do
+      message = stub_message("example_event")
+      lambda { filter.receive(message) }.should_not raise_error
+    end
+
+    it "ignores event names with empty blocks" do
+      message = stub_message("example_event")
+      filter.hear("example_event") {}
+      lambda { filter.receive(message) }.should_not raise_error
+    end
+  end
+
+  def stub_message(event_name, value = "")
+    stub("message", event: event_name, value: value)
+  end
+end

data/spec/noam_lemma/message_spec.rb

@@ -0,0 +1,8 @@
+describe Noam::Message do
+  describe "::encode_length" do
+    it "expands the length out to 6 digits" do
+      Noam::Message.encode_length(6).should == "000006"
+      Noam::Message.encode_length(123456).should == "123456"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'require_all'
+
+libs = Dir[File.dirname(File.expand_path(__FILE__)) + "/../lib/**/*.rb"]
+require_all(libs)
+
+support_libs = Dir[File.dirname(File.expand_path(__FILE__)) + "/support/**/*.rb"]
+require_all(support_libs)
+
+class FakeManager
+  def self.start
+    @@beacon = NoamTest::FakeBeacon.new(Noam::BEACON_PORT)
+    @@beacon.start
+
+    @@server = NoamTest::FakeServer.new
+    @@server.start
+  end
+
+  def self.stop
+    @@beacon.stop
+    @@server.stop
+  end
+
+  def self.server
+    @@server
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+end

data/spec/support/fake_server.rb

@@ -0,0 +1,187 @@
+require 'json'
+require 'socket'
+
+class FakeBeaconThreadCancelled < Exception; end
+class FakeServerThreadCancelled < Exception; end
+
+class UnexpectedRegisterText < Exception; end
+class UnexpectedSystemVersion < Exception; end
+
+module NoamTest
+  class FakeBeacon
+    LOOP_DELAY = 0.001
+
+    def initialize(udp_broadcast_port)
+      @socket = UDPSocket.new
+      @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+    end
+
+    def start
+      @thread = Thread.new do |t|
+        begin
+          loop do
+            msg = ["beacon", "fake_beacon", NoamTest::FakeServer::PORT].to_json
+            @socket.send(msg, 0, "255.255.255.255", Noam::BEACON_PORT)
+
+            # This is normally at 5.0 seconds, but we run faster in order to
+            # make tests faster.
+            sleep(LOOP_DELAY)
+          end
+        rescue FakeBeaconThreadCancelled
+          # going down
+        ensure
+          @socket.close
+        end
+      end
+    end
+
+    def stop
+      @thread.raise(FakeBeaconThreadCancelled)
+      @thread.join
+      @thread = nil
+    end
+  end
+
+  class FakeServer
+    PORT = 7733
+
+    def initialize
+      @sock = TCPServer.new(FakeServer::PORT)
+    end
+
+    def start
+      @clients = []
+      @thread = Thread.new do |t|
+        begin
+          loop do
+            s = @sock.accept
+            @clients << (c = Client.new(s))
+            c.start
+          end
+        rescue FakeServerThreadCancelled
+          # going down
+        ensure
+          @sock.close
+        end
+      end
+    end
+
+    def stop
+      @thread.raise(FakeServerThreadCancelled)
+      @thread.join
+      @thread = nil
+
+      @clients.each do |c|
+        c.stop
+      end
+      @clients = nil
+    end
+
+    def clients
+      @clients.reject {|c| c.closed}
+    end
+
+    def messages
+      clients.map {|c| c.messages}.flatten(1)
+    end
+
+    def send_message(m)
+      s = m.to_json
+      l = "%06u" % s.length
+
+      msg = l + s
+
+      clients.each do |c|
+        c.send_message(msg)
+      end
+    end
+  end
+
+  class Client
+    attr_reader :closed, :responder, :port, :hears, :speaks
+
+    def initialize(client_socket)
+      @sock = client_socket
+      @client_host = @sock.peeraddr[2]
+      @queue = Queue.new
+    end
+    
+    def start
+      @thread = Thread.new do |t|
+        begin
+          read_register_msg
+          @responder = ClientResponder.new(@client_host, @port)
+
+          loop do
+            # Ignoring bad message.
+            #
+            # It seems the order in which sockets get shut down are a little
+            # weird.  The following two checks give us a means to try and bail
+            # out in the circumstance that a socket dies. In that case, it
+            # *should* have been shut down and we're probably just spinning
+            # until the exception finally bubbles up.
+            if (len = @sock.read(6)) == ""
+              next
+            end
+            if (str = @sock.read(len.to_i)) == ""
+              next
+            end
+
+            msg = JSON.parse(str)
+            @queue.push(msg)
+          end
+        rescue FakeServerThreadCancelled
+          # going down
+          @closed = true
+          @responder.stop
+        ensure
+          @sock.close
+        end
+      end
+    end
+
+    def stop
+      @thread.raise(FakeServerThreadCancelled)
+      @thread.join
+    end
+
+    def messages
+      @queue.length.times.map { @queue.pop }
+    end
+
+    def send_message(m)
+      @responder.send_message(m)
+    end
+
+    private
+
+    def read_register_msg
+       len = @sock.read(6)
+       m = JSON.parse(@sock.read(len.to_i))
+       txt, _, @port, @hears, @speaks, _, ver = m
+
+       unless txt == "register"
+         raise UnexpectedRegisterText.new(txt)
+       end
+
+       unless ver == Noam::VERSION
+         raise UnexpectedSystemVersion.new(ver)
+       end
+    end
+  end
+
+  class ClientResponder
+    def initialize(host, port)
+      @sock = TCPSocket.new(host, port)
+    end
+
+    def send_message(m)
+      @sock.write(m)
+      @sock.flush
+    end
+
+    def stop
+      @sock.close
+    end
+  end
+end