avro-patches 0.1.0.rc0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5f260a70b867406ed25e517f37a3830674d2518
+  data.tar.gz: 3574d8e9dcfc41c7bb33eec6957b9d5f6fd5dc74
+SHA512:
+  metadata.gz: 5b063beb14f653c46b0921cb2cfcb99961e63e782167a5f0c66a54875cc8b1e9aa3d953be562829ca02961c3976576e5f20f7c7c5fd0a12ea0905dedfcb820be
+  data.tar.gz: 1e30342006998a39a3f4be96cfe94ada879b94c0b12deeb38656c9fdfe5b3859a0333ea822dd08d3b1d3ed4874a04726df76e771df214892eb87c06ce19c76bc

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.overcommit.yml

@@ -0,0 +1,8 @@
+PreCommit:
+  HardTabs:
+    enabled: true
+    required: false
+
+CommitMsg:
+  TrailingPeriod:
+    enabled: false

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.3.4
+  - 2.4.1
+before_install: gem install bundler -v 1.15.0 --no-document
+script:
+  - bundle exec rake test

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# avro-patches
+
+## v0.1.0
+- Initial version

data/Gemfile

@@ -0,0 +1,9 @@
+
+source 'https://rubygems.org'
+
+
+# override the :github shortcut to be secure by using HTTPS
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}.git" }
+
+# Specify your gem's dependencies in avro-patches.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Salsify, Inc
+
+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,57 @@
+# avro-patches
+
+This gem contains patches to the official [Apache Avro](https://avro.apache.org/)
+Ruby gem v1.8.2.
+
+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)
+
+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)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'avro-patches'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install avro-patches
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then,
+run `rake test` to run the tests. You can also run `bin/console` for an
+interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to
+[rubygems.org](https://rubygems.org)
+.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/salsify/avro-patches.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test*.rb'
+end

data/avro-patches.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'avro-patches/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'avro-patches'
+  spec.version       = AvroPatches::VERSION
+  spec.authors       = ['Salsify, Inc']
+  spec.email         = ['engineering@salsify.com']
+
+  spec.summary       = 'Patches for the official Apache Avro Ruby implementation'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/salsify/avro-patches'
+
+  spec.license       = 'MIT'
+
+  # Set 'allowed_push_post' to control where this gem can be published.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency 'overcommit'
+
+  spec.add_runtime_dependency 'avro', '1.8.2'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'avro-patches'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -v
+
+bundle update
+
+overcommit --install

data/lib/avro-patches.rb

@@ -0,0 +1,6 @@
+require 'avro-patches/version'
+
+require 'avro'
+require 'avro-patches/schema_validator'
+require 'avro-patches/logical_types'
+require 'avro-patches/schema_compatibility'

data/lib/avro-patches/logical_types.rb

@@ -0,0 +1,6 @@
+# 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

@@ -0,0 +1,42 @@
+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, 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

@@ -0,0 +1,67 @@
+require 'date'
+
+module Avro
+  module LogicalTypes
+    module IntDate
+      EPOCH_START = Date.new(1970, 1, 1)
+
+      def self.encode(date)
+        (date - EPOCH_START).to_i
+      end
+
+      def self.decode(int)
+        EPOCH_START + int
+      end
+    end
+
+    module TimestampMillis
+      def self.encode(value)
+        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)
+        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, {}).fetch(logical_type, Identity)
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+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::Schema::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::Schema::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)
+        else
+          raise Avro::Schema::SchemaParseError.new("Unknown named type: #{type}")
+        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::Schema::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::Schema::UnknownSchemaError.new(json_obj)
+    end
+  end
+
+  # Determine if a ruby datum is an instance of a schema
+  def self.validate(expected_schema, logical_datum, encoded = false)
+    Avro::SchemaValidator.validate!(expected_schema, logical_datum, encoded)
+    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

