interop 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6369ad96be9d4e4a7946a23c56d4a06b96dc23553b2bb602e6708e34154561c7
+  data.tar.gz: fdf11d65dec06324fc6207c18318b17130a51ddaf580b5069f48710ee12605ed
+SHA512:
+  metadata.gz: 06c118089ef25d6c1f122bacdefd11e7ecdd923fb82ccc3ad853e9782d768e374c43b6a55cd96f4bb9d11f582262facc50f9f2e4c0edf0f601e403b68e278369
+  data.tar.gz: 70b6a14d430ffb08785a731aec8a0cea4a782faae584b9b9758af5306ba5d4483fee103d3e5ed5c371501dbed5fc0eecfadec8541deef222248f3af7dd22a2f9

data/lib/interop.rb

@@ -0,0 +1,16 @@
+require 'pathname'
+
+require 'interop/error'
+require 'interop/version'
+require 'interop/connection'
+require 'interop/pipe'
+require 'interop/interceptor'
+require 'interop/middleware'
+require 'interop/rpc/client'
+require 'interop/rpc/server'
+
+module Hx
+  module Interop
+    ROOT = Pathname(__dir__).parent
+  end
+end

data/lib/interop/channel.rb

@@ -0,0 +1,118 @@
+require 'interop/error'
+
+# TODO: the only reason this class exists is because SizedQueue doesn't allow a zero max.
+#   Figure out a way to block on the first push to a SizedQueue, and this messy situation
+#   can go away for good. In the meantime, a buffered version of this class is like a
+#   SizedQueue already, so that functionality can be removed.
+
+module Hx
+  module Interop
+    # :nodoc:
+    class Channel
+      # :nodoc:
+      class Blocker
+        def initialize
+          @queue = Queue.new
+          @mutex = Mutex.new
+        end
+
+        def resolve
+          @queue << nil
+          @queue.close
+          @value
+        end
+
+        def wait
+          @mutex.synchronize do
+            next unless @queue
+
+            @queue.shift
+            @queue = nil
+          end
+          @value
+        end
+      end
+
+      # :nodoc:
+      class Put < Blocker
+        def initialize(value)
+          @value = value
+          super()
+        end
+      end
+
+      # :nodoc:
+      class Get < Blocker
+        def resolve(value)
+          @value = value
+          super()
+        end
+      end
+
+      Deadlock = Class.new(Error)
+      Closed   = Class.new(Error)
+
+      def initialize(butter_limit = 0)
+        @buffer_limit = butter_limit
+        @buffer       = []
+        @gets         = []
+        @puts         = []
+        @mutex        = Mutex.new
+      end
+
+      def put(*objects)
+        objects.each &method(:<<)
+        self
+      end
+
+      def <<(obj)
+        put = nil
+        @mutex.synchronize do
+          raise Closed if @closed
+
+          if (get = @gets.shift)
+            get.resolve obj
+          elsif @buffer.length < @buffer_limit
+            @buffer << obj
+          else
+            raise Deadlock if Thread.list.one?
+
+            put = Put.new(obj)
+            @puts << put
+          end
+        end
+        put&.wait
+
+        self
+      end
+
+      def get
+        get = nil
+        @mutex.synchronize do
+          return if @closed
+
+          put = @puts.shift
+          return put.resolve if put
+          return @buffer.shift if @buffer.any?
+
+          raise Deadlock if Thread.list.one?
+
+          get = Get.new
+          @gets << get
+        end
+        get.wait
+      end
+
+      def close
+        raise Closed if @closed
+
+        @mutex.synchronize do
+          @closed = true
+          @puts.each &:resolve
+          @gets.each { |g| g.resolve nil }
+        end
+        @buffer
+      end
+    end
+  end
+end

data/lib/interop/connection.rb

@@ -0,0 +1,43 @@
+require 'interop/stream_reader'
+require 'interop/stream_writer'
+require 'interop/reader_writer'
+
+module Hx
+  module Interop
+    # Combines a Reader and a Writer
+    class Connection
+      include ReaderWriter
+
+      # @param [Reader, IO, StringIO] reader
+      # @param [Writer, IO, StringIO] writer
+      def self.build(reader, writer = reader)
+        return reader if reader.is_a?(ReaderWriter) && writer.equal?(reader)
+
+        reader = StreamReader.new(reader) if reader.respond_to? :readline
+        writer = StreamWriter.new(writer) if writer.respond_to? :puts
+
+        new reader, writer
+      end
+
+      # @param [Reader] reader
+      # @param [Writer] writer
+      def initialize(reader, writer)
+        raise ArgumentError, "Expected a #{Reader}" unless reader.is_a? Reader
+        raise ArgumentError, "Expected a #{Writer}" unless writer.is_a? Writer
+
+        @reader = reader
+        @writer = writer
+      end
+
+      protected
+
+      def _read
+        @reader.read
+      end
+
+      def _write(message)
+        @writer.write message
+      end
+    end
+  end
+end

