avro 1.10.2 → 1.11.0

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
@@ -292,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
@@ -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
@@ -557,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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro
 version: !ruby/object:Gem::Version
-  version: 1.10.2
+  version: 1.11.0
 platform: ruby
 authors:
 - Apache Software Foundation
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-09 00:00:00.000000000 Z
+date: 2021-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -16,34 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '1.0'
 description: Avro is a data serialization and RPC format
 email: dev@avro.apache.org
 executables: []
 extensions: []
-extra_rdoc_files:
-- CHANGELOG
-- LICENSE
-- lib/avro.rb
-- lib/avro/VERSION.txt
-- lib/avro/data_file.rb
-- lib/avro/io.rb
-- lib/avro/ipc.rb
-- lib/avro/logical_types.rb
-- lib/avro/protocol.rb
-- lib/avro/schema.rb
-- lib/avro/schema_compatibility.rb
-- lib/avro/schema_normalization.rb
-- lib/avro/schema_validator.rb
+extra_rdoc_files: []
 files:
-- CHANGELOG
 - LICENSE
 - Manifest
 - NOTICE
@@ -82,7 +68,11 @@ files:
 homepage: https://avro.apache.org/
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  homepage_uri: https://avro.apache.org/
+  bug_tracker_uri: https://issues.apache.org/jira/browse/AVRO
+  source_code_uri: https://github.com/apache/avro
+  documentation_uri: https://avro.apache.org/docs/1.11.0/
 post_install_message: 
 rdoc_options:
 - "--line-numbers"
@@ -94,27 +84,33 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.2'
+      version: '0'
 requirements: []
-rubyforge_project: avro
-rubygems_version: 2.5.2.1
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Apache Avro for Ruby
 test_files:
-- test/test_schema.rb
-- test/test_socket_transport.rb
+- test/case_finder.rb
+- test/random_data.rb
+- test/sample_ipc_client.rb
+- test/sample_ipc_http_client.rb
+- test/sample_ipc_http_server.rb
+- test/sample_ipc_server.rb
+- test/test_datafile.rb
+- test/test_fingerprints.rb
+- test/test_help.rb
 - test/test_io.rb
 - test/test_logical_types.rb
-- test/test_help.rb
-- test/test_datafile.rb
 - test/test_protocol.rb
-- test/test_schema_validator.rb
+- test/test_schema.rb
 - test/test_schema_compatibility.rb
 - test/test_schema_normalization.rb
-- test/test_fingerprints.rb
+- test/test_schema_validator.rb
+- test/test_socket_transport.rb
+- test/tool.rb

data/CHANGELOG

@@ -1 +0,0 @@
-v0.0.1 stuff