@@ -0,0 +1,26 @@
+module AvroPatches
+  module LogicalTypes
+    module SchemaValidatorPatch
+      def validate!(expected_schema, logical_datum, encoded = false)
+        result = Avro::SchemaValidator::Result.new
+        validate_recursive(expected_schema, logical_datum, Avro::SchemaValidator::ROOT_IDENTIFIER, result, encoded)
+        fail Avro::SchemaValidator::ValidationError, result if result.failure?
+        result
+      end
+
+      private
+
+      def validate_recursive(expected_schema, logical_datum, path, result, encoded = false)
+        datum = if encoded
+                  logical_datum
+                else
+                  expected_schema.type_adapter.encode(logical_datum) rescue nil
+                end
+
+        super(expected_schema, datum, path, result)
+      end
+    end
+  end
+end
+
+Avro::SchemaValidator.singleton_class.prepend(AvroPatches::LogicalTypes::SchemaValidatorPatch)

data/lib/avro-patches/schema_compatibility.rb

@@ -0,0 +1,5 @@
+# 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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,145 @@
+module Avro
+  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
+
+      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
+
+      def match_record_schemas(writers_schema, readers_schema)
+        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
+
+      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

@@ -0,0 +1,4 @@
+# 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'

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

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

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

@@ -0,0 +1,194 @@
+# 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]
+
+    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
+      def validate!(expected_schema, datum)
+        result = Result.new
+        validate_recursive(expected_schema, datum, ROOT_IDENTIFIER, result)
+        fail ValidationError, result if result.failure?
+        result
+      end
+
+      private
+
+      def validate_recursive(expected_schema, datum, path, result)
+        case expected_schema.type_sym
+        when :null
+          fail TypeMismatchError unless datum.nil?
+        when :boolean
+          fail TypeMismatchError unless [true, false].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 [Float, Integer].any?(&datum.method(:is_a?))
+        when :fixed
+          if datum.is_a? String
+            message = "expected fixed with size #{expected_schema.size}, got \"#{datum}\" with size #{datum.size}"
+            result.add_error(path, message) 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
+          message = "expected enum with values #{expected_schema.symbols}, got #{actual_value_message(datum)}"
+          result.add_error(path, message) unless expected_schema.symbols.include?(datum)
+        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
+        else
+          fail "Unexpected schema type #{expected_schema.type_sym} #{expected_schema.inspect}"
+        end
+      rescue TypeMismatchError
+        result.add_error(path, "expected type #{expected_schema.type_sym}, 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)
+        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
+        types_and_results = validate_possible_types(datum, expected_schema, path)
+        failures, successes = types_and_results.partition { |r| r[:result].failure? }
+        return if successes.any?
+        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 validate_possible_types(datum, expected_schema, path)
+        expected_schema.schemas.map do |schema|
+          result = Result.new
+          validate_recursive(schema, datum, path, result)
+          { type: schema.type_sym, result: result }
+        end
+      end
+
+      def deeper_path_for_hash(sub_key, path)
+        "#{path}#{PATH_SEPARATOR}#{sub_key}".squeeze(PATH_SEPARATOR)
+      end
+
+      private
+
+      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

data/lib/avro-patches/version.rb

@@ -0,0 +1,3 @@
+module AvroPatches
+  VERSION = '0.1.0.rc0'.freeze
+end

data/lib/avro_patches.rb

@@ -0,0 +1 @@
+require 'avro-patches'

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: avro-patches
+version: !ruby/object:Gem::Version
+  version: 0.1.0.rc0
+platform: ruby
+authors:
+- Salsify, Inc
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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: overcommit
+  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: avro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+description: Patches for the official Apache Avro Ruby implementation
+email:
+- engineering@salsify.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".overcommit.yml"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- avro-patches.gemspec
+- bin/console
+- bin/setup
+- lib/avro-patches.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/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
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Patches for the official Apache Avro Ruby implementation
+test_files: []