data/lib/interop/error.rb

@@ -0,0 +1,14 @@
+module Hx
+  module Interop
+    class Error < StandardError
+      class Fatal < self
+      end
+
+      class InvalidHeader < Fatal
+      end
+
+      class NotDecodable < self
+      end
+    end
+  end
+end

data/lib/interop/headers.rb

@@ -0,0 +1,90 @@
+module Hx
+  module Interop
+    # Represents MIME headers for a message.
+    class Headers
+      ID             = 'Interop-Rpc-Id'.freeze
+      CLASS          = 'Interop-Rpc-Class'.freeze
+      ERROR          = 'Interop-Error'.freeze
+      CONTENT_TYPE   = 'Content-Type'.freeze
+      CONTENT_LENGTH = 'Content-Length'.freeze
+
+      def initialize(headers = nil)
+        @headers = {}
+        merge! headers unless headers.nil?
+      end
+
+      def [](key)
+        @headers[canonical_key key]
+      end
+
+      def []=(key, value)
+        key = canonical_key(key)
+        if value.nil?
+          @headers.delete key
+        else
+          @headers[key] = value.to_s
+        end
+      end
+
+      def merge!(*others)
+        others.each do |other|
+          other.each do |key, value|
+            self[key] = value
+          end
+        end
+        self
+      end
+
+      def merge(*others)
+        dup.merge! others
+      end
+
+      def fetch(key, *args, &block)
+        @headers.fetch canonical_key(key, *args, &block)
+      end
+
+      def dup
+        headers = @headers.dup
+        self.class.new.instance_exec do
+          @headers = headers
+          self
+        end
+      end
+
+      def freeze
+        @headers.freeze
+        super
+      end
+
+      def inspect
+        "<##{self.class.name} #{@headers.inspect[1..-2]}>"
+      end
+
+      def to_s
+        map { |k, v| "#{k}: #{v}" }.join "\n"
+      end
+
+      private
+
+      def method_missing(symbol, *args, &block)
+        if @headers.respond_to? symbol
+          @headers.__send__ symbol, *args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(symbol, *)
+        @headers.respond_to?(symbol) or super
+      end
+
+      def canonical_key(key)
+        key
+          .to_s
+          .split(/[-_\s]+/)
+          .map { |str| str[0].upcase + str[1..].downcase }
+          .join('-')
+      end
+    end
+  end
+end

data/lib/interop/interceptor.rb

@@ -0,0 +1,60 @@
+require 'interop/connection'
+require 'interop/interceptor/read'
+require 'interop/interceptor/write'
+
+module Hx
+  module Interop
+    # Module for building simple duplex interceptors
+    module Interceptor
+      # :nodoc:
+      class Builder
+        # @param [ReaderWriter, nil] connection
+        def initialize(connection)
+          @conn = connection
+        end
+
+        # @param [Reader] reader
+        def read(reader = @conn, &block)
+          raise 'Reader already declared' if @reader
+          raise TypeError, 'Expected a Reader' unless reader.is_a? Reader
+
+          @reader = Read.new(reader, &block)
+        end
+
+        # @param [Writer] writer
+        def write(writer = @conn, &block)
+          raise 'Reader already declared' if @writer
+          raise TypeError, 'Expected a Writer' unless writer.is_a? Writer
+
+          @writer = Write.new(writer, &block)
+        end
+
+        def build(&block)
+          if block.arity.zero?
+            instance_exec &block
+          else
+            block.call self
+          end
+
+          consolidate!
+
+          return Connection.new @reader, @writer if @reader && @writer
+
+          @reader || @writer || @conn or raise 'Nothing to build'
+        end
+
+        private
+
+        def consolidate!
+          @reader ||= @writer && @conn if @conn.is_a?(Reader)
+          @writer ||= @reader && @conn if @conn.is_a?(Writer)
+        end
+      end
+
+      # @param [ReaderWriter, nil] connection
+      def self.build(connection = nil, &block)
+        Builder.new(connection).build(&block)
+      end
+    end
+  end
+end

