tros 1.7.6.1 → 1.7.6.2

data/.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
+/pkg
 /tmp
 /interop
 data.avr

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tros (1.7.6.1)
+    tros (1.7.6.2)
 
 GEM
   remote: https://rubygems.org/
@@ -10,6 +10,7 @@ GEM
     rake (10.3.2)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES

data/lib/tros.rb

@@ -22,9 +22,9 @@ require 'stringio'
 require 'zlib'
 
 module Tros
-  class TrosError < StandardError; end
+  class AvroError < StandardError; end
 
-  class TrosTypeError < Tros::TrosError
+  class AvroTypeError < Tros::AvroError
     def initialize(schm=nil, datum=nil, msg=nil)
       msg ||= "Not a #{schm.to_s}: #{datum}"
       super(msg)

data/lib/tros/data_file.rb

@@ -26,7 +26,7 @@ module Tros
     META_SCHEMA = Schema.parse('{"type": "map", "values": "bytes"}')
     VALID_ENCODINGS = ['binary'] # not used yet
 
-    class DataFileError < TrosError; end
+    class DataFileError < AvroError; end
 
     def self.open(file_path, mode='r', schema=nil, codec=nil)
       schema = Tros::Schema.parse(schema) if schema

data/lib/tros/io.rb

@@ -17,14 +17,14 @@
 module Tros
   module IO
     # Raised when datum is not an example of schema
-    class AvroTypeError < TrosError
+    class AvroTypeError < AvroError
       def initialize(expected_schema, datum)
         super("The datum #{datum.inspect} is not an example of schema #{expected_schema}")
       end
     end
 
     # Raised when writer's and reader's schema do not match
-    class SchemaMatchException < TrosError
+    class SchemaMatchException < AvroError
       def initialize(writers_schema, readers_schema)
         super("Writer's schema #{writers_schema} and Reader's schema " +
               "#{readers_schema} do not match.")
@@ -205,7 +205,7 @@ module Tros
       # A string is encoded as a long followed by that many bytes of
       # UTF-8 encoded character data
       def write_string(datum)
-        write_bytes(datum.encode('UTF-8'))
+        write_bytes(datum.encode('UTF-8').force_encoding('binary'))
       end
 
       # Write an arbritary datum.
@@ -304,7 +304,7 @@ module Tros
         when :union;   read_union(writers_schema, readers_schema, decoder)
         when :record, :error, :request;  read_record(writers_schema, readers_schema, decoder)
         else
-          raise TrosError, "Cannot read unknown schema type: #{writers_schema.type}"
+          raise AvroError, "Cannot read unknown schema type: #{writers_schema.type}"
         end
       end
 
@@ -441,7 +441,7 @@ module Tros
           return read_record
         else
           fail_msg = "Unknown type: #{field_schema.type}"
-          raise TrosError, fail_msg
+          raise AvroError, fail_msg
         end
       end
 
@@ -476,7 +476,7 @@ module Tros
         when :record, :error, :request
           skip_record(writers_schema, decoder)
         else
-          raise TrosError, "Unknown schema type: #{writers_schema.type}"
+          raise AvroError, "Unknown schema type: #{writers_schema.type}"
         end
       end
 
@@ -535,7 +535,7 @@ module Tros
 
       def write_data(writers_schema, datum, encoder)
         unless Schema.validate(writers_schema, datum)
-          raise TrosTypeError.new(writers_schema, datum)
+          raise AvroTypeError.new(writers_schema, datum)
         end
 
         # function dispatch to write datum
@@ -555,7 +555,7 @@ module Tros
         when :union;   write_union(writers_schema, datum, encoder)
         when :record, :error, :request;  write_record(writers_schema, datum, encoder)
         else
-          raise TrosError.new("Unknown type: #{writers_schema.type}")
+          raise AvroError.new("Unknown type: #{writers_schema.type}")
         end
       end
 
@@ -590,14 +590,12 @@ module Tros
       end
 
       def write_union(writers_schema, datum, encoder)
