avro-patches 1.0.0.pre0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1818ee748fd5ee8c17e74d141bcfc9dc29c195762e3e05e10a475a609528c9c
-  data.tar.gz: 2d5ad54b308815f87dc0d2ac05d238926f14ecfd081f2dc5ef3aecf7cdefa4b4
+  metadata.gz: cd089766c05ce4cdd751d3daec9f49fe60d54b579c9c27b38caca027a1551653
+  data.tar.gz: dffabc9b71215adc99ce91578db8967dc494df108c83007d23274731db6d4502
 SHA512:
-  metadata.gz: b07ce6b1231d84258d3e88d7342bd76ea0b28244de5805f9e75cad6ade35c4b46f6c445899bb180766bd66c59d3fa0cb27c8c79281b3d1176dc105fd5df4bfa6
-  data.tar.gz: 430350d55b3096351c7a6b00fd45682476d574585ce2184319496c7206ece97a2b5ade02d4422597b27700c6c84370f30fd7b978b1b1a0e804daaf840a5c2eb5
+  metadata.gz: 41d70773537c150975e7cb409a5c6a2cc3924de378f11593c596eb6bd50d0380cbbcf5cc43a095c621d8caec0ae3b0ea2e7ecc4ddad16e01412dcb80475d8dff
+  data.tar.gz: 8e7e5ee24b8e56fc1c0b675cd9cbe456fc372b00b62a745bbedbf61068ec1aa92cc6f25be7c02967dfba360db6cb6cf8297ec2526eb1daf62cc1b8a385056d0c

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - 2.3.5
-  - 2.4.4
-  - 2.5.1
-before_install: gem install bundler -v 1.16.2 --no-document
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+before_install: gem install bundler -v 2.0.1 --no-document
 script:
   - bundle exec rake test

data/CHANGELOG.md

@@ -4,6 +4,9 @@
 - Release for Avro v1.9.0. This removes all patches as all changes
   from the previous release are included in Avro v1.9.0.
 
+## v0.4.1
+- Optimize binary encoder and decoder.
+
 ## v0.4.0
 - Optionally fail validation when extra fields are present.
 - Check that field defaults have the correct type.

data/README.md

@@ -1,25 +1,18 @@
 # avro-patches
 