data/lib/interop/interceptor/base.rb

@@ -0,0 +1,15 @@
+module Hx
+  module Interop
+    module Interceptor
+      # Base class for read and write interceptors
+      class Base
+        def initialize(stream, &block)
+          raise ArgumentError, 'Expected a block that takes exactly 2 arguments' unless [2, -1].include? block&.arity
+
+          @stream  = stream
+          @handler = block
+        end
+      end
+    end
+  end
+end

data/lib/interop/interceptor/read.rb

@@ -0,0 +1,30 @@
+require 'interop/interceptor/base'
+require 'interop/reader'
+
+module Hx
+  module Interop
+    module Interceptor
+      # Intercept reads
+      # TODO: consider a background-processed version (like the Go version)
+      class Read < Base
+        include Reader
+
+        # @param [Reader] reader
+        def initialize(reader, &block)
+          super
+          @queue = []
+          @mutex = Mutex.new
+        end
+
+        protected
+
+        def _read
+          @mutex.synchronize do
+            @handler[@stream.read, @queue] while @queue.empty?
+            @queue.shift
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interop/interceptor/write.rb

@@ -0,0 +1,19 @@
+require 'interop/interceptor/base'
+require 'interop/writer'
+
+module Hx
+  module Interop
+    module Interceptor
+      # Intercept writes
+      class Write < Base
+        include Writer
+
+        protected
+
+        def _write(message)
+          @handler[message, @stream]
+        end
+      end
+    end
+  end
+end

data/lib/interop/message.rb

@@ -0,0 +1,83 @@
+require 'json'
+
+require 'interop/headers'
+
+module Hx
+  module Interop
+    # Represents a single interop message, with headers and a body.
+    class Message
+      module Types
+        JSON   = 'application/json'.freeze
+        BINARY = 'application/octet-stream'.freeze
+      end
+
+      class << self
+        def json_parse_options
+          @json_parse_options ||= {}
+        end
+
+        def build(*args)
+          return args.first if args.one? && args.first.is_a?(Message)
+
+          new.tap do |message|
+            args.each do |arg|
+              assign_build_arg message, arg
+            end
+          end
+        end
+
+        def json(object, *args)
+          build JSON.generate(object) << "\n", {Headers::CONTENT_TYPE => Types::JSON}, *args
+        end
+
+        private
+
+        def assign_build_arg(message, arg)
+          case arg
+          when nil
+            # Ignore nils
+          when Hash
+            message.headers.merge! arg
+          when Message
+            message.headers.merge! arg.headers
+            message.body = arg.body
+          else
+            message.body                     = arg.to_s
+            message[Headers::CONTENT_LENGTH] = message.body.bytesize
+          end
+        end
+      end
+
+      attr_reader :headers, :body
+
+      def initialize(headers = nil, body = nil)
+        @headers  = Headers.new(headers)
+        self.body = body unless body.nil?
+      end
+
+      def [](key)
+        @headers[key]
+      end
+
+      def []=(key, value)
+        @headers[key] = value
+      end
+
+      def body=(value)
+        @body = value.to_s
+      end
+
+      def decode
+        case @headers[Headers::CONTENT_TYPE]
+        when Types::JSON
+          return JSON.parse @body, self.class.json_parse_options
+        end
+        raise Error::NotDecodable, 'Message is not in a decodable format'
+      end
+
+      def dup
+        Message.new headers.to_h, body.dup
+      end
+    end
+  end
+end

data/lib/interop/middleware.rb

