avro 1.10.1 → 1.11.1

data/test/test_logical_types.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -16,6 +17,7 @@
 # limitations under the License.
 
 require 'test_help'
+require 'memory_profiler'
 
 class TestLogicalTypes < Test::Unit::TestCase
   def test_int_date
@@ -98,8 +100,143 @@ class TestLogicalTypes < Test::Unit::TestCase
     assert_equal 'duration', schema.logical_type
   end
 
+  def test_bytes_decimal
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "bytes", "logicalType": "decimal", "precision": 9, "scale": 6 }
+    SCHEMA
+
+    assert_equal 'decimal', schema.logical_type
+    assert_equal 9, schema.precision
+    assert_equal 6, schema.scale
+
+    assert_encode_and_decode BigDecimal('-3.4562'), schema
+    assert_encode_and_decode BigDecimal('3.4562'), schema
+    assert_encode_and_decode 15.123, schema
+    assert_encode_and_decode 15, schema
+    assert_encode_and_decode BigDecimal('0.123456'), schema
+    assert_encode_and_decode BigDecimal('0'), schema
+    assert_encode_and_decode BigDecimal('1'), schema
+    assert_encode_and_decode BigDecimal('-1'), schema
+
+    assert_raise ArgumentError do
+      type = Avro::LogicalTypes::BytesDecimal.new(schema)
+      type.encode('1.23')
+    end
+  end
+
+  def test_bytes_decimal_range_errors
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "bytes", "logicalType": "decimal", "precision": 4, "scale": 2 }
+    SCHEMA
+
+    type = Avro::LogicalTypes::BytesDecimal.new(schema)
+
+    assert_raises RangeError do
+      type.encode(BigDecimal('345'))
+    end
+
+    assert_raises RangeError do
+      type.encode(BigDecimal('1.5342'))
+    end
+
+    assert_raises RangeError do
+      type.encode(BigDecimal('-1.5342'))
+    end
+
+    assert_raises RangeError do
+      type.encode(BigDecimal('-100.2'))
+    end
+
+    assert_raises RangeError do
+      type.encode(BigDecimal('-99.991'))
+    end
+  end
+
+  def test_bytes_decimal_conversion
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "bytes", "logicalType": "decimal", "precision": 12, "scale": 6 }
+    SCHEMA
+
+    type = Avro::LogicalTypes::BytesDecimal.new(schema)
+
+    enc = "\xcb\x43\x38".dup.force_encoding('BINARY')
+    assert_equal enc, type.encode(BigDecimal('-3.4562'))
+    assert_equal BigDecimal('-3.4562'), type.decode(enc)
+
+    assert_equal "\x34\xbc\xc8".dup.force_encoding('BINARY'), type.encode(BigDecimal('3.4562'))
+    assert_equal BigDecimal('3.4562'), type.decode("\x34\xbc\xc8".dup.force_encoding('BINARY'))
+
+    assert_equal "\x6a\x33\x0e\x87\x00".dup.force_encoding('BINARY'), type.encode(BigDecimal('456123.123456'))
+    assert_equal BigDecimal('456123.123456'), type.decode("\x6a\x33\x0e\x87\x00".dup.force_encoding('BINARY'))
+  end
+
+  def test_logical_type_with_schema
+    exception = assert_raises(ArgumentError) do
+      Avro::LogicalTypes::LogicalTypeWithSchema.new(nil)
+    end
+    assert_equal exception.to_s, 'schema is required'
+
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "bytes", "logicalType": "decimal", "precision": 12, "scale": 6 }
+    SCHEMA
+
+    assert_nothing_raised do
+      Avro::LogicalTypes::LogicalTypeWithSchema.new(schema)
+    end
+
+    assert_raises NotImplementedError do
+      Avro::LogicalTypes::LogicalTypeWithSchema.new(schema).encode(BigDecimal('2'))
+    end
+
+    assert_raises NotImplementedError do
+      Avro::LogicalTypes::LogicalTypeWithSchema.new(schema).decode('foo')
+    end
+  end
+
+  def test_bytes_decimal_object_allocations_encode
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "bytes", "logicalType": "decimal", "precision": 4, "scale": 2 }
+    SCHEMA
+
+    type = Avro::LogicalTypes::BytesDecimal.new(schema)
+
+    positive_value = BigDecimal('5.2')
+    negative_value = BigDecimal('-5.2')
+
+    [positive_value, negative_value].each do |value|
+      report = MemoryProfiler.report do
+        type.encode(value)
+      end
+
+      assert_equal 5, report.total_allocated
+      # Ruby 2.7 does not retain anything. Ruby 2.6 retains 1
+      assert_operator 1, :>=, report.total_retained
+    end
+  end
+
+  def test_bytes_decimal_object_allocations_decode
+    schema = Avro::Schema.parse <<-SCHEMA
+      { "type": "bytes", "logicalType": "decimal", "precision": 4, "scale": 2 }
+    SCHEMA
+
+    type = Avro::LogicalTypes::BytesDecimal.new(schema)
+
+    positive_enc = "\x02\b".dup.force_encoding('BINARY')
+    negative_enc = "\xFD\xF8".dup.force_encoding('BINARY')
+
+    [positive_enc, negative_enc].each do |encoded|
+      report = MemoryProfiler.report do
+        type.decode(encoded)
+      end
+
+      assert_equal 5, report.total_allocated
+      # Ruby 2.7 does not retain anything. Ruby 2.6 retains 1
+      assert_operator 1, :>=, report.total_retained
+    end
+  end
+
   def encode(datum, schema)
