lis 0.2.1 → 0.2.2

data/lib/lis/io_listener.rb

@@ -1,114 +0,0 @@
-require 'strscan'
-
-module LIS::Transfer
-
-  # a chainable IO-Listener that provides two methods:
-  #
-  # {#on_data} ::
-  #   a callback that is called whenever a message is received
-  # {#write} ::
-  #   can be called so send messages to the underlying IO
-  #
-  # when overriding this class, you need to implement two methods:
-  #
-  # {#receive} ::
-  #   is called from an underlying IO whenever a message is received
-  #   the message can be handled.  Call {#forward} to propagate
-  #
-  # {#write} ::
-  #   transform/encode a message before sending it. Call +super+ to propagate
-  #
-  # See {LineBasedProtocol} for a toy implementation which strips
-  # newlines and only forwards complete lines.
-  #
-  class Base
-
-    # @param [Base, #on_data] read data source
-    # @param [Base, IO, #write] write object where messages are written to
-    #
-    def initialize(read, write = read)
-      @reader, @writer = read, write
-      @on_data = nil
-      @reader.on_data { |*data| receive(*data) } if @reader.respond_to?(:on_data)
-    end
-
-    # register a block, to be run whenever the protocol implementation
-    # receives data (by calling {#forward})
-    #
-    # this is used to chain protocol layers together
-    #
-    # @return [self]
-    # @yield [*args] called whenever the protocol implementaion calls {#forward}
-    # @yieldreturn [nil]
-    #
-    def on_data(&block)
-      @on_data = block
-      self
-    end
-
-    # @see #write
-    def <<(*args)
-      write(*args)
-    end
-
-    # write data to underlying interface. override if data needs to be preprocessed
-    #
-    def write(*args)
-      @writer.<<(*args) if @writer
-    end
-
-
-    protected
-
-    # override this method to handle data received from an underlying interface, for
-    # example splitting it into messages or only passing on complete lines
-    # (see {LineBasedProtocol#receive} for an example)
-    #
-    # call {#forward} to pass it on to higher levels
-    #
-    # @return [nil]
-    #
-    def receive(data)
-      forward(data)
-    end
-
-    def forward(*data)
-      @on_data.call(*data) if @on_data
-    end
-  end
-
-
-  class LineBasedProtocol < Base
-
-    # strip newlines from received data and pass on complete lines
-    #
-    # @param [String] data
-    #
-    def receive(data)
-      @memo ||= ""
-      scanner = StringScanner.new(@memo + data)
-      while s = scanner.scan(/.*?\n/)
-        forward(s.strip)
-      end
-      @memo = scanner.rest
-      nil
-    end
-
-    # add a newline to data and pass it on
-    # @param [String] data
-    #
-    def write(data)
-      super(data + "\n")
-    end
-  end
-
-  class IOListener < Base
-    def run!
-      while not @reader.eof?
-        str = @reader.readpartial(4096)
-        forward(str)
-      end
-    end
-  end
-end
-

data/test/test_io_listener.rb

@@ -1,34 +0,0 @@
-require 'helper'
-
-class TestIOListener < Test::Unit::TestCase
-  context "a server" do
-    setup do
-      r1, w1 = IO.pipe # Immulite -> LIS
-      r2, w2 = IO.pipe # LIS -> Immulite
-
-      @server = LIS::Transfer::IOListener.new(r1, w2)
-      @protocol = LIS::Transfer::LineBasedProtocol.new(@server)
-      @device = Mock::Server.new(r2, w1)
-    end
-
-    should "exist" do
-      assert_not_nil @server
-    end
-
-    should "yield packets written to it" do
-      @packets = []
-      @protocol.on_data { |packet| @packets << packet }
-
-      @device.write("fo").wait.write("o\n").wait.write("bar\n").eof
-      @server.run!
-
-      assert_equal ["foo", "bar"], @packets
-    end
-
-    should "send data" do
-      @protocol << "hello world"
-      data = @device.read_all
-      assert_equal "hello world\n", data
-    end
-  end
-end