@@ -0,0 +1,62 @@
+require 'interop/reader_writer'
+
+module Hx
+  module Interop
+    # Base class for interop middleware.
+    class Middleware
+      include ReaderWriter
+
+      # :nodoc:
+      module BuildMessageOnWrite
+        def write(*args)
+          super Message.build(*args)
+        end
+      end
+
+      def self.inherited(subclass)
+        subclass.prepend BuildMessageOnWrite
+        super
+      end
+
+      # @param [Array<Class>] classes
+      # @param [ReaderWriter] connection
+      def self.stack(*classes, connection)
+        raise ArgumentError, "Expected an instance of #{ReaderWriter}" unless connection.is_a? ReaderWriter
+
+        classes.reverse.reduce connection do |wrapped, klass|
+          raise ArgumentError, "Expected subclasses of #{self}" unless klass.is_a?(Class) && klass < self
+
+          klass.new(wrapped)
+        end
+      end
+
+      attr_reader :connection
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      # Return the complete Middleware stack as an array, with this instance as the first item, and
+      # the core (or shallowest non-Middleware layer) as the last.
+      def stack
+        result = [self]
+        if @connection.is_a? Middleware
+          result.concat @connection.stack
+        else
+          result << @connection
+        end
+        result
+      end
+
+      protected
+
+      def _read
+        @connection.read
+      end
+
+      def _write(message)
+        @connection.write message
+      end
+    end
+  end
+end

data/lib/interop/pipe.rb

@@ -0,0 +1,30 @@
+require 'interop/channel'
+require 'interop/message'
+require 'interop/reader_writer'
+
+module Hx
+  module Interop
+    # A message pipe. You can read exactly what is written to it.
+    class Pipe
+      include ReaderWriter
+
+      def initialize(buffer_size = 0)
+        @channel = Channel.new(buffer_size)
+      end
+
+      def close
+        @channel.close
+      end
+
+      protected
+
+      def _read
+        @channel.get or raise EOFError
+      end
+
+      def _write(message)
+        @channel.put message
+      end
+    end
+  end
+end

data/lib/interop/reader.rb

@@ -0,0 +1,36 @@
+module Hx
+  module Interop
+    # Anything from which you can read a message.
+    module Reader
+      def self.new(*args, &block)
+        StreamReader.new *args, &block
+      end
+
+      # Read a message from the stream, blocking until a completed message is read.
+      # @return [Message]
+      def read
+        _read
+      end
+
+      # Yields messages as they are read. Returns self when EOF is reached.
+      # @return [Enumerable, Reader]
+      # @yieldparam [Message]
+      def read_all
+        return enum_for :read_all unless block_given?
+
+        loop do
+          yield read
+        rescue EOFError
+          break
+        end
+        self
+      end
+
+      protected
+
+      def _read
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/interop/reader_writer.rb

@@ -0,0 +1,10 @@
+require 'interop/reader'
+require 'interop/writer'
+
+module Hx
+  module Interop
+    module ReaderWriter
+      include Reader, Writer
+    end
+  end
+end

data/lib/interop/rpc/base.rb

@@ -0,0 +1,60 @@
+require 'interop/connection'
+require 'interop/rpc/dispatcher'
+require 'interop/rpc/controller'
+
+module Hx
+  module Interop
+    module RPC
+      # Base class for RPC Client and Server
+      class Base
+        def initialize(reader, writer = reader)
+          @connection = Connection.build(reader, writer)
+          @dispatcher = Dispatcher.new
+          @io_thread  = Thread.new do
+            run
+          rescue StandardError => e
+            @error = e
+          end
+        end
+
+        # TODO: custom exception handler?
+
+        # Wait for the process to finish (i.e. for the connection to close).
+        def wait
+          @io_thread.join
+          raise @error if @error # TODO: wrap in something specific, to preserve backtrace
+
+          self
+        end
+
+        def on(criteria, *handler, &block)
+          @dispatcher.on criteria, *handler, &block
+          self
+        end
+
+        protected
+
+        attr_reader :dispatcher
+
+        def build_message(first, *rest)
+          first = {Headers::CLASS => first} if first.is_a?(String) || first.is_a?(Symbol)
+          Message.build first, *rest
+        end
+
+        def write(*args)
+          @connection.write *args
+        end
+
+        def run
+          @connection.read_all do |request|
+            Thread.new do
+              yield request
+            rescue StandardError => e
+              @io_thread.raise e
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interop/rpc/client.rb