-    buffer = StringIO.new("")
+    buffer = StringIO.new
     encoder = Avro::IO::BinaryEncoder.new(buffer)
 
     datum_writer = Avro::IO::DatumWriter.new(schema)

data/test/test_protocol.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -184,7 +185,7 @@ EOS
   }
 }
 EOS
-]
+].freeze
 
   Protocol = Avro::Protocol
   def test_parse

data/test/test_schema.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -541,6 +542,76 @@ class TestSchema < Test::Unit::TestCase
                  exception.to_s)
   end
 
+  def test_fixed_decimal_to_include_precision_scale
+    schema = Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "fixed",
+        "name": "aFixed",
+        "logicalType": "decimal",
+        "size": 4,
+        "precision": 9,
+        "scale": 2
+      }
+    SCHEMA
+
+    schema_hash =
+      {
+        'type' => 'fixed',
+        'name' => 'aFixed',
+        'logicalType' => 'decimal',
+        'size' => 4,
+        'precision' => 9,
+        'scale' => 2
+      }
+
+    assert_equal schema_hash, schema.to_avro
+  end
+
+  def test_fixed_decimal_to_include_precision_no_scale
+    schema = Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "fixed",
+        "name": "aFixed",
+        "logicalType": "decimal",
+        "size": 4,
+        "precision": 9
+      }
+    SCHEMA
+
+    schema_hash =
+      {
+        'type' => 'fixed',
+        'name' => 'aFixed',
+        'logicalType' => 'decimal',
+        'size' => 4,
+        'precision' => 9
+      }
+
+    assert_equal schema_hash, schema.to_avro
+  end
+
+  # Note: this is not valid but validation is not yet implemented
+  def test_fixed_decimal_to_without_precision_scale
+    schema = Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "fixed",
+        "size": 4,
+        "name": "aFixed",
+        "logicalType": "decimal"
+      }
+    SCHEMA
+
+    schema_hash =
+      {
+        'type' => 'fixed',
+        'name' => 'aFixed',
+        'logicalType' => 'decimal',
+        'size' => 4
+      }
+
+    assert_equal schema_hash, schema.to_avro
+  end
+
   def test_bytes_decimal_to_include_precision_scale
     schema = Avro::Schema.parse <<-SCHEMA
       {
@@ -562,23 +633,82 @@ class TestSchema < Test::Unit::TestCase
     assert_equal schema_hash, schema.to_avro
   end
 
-  def test_bytes_decimal_to_without_precision_scale
+  def test_bytes_decimal_with_string_precision_no_scale
     schema = Avro::Schema.parse <<-SCHEMA
       {
         "type": "bytes",
-        "logicalType": "decimal"
+        "logicalType": "decimal",
+        "precision": "7"
       }
     SCHEMA
 
     schema_hash =
       {
         'type' => 'bytes',
-        'logicalType' => 'decimal'
+        'logicalType' => 'decimal',
+        'precision' => 7
       }
 
     assert_equal schema_hash, schema.to_avro
   end
 
+  def test_bytes_decimal_without_precision_or_scale
+    error = assert_raise Avro::SchemaParseError do
+      Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "bytes",
+        "logicalType": "decimal"
+      }
+      SCHEMA
+    end
+
+    assert_equal 'Precision must be positive', error.message
+  end
+
+  def test_bytes_decimal_to_negative_precision
+    error = assert_raise Avro::SchemaParseError do
+      Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "bytes",
+        "logicalType": "decimal",
+        "precision": -1
+      }
+      SCHEMA
+    end
+
+    assert_equal 'Precision must be positive', error.message
+  end
+
+  def test_bytes_decimal_to_negative_scale
+    error = assert_raise Avro::SchemaParseError do
+      Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "bytes",
+        "logicalType": "decimal",
+        "precision": 2,
+        "scale": -1
+      }
+      SCHEMA
+    end
+
+    assert_equal 'Scale must be greater than or equal to 0', error.message
+  end
+
+  def test_bytes_decimal_with_precision_less_than_scale
+    error = assert_raise Avro::SchemaParseError do
+      Avro::Schema.parse <<-SCHEMA
+      {
+        "type": "bytes",
+        "logicalType": "decimal",
+        "precision": 3,
+        "scale": 4
+      }
+      SCHEMA
+    end
+
+    assert_equal 'Precision must be greater than scale', error.message
+  end
+
   def test_bytes_schema
     schema = Avro::Schema.parse <<-SCHEMA
       {
@@ -644,7 +774,7 @@ class TestSchema < Test::Unit::TestCase
   ensure
     Avro.disable_enum_symbol_validation = nil
   end
-  
+
   def test_validate_field_aliases
     exception = assert_raise(Avro::SchemaParseError) do
       hash_to_schema(

data/test/test_schema_compatibility.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -25,7 +26,9 @@ class TestSchemaCompatibility < Test::Unit::TestCase
   end
 
   def test_compatible_reader_writer_pairs
+    cached_schema = a_int_record1_schema
     [
+      cached_schema, cached_schema,
       long_schema, int_schema,
       float_schema, int_schema,
       float_schema, long_schema,
@@ -290,6 +293,111 @@ class TestSchemaCompatibility < Test::Unit::TestCase
     assert_false(can_read?(writer_schema, reader_schema))
   end
 
+  def test_bytes_decimal
+    bytes_decimal_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4, "scale":4}')
+    bytes2_decimal_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4, "scale":4}')
+    bytes_decimal_different_precision_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":5, "scale":4}')
+    bytes_decimal_no_scale_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4}')
+    bytes2_decimal_no_scale_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4}')
+    bytes_decimal_zero_scale_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4, "scale":0}')
+    bytes_unknown_logical_type_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"unknown"}')
+
+    # decimal bytes and non-decimal bytes can be mixed
+    assert_true(can_read?(bytes_schema, bytes_decimal_schema))
+    assert_true(can_read?(bytes_decimal_schema, bytes_schema))
+    assert_true(can_read?(bytes_decimal_schema, bytes_unknown_logical_type_schema))
+
+    # decimal bytes match even if precision and scale differ
+    assert_true(can_read?(bytes_decimal_schema, bytes_decimal_different_precision_schema))
+    assert_true(can_read?(bytes_decimal_schema, bytes_decimal_no_scale_schema))
+    assert_true(can_read?(bytes_decimal_schema, bytes_decimal_zero_scale_schema))
+    # - zero and no scale are equivalent
+    assert_true(can_read?(bytes_decimal_zero_scale_schema, bytes_decimal_no_scale_schema))
+    # - different schemas with the same attributes match
+    assert_true(can_read?(bytes_decimal_schema, bytes2_decimal_schema))
+    # - different schemas with the same no scale match
+    assert_true(can_read?(bytes2_decimal_no_scale_schema, bytes_decimal_no_scale_schema))
+  end
+
+  def test_fixed_decimal
+    fixed_decimal_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4, "scale":2}')
+    fixed2_decimal_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed2", "logicalType":"decimal", "precision":4, "scale":2}')
+    fixed_decimal_different_precision_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":3, "scale":2}')
+    fixed_decimal_size3_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":3, "name":"FixedS3", "logicalType":"decimal", "precision":4, "scale":2}')
+    fixed_unknown_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"unknown"}')
+    fixed_decimal_zero_scale_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4, "scale":0}')
+    fixed_decimal_no_scale_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4}')
+
+    # decimal fixed and non-decimal can be mixed if fixed name matches
+    assert_true(can_read?(fixed_decimal_schema, fixed1_schema))
+    assert_true(can_read?(fixed1_schema, fixed_decimal_schema))
+    assert_false(can_read?(fixed2_schema, fixed_decimal_schema))
+
+    # decimal logical types match even if fixed name differs
+    assert_true(can_read?(fixed_decimal_schema, fixed2_decimal_schema))
+
+    # fixed with the same name & size match even if decimal precision and scale differ
+    assert_true(can_read?(fixed_decimal_schema, fixed_decimal_different_precision_schema))
+    assert_true(can_read?(fixed_decimal_schema, fixed_decimal_size3_schema))
+    assert_true(can_read?(fixed_decimal_schema, fixed_unknown_schema))
+    # - zero and no scale are equivalent but these match anyway due to same name & size
+    assert_true(can_read?(fixed_decimal_no_scale_schema, fixed_decimal_zero_scale_schema))
+    # - scale does not match
+    assert_true(can_read?(fixed_decimal_schema, fixed_decimal_no_scale_schema))
+    assert_true(can_read?(fixed_decimal_schema, fixed_decimal_zero_scale_schema))
+  end
+
+  def test_decimal_different_types
+    fixed_decimal_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4, "scale":2}')
+    fixed_decimal_scale4_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4, "scale":4}')
+    bytes_decimal_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4, "scale":2}')
+    fixed_decimal_zero_scale_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4, "scale":0}')
+    fixed_decimal_no_scale_schema = Avro::Schema.
+      parse('{"type":"fixed", "size":2, "name":"Fixed1", "logicalType":"decimal", "precision":4}')
+    bytes_decimal_zero_scale_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4, "scale":0}')
+    bytes_decimal_no_scale_schema = Avro::Schema.
+      parse('{"type":"bytes", "logicalType":"decimal", "precision":4}')
+
+    # decimal logical types can be read
+    assert_true(can_read?(fixed_decimal_schema, bytes_decimal_schema))
+    assert_true(can_read?(bytes_decimal_schema, fixed_decimal_schema))
+
+    # non-decimal bytes and fixed cannot be mixed
+    assert_false(can_read?(fixed_decimal_schema, bytes_schema))
+    assert_false(can_read?(bytes_schema, fixed_decimal_schema))
+    assert_false(can_read?(fixed1_schema, bytes_decimal_schema))
+    assert_false(can_read?(bytes_decimal_schema, fixed1_schema))
+
+    # decimal precision and scale must match
+    assert_false(can_read?(fixed_decimal_scale4_schema, bytes_decimal_schema))
+    assert_false(can_read?(bytes_decimal_schema, fixed_decimal_scale4_schema))
+
+    # zero scale and no scale are equivalent
+    assert_true(can_read?(bytes_decimal_no_scale_schema, fixed_decimal_zero_scale_schema))
+    assert_true(can_read?(fixed_decimal_zero_scale_schema, bytes_decimal_no_scale_schema))
+    assert_true(can_read?(bytes_decimal_zero_scale_schema, fixed_decimal_no_scale_schema))
+    assert_true(can_read?(fixed_decimal_no_scale_schema, bytes_decimal_zero_scale_schema))
+  end
+
   # Tests from lang/java/avro/src/test/java/org/apache/avro/io/parsing/TestResolvingGrammarGenerator2.java
 
   def point_2d_schema