-This gem contains patches to the official [Apache Avro](https://avro.apache.org/)
-Ruby gem v1.8.2.
-
-We have attempted to follow the coding conventions used in the official `avro`
-repo.
-
-The following pending or unreleased changes are included:
-- [AVRO-1886: Add validation messages](https://github.com/apache/avro/pull/111)
-- [AVRO-1695: Ruby support for logical types revisited](https://github.com/apache/avro/pull/116)
-- [AVRO-1969: Add schema compatibility checker for Ruby](https://github.com/apache/avro/pull/170)
-- [AVRO-2039: Ruby encoding performance improvements](https://github.com/apache/avro/pull/230)
-- [AVRO-2200: Option to fail when extra fields are in the payload](https://github.com/apache/avro/pull/321)
-- [AVRO-2199: Validate that field defaults have the correct type](https://github.com/apache/avro/pull/320)
-
-In addition, compatibility with Ruby 2.4 (https://github.com/apache/avro/pull/191)
-has been integrated with the changes above.
-
-The following Ruby changes are not included, but could be added in the future:
-- [AVRO-2001: Adding support for doc attribute](https://github.com/apache/avro/pull/197)
-- [AVRO-1873: Add CRC32 checksum to Snappy-compressed blocks](https://github.com/apache/avro/pull/121)
+## Avro v1.9.0
+
+After the official release of [Apache Avro](https://avro.apache.org/) v1.9.0 this
+gem non longer contains any patches. This version is being released as a compatibility
+layer for Avro v1.9.0.
+
+As Ruby changes are submitted for the next Avro release, it is expected that they
+be collected in future releases of this gem.
+
+## Avro v1.8.2
+
+See the [avro-v1.8.2 branch](https://github.com/salsify/avro-patches/tree/avro-1.8.2)
+for details about the previous version of this gem which supported Avro v1.8.2. 
 
 ## Installation
 

data/avro-patches.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(bin|test|spec|features)/}) }
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'test-unit'
   spec.add_development_dependency 'overcommit'

data/lib/avro-patches/version.rb

@@ -1,3 +1,3 @@
 module AvroPatches
-  VERSION = '1.0.0.pre0'.freeze
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro-patches
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre0
+  version: 1.0.0
 platform: ruby
 authors:
 - Salsify, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-26 00:00:00.000000000 Z
+date: 2019-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -100,23 +100,6 @@ files:
 - Rakefile
 - avro-patches.gemspec
 - lib/avro-patches.rb
-- lib/avro-patches/default_validation.rb
-- lib/avro-patches/default_validation/schema.rb
-- lib/avro-patches/ensure_encoding.rb
-- lib/avro-patches/ensure_encoding/io.rb
-- lib/avro-patches/logical_types.rb
-- lib/avro-patches/logical_types/io.rb
-- lib/avro-patches/logical_types/logical_types.rb
-- lib/avro-patches/logical_types/schema.rb
-- lib/avro-patches/logical_types/schema_validator.rb
-- lib/avro-patches/schema_compatibility.rb
-- lib/avro-patches/schema_compatibility/io.rb
-- lib/avro-patches/schema_compatibility/schema.rb
-- lib/avro-patches/schema_compatibility/schema_compatibility.rb
-- lib/avro-patches/schema_validator.rb
-- lib/avro-patches/schema_validator/io.rb
-- lib/avro-patches/schema_validator/schema.rb
-- lib/avro-patches/schema_validator/schema_validator.rb
 - lib/avro-patches/version.rb
 - lib/avro_patches.rb
 homepage: https://github.com/salsify/avro-patches
@@ -135,9 +118,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 

data/lib/avro-patches/default_validation.rb

@@ -1 +0,0 @@
-require "avro-patches/default_validation/schema"

data/lib/avro-patches/default_validation/schema.rb

@@ -1,27 +0,0 @@
-module AvroPatches
-  module DefaultValidation
-    module FieldPatch
-      def initialize(type, name, default=:no_default, order=nil, names=nil, namespace=nil)
-        super
-
-        validate_default! if default?
-      end
-
-      private
-
-      def validate_default!
-        type_for_default = if type.type_sym == :union
-                             type.schemas.first
-                           else
-                             type
-                           end
-
-        Avro::SchemaValidator.validate!(type_for_default, default)
-      rescue Avro::SchemaValidator::ValidationError => e
-        raise Avro::SchemaParseError, "Error validating default for #{name}: #{e.message}"
-      end
-    end
-  end
-end
-
-Avro::Schema::Field.prepend(AvroPatches::DefaultValidation::FieldPatch)

data/lib/avro-patches/ensure_encoding.rb

@@ -1,5 +0,0 @@
-# Change from "AVRO-1783: Ruby: Ensure correct binary encoding for byte strings"
-# https://github.com/apache/avro/commit/315d842148d57590a58fafecf6e5ea378e9e0d74
-
-# Only part of the above commit is included as we are not using protocols and RPC
-require_relative 'ensure_encoding/io'

data/lib/avro-patches/ensure_encoding/io.rb

@@ -1,12 +0,0 @@
-Avro::IO::DatumWriter.class_eval do
-  # A string is encoded as a long followed by that many bytes of
-  # UTF-8 encoded character data
-  def write_string(datum)
-    # The original commit used:
-    #   datum = datum.encode('utf-8') if datum.respond_to? :encode
-    # This always allocated a new string even if the string was already UTF-8 encoded.
-    # The form below is slightly more efficient.
-    datum = datum.encode(Encoding::UTF_8) if datum.respond_to?(:encode) && datum.encoding != Encoding::UTF_8
-    write_bytes(datum)
-  end
-end

data/lib/avro-patches/logical_types.rb

@@ -1,6 +0,0 @@
-# Changes from "AVRO-1695: Ruby support for logical types revisited"
-# https://github.com/apache/avro/pull/116
-require_relative 'logical_types/logical_types'
-require_relative 'logical_types/schema_validator'
-require_relative 'logical_types/schema'
-require_relative 'logical_types/io'

data/lib/avro-patches/logical_types/io.rb

@@ -1,42 +0,0 @@
-Avro::IO::DatumWriter.class_eval do
-  def write_data(writers_schema, logical_datum, encoder)
-    datum = writers_schema.type_adapter.encode(logical_datum)
-
-    unless Avro::Schema.validate(writers_schema, datum, { recursive: false, encoded: true })
-      raise Avro::IO::AvroTypeError.new(writers_schema, datum)
-    end
-
-    # function dispatch to write datum
-    case writers_schema.type_sym
-    when :null;    encoder.write_null(datum)
-    when :boolean; encoder.write_boolean(datum)
-    when :string;  encoder.write_string(datum)
-    when :int;     encoder.write_int(datum)
-    when :long;    encoder.write_long(datum)
-    when :float;   encoder.write_float(datum)
-    when :double;  encoder.write_double(datum)
-    when :bytes;   encoder.write_bytes(datum)
-    when :fixed;   write_fixed(writers_schema, datum, encoder)
-    when :enum;    write_enum(writers_schema, datum, encoder)
-    when :array;   write_array(writers_schema, datum, encoder)
-    when :map;     write_map(writers_schema, datum, encoder)
-    when :union;   write_union(writers_schema, datum, encoder)
-    when :record, :error, :request;  write_record(writers_schema, datum, encoder)
-    else
-      raise Avro::AvroError.new("Unknown type: #{writers_schema.type}")
-    end
-  end
-end
-
-module AvroPatches
-  module LogicalTypes
-    module DatumReaderPatch
-      def read_data(writers_schema, readers_schema, decoder)
-        datum = super
-        readers_schema.type_adapter.decode(datum)
-      end
-    end
-  end
-end
-
-Avro::IO::DatumReader.prepend(AvroPatches::LogicalTypes::DatumReaderPatch)

data/lib/avro-patches/logical_types/logical_types.rb

@@ -1,73 +0,0 @@
-require 'date'
-
-module Avro
-  module LogicalTypes
-    module IntDate
-      EPOCH_START = Date.new(1970, 1, 1)
-
-      def self.encode(date)
-        return date.to_i if date.is_a?(Numeric)
-
-        (date - EPOCH_START).to_i
-      end
-
-      def self.decode(int)
-        EPOCH_START + int
-      end
-    end
-
-    module TimestampMillis
-      def self.encode(value)
-        return value.to_i if value.is_a?(Numeric)
-
-        time = value.to_time
-        time.to_i * 1000 + time.usec / 1000
-      end
-
-      def self.decode(int)
-        s, ms = int / 1000, int % 1000
-        Time.at(s, ms * 1000).utc
-      end
-    end
-
-    module TimestampMicros
-      def self.encode(value)
-        return value.to_i if value.is_a?(Numeric)
-
-        time = value.to_time
-        time.to_i * 1000_000 + time.usec
-      end
-
-      def self.decode(int)
-        s, us = int / 1000_000, int % 1000_000
-        Time.at(s, us).utc
-      end
-    end
-
-    module Identity
-      def self.encode(datum)
-        datum
-      end
-
-      def self.decode(datum)
-        datum
-      end
-    end
-
-    TYPES = {
-      "int" => {
-        "date" => IntDate
-      },
-      "long" => {
-        "timestamp-millis" => TimestampMillis,
-        "timestamp-micros" => TimestampMicros
-      },
-    }.freeze
-
-    def self.type_adapter(type, logical_type)
-      return unless logical_type
-
-      TYPES.fetch(type, {}.freeze).fetch(logical_type, Identity)
-    end
-  end
-end

data/lib/avro-patches/logical_types/schema.rb

@@ -1,110 +0,0 @@
-Avro::Schema.class_eval do
-  attr_reader :logical_type
-
-  # Build Avro Schema from data parsed out of JSON string.
-  def self.real_parse(json_obj, names=nil, default_namespace=nil)
-    if json_obj.is_a? Hash
-      type = json_obj['type']
-      logical_type = json_obj['logicalType']
-      raise Avro::SchemaParseError, %Q(No "type" property: #{json_obj}) if type.nil?
-
-      # Check that the type is valid before calling #to_sym, since symbols are never garbage
-      # collected (important to avoid DoS if we're accepting schemas from untrusted clients)
-      unless Avro::Schema::VALID_TYPES.include?(type)
-        raise Avro::SchemaParseError, "Unknown type: #{type}"
-      end
-
-      type_sym = type.to_sym
-      if Avro::Schema::PRIMITIVE_TYPES_SYM.include?(type_sym)
-        return Avro::Schema::PrimitiveSchema.new(type_sym, logical_type)
-
-      elsif Avro::Schema::NAMED_TYPES_SYM.include? type_sym
-        name = json_obj['name']
-        namespace = json_obj.include?('namespace') ? json_obj['namespace'] : default_namespace
-        case type_sym
-        when :fixed
-          size = json_obj['size']
-          return Avro::Schema::FixedSchema.new(name, namespace, size, names, logical_type)
-        when :enum
-          symbols = json_obj['symbols']
-          return Avro::Schema::EnumSchema.new(name, namespace, symbols, names)
-        when :record, :error
-          fields = json_obj['fields']
-          return Avro::Schema::RecordSchema.new(name, namespace, fields, names, type_sym)
-        end
-
-      else
-        case type_sym
-        when :array
-          return Avro::Schema::ArraySchema.new(json_obj['items'], names, default_namespace)
-        when :map
-          return Avro::Schema::MapSchema.new(json_obj['values'], names, default_namespace)
-        else
-          raise Avro::SchemaParseError.new("Unknown Valid Type: #{type}")
-        end
-      end
-
-    elsif json_obj.is_a? Array
-      # JSON array (union)
-      return Avro::Schema::UnionSchema.new(json_obj, names, default_namespace)
-    elsif Avro::Schema::PRIMITIVE_TYPES.include? json_obj
-      return Avro::Schema::PrimitiveSchema.new(json_obj)
-    else
-      raise Avro::UnknownSchemaError.new(json_obj)
-    end
-  end
-
-  # Determine if a ruby datum is an instance of a schema
-  def self.validate(expected_schema, logical_datum, options = { recursive: true, encoded: false })
-    Avro::SchemaValidator.validate!(expected_schema, logical_datum, options)
-    true
-  rescue Avro::SchemaValidator::ValidationError
-    false
-  end
-
-  def initialize(type, logical_type=nil)
-    @type_sym = type.is_a?(Symbol) ? type : type.to_sym
-    @logical_type = logical_type
-  end
-
-  def type_adapter
-    @type_adapter ||= Avro::LogicalTypes.type_adapter(type, logical_type) || Avro::LogicalTypes::Identity
-  end
-
-  def to_avro(names=nil)
-    props = {'type' => type}
-    props['logicalType'] = logical_type if logical_type
-    props
-  end
-end
-
-Avro::Schema::NamedSchema.class_eval do
-  def initialize(type, name, namespace=nil, names=nil, logical_type=nil)
-    super(type, logical_type)
-    @name, @namespace = Avro::Name.extract_namespace(name, namespace)
-    Avro::Name.add_name(names, self)
-  end
-end
-
-Avro::Schema::PrimitiveSchema.class_eval do
-  def initialize(type, logical_type=nil)
-    if Avro::Schema::PRIMITIVE_TYPES_SYM.include?(type)
-      super(type, logical_type)
-    elsif Avro::Schema::PRIMITIVE_TYPES.include?(type)
-      super(type.to_sym, logical_type)
-    else
-      raise Avro::AvroError.new("#{type} is not a valid primitive type.")
-    end
-  end
-end
-
-Avro::Schema::FixedSchema.class_eval do
-  def initialize(name, space, size, names=nil, logical_type=nil)
-    # Ensure valid cto args
-    unless size.is_a?(Integer)
-      raise Avro::AvroError, 'Fixed Schema requires a valid integer for size property.'
-    end
-    super(:fixed, name, space, names, logical_type)
-    @size = size
-  end
-end

data/lib/avro-patches/logical_types/schema_validator.rb

@@ -1,69 +0,0 @@
-module AvroPatches
-  module LogicalTypes
-    module SchemaValidatorPatch
-      def validate!(expected_schema, logical_datum, options = { recursive: true, encoded: false, fail_on_extra_fields: false})
-        options ||= {}
-        options[:recursive] = true unless options.key?(:recursive)
-
-        result = Avro::SchemaValidator::Result.new
-        if options[:recursive]
-          validate_recursive(expected_schema, logical_datum,
-                             Avro::SchemaValidator::ROOT_IDENTIFIER, result, options)
-        else
-          validate_simple(expected_schema, logical_datum,
-                          Avro::SchemaValidator::ROOT_IDENTIFIER, result, options)
-        end
-        fail Avro::SchemaValidator::ValidationError, result if result.failure?
-        result
-      end
-
-      private
-
-      def validate_recursive(expected_schema, logical_datum, path, result, options = {})
-        datum = resolve_datum(expected_schema, logical_datum, options[:encoded])
-
-        # The entire method is overridden so that encoded: true can be passed here
-        validate_simple(expected_schema, datum, path, result, encoded: true)
-
-        case expected_schema.type_sym
-        when :array
-          validate_array(expected_schema, datum, path, result)
-        when :map
-          validate_map(expected_schema, datum, path, result)
-        when :union
-          validate_union(expected_schema, datum, path, result)
-        when :record, :error, :request
-          fail Avro::SchemaValidator::TypeMismatchError unless datum.is_a?(Hash)
-          expected_schema.fields.each do |field|
-            deeper_path = deeper_path_for_hash(field.name, path)
-            validate_recursive(field.type, datum[field.name], deeper_path, result)
-          end
-          if options[:fail_on_extra_fields]
-            datum_fields = datum.keys.map(&:to_s)
-            schema_fields = expected_schema.fields.map(&:name)
-            (datum_fields - schema_fields).each do |extra_field|
-              result.add_error(path, "extra field '#{extra_field}' - not in schema")
-            end
-          end
-        end
-      rescue Avro::SchemaValidator::TypeMismatchError
-        result.add_error(path, "expected type #{expected_schema.type_sym}, got #{actual_value_message(datum)}")
-      end
-
-      def validate_simple(expected_schema, logical_datum, path, result, options = {})
-        datum = resolve_datum(expected_schema, logical_datum, options[:encoded])
-        super(expected_schema, datum, path, result)
-      end
-
-      def resolve_datum(expected_schema, logical_datum, encoded)
-        if encoded
-          logical_datum
-        else
-          expected_schema.type_adapter.encode(logical_datum) rescue nil
-        end
-      end
-    end
-  end
-end
-
-Avro::SchemaValidator.singleton_class.prepend(AvroPatches::LogicalTypes::SchemaValidatorPatch)

data/lib/avro-patches/schema_compatibility.rb

@@ -1,5 +0,0 @@
-# Changes from "AVRO-1969: Add schema compatibility checker for Ruby"
-# https://github.com/apache/avro/pull/170
-require_relative 'schema_compatibility/schema_compatibility'
-require_relative 'schema_compatibility/schema'
-require_relative 'schema_compatibility/io'

data/lib/avro-patches/schema_compatibility/io.rb

@@ -1,35 +0,0 @@
-Avro::IO::DatumReader.class_eval do
-  def self.match_schemas(writers_schema, readers_schema)
-    Avro::SchemaCompatibility.match_schemas(writers_schema, readers_schema)
-  end
-
-  def read_record(writers_schema, readers_schema, decoder)
-    readers_fields_hash = readers_schema.fields_hash
-    read_record = {}
-    writers_schema.fields.each do |field|
-      if readers_field = readers_fields_hash[field.name]
-        field_val = read_data(field.type, readers_field.type, decoder)
-        read_record[field.name] = field_val
-      else
-        skip_data(field.type, decoder)
-      end
-    end
-
-    # fill in the default values
-    if readers_fields_hash.size > read_record.size
-      writers_fields_hash = writers_schema.fields_hash
-      readers_fields_hash.each do |field_name, field|
-        unless writers_fields_hash.has_key? field_name
-          if field.default?
-            field_val = read_default_value(field.type, field.default)
-            read_record[field.name] = field_val
-          else
-            raise Avro::AvroError, "Missing data for #{field.type} with no default"
-          end
-        end
-      end
-    end
-
-    read_record
-  end
-end

data/lib/avro-patches/schema_compatibility/schema.rb

@@ -1,69 +0,0 @@
-Avro::Schema.class_eval do
-  def read?(writers_schema)
-    Avro::SchemaCompatibility.can_read?(writers_schema, self)
-  end
-
-  def be_read?(other_schema)
-    other_schema.read?(self)
-  end
-
-  def mutual_read?(other_schema)
-    Avro::SchemaCompatibility.mutual_read?(other_schema, self)
-  end
-end
-
-Avro::Schema::RecordSchema.class_eval do
-  def initialize(name, namespace, fields, names=nil, schema_type=:record)
-    if schema_type == :request || schema_type == 'request'
-      @type_sym = schema_type.to_sym
-      @namespace = namespace
-    else
-      super(schema_type, name, namespace, names)
-    end
-    @fields = if fields
-                self.class.make_field_objects(fields, names, self.namespace)
-              else
-                {}
-              end
-  end
-end
-
-Avro::Schema::UnionSchema.class_eval do
-  def initialize(schemas, names=nil, default_namespace=nil)
-    super(:union)
-
-    @schemas = schemas.each_with_object([]) do |schema, schema_objects|
-      new_schema = subparse(schema, names, default_namespace)
-      ns_type = new_schema.type_sym
-
-      if Avro::Schema::VALID_TYPES_SYM.include?(ns_type) &&
-        !Avro::Schema::NAMED_TYPES_SYM.include?(ns_type) &&
-        schema_objects.any?{|o| o.type_sym == ns_type }
-        raise Avro::SchemaParseError, "#{ns_type} is already in Union"
-      elsif ns_type == :union
-        raise Avro::SchemaParseError, "Unions cannot contain other unions"
-      else
-        schema_objects << new_schema
-      end
-    end
-  end
-end
-
-
-module AvroPatches
-  module SchemaCompatibility
-    module FieldPatch
-      def default?
-        @default != :no_default
-      end
-
-      def to_avro(names = Set.new)
-        super.tap do |avro|
-          avro['default'] = default if default?
-        end
-      end
-    end
-  end
-end
-
-Avro::Schema::Field.prepend(AvroPatches::SchemaCompatibility::FieldPatch)

data/lib/avro-patches/schema_compatibility/schema_compatibility.rb

@@ -1,154 +0,0 @@
-module Avro
-
-  # see http://avro.apache.org/docs/current/spec.html#Schema+Resolution for what this should do
-  module SchemaCompatibility
-    def self.can_read?(writers_schema, readers_schema)
-      Checker.new.can_read?(writers_schema, readers_schema)
-    end
-
-    def self.mutual_read?(writers_schema, readers_schema)
-      Checker.new.mutual_read?(writers_schema, readers_schema)
-    end
-
-    def self.match_schemas(writers_schema, readers_schema)
-      # Note: this does not support aliases!
-      w_type = writers_schema.type_sym
-      r_type = readers_schema.type_sym
-
-      # This conditional is begging for some OO love.
-      if w_type == :union || r_type == :union
-        return true
-      end
-
-      if w_type == r_type
-        return true if Avro::Schema::PRIMITIVE_TYPES_SYM.include?(r_type)
-
-        case r_type
-        when :record
-          return writers_schema.fullname == readers_schema.fullname
-        when :error
-          return writers_schema.fullname == readers_schema.fullname
-        when :request
-          return true
-        when :fixed
-          return writers_schema.fullname == readers_schema.fullname &&
-            writers_schema.size == readers_schema.size
-        when :enum
-          return writers_schema.fullname == readers_schema.fullname
-        when :map
-          return match_schemas(writers_schema.values, readers_schema.values)
-        when :array
-          return match_schemas(writers_schema.items, readers_schema.items)
-        end
-      end
-
-      # Handle schema promotion
-      if w_type == :int && [:long, :float, :double].include?(r_type)
-        return true
-      elsif w_type == :long && [:float, :double].include?(r_type)
-        return true
-      elsif w_type == :float && r_type == :double
-        return true
-      elsif w_type == :string && r_type == :bytes
-        return true
-      elsif w_type == :bytes && r_type == :string
-        return true
-      end
-
-      return false
-    end
-
-    class Checker
-      SIMPLE_CHECKS = Avro::Schema::PRIMITIVE_TYPES_SYM.dup.add(:fixed).freeze
-
-      attr_reader :recursion_set
-      private :recursion_set
-
-      def initialize
-        @recursion_set = Set.new
-      end
-
-      def can_read?(writers_schema, readers_schema)
-        full_match_schemas(writers_schema, readers_schema)
-      end
-
-      def mutual_read?(writers_schema, readers_schema)
-        can_read?(writers_schema, readers_schema) && can_read?(readers_schema, writers_schema)
-      end
-
-      private
-
-      def full_match_schemas(writers_schema, readers_schema)
-        return true if recursion_in_progress?(writers_schema, readers_schema)
-
-        return false unless Avro::SchemaCompatibility.match_schemas(writers_schema, readers_schema)
-
-        if writers_schema.type_sym != :union && SIMPLE_CHECKS.include?(readers_schema.type_sym)
-          return true
-        end
-
-        case readers_schema.type_sym
-        when :record
-          match_record_schemas(writers_schema, readers_schema)
-        when :map
-          full_match_schemas(writers_schema.values, readers_schema.values)
-        when :array
-          full_match_schemas(writers_schema.items, readers_schema.items)
-        when :union
-          match_union_schemas(writers_schema, readers_schema)
-        when :enum
-          # reader's symbols must contain all writer's symbols
-          (writers_schema.symbols - readers_schema.symbols).empty?
-        else
-          if writers_schema.type_sym == :union && writers_schema.schemas.size == 1
-            full_match_schemas(writers_schema.schemas.first, readers_schema)
-          else
-            false
-          end
-        end
-      end
-
-      # reader is a union
-      def match_union_schemas(writers_schema, readers_schema)
-        raise 'readers_schema must be a union' unless readers_schema.type_sym == :union
-
-        case writers_schema.type_sym
-        when :union
-          writers_schema.schemas.all? { |writer_type| full_match_schemas(writer_type, readers_schema) }
-        else
-          readers_schema.schemas.any? { |reader_type| full_match_schemas(writers_schema, reader_type) }
-        end
-      end
-
-      # reader is a record
-      def match_record_schemas(writers_schema, readers_schema)
-        case writers_schema.type_sym
-        when :union
-          return false
-        else
-          writer_fields_hash = writers_schema.fields_hash
-          readers_schema.fields.each do |field|
-            if writer_fields_hash.key?(field.name)
-              return false unless full_match_schemas(writer_fields_hash[field.name].type, field.type)
-            else
-              return false unless field.default?
-            end
-          end
-
-          return true
-        end
-      end
-
-      def recursion_in_progress?(writers_schema, readers_schema)
-        key = [writers_schema.object_id, readers_schema.object_id]
-
-        if recursion_set.include?(key)
-          true
-        else
-          recursion_set.add(key)
-          false
-        end
-      end
-    end
-  end
-end

data/lib/avro-patches/schema_validator.rb

@@ -1,5 +0,0 @@
-# Changes from "AVRO-1886: Add validation messages"
-# https://github.com/apache/avro/pull/111
-require_relative 'schema_validator/schema_validator'
-require_relative 'schema_validator/schema'
-require_relative 'schema_validator/io'

data/lib/avro-patches/schema_validator/io.rb

@@ -1,50 +0,0 @@
-Avro::IO::DatumWriter.class_eval do
-  def write_data(writers_schema, datum, encoder)
-    unless Avro::Schema.validate(writers_schema, datum, recursive: false)
-      raise Avro::IO::AvroTypeError.new(writers_schema, datum)
-    end
-
-    # function dispatch to write datum
-    case writers_schema.type_sym
-    when :null;    encoder.write_null(datum)
-    when :boolean; encoder.write_boolean(datum)
-    when :string;  encoder.write_string(datum)
-    when :int;     encoder.write_int(datum)
-    when :long;    encoder.write_long(datum)
-    when :float;   encoder.write_float(datum)
-    when :double;  encoder.write_double(datum)
-    when :bytes;   encoder.write_bytes(datum)
-    when :fixed;   write_fixed(writers_schema, datum, encoder)
-    when :enum;    write_enum(writers_schema, datum, encoder)
-    when :array;   write_array(writers_schema, datum, encoder)
-    when :map;     write_map(writers_schema, datum, encoder)
-    when :union;   write_union(writers_schema, datum, encoder)
-    when :record, :error, :request;  write_record(writers_schema, datum, encoder)
-    else
-      raise Avro::AvroError.new("Unknown type: #{writers_schema.type}")
-    end
-  end
-end
-
-module AvroPatches
-  module SchemaValidator
-    module IOPatches
-      def write_record(writers_schema, datum, encoder)
-        raise Avro::IO::AvroTypeError.new(writers_schema, datum) unless datum.is_a?(Hash)
-        super
-      end
-
-      def write_array(writers_schema, datum, encoder)
-        raise Avro::IO::AvroTypeError.new(writers_schema, datum) unless datum.is_a?(Array)
-        super
-      end
-
-      def write_map(writers_schema, datum, encoder)
-        raise Avro::IO::AvroTypeError.new(writers_schema, datum) unless datum.is_a?(Hash)
-        super
-      end
-    end
-  end
-end
-
-Avro::IO::DatumWriter.prepend(AvroPatches::SchemaValidator::IOPatches)

data/lib/avro-patches/schema_validator/schema.rb

@@ -1,9 +0,0 @@
-Avro::Schema.class_eval do
-  # Determine if a ruby datum is an instance of a schema
-  def self.validate(expected_schema, datum, options = { recursive: true })
-    Avro::SchemaValidator.validate!(expected_schema, datum, options)
-    true
-  rescue Avro::SchemaValidator::ValidationError
-    false
-  end
-end

data/lib/avro-patches/schema_validator/schema_validator.rb

@@ -1,228 +0,0 @@
-# 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
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module Avro
-  class SchemaValidator
-    ROOT_IDENTIFIER = '.'.freeze
-    PATH_SEPARATOR = '.'.freeze
-    INT_RANGE = Schema::INT_MIN_VALUE..Schema::INT_MAX_VALUE
-    LONG_RANGE = Schema::LONG_MIN_VALUE..Schema::LONG_MAX_VALUE
-    COMPLEX_TYPES = [:array, :error, :map, :record, :request].freeze
-    BOOLEAN_VALUES = [true, false].freeze
-
-    class Result
-      attr_reader :errors
-
-      def initialize
-        @errors = []
-      end
-
-      def <<(error)
-        @errors << error
-      end
-
-      def add_error(path, message)
-        self << "at #{path} #{message}"
-      end
-
-      def failure?
-        @errors.any?
-      end
-
-      def to_s
-        errors.join("\n")
-      end
-    end
-
-    class ValidationError < StandardError
-      attr_reader :result
-
-      def initialize(result = Result.new)
-        @result = result
-        super
-      end
-
-      def to_s
-        result.to_s
-      end
-    end
-
-    TypeMismatchError = Class.new(ValidationError)
-
-    class << self
-      # This method is replaced by code in AvroPatches::LogicalTypes::SchemaValidatorPatch.
-      def validate!(expected_schema, datum, options = { recursive: true })
-        options ||= {}
-        options[:recursive] = true unless options.key?(:recursive)
-
-        result = Avro::SchemaValidator::Result.new
-        if options[:recursive]
-          validate_recursive(expected_schema, datum, ROOT_IDENTIFIER, result)
-        else
-          validate_simple(expected_schema, datum, ROOT_IDENTIFIER, result)
-        end
-        fail Avro::SchemaValidator::ValidationError, result if result.failure?
-        result
-      end
-
-      private
-
-      def validate_type(expected_schema)
-        unless Avro::Schema::VALID_TYPES_SYM.include?(expected_schema.type_sym)
-          fail "Unexpected schema type #{expected_schema.type_sym} #{expected_schema.inspect}"
-        end
-      end
-
-      # This method is replaced by code in AvroPatches::LogicalTypes::SchemaValidatorPatch.
-      # The patches are layered this way because SchemaValidator exists on
-      # avro's master branch but logical type support is still in PR.
-      def validate_recursive(expected_schema, datum, path, result)
-        validate_simple(expected_schema, datum, path, result)
-
-        case expected_schema.type_sym
-        when :array
-          validate_array(expected_schema, datum, path, result)
-        when :map
-          validate_map(expected_schema, datum, path, result)
-        when :union
-          validate_union(expected_schema, datum, path, result)
-        when :record, :error, :request
-          fail TypeMismatchError unless datum.is_a?(Hash)
-          expected_schema.fields.each do |field|
-            deeper_path = deeper_path_for_hash(field.name, path)
-            validate_recursive(field.type, datum[field.name], deeper_path, result)
-          end
-        end
-      rescue TypeMismatchError
-        result.add_error(path, "expected type #{expected_schema.type_sym}, got #{actual_value_message(datum)}")
-      end
-
-      def validate_simple(expected_schema, datum, path, result)
-        validate_type(expected_schema)
-
-        case expected_schema.type_sym
-        when :null
-          fail TypeMismatchError unless datum.nil?
-        when :boolean
-          fail TypeMismatchError unless BOOLEAN_VALUES.include?(datum)
-        when :string, :bytes
-          fail TypeMismatchError unless datum.is_a?(String)
-        when :int
-          fail TypeMismatchError unless datum.is_a?(Integer)
-          result.add_error(path, "out of bound value #{datum}") unless INT_RANGE.cover?(datum)
-        when :long
-          fail TypeMismatchError unless datum.is_a?(Integer)
-          result.add_error(path, "out of bound value #{datum}") unless LONG_RANGE.cover?(datum)
-        when :float, :double
-          fail TypeMismatchError unless datum.is_a?(Float) || datum.is_a?(Integer)
-        when :fixed
-          if datum.is_a? String
-            result.add_error(path, fixed_string_message(expected_schema.size, datum)) unless datum.bytesize == expected_schema.size
-          else
-            result.add_error(path, "expected fixed with size #{expected_schema.size}, got #{actual_value_message(datum)}")
-          end
-        when :enum
-          result.add_error(path, enum_message(expected_schema.symbols, datum)) unless expected_schema.symbols.include?(datum)
-        end
-      rescue TypeMismatchError
-        result.add_error(path, "expected type #{expected_schema.type_sym}, got #{actual_value_message(datum)}")
-      end
-
-      def fixed_string_message(size, datum)
-        "expected fixed with size #{size}, got \"#{datum}\" with size #{datum.size}"
-      end
-
-      def enum_message(symbols, datum)
-        "expected enum with values #{symbols}, got #{actual_value_message(datum)}"
-      end
-
-      def validate_array(expected_schema, datum, path, result)
-        fail TypeMismatchError unless datum.is_a?(Array)
-        datum.each_with_index do |d, i|
-          validate_recursive(expected_schema.items, d, path + "[#{i}]", result)
-        end
-      end
-
-      def validate_map(expected_schema, datum, path, result)
-        fail TypeMismatchError unless datum.is_a?(Hash)
-        datum.keys.each do |k|
-          result.add_error(path, "unexpected key type '#{ruby_to_avro_type(k.class)}' in map") unless k.is_a?(String)
-        end
-        datum.each do |k, v|
-          deeper_path = deeper_path_for_hash(k, path)
-          validate_recursive(expected_schema.values, v, deeper_path, result)
-        end
-      end
-
-      def validate_union(expected_schema, datum, path, result)
-        if expected_schema.schemas.size == 1
-          validate_recursive(expected_schema.schemas.first, datum, path, result)
-          return
-        end
-        failures = []
-        compatible_type = first_compatible_type(datum, expected_schema, path, failures)
-        return unless compatible_type.nil?
-
-        complex_type_failed = failures.detect { |r| COMPLEX_TYPES.include?(r[:type]) }
-        if complex_type_failed
-          complex_type_failed[:result].errors.each { |error| result << error }
-        else
-          types = expected_schema.schemas.map { |s| "'#{s.type_sym}'" }.join(', ')
-          result.add_error(path, "expected union of [#{types}], got #{actual_value_message(datum)}")
-        end
-      end
-
-      def first_compatible_type(datum, expected_schema, path, failures)
-        expected_schema.schemas.find do |schema|
-          result = Result.new
-          validate_recursive(schema, datum, path, result)
-          failures << { type: schema.type_sym, result: result } if result.failure?
-          !result.failure?
-        end
-      end
-
-      def deeper_path_for_hash(sub_key, path)
-        "#{path}#{PATH_SEPARATOR}#{sub_key}".squeeze(PATH_SEPARATOR)
-      end
-
-      def actual_value_message(value)
-        avro_type = if value.is_a?(Integer)
-                      ruby_integer_to_avro_type(value)
-                    else
-                      ruby_to_avro_type(value.class)
-                    end
-        if value.nil?
-          avro_type
-        else
-          "#{avro_type} with value #{value.inspect}"
-        end
-      end
-
-      def ruby_to_avro_type(ruby_class)
-        {
-          NilClass => 'null',
-          String => 'string',
-          Float => 'float',
-          Hash => 'record'
-        }.fetch(ruby_class, ruby_class)
-      end
-
-      def ruby_integer_to_avro_type(value)
-        INT_RANGE.cover?(value) ? 'int' : 'long'
-      end
-    end
-  end
-end