-        index_of_schema = -1
-        found = writers_schema.schemas.
-          find{|e| index_of_schema += 1; found = Schema.validate(e, datum) }
-        unless found  # Because find_index doesn't exist in 1.8.6
-          raise TrosTypeError.new(writers_schema, datum)
-        end
-        encoder.write_long(index_of_schema)
-        write_data(writers_schema.schemas[index_of_schema], datum, encoder)
+        index = writers_schema.schemas.find_index { |s| Schema.validate_strictly(s, datum) }
+        index ||= writers_schema.schemas.find_index { |s| Schema.validate(s, datum) }
+        raise AvroTypeError.new(writers_schema, datum) if index.nil?
+
+        encoder.write_long(index)
+        write_data(writers_schema.schemas[index], datum, encoder)
       end
 
       def write_record(writers_schema, datum, encoder)

data/lib/tros/ipc.rb

@@ -18,7 +18,7 @@ require "net/http"
 
 module Tros::IPC
 
-  class TrosRemoteError < Tros::TrosError; end
+  class TrosRemoteError < Tros::AvroError; end
 
   HANDSHAKE_REQUEST_SCHEMA = Tros::Schema.parse <<-JSON
   {
@@ -70,9 +70,9 @@ module Tros::IPC
   BUFFER_SIZE = 8192
 
   # Raised when an error message is sent by an Tros requestor or responder.
-  class TrosRemoteException < Tros::TrosError; end
+  class TrosRemoteException < Tros::AvroError; end
 
-  class ConnectionClosedException < Tros::TrosError; end
+  class ConnectionClosedException < Tros::AvroError; end
 
   class Requestor
     """Base class for the client side of a protocol interaction."""
@@ -149,7 +149,7 @@ module Tros::IPC
 
       message = local_protocol.messages[message_name]
       unless message
-        raise TrosError, "Unknown message: #{message_name}"
+        raise AvroError, "Unknown message: #{message_name}"
       end
       encoder.write_string(message.name)
 
@@ -170,18 +170,18 @@ module Tros::IPC
         self.send_protocol = false
         we_have_matching_schema = true
       when 'CLIENT'
-        raise TrosError.new('Handshake failure. match == CLIENT') if send_protocol
+        raise AvroError.new('Handshake failure. match == CLIENT') if send_protocol
         self.remote_protocol = Tros::Protocol.parse(handshake_response['serverProtocol'])
         self.remote_hash = handshake_response['serverHash']
         self.send_protocol = false
         we_have_matching_schema = true
       when 'NONE'
-        raise TrosError.new('Handshake failure. match == NONE') if send_protocol
+        raise AvroError.new('Handshake failure. match == NONE') if send_protocol
         self.remote_protocol = Tros::Protocol.parse(handshake_response['serverProtocol'])
         self.remote_hash = handshake_response['serverHash']
         self.send_protocol = true
       else
-        raise TrosError.new("Unexpected match: #{match}")
+        raise AvroError.new("Unexpected match: #{match}")
       end
 
       return we_have_matching_schema
@@ -199,12 +199,12 @@ module Tros::IPC
 
       # remote response schema
       remote_message_schema = remote_protocol.messages[message_name]
-      raise TrosError.new("Unknown remote message: #{message_name}") unless remote_message_schema
+      raise AvroError.new("Unknown remote message: #{message_name}") unless remote_message_schema
 
       # local response schema
       local_message_schema = local_protocol.messages[message_name]
       unless local_message_schema
-        raise TrosError.new("Unknown local message: #{message_name}")
+        raise AvroError.new("Unknown local message: #{message_name}")
       end
 
       # error flag
@@ -264,11 +264,11 @@ module Tros::IPC
         # schema resolution (one fine day)
         remote_message = remote_protocol.messages[remote_message_name]
         unless remote_message
-          raise TrosError.new("Unknown remote message: #{remote_message_name}")
+          raise AvroError.new("Unknown remote message: #{remote_message_name}")
         end
         local_message = local_protocol.messages[remote_message_name]
         unless local_message
-          raise TrosError.new("Unknown local message: #{remote_message_name}")
+          raise AvroError.new("Unknown local message: #{remote_message_name}")
         end
         writers_schema = remote_message.request
         readers_schema = local_message.request
@@ -292,7 +292,7 @@ module Tros::IPC
           writers_schema = local_message.errors || SYSTEM_ERROR_SCHEMA
           write_error(writers_schema, error, buffer_encoder)
         end
-      rescue Tros::TrosError => e
+      rescue Tros::AvroError => e
         error = TrosRemoteException.new(e.to_s)
         buffer_encoder = Tros::IO::BinaryEncoder.new(StringIO.new)
         META_WRITER.write(response_metadata, buffer_encoder)

data/lib/tros/protocol.rb

@@ -18,7 +18,7 @@ module Tros
   class Protocol
     VALID_TYPE_SCHEMA_TYPES = Set.new(%w[enum record error fixed])
     VALID_TYPE_SCHEMA_TYPES_SYM = Set.new(VALID_TYPE_SCHEMA_TYPES.map(&:to_sym))
-    class ProtocolParseError < Tros::TrosError; end
+    class ProtocolParseError < Tros::AvroError; end
 
     attr_reader :name, :namespace, :types, :messages, :md5
     def self.parse(protocol_string)

data/lib/tros/schema.rb

@@ -93,6 +93,17 @@ module Tros
 
     # Determine if a ruby datum is an instance of a schema
     def self.validate(expected_schema, datum)
+      return true if validate_strictly(expected_schema, datum)
+      case expected_schema.type_sym
+      when :float, :double
+        datum.is_a?(Float) || datum.is_a?(Fixnum) || datum.is_a?(Bignum)
+      else
+        return false
+      end
+    end
+
+    # Determine if a ruby datum is an instance of a schema
+    def self.validate_strictly(expected_schema, datum)
       case expected_schema.type_sym
       when :null
         datum.nil?
@@ -107,24 +118,24 @@ module Tros
         (datum.is_a?(Fixnum) || datum.is_a?(Bignum)) &&
             (LONG_MIN_VALUE <= datum) && (datum <= LONG_MAX_VALUE)
       when :float, :double
-        datum.is_a?(Float) || datum.is_a?(Fixnum) || datum.is_a?(Bignum)
+        datum.is_a?(Float)
       when :fixed
         datum.is_a?(String) && datum.size == expected_schema.size
       when :enum
         expected_schema.symbols.include? datum
       when :array
         datum.is_a?(Array) &&
-          datum.all?{|d| validate(expected_schema.items, d) }
+          datum.all?{|d| validate_strictly(expected_schema.items, d) }
       when :map
           datum.keys.all?{|k| k.is_a? String } &&
-          datum.values.all?{|v| validate(expected_schema.values, v) }
+          datum.values.all?{|v| validate_strictly(expected_schema.values, v) }
       when :union
-        expected_schema.schemas.any?{|s| validate(s, datum) }
+        expected_schema.schemas.any?{|s| validate_strictly(s, datum) }
       when :record, :error, :request
         datum.is_a?(Hash) &&
-          expected_schema.fields.all?{|f| validate(f.type, datum[f.name]) }
+          expected_schema.fields.all?{|f| validate_strictly(f.type, datum[f.name]) }
       else
-        raise "you suck #{expected_schema.inspect} is not allowed."
+        raise TypeError, "#{expected_schema.inspect} is not recognized as type."
       end
     end
 
@@ -322,7 +333,7 @@ module Tros
         elsif PRIMITIVE_TYPES.include?(type)
           super(type.to_sym)
         else
-          raise TrosError.new("#{type} is not a valid primitive type.")
+          raise AvroError.new("#{type} is not a valid primitive type.")
         end
       end
 
@@ -337,7 +348,7 @@ module Tros
       def initialize(name, space, size, names=nil)
         # Ensure valid cto args
         unless size.is_a?(Fixnum) || size.is_a?(Bignum)
-          raise TrosError, 'Fixed Schema requires a valid integer for size property.'
+          raise AvroError, 'Fixed Schema requires a valid integer for size property.'
         end
         super(:fixed, name, space, names)
         @size = size
@@ -368,7 +379,7 @@ module Tros
     end
   end
 
-  class SchemaParseError < TrosError; end
+  class SchemaParseError < AvroError; end
 
   module Name
     def self.extract_namespace(name, namespace)

data/lib/tros/version.rb

@@ -1,3 +1,3 @@
 module Tros
-  VERSION = "1.7.6.1"
+  VERSION = "1.7.6.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tros
 version: !ruby/object:Gem::Version
-  version: 1.7.6.1
+  version: 1.7.6.2
   prerelease: 
 platform: ruby
 authors:
@@ -103,12 +103,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 141493864149925103
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 141493864149925103
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23