data/test/test_schema_normalization.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information

data/test/test_schema_validator.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -17,7 +18,7 @@
 require 'test_help'
 
 class TestSchemaValidator < Test::Unit::TestCase
-  def validate!(schema, value, options=nil)
+  def validate!(schema, value, options = {})
     Avro::SchemaValidator.validate!(schema, value, options)
   end
 
@@ -169,13 +170,13 @@ class TestSchemaValidator < Test::Unit::TestCase
   def test_validate_float
     schema = hash_to_schema(type: 'float', name: 'name')
 
-    assert_valid_schema(schema, [1.1, 1, Avro::Schema::LONG_MAX_VALUE], ['string'], true)
+    assert_valid_schema(schema, [1.1, 1, BigDecimal('1.1'), Avro::Schema::LONG_MAX_VALUE], ['string'], true)
   end
 
   def test_validate_double
     schema = hash_to_schema(type: 'double', name: 'name')
 
-    assert_valid_schema(schema, [1.1, 1, Avro::Schema::LONG_MAX_VALUE], ['string'], true)
+    assert_valid_schema(schema, [1.1, 1, BigDecimal('1.1'), Avro::Schema::LONG_MAX_VALUE], ['string'], true)
   end
 
   def test_validate_fixed
@@ -196,6 +197,12 @@ class TestSchemaValidator < Test::Unit::TestCase
     assert_valid_schema(schema, [{ 'sub' => nil }], [{ 'sub' => 1 }])
   end
 