@@ -0,0 +1,63 @@
+require 'interop/rpc/base'
+require 'interop/rpc/magic'
+
+module Hx
+  module Interop
+    # Contains RPC-specific classes.
+    module RPC
+      # An RPC client.
+      class Client < Base
+        attr_accessor :id_prefix
+
+        def initialize(*)
+          @next_id = 1
+          @queues  = {}
+          @mutex   = Mutex.new
+          super
+        end
+
+        # @param [Message] request
+        # @return [Message]
+        def call(request, *args)
+          request = build_message(request, *args)
+
+          queue = Queue.new
+
+          @mutex.synchronize do
+            id = "#{id_prefix}#{@next_id}"
+            @next_id += 1
+            request[Headers::ID] = id
+            @queues[id] = queue
+          end
+
+          write request
+
+          queue.pop
+        end
+
+        alias [] call
+
+        def call_json(message_class, unencoded_body, *args)
+          call message_class, Message.json(unencoded_body, *args)
+        end
+
+        def magic(&block)
+          Magic.new self, :call, &block
+        end
+
+        private
+
+        def run
+          super do |message|
+            if (id = message[Headers::ID]) && (queue = @mutex.synchronize { @queues.delete id })
+              queue << message
+              queue.close
+            else
+              dispatcher << message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interop/rpc/controller.rb

@@ -0,0 +1,37 @@
+require 'interop/message'
+
+module Hx
+  module Interop
+    module RPC
+      # Abstract class for RPC server controllers.
+      class Controller
+        # TODO: hooks, error handlers
+
+        def self.make_handler(action)
+          action = action.to_sym
+
+          unless public_instance_methods(false).include? action
+            raise ArgumentError, "Invalid action '#{action}' on #{self}"
+          end
+
+          klass = self
+          lambda do |message|
+            controller = klass.new(message)
+            controller.__send__ action
+            controller.response
+          end
+        end
+
+        attr_reader :request
+
+        def initialize(request)
+          @request = request
+        end
+
+        def response
+          @response ||= Message.new
+        end
+      end
+    end
+  end
+end

data/lib/interop/rpc/dispatcher.rb

@@ -0,0 +1,70 @@
+require 'interop/rpc/controller'
+
+module Hx
+  module Interop
+    module RPC
+      # Message dispatcher used by Client and Server.
+      class Dispatcher
+        Route = Struct.new :matcher, :handler do
+          def call(message)
+            handler[message]
+          end
+
+          def match?(message)
+            matcher[message]
+          end
+        end
+
+        def initialize
+          @routes = []
+        end
+
+        def on(criteria, *handler, &block)
+          @routes << Route.new(
+            make_matcher(criteria),
+            make_handler(*handler, &block)
+          )
+        end
+
+        def dispatch(message)
+          @routes.each do |route|
+            route.call message if route.match? message
+          end
+          self
+        end
+
+        def match(message)
+          @routes.find { |r| r.match? message }
+        end
+
+        alias << dispatch
+
+        private
+
+        def make_matcher(criteria)
+          case criteria
+          when Proc
+            criteria
+          when String, Regexp
+            -> message { criteria === message.headers[Headers::CLASS] }
+          when Symbol
+            make_matcher criteria.to_s
+          else
+            raise ArgumentError, 'Invalid message match criteria'
+          end
+        end
+
+        def make_handler(*args, &block)
+          return block if block && args.empty?
+
+          if args.length == 2
+            controller, action = args
+            return controller.make_handler(action) if controller.is_a?(Class) && controller < Controller
+          end
+
+          raise ArgumentError, 'Invalid message handler'
+        end
+      end
+    end
+  end
+end

data/lib/interop/rpc/magic.rb

@@ -0,0 +1,25 @@
+module Hx
+  module Interop
+    module RPC
+      # :nodoc:
+      class Magic < BasicObject
+        def initialize(receiver, symbol, &transformer)
+          @receiver    = receiver
+          @symbol      = symbol
+          @transformer = transformer
+        end
+
+        private
+
+        def method_missing(symbol, *args)
+          args = [@transformer.call(*args)] if @transformer
+          @receiver.__send__ @symbol, symbol, *args
+        end
+
+        def respond_to_missing?(*)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/interop/rpc/server.rb

@@ -0,0 +1,42 @@
+require 'interop/rpc/base'
+
+module Hx
+  module Interop
+    # Contains RPC-specific classes.
+    module RPC
+      # An RPC server.
+      class Server < Base
+        # @param [Message] event
+        def send(event, *args)
+          event = build_message(event, *args)
+
+          raise ArgumentError, 'Cannot send an event with an ID' if event.headers.key? Headers::ID
+
+          @connection.write event
+        end
+
+        alias << send
+
+        private
+
+        def run
+          super do |request|
+            response = make_response(dispatcher.match(request)&.call request)
+            response[Headers::ID] = request[Headers::ID]
+            write response
+          rescue StandardError => e
+            write Headers::ERROR => "Unhandled exception: #{e}"
+            raise
+          end
+        end
+
+        def make_response(result)
+          return result if result.is_a? Message
+
+          result = [result] unless result.is_a? Array
+          Message.build *result
+        end
+      end
+    end
+  end
+end

