rabx-message 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 07ba374abe002ab50743fb9c8a81b96855e27015
+  data.tar.gz: 363d8672a81d05b0ab1621b74da7084009b980dd
+SHA512:
+  metadata.gz: 1e2d11ab1bb67e1033212640602abd2c82eb345bc99805d7862639a9261e49a8327d56b5faf98a5763936ef555df7db72b513fd897e829d63e50e6a6f3a0e298
+  data.tar.gz: 064e5b31853c42a501181b83a1aff1a8e6dbe3711c7c3ab496275e167fa63e115a6304e8e2bf24ae6351e5f5244ce137f27e24a283b48db342000369a76f8163

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+.yardoc
+Gemfile.lock
+doc/*
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0

data/.yardopts

@@ -0,0 +1,4 @@
+--no-private
+--hide-void-return
+--embed-mixin ClassMethods
+--markup=markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in the gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 James McKinney
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# RPC using Anything But XML (RABX) message parser and emitter
+
+[![Gem Version](https://badge.fury.io/rb/rabx-message.svg)](http://badge.fury.io/rb/rabx-message)
+[![Build Status](https://secure.travis-ci.org/jpmckinney/rabx-message.png)](http://travis-ci.org/jpmckinney/rabx-message)
+[![Dependency Status](https://gemnasium.com/jpmckinney/rabx-message.png)](https://gemnasium.com/jpmckinney/rabx-message)
+[![Coverage Status](https://coveralls.io/repos/jpmckinney/rabx-message/badge.png)](https://coveralls.io/r/jpmckinney/rabx-message)
+[![Code Climate](https://codeclimate.com/github/jpmckinney/rabx-message.png)](https://codeclimate.com/github/jpmckinney/rabx-message)
+
+The RABX specification is a [Perl module](https://github.com/mysociety/commonlib/blob/master/perllib/RABX.pm) by [mySociety](https://www.mysociety.org/).
+
+## Usage
+
+```ruby
+require 'rabx/message'
+```
+
+Dump a RABX message:
+
+```ruby
+RABX::Message.dump('R', 'RPC.method', ['argument', 3])
+# => "R1:0,10:RPC.method,L1:2,T8:argument,I1:3,"
+RABX::Message.dump('S', {name: 'foo', email: 'foo@example.com'})
+# => "S1:0,A1:2,T4:name,T3:foo,T5:email,T15:foo@example.com,"
+RABX::Message.dump('E', 404, 'Not Found')
+# => "E1:0,3:404,9:Not Found,N"
+```
+
+Load a RABX message:
+
+```ruby
+message = RABX::Message.load("R1:0,10:RPC.method,L1:2,T8:argument,I1:3,")
+message.type # "R"
+message.method # "RPC.method"
+message.argumetns # ["argument", 3]
+
+message = RABX::Message.load("S1:0,A1:2,T4:name,T3:foo,T5:email,T15:foo@example.com,")
+message.type # "S"
+message.value # {"name"=>"foo", "email"=>"foo@example.com"}
+
+message = RABX::Message.load("E1:0,3:404,9:Not Found,N")
+message.type # "E"
+message.code # "404"
+message.text # "Not Found"
+message.extra # nil
+```
+
+See the [documentation](http://www.rubydoc.info/gems/rabx-message) to see how to work with `RABX::Message` instances.
+
+## Notes
+
+Generic RABX clients include:
+
+* [Perl](https://github.com/mysociety/commonlib/blob/master/perllib/RABX.pm)
+* [PHP](https://github.com/mysociety/commonlib/blob/master/phplib/rabx.php)
+* [Python](https://github.com/mysociety/commonlib/blob/master/pylib/mysociety/rabx.py) (REST interface)
+* [Ruby](https://github.com/mysociety/commonlib/blob/master/rblib/rabx.rb) (REST interface)
+* [Command-line](https://github.com/mysociety/misc-scripts/blob/master/bin/rabx)
+
+mySociety has scripts to convert a Perl RABX server to a server-specific client in:
+
+* [Perl](https://github.com/mysociety/misc-scripts/blob/master/bin/rabxtopl.pl)
+* [PHP](https://github.com/mysociety/misc-scripts/blob/master/bin/rabxtophp.pl)
+* [Python](https://github.com/mysociety/misc-scripts/blob/master/bin/rabxresttopy.pl)
+* [Ruby](https://github.com/mysociety/misc-scripts/blob/master/bin/rabxresttorb.pl)
+
+Copyright (c) 2014 James McKinney, released under the MIT license

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/USAGE

@@ -0,0 +1 @@
+See README.md for full usage details.

data/lib/50418

@@ -0,0 +1 @@
+E1:0,3:515,48:first byte of call string should be "R", not "D",N

data/lib/rabx/message.rb

@@ -0,0 +1,225 @@
+require 'netstring'
+
+module RABX
+  class Message
+    class Error < StandardError; end
+    class ProtocolError < Error; end
+    class InterfaceError < Error; end
+
+    # Dumps a RABX message.
+    #
+    # @param [String] type a message type
+    # @param [Array] args message contents
+    # @return [String] the REBX message
+    def self.dump(type, *args)
+      string = type + Netstring.dump('0')
+      if type == 'R'
+        string + Netstring.dump(args[0]) + _dump(args[1])
+      elsif type == 'S'
+        if args.size.zero?
+          string
+        else
+          string + _dump(args[0])
+        end
+      elsif type == 'E'
+        string + Netstring.dump(args[0].to_s) + Netstring.dump(args[1]) + _dump(args[2])
+      end
+    end
+
+    # Loads a RABX message.
+    #
+    # @param [String] s a RABX message
+    # @return [Message] a parsed message
+    def self.load(s)
+      case s[0]
+      when 'R'
+        RequestMessage.new(s)
+      when 'S'
+        SuccessMessage.new(s)
+      when 'E'
+        ErrorMessage.new(s)
+      else
+        raise ProtocolError, %(unknown RABX message type "#{s[0]}")
+      end
+    end
+
+    attr_reader :version
+
+    # @param [String] s a RABX message
+    def initialize(s)
+      if s.empty?
+        raise ProtocolError, 'string is too short'
+      end
+      @s = s.dup # string
+      @p = 1 # pointer
+      @size = @s.size
+      @version = getnetstring
+      parse
+    end
+
+    # Returns the RABX message.
+    #
+    # @return [String] the RABX message
+    def to_s
+      @s
+    end
+
+    # Returns the message type.
+    #
+    # @return [String] the message type
+    def type
+      @s[0]
+    end
+
+    # Returns whether the reader has reached the end-of-file.
+    #
+    # @return [Boolean] whether the reader has reached the end-of-file
+    def eof?
+      @p == @size
+    end
+
+    # Loads a netstring from the current position in the message.
+    #
+    # @return [Netstring,nil] a string, or nil if at end-of-file
+    def getnetstring
+      if eof?
+        nil
+      else
+        string = Netstring.load(@s[@p..-1])
+        @p += string.netstring.size
+        string
+      end
+    rescue Netstring::Error => e
+      raise ProtocolError, "#{e.message} in netstring starting at #{@p}"
+    end
+
+    # Loads a typed netstring from the current position in the message.
+    #
+    # @return the contents of the netstring, or nil if at end-of-file
+    def gets
+      if eof?
+        nil
+      else
+        type = @s[@p]
+        @p += 1
+
+        if type == 'N' # null
+          return nil
+        end
+
+        case type
+        when 'I' # integer
+          value = getnetstring.to_s
+          begin
+            Integer(value)
+          rescue ArgumentError
+            raise ProtocolError, %(expected integer, got #{value.inspect} at position #{@p - value.size - 1})
+          end
+        when 'R' # real
+          value = getnetstring.to_s
+          begin
+            Float(value)
+          rescue ArgumentError
+            raise ProtocolError, %(expected float, got #{value.inspect} at position #{@p - value.size - 1})
+          end
+        when 'T', 'B' # text, binary
+          getnetstring
+        when 'L' # list
+          value = getnetstring.to_s
+          begin
+            size = Integer(value)
+          rescue ArgumentError
+            raise ProtocolError, %(expected integer, got #{value.inspect} at position #{@p - value.size - 1})
+          end
+          array = []
+          size.times do |n|
+            if eof?
+              raise ProtocolError, %(expected #{size} items, got #{n} items at position #{@p})
+            end
+            array << gets
+          end
+          array
+        when 'A' # associative array
+          value = getnetstring.to_s
+          begin
+            size = Integer(value)
+          rescue ArgumentError
+            raise ProtocolError, %(expected integer, got #{value.inspect} at position #{@p - value.size - 1})
+          end
+          hash = {}
+          size.times do |n|
+            if eof?
+              raise ProtocolError, %(expected #{size} items, got #{n} items at position #{@p})
+            end
+            key = gets # test for repeated keys?
+            if eof?
+              raise ProtocolError, %(expected value, got end-of-file at position #{@p})
+            end
+            hash[key] = gets
+          end
+          hash
+        else
+          raise ProtocolError, %(bad type character "#{type}" at position #{@p})
+        end
+      end
+    end
+
+  private
+
+    def parse
+      # If not implemented, user can read message using `getnetstring` and `gets`.
+    end
+
+    def self._dump(args)
+      case args
+      when nil
+        'N'
+      when true
+        'I' + Netstring.dump('1')
+      when false
+        'I' + Netstring.dump('0')
+      when Integer
+        'I' + Netstring.dump(args.to_s)
+      when Float
+        'R' + Netstring.dump(args.to_s)
+      when String
+        'T' + Netstring.dump(args)
+      when Symbol
+        'T' + Netstring.dump(args.to_s)
+      when Array
+        'L' + Netstring.dump(args.size.to_s) + args.map{|arg| _dump(arg)}.join
+      when Hash
+        'A' + Netstring.dump(args.size.to_s) + args.map{|k,v| _dump(k) + _dump(v)}.join
+      else
+        raise InterfaceError, "can't pass #{args.class} over RABX"
+      end
+    end
+  end
+
+  class RequestMessage < Message
+    attr_reader :method, :arguments
+
+    def parse
+      @method = getnetstring
+      @arguments = gets
+    end
+  end
+
+  class SuccessMessage < Message
+    attr_reader :value
+
+    def parse
+      @value = gets
+    end
+  end
+
+  class ErrorMessage < Message
+    attr_reader :code, :text, :extra
+
+    def parse
+      @code = getnetstring
+      @text = getnetstring
+      @extra = gets unless eof?
+    end
+  end
+end

data/lib/rabx/message/version.rb

@@ -0,0 +1,5 @@
+module RABX
+  class Message
+    VERSION = "0.0.1"
+  end
+end

data/rabx-message.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rabx/message/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "rabx-message"
+  s.version     = RABX::Message::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["James McKinney"]
+  s.homepage    = "http://github.com/jpmckinney/rabx-message"
+  s.summary     = %q{A RPC using Anything But XML (RABX) message parser and emitter}
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency('netstring', '~> 0.0')
+
+  s.add_development_dependency('coveralls')
+  s.add_development_dependency('json', '~> 1.8') # to silence coveralls warning
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 3.1')
+end

data/spec/message_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+
+RSpec.describe RABX::Message do
+  let :invalid_netstring do
+    RABX::Message.new('R1:0,1:x')
+  end
+
+  let :invalid_rabx do
+    RABX::Message.new('S1:0,I1:x')
+  end
+
+  let :n do
+    RABX::Message.new('S1:0,N')
+  end
+
+  let :i do
+    RABX::Message.new('S1:0,I2:34,')
+  end
+  let :invalid_i do
+    RABX::Message.new('S1:0,I2:xy,')
+  end
+
+  let :r do
+    RABX::Message.new('S1:0,R4:1.23,')
+  end
+  let :invalid_r do
+    RABX::Message.new('S1:0,R4:abcd,')
+  end
+
+  let :t do
+    RABX::Message.new('S1:0,T2:xy,')
+  end
+
+  let :b do
+    RABX::Message.new('S1:0,B2:ab,')
+  end
+
+  let :l do
+    RABX::Message.new('S1:0,L1:2,I2:34,T2:xy,')
+  end
+  let :invalid_l_size do
+    RABX::Message.new('S1:0,L1:x,I2:34,T2:xy,')
+  end
+  let :missing_l_item do
+    RABX::Message.new('S1:0,L1:2,I2:34,')
+  end
+
+  let :a do
+    RABX::Message.new('S1:0,A1:2,I2:34,T2:xy,R4:1.23,B2:ab,')
+  end
+  let :invalid_a_size do
+    RABX::Message.new('S1:0,A1:x,I2:34,T2:xy,R4:1.23,B2:ab,')
+  end
+  let :missing_a_item do
+    RABX::Message.new('S1:0,A1:2,I2:34,T2:xy,')
+  end
+  let :missing_a_value do
+    RABX::Message.new('S1:0,A1:2,I2:34,T2:xy,R4:1.23,')
+  end
+
+  let :invalid_type do
+    RABX::Message.new('S1:0,U1:x,')
+  end
+
+  let :empty_message do
+    'S1:0,'
+  end
+  let :empty do
+    RABX::Message.new(empty_message)
+  end
+
+  let :request_message do
+    'R1:0,6:method,L1:2,I2:34,T2:xy,'
+  end
+  let :request do
+    RABX::Message.new(request_message)
+  end
+
+  let :success_message do
+    'S1:0,A1:2,I2:34,T2:xy,R4:1.23,T2:ab,'
+  end
+  let :success do
+    RABX::Message.new(success_message)
+  end
+
+  let :error_message do
+    "E1:0,3:404,9:Not Found,N"
+  end
+  let :error do
+    RABX::Message.new(error_message)
+  end
+
+  let :unknown_message do
+    'U1:0,'
+  end
+  let :unknown do
+    RABX::Message.new(unknown_message)
+  end
+
+  describe '.dump' do
+    it 'should dump a RABX message' do
+      {
+        ['S'] => empty_message,
+        ['R', 'method', [34, 'xy']] => request_message,
+        ['S', {34 => 'xy', 1.23 => 'ab'}] => success_message,
+        ['E', 404, 'Not Found'] => error_message,
+        ['S', nil] => 'S1:0,N',
+        ['S', true] => 'S1:0,I1:1,',
+        ['S', false] => 'S1:0,I1:0,',
+        ['S', 1] => 'S1:0,I1:1,',
+        ['S', 1.1] => 'S1:0,R3:1.1,',
+        ['S', 'x'] => 'S1:0,T1:x,',
+        ['S', :x] => 'S1:0,T1:x,',
+        ['S', []] => 'S1:0,L1:0,',
+        ['S', {}] => 'S1:0,A1:0,',
+      }.each do |args,string|
+        expect(RABX::Message.dump(*args)).to eq(string)
+      end
+    end
+  end
+
+  describe '.load' do
+    it 'should load a RABX request message' do
+      message = RABX::Message.load(request_message)
+      expect(message.method).to eq('method')
+      expect(message.arguments).to eq([34, 'xy'])
+    end
+
+    it 'should load a RABX success message' do
+      message = RABX::Message.load(success_message)
+      expect(message.value).to eq({34 => 'xy', 1.23 => 'ab'})
+    end
+
+    it 'should load a RABX error message' do
+      message = RABX::Message.load(error_message)
+      expect(message.code).to eq('404')
+      expect(message.text).to eq('Not Found')
+      expect(message.extra).to eq(nil)
+    end
+
+    it 'should raise an error if type is unknown' do
+      expect{RABX::Message.load(unknown_message)}.to raise_error(RABX::Message::ProtocolError, 'unknown RABX message type "U"')
+    end
+  end
+
+  describe '#initialize' do
+    it 'should initialize a RABX message' do
+      expect{request}.to_not raise_error
+    end
+
+    it 'should make a copy of the string' do
+      expect(request.instance_variable_get(:@s)).to eq('R1:0,6:method,L1:2,I2:34,T2:xy,')
+      request_message.reverse!
+      expect(request.instance_variable_get(:@s)).to eq('R1:0,6:method,L1:2,I2:34,T2:xy,')
+    end
+
+    it 'should raise an error if the string is empty' do
+      expect{RABX::Message.new('')}.to raise_error(RABX::Message::ProtocolError, 'string is too short')
+    end
+  end
+
+  describe '#to_s' do
+    it 'should return the message' do
+      expect(request.to_s).to eq(request_message)
+    end
+  end
+
+  describe '#type' do
+    it 'should return the message type' do
+      expect(request.type).to eq('R')
+      expect(success.type).to eq('S')
+      expect(error.type).to eq('E')
+    end
+  end
+
+  describe '#eof?' do
+    it 'should return true only if the message has been read' do
+      message = RABX::Message.new('S1:0,N')
+      expect(message.eof?).to eq(false)
+      expect(message.gets).to eq(nil)
+      expect(message.eof?).to eq(true)
+    end
+  end
+
+  describe '#getnetstring' do
+    it 'should read a netstring' do
+      expect(error.getnetstring).to eq('404')
+      expect(error.getnetstring).to eq('Not Found')
+    end
+
+    it 'should return nil if at end of message' do
+      expect(empty.getnetstring).to eq(nil)
+      expect(empty.getnetstring).to eq(nil)
+      expect(empty.getnetstring).to eq(nil)
+    end
+
+    it 'should raise an error if the netstring is invalid' do
+      expect{invalid_netstring.getnetstring}.to raise_error(RABX::Message::ProtocolError)
+    end
+  end
+
+  describe '#gets' do
+    it 'should read a N message' do
+      expect(n.gets).to eq(nil)
+    end
+
+    it 'should read a I message' do
+      expect(i.gets).to eq(34)
+    end
+    it 'should raise an error if an integer is invalid' do
+      expect{invalid_i.gets}.to raise_error(RABX::Message::ProtocolError, 'expected integer, got "xy" at position 8')
+    end
+
+    it 'should read a R message' do
+      expect(r.gets).to eq(1.23)
+    end
+    it 'should raise an error if a float is invalid' do
+      expect{invalid_r.gets}.to raise_error(RABX::Message::ProtocolError, 'expected float, got "abcd" at position 8')
+    end
+
+    it 'should read a T message' do
+      expect(t.gets).to eq('xy')
+    end
+
+    it 'should read a B message' do
+      expect(b.gets).to eq('ab')
+    end
+
+    it 'should read a L message' do
+      expect(l.gets).to eq([34, 'xy'])
+    end
+    it 'should raise an error if a list size is invalid' do
+      expect{invalid_l_size.gets}.to raise_error(RABX::Message::ProtocolError, 'expected integer, got "x" at position 8')
+    end
+    it 'should raise an error if a list item is missing' do
+      expect{missing_l_item.gets}.to raise_error(RABX::Message::ProtocolError, 'expected 2 items, got 1 items at position 16')
+    end
+
+    it 'should read a A message' do
+      expect(a.gets).to eq({34 => 'xy', 1.23 => 'ab'})
+    end
+    it 'should raise an error if a hash size is invalid' do
+      expect{invalid_a_size.gets}.to raise_error(RABX::Message::ProtocolError, 'expected integer, got "x" at position 8')
+    end
+    it 'should raise an error if a hash item is missing' do
+      expect{missing_a_item.gets}.to raise_error(RABX::Message::ProtocolError, 'expected 2 items, got 1 items at position 22')
+    end
+    it 'should raise an error if a hash value is missing' do
+      expect{missing_a_value.gets}.to raise_error(RABX::Message::ProtocolError, 'expected value, got end-of-file at position 30')
+    end
+
+    it 'should raise an error if the type is invalid' do
+      expect{invalid_type.gets}.to raise_error(RABX::Message::ProtocolError, 'bad type character "U" at position 6')
+    end
+
+    it 'should return nil if at end of message' do
+      expect(empty.gets).to eq(nil)
+      expect(empty.gets).to eq(nil)
+      expect(empty.gets).to eq(nil)
+    end
+
+    it 'should raise an error if the netstring is invalid' do
+      expect{invalid_rabx.gets}.to raise_error(RABX::Message::ProtocolError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+require 'rspec'
+require File.dirname(__FILE__) + '/../lib/rabx/message'

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: rabx-message
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James McKinney
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: netstring
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- USAGE
+- lib/50418
+- lib/rabx/message.rb
+- lib/rabx/message/version.rb
+- rabx-message.gemspec
+- spec/message_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/jpmckinney/rabx-message
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A RPC using Anything But XML (RABX) message parser and emitter
+test_files:
+- spec/message_spec.rb
+- spec/spec_helper.rb