+  def test_validate_record_with_symbol_keys
+    schema = hash_to_schema(type: 'record', name: 'name', fields: [{ type: 'int', name: 'sub' }])
+
+    assert_valid_schema(schema, [{ sub: 1 }], [{ sub: '1' }])
+  end
+
   def test_validate_shallow_record
     schema = hash_to_schema(
       type: 'record', name: 'name', fields: [{ type: 'int', name: 'sub' }]
@@ -551,4 +558,18 @@ class TestSchemaValidator < Test::Unit::TestCase
     assert_equal(1, exception.result.errors.size)
     assert_equal("at . extra field 'color' - not in schema", exception.to_s)
   end
+
+  def test_validate_bytes_decimal
+    schema = hash_to_schema(type: 'bytes', logicalType: 'decimal', precision: 4, scale: 2)
+    assert_valid_schema(schema, [BigDecimal('1.23'), 4.2, 1], ['4.2', BigDecimal('233.2')], true)
+
+    schema = hash_to_schema(type: 'bytes', logicalType: 'decimal', precision: 4, scale: 4)
+    assert_valid_schema(schema, [BigDecimal('0.2345'), 0.2, 0.1], ['4.2', BigDecimal('233.2')], true)
+
+    schema = hash_to_schema(type: 'bytes', logicalType: 'decimal', precision: 4, scale: 0)
+    assert_valid_schema(schema, [BigDecimal('123'), 2], ['4.2', BigDecimal('233.2')], true)
+
+    schema = hash_to_schema(type: 'bytes', logicalType: 'decimal', precision: 4)
+    assert_valid_schema(schema, [BigDecimal('123'), 2], ['4.2', BigDecimal('233.2')], true)
+  end
 end

data/test/test_socket_transport.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information

data/test/tool.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -21,7 +22,7 @@ require 'logger'
 
 class GenericResponder < Avro::IPC::Responder
   def initialize(proto, msg, datum)
-    proto_json = open(proto).read
+    proto_json = File.open(proto).read
     super(Avro::Protocol.parse(proto_json))
     @msg = msg
     @datum = datum
@@ -62,14 +63,14 @@ end
 def send_message(uri, proto, msg, datum)
   uri = URI.parse(uri)
   trans = Avro::IPC::HTTPTransceiver.new(uri.host, uri.port)
-  proto_json = open(proto).read
+  proto_json = File.open(proto).read
   requestor = Avro::IPC::Requestor.new(Avro::Protocol.parse(proto_json),
                                        trans)
   p requestor.request(msg, datum)
 end
 
 def file_or_stdin(f)
-  f == "-" ? STDIN : open(f)
+  f == "-" ? STDIN : File.open(f)
 end
 
 def main
@@ -100,9 +101,9 @@ def main
     if ARGV.size > 4
       case ARGV[4]
       when "-file"
-        Avro::DataFile.open(ARGV[5]) {|f|
-          f.each{|e| datum = e; break }
-        }
+        Avro::DataFile.open(ARGV[5]) do |f|
+          datum = f.first
+        end
       when "-data"
         puts "JSON Decoder not yet implemented."
         return 1
@@ -124,7 +125,7 @@ def main
     if ARGV.size > 4
       case ARGV[4]
       when "-file"
-        Avro::DataFile.open(ARGV[5]){|f| f.each{|e| datum = e; break } }
+        Avro::DataFile.open(ARGV[5]){ |f| datum = f.first }
       when "-data"
         puts "JSON Decoder not yet implemented"
         return 1