data/lib/interop/stream_reader.rb

@@ -0,0 +1,58 @@
+require 'interop/message'
+require 'interop/reader'
+
+module Hx
+  module Interop
+    # Reads messages from a stream (e.g. STDIN)
+    class StreamReader
+      include Reader
+
+      # Acceptable line terminators
+      NEWLINES = Set.new(%W[\n \r\n]).freeze
+
+      # @param [IO, StringIO] stream
+      def initialize(stream)
+        @stream = stream
+        @mutex  = Mutex.new
+      end
+
+      protected
+
+      def _read
+        @mutex.synchronize do
+          message      = Message.new(read_headers)
+          length       = message.headers[Headers::CONTENT_LENGTH]&.to_i
+          message.body =
+            if length&.positive?
+              @stream.read length
+            elsif length.nil?
+              read_paragraph.join
+            else
+              ''
+            end
+          message
+        end
+      end
+
+      private
+
+      # @return [Hash]
+      def read_headers
+        read_paragraph.to_h do |line|
+          line.strip.split(/:\s*/).tap do |pair|
+            raise Error::InvalidHeader unless pair.length == 2
+          end
+        end
+      end
+
+      def read_paragraph
+        lines = []
+        while (line = @stream.readline("\n"))
+          return lines if NEWLINES.include? line
+
+          lines << line
+        end
+      end
+    end
+  end
+end

data/lib/interop/stream_writer.rb

@@ -0,0 +1,31 @@
+require 'interop/message'
+require 'interop/writer'
+
+module Hx
+  module Interop
+    # Writes messages to a stream (e.g. STDOUT)
+    class StreamWriter
+      include Writer
+
+      # @param [IO, StringIO] stream
+      def initialize(stream)
+        @stream = stream
+        @mutex  = Mutex.new
+      end
+
+      protected
+
+      # @param [Message] message
+      def _write(message)
+        @mutex.synchronize do
+          message.headers.each do |k, v|
+            @stream.puts "#{k}: #{v}"
+          end
+          @stream.puts
+          @stream.write message.body
+          @stream.puts
+        end
+      end
+    end
+  end
+end

data/lib/interop/version.rb

@@ -0,0 +1,5 @@
+module Hx
+  module Interop
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/interop/writer.rb

@@ -0,0 +1,28 @@
+require 'interop/message'
+
+module Hx
+  module Interop
+    # Anything to which you can write a message
+    module Writer
+      def self.new(*args, &block)
+        StreamWriter.new(*args, &block)
+      end
+
+      # @param [Message] message
+      def write(message, *args)
+        _write Message.build(message, *args)
+        self
+      end
+
+      def <<(*args)
+        write *args
+      end
+
+      protected
+
+      def _write(*)
+        raise NotImplementedError
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: interop
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Neil E. Pearson
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-12-03 00:00:00.000000000 Z
+dependencies: []
+description: Ruby implementation of hx/interop cross-language interop abstraction
+email:
+- neil@pearson.sydney
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/interop.rb
+- lib/interop/channel.rb
+- lib/interop/connection.rb
+- lib/interop/error.rb
+- lib/interop/headers.rb
+- lib/interop/interceptor.rb
+- lib/interop/interceptor/base.rb
+- lib/interop/interceptor/read.rb
+- lib/interop/interceptor/write.rb
+- lib/interop/message.rb
+- lib/interop/middleware.rb
+- lib/interop/pipe.rb
+- lib/interop/reader.rb
+- lib/interop/reader_writer.rb
+- lib/interop/rpc/base.rb
+- lib/interop/rpc/client.rb
+- lib/interop/rpc/controller.rb
+- lib/interop/rpc/dispatcher.rb
+- lib/interop/rpc/magic.rb
+- lib/interop/rpc/server.rb
+- lib/interop/stream_reader.rb
+- lib/interop/stream_writer.rb
+- lib/interop/version.rb
+- lib/interop/writer.rb
+homepage: https://github.com/hx/interop
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://github.com/hx/interop
+  source_code_uri: https://github.com/hx/interop
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: Cross-language interop abstraction
+test_files: []