avro-builder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fc0e206e5b0cfe57f356bcc17de31819fc2db7ea
+  data.tar.gz: c7ebe9cd48e6ea8a55762d71d1349405e78d022a
+SHA512:
+  metadata.gz: b02e6bf7877bb667d2602c871aceda94b5943adbbe356ca80b7479044dab2dbdaa05d130d9f4732dee2314aa87484159195a845c1af354db0855105259fe2e06
+  data.tar.gz: b22b39dae5253d9b021fe4deabd8b50ef3757dff483cf0a10ef28612045c32f8ed149db761b68427eb191c8df7751bdabf5e8e98dce88e0b2ccac5180ad9d2a4

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# avro-builder changelog
+
+## v0.1.0
+- Initial release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in avro-builder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 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,156 @@
+# Avro::Builder
+
+`Avro::Builder` provides a Ruby DSL to create [Apache Avro](https://avro.apache.org/docs/current/) Schemas.
+
+This DSL was created because:
+* The [Avro IDL](https://avro.apache.org/docs/current/idl.html) is not supported in Ruby.
+* The Avro IDL can only be used to define Protocols.
+* Schemas can be extracted as JSON from an IDL Protocol but support
+  for imports is still limited.
+
+## Features
+* The syntax is designed for ease-of-use.
+* Definitions can be imported by name. This includes auto-loading from a configured
+  set of paths. This allows definitions to split across files and even reused
+  between projects.
+* Record definitions can inherit from other record definitions.
+
+## Limitations
+
+* Only Avro Schemas, not Protocols are supported.
+* See [Issues](https://github.com/salsify/avro-builder/issues) for functionality
+  that has yet to be implemented.
+* This is alpha quality code. There may be breaking changes until version 1.0 is
+  released.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'avro-builder'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install avro-builder
+
+## Usage
+
+To use `Avro::Builder` define a schema:
+
+```ruby
+namespace 'com.example'
+
+fixed :password, 8
+
+enum :user_type, :ADMIN, :REGULAR
+
+record :user do
+  required :id, :long
+  required :user_name, :string
+  required :type, :user_type, default: :REGULAR
+  required :pw, :password
+  optional :full_name, :string
+end
+```
+
+The schema definition may be passed as a string or a block to
+`Avro::Builder.build`.
+
+This generates the following Avro JSON schema:
+```json
+{
+  "type": "record",
+  "name": "user",
+  "namespace": "com.example",
+  "fields": [
+    {
+      "name": "id",
+      "type": "long"
+    },
+    {
+      "name": "user_name",
+      "type": "string"
+    },
+    {
+      "name": "type",
+      "type": {
+        "name": "user_type",
+        "type": "enum",
+        "symbols": [
+          "ADMIN",
+          "REGULAR"
+        ],
+        "namespace": "com.example"
+      },
+      "default": "REGULAR"
+    },
+    {
+      "name": "pw",
+      "type": {
+        "name": "password",
+        "type": "fixed",
+        "size": 8,
+        "namespace": "com.example"
+      }
+    },
+    {
+      "name": "full_name",
+      "type": [
+        "null",
+        "string"
+      ]
+    }
+  ]
+}
+```
+
+### Required and Optional
+
+Fields for a record a specified as `required` or `optional`. Optional fields are
+implemented as a union in Avro, where `null` is the first type in the union.
+
+### Named Types
+
+`fixed` and `enum` fields may be specified inline as part of a record
+or as standalone named types.
+
+### Auto-loading and Imports
+
+Specify paths to search for definitions:
+
+```ruby
+Avro::Builder.add_load_path('/path/to/dsl/files')
+```
+
+Undefined references are automatically loaded from a file with the same name.
+The load paths are searched for `.rb` file with a matching name.
+
+Files may also be explicitly imported using `import <filename>`.
+
+### Extends
+
+A previously defined record may be referenced in the definition of another
+record using `extends <record_name>`. This adds all of the fields from
+the referenced record to the current record. The current record may override
+fields in the record that it extends.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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
+
+Issues and pull requests are welcome on GitHub at https://github.com/salsify/avro-builder.
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/avro-builder.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'avro/builder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "avro-builder"
+  spec.version       = Avro::Builder::VERSION
+  spec.authors       = ["Salsify Engineering"]
+  spec.email         = ["engineering@salsify.com"]
+
+  spec.summary       = %q{Ruby DSL to create Avro schemas}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/salsify/avro-builder.git"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "avro", ">= 1.7.0"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "json_spec"
+  spec.add_development_dependency "simplecov"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "avro/builder"
+
+# 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 -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/avro/builder/dsl.rb

@@ -0,0 +1,124 @@
+require 'avro'
+require 'avro/builder/dsl_attributes'
+require 'avro/builder/namespaceable'
+require 'avro/builder/type_factory'
+require 'avro/builder/types'
+require 'avro/builder/field'
+require 'avro/builder/record'
+require 'avro/builder/file_handler'
+require 'avro/builder/schema_serializer_reference_state'
+
+module Avro
+  module Builder
+    # This class is used to construct Avro schemas (not protocols) using a ruby
+    # DSL
+    class DSL
+      include Avro::Builder::DslAttributes
+      include Avro::Builder::FileHandler
+      include Avro::Builder::TypeFactory
+
+      dsl_attribute :namespace
+
+      # An instance of the DSL is initialized with a string or a block to
+      # evaluate to define Avro schema objects.
+      def initialize(str = nil, &block)
+        str ? instance_eval(str) : instance_eval(&block)
+      end
+
+      # Define an Avro schema record
+      def record(name, options = {}, &block)
+        add_schema_object(build_record(name, options, &block))
+      end
+
+      # Imports from the file with specified name fragment.
+      def import(name)
+        previous_namespace = namespace
+        eval_file(name)
+        namespace(previous_namespace)
+      end
+
+      ## DSL methods for Types
+
+      def enum(name, *symbols, **options, &block)
+        type(name, :enum, { symbols: symbols }.merge(options), &block)
+      end
+
+      def fixed(name, size = nil, options = {}, &block)
+        type(name, :fixed, { size: size }.merge(options), &block)
+      end
+
+      def type(name, type_name, options = {}, &block)
+        build_type(type_name,
+                   builder: self,
+                   internal: { name: name, namespace: namespace },
+                   options: options,
+                   &block).tap do |type|
+          add_schema_object(type)
+        end
+      end
+
+      # Lookup an Avro schema object by name, possibly fully qualified by namespace.
+      def lookup(key, required: true)
+        key_str = key.to_s
+        object = schema_objects[key_str]
+
+        unless object
+          import(key)
+          object = schema_objects[key_str]
+        end
+
+        raise "Schema object #{key} not found" if required && !object
+        object
+      rescue
+        raise if required
+        nil
+      end
+
+      # Return the last schema object processed as a Hash representing
+      # the Avro schema.
+      def to_h
+        @last_object.to_h(SchemaSerializerReferenceState.new)
+      end
+
+      # Return the last schema object processed as an Avro JSON schema
+      def to_json(validate: true, pretty: true)
+        hash = to_h
+        (pretty ? JSON.pretty_generate(hash) : hash.to_json).tap do |json|
+          # Parse the schema to validate before returning
+          ::Avro::Schema.parse(json) if validate
+        end
+      end
+
+      def as_schema
+        Avro::Schema.parse(to_json(validate: false))
+      end
+
+      private
+
+      def builder
+        self
+      end
+
+      def schema_objects
+        @schema_objects ||= {}
+      end
+
+      def add_schema_object(object)
+        @last_object = object
+        schema_objects[object.name.to_s] = object
+        schema_objects[object.fullname] = object if object.namespace
+      end
+
+      def build_record(name, options, &block)
+        Record.new(name, options.merge(namespace: namespace)).tap do |record|
+          record.builder = builder
+          record.instance_eval(&block)
+        end
+      end
+
+      def eval_file(name)
+        instance_eval(read_file(name))
+      end
+    end
+  end
+end

data/lib/avro/builder/dsl_attributes.rb

@@ -0,0 +1,59 @@
+module Avro
+  module Builder
+
+    # This module provides methods for defining attributes that can be
+    # set  via the DSL on various objects.
+    #
+    # The methods generated for DSL attributes are combined getter/setters
+    # of the form:
+    #
+    #   attribute(value = nil)
+    #
+    # When value is provided the attribute is set, and when it is nil the
+    # current value is returned.
+    #
+    # When a DSL attribute is defined, the class also keeps track of the
+    # attribute names.
+    module DslAttributes
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def has_dsl_attribute?(name)
+        self.class.dsl_attribute_names.include?(name.to_sym)
+      end
+
+      module ClassMethods
+        def dsl_attributes(*names)
+          names.each do |name|
+            dsl_attribute_names << name
+            ivar = :"@#{name}"
+            define_method(name) do |value = nil|
+              value ? instance_variable_set(ivar, value) : instance_variable_get(ivar)
+            end
+          end
+        end
+
+        # If a block is specified then it is used to define the
+        # combined getter/setter method for the DSL attribute.
+        def dsl_attribute(name, &block)
+          if block_given?
+            dsl_attribute_names << name
+            define_method(name, &block)
+          else
+            dsl_attributes(name)
+          end
+        end
+
+        def dsl_attribute_names
+          @dsl_attribute_names ||=
+            if superclass.respond_to?(:dsl_attribute_names)
+              superclass.dsl_attribute_names.dup
+            else
+              Set.new
+            end
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/field.rb

@@ -0,0 +1,78 @@
+require 'avro/builder/type_factory'
+
+module Avro
+  module Builder
+
+    # This class represents a field in a record.
+    # A field must be initialized with a type.
+    class Field
+      include Avro::Builder::DslAttributes
+      include Avro::Builder::Namespaceable
+      include Avro::Builder::TypeFactory
+
+      INTERNAL_ATTRIBUTES = Set.new(%i(optional)).freeze
+
+      attr_accessor :type, :optional, :builder
+
+      # These attributes may be set as options or via a block in the DSL
+      dsl_attributes :doc, :aliases, :default, :order
+
+      def initialize(name:, type_name:, builder:, internal: {}, options: {}, &block)
+        @builder = builder
+        @name = name.to_s
+
+        internal.each do |key, value|
+          send("#{key}=", value) if INTERNAL_ATTRIBUTES.include?(key)
+        end
+
+        options.each do |key, value|
+          send(key, value) if has_dsl_attribute?(key)
+        end
+
+        @type = builder.lookup(type_name, required: false) ||
+          build_type(type_name, field: self, internal: internal, options: options)
+
+        # DSL calls must be evaluated after the type has been constructed
+        instance_eval(&block) if block_given?
+      end
+
+      ## Delegate additional DSL calls to the type
+
+      def respond_to_missing?(id, include_all = false)
+        super || type.respond_to?(id, include_all)
+      end
+
+      def method_missing(id, *args)
+        type.respond_to?(id) ? type.send(id, *args) : super
+      end
+
+      # Delegate setting name explicitly via DSL to type
+      def name(value = nil)
+        if value
+          type.name(value)
+        else
+          # Return the name of the field
+          @name
+        end
+      end
+
+      def serialize(reference_state)
+        {
+          name: name,
+          type: serialized_type(reference_state),
+          doc: doc,
+          default: default,
+          aliases: aliases
+        }.reject { |_, v| v.nil? }
+      end
+
+      private
+
+      # Optional types must be serialized as an array.
+      def serialized_type(reference_state)
+        result = type.serialize(reference_state)
+        optional ? [:null, result] : result
+      end
+    end
+  end
+end

data/lib/avro/builder/file_handler.rb

@@ -0,0 +1,39 @@
+module Avro
+  module Builder
+    # TODO: eventually this should be refactored into something standalone
+    # instead of a module that is included to provide the file handling methods.
+    module FileHandler
+
+      module ClassMethods
+        # Load paths are used to search for imports and extends.
+        def load_paths
+          @load_paths ||= Set.new
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def read_file(name)
+        File.read(find_file(name))
+      end
+
+      private
+
+      def find_file(name)
+        file_name = "#{name.to_s.sub(/\.rb$/, '')}.rb"
+        matches = self.class.load_paths.flat_map do |load_path|
+          Dir["#{load_path}/**/*.rb"].select do |file_path|
+            file_path.end_with?(file_name)
+          end
+        end
+        raise "Multiple matches: #{matches}" if matches.size > 1
+        raise "File not found #{name}" if matches.empty?
+
+        matches.first
+      end
+
+    end
+  end
+end

data/lib/avro/builder/namespaceable.rb

@@ -0,0 +1,12 @@
+module Avro
+  module Builder
+
+    # This concern is used to generate the full name for objects that may
+    # be namespaced.
+    module Namespaceable
+      def fullname
+        [namespace, name].compact.join('.')
+      end
+    end
+  end
+end

data/lib/avro/builder/record.rb

@@ -0,0 +1,84 @@
+module Avro
+  module Builder
+    # This class represents a record in an Avro schema.
+    class Record
+      include Avro::Builder::DslAttributes
+      include Avro::Builder::Namespaceable
+
+      attr_accessor :builder
+      attr_reader :name
+
+      dsl_attributes :doc, :aliases, :namespace
+
+      def initialize(name, options = {})
+        @name = name
+        options.each do |key, value|
+          send(key, value)
+        end
+      end
+
+      # Add a required field to the record
+      def required(name, type_name, options = {}, &block)
+        new_field = Avro::Builder::Field.new(name: name,
+                                             type_name: type_name,
+                                             builder: builder,
+                                             internal: { namespace: namespace },
+                                             options: options,
+                                             &block)
+        add_field(new_field)
+      end
+
+      # Add an optional field to the record. In Avro this is represented
+      # as a union of null and the type specified here.
+      def optional(name, type_name, options = {}, &block)
+        new_field = Avro::Builder::Field.new(name: name,
+                                             type_name: type_name,
+                                             builder: builder,
+                                             internal: { namespace: namespace,
+                                                         optional: true },
+                                             options: options,
+                                             &block)
+        add_field(new_field)
+      end
+
+      # Adds fields from the record with the specified name to the current
+      # record.
+      def extends(name)
+        fields.merge!(builder.lookup(name).duplicated_fields)
+      end
+
+      def to_h(reference_state = SchemaSerializerReferenceState.new)
+        reference_state.definition_or_reference(fullname) do
+          {
+            type: :record,
+            name: name,
+            namespace: namespace,
+            doc: doc,
+            aliases: aliases,
+            fields: fields.values.map { |field| field.serialize(reference_state) }
+          }.reject { |_, v| v.nil? }
+        end
+      end
+
+      protected
+
+      def duplicated_fields
+        fields.each_with_object(Hash.new) do |(name, field), result|
+          field_copy = field.dup
+          result[name] = field_copy
+        end
+      end
+
+      private
+
+      # Add field, replacing any existing field with the same name.
+      def add_field(field)
+        fields[field.name] = field
+      end
+
+      def fields
+        @fields ||= {}
+      end
+    end
+  end
+end

data/lib/avro/builder/schema_serializer_reference_state.rb

@@ -0,0 +1,27 @@
+module Avro
+  module Builder
+
+    # This class is used to keep track of references to each named type while
+    # generating an Avro JSON schema. Only the first reference to the type
+    # can include all of details of the definition. All subsequent references
+    # must use the full name for the type.
+    class SchemaSerializerReferenceState
+
+      attr_reader :references
+      private :references
+
+      def initialize
+        @references = Set.new
+      end
+
+      def definition_or_reference(fullname)
+        if references.include?(fullname)
+          fullname
+        else
+          references << fullname
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/type_factory.rb

@@ -0,0 +1,33 @@
+module Avro
+  module Builder
+
+    # This concern is used by classes that create new Type instances.
+    module TypeFactory
+
+      private
+
+      # Return a new Type instance
+      def create_type(type_name)
+        case
+        when Avro::Schema::PRIMITIVE_TYPES_SYM.include?(type_name.to_sym)
+          Avro::Builder::Types::Type.new(type_name)
+        else
+          type_class_name = "#{type_name.to_s.capitalize}Type"
+          Avro::Builder::Types.const_get(type_class_name).new
+        end
+      end
+
+      # Return a new Type instance, including propagating internal state
+      # and setting attributes via the DSL
+      def build_type(type_name, field: nil, builder: nil, internal: {}, options: {}, &block)
+        create_type(type_name).tap do |type|
+          type.field = field
+          type.builder = builder
+          type.configure_options(internal.merge(options))
+          type.instance_eval(&block) if block_given?
+        end
+      end
+
+    end
+  end
+end

data/lib/avro/builder/types/array_type.rb

@@ -0,0 +1,29 @@
+require 'avro/builder/types/configurable_type'
+require 'avro/builder/types/type_referencer'
+
+module Avro
+  module Builder
+    module Types
+      class ArrayType < Type
+        include Avro::Builder::Types::SpecificType
+        include Avro::Builder::Types::ConfigurableType
+        include Avro::Builder::Types::TypeReferencer
+
+        dsl_attribute :items do |items_type = nil|
+          if items_type
+            @items = find_or_create_type(items_type)
+          else
+            @items
+          end
+        end
+
+        def serialize(referenced_state)
+          {
+            type: type_name,
+            items: items.serialize(referenced_state)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/configurable_type.rb

@@ -0,0 +1,16 @@
+module Avro
+  module Builder
+    module Types
+
+      # This concern is used by Types that can be configured using DSL
+      # attributes.
+      module ConfigurableType
+        def configure_options(options = {})
+          options.each do |key, value|
+            send(key, value) if has_dsl_attribute?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/enum_type.rb

@@ -0,0 +1,33 @@
+module Avro
+  module Builder
+    module Types
+      class EnumType < NamedType
+
+        dsl_attribute :doc
+
+        dsl_attribute :symbols do |*values|
+          # Define symbols explicitly to support values as a splat or single array
+          if !values.empty?
+            @symbols = values.flatten
+          else
+            @symbols
+          end
+        end
+
+        def serialize(reference_state)
+          super(reference_state, overrides: serialized_attributes)
+        end
+
+        def to_h(reference_state)
+          super(reference_state, overrides: serialized_attributes)
+        end
+
+        private
+
+        def serialized_attributes
+          { symbols: symbols, doc: doc }
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/fixed_type.rb

@@ -0,0 +1,24 @@
+module Avro
+  module Builder
+    module Types
+      class FixedType < NamedType
+
+        dsl_attribute :size
+
+        def serialize(reference_state)
+          super(reference_state, overrides: serialized_attributes)
+        end
+
+        def to_h(reference_state)
+          super(reference_state, overrides: serialized_attributes)
+        end
+
+        private
+
+        def serialized_attributes
+          { size: size }
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/map_type.rb

@@ -0,0 +1,29 @@
+require 'avro/builder/types/configurable_type'
+require 'avro/builder/types/type_referencer'
+
+module Avro
+  module Builder
+    module Types
+      class MapType < Type
+        include Avro::Builder::Types::SpecificType
+        include Avro::Builder::Types::ConfigurableType
+        include Avro::Builder::Types::TypeReferencer
+
+        dsl_attribute :values do |value_type = nil|
+          if value_type
+            @values = find_or_create_type(value_type)
+          else
+            @values
+          end
+        end
+
+        def serialize(referenced_state)
+          {
+            type: type_name,
+            values: values.serialize(referenced_state)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/named_type.rb

@@ -0,0 +1,48 @@
+require 'avro/builder/types/configurable_type'
+require 'avro/builder/namespaceable'
+
+module Avro
+  module Builder
+    module Types
+
+      # This is an abstract class that represents a type that can be defined
+      # with a name, outside a record.
+      class NamedType < Type
+        include Avro::Builder::Types::SpecificType
+        include Avro::Builder::Namespaceable
+        include Avro::Builder::Types::ConfigurableType
+
+        dsl_attributes :name, :namespace, :aliases
+
+        def generated_name
+          name || "__#{field.name}_#{type_name}"
+        end
+
+        # As a type for a field
+        # Subclasses may call super with additional overrides to be added
+        # to the serialized value.
+        def serialize(reference_state, overrides: {})
+          reference_state.definition_or_reference(fullname) do
+            {
+              name: generated_name,
+              type: type_name,
+              namespace: namespace
+            }.merge(overrides).reject { |_, v| v.nil? }
+          end
+        end
+
+        # As a top-level, named type
+        # Subclasses may call super with additional overrides to be added
+        # to the hash representation.
+        def to_h(_reference_state, overrides: {})
+          {
+            name: name,
+            type: type_name,
+            namespace: namespace,
+            aliases: aliases
+          }.merge(overrides).reject { |_, v| v.nil? }
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/specific_type.rb

@@ -0,0 +1,31 @@
+module Avro
+  module Builder
+    module Types
+
+      # This module provides common functionality for Types with a specific
+      # type name vs the generic Type class.
+      module SpecificType
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        # Override initialize so that type name is not required
+        def initialize
+        end
+
+        def type_name
+          self.class.type_name
+        end
+
+        module ClassMethods
+
+          # Infer type_name based on class
+          def type_name
+            @type_name ||= name.split('::').last.sub('Type', '').downcase.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/type.rb

@@ -0,0 +1,31 @@
+module Avro
+  module Builder
+    module Types
+      # Base class for simple types. The type name is specified when the
+      # type is constructed. The type has no additional attributes, and
+      # the type is serialized as just the type name.
+      class Type
+        include Avro::Builder::DslAttributes
+
+        attr_reader :type_name
+        attr_accessor :field, :builder
+
+        def initialize(type_name)
+          @type_name = type_name
+        end
+
+        def serialize(_reference_state)
+          type_name
+        end
+
+        def namespace
+          nil
+        end
+
+        def configure_options(_options = {})
+          # No-op
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types/type_referencer.rb

@@ -0,0 +1,21 @@
+require 'avro/builder/type_factory'
+
+module Avro
+  module Builder
+    module Types
+
+      # This concern is used by Types that reference other types.
+      module TypeReferencer
+        include Avro::Builder::TypeFactory
+
+        def builder
+          (!field.nil? && field.builder) || super
+        end
+
+        def find_or_create_type(type_name)
+          builder.lookup(type_name, required: false) || create_type(type_name)
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types.rb

@@ -0,0 +1,7 @@
+require 'avro/builder/types/type'
+require 'avro/builder/types/specific_type'
+require 'avro/builder/types/named_type'
+require 'avro/builder/types/enum_type'
+require 'avro/builder/types/fixed_type'
+require 'avro/builder/types/array_type'
+require 'avro/builder/types/map_type'

data/lib/avro/builder/version.rb

@@ -0,0 +1,5 @@
+module Avro
+  module Builder
+    VERSION = "0.1.0"
+  end
+end

data/lib/avro/builder.rb

@@ -0,0 +1,22 @@
+require 'avro/builder/version'
+require 'avro/builder/dsl'
+
+module Avro
+  module Builder
+
+    # Accepts a string or block to eval to define a JSON schema
+    def self.build(str = nil, &block)
+      Avro::Builder::DSL.new(str, &block).to_json
+    end
+
+    # Accepts a string or block to eval and returns an Avro::Schema
+    def self.build_schema(str = nil, &block)
+      Avro::Builder::DSL.new(str, &block).as_schema
+    end
+
+    # Add paths that will be searched for definitions
+    def self.add_load_path(*paths)
+      Avro::Builder::DSL.load_paths.merge(paths)
+    end
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: avro-builder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Salsify Engineering
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: avro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json_spec
+  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: simplecov
+  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'
+description: Ruby DSL to create Avro schemas
+email:
+- engineering@salsify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- avro-builder.gemspec
+- bin/console
+- bin/setup
+- lib/avro/builder.rb
+- lib/avro/builder/dsl.rb
+- lib/avro/builder/dsl_attributes.rb
+- lib/avro/builder/field.rb
+- lib/avro/builder/file_handler.rb
+- lib/avro/builder/namespaceable.rb
+- lib/avro/builder/record.rb
+- lib/avro/builder/schema_serializer_reference_state.rb
+- lib/avro/builder/type_factory.rb
+- lib/avro/builder/types.rb
+- lib/avro/builder/types/array_type.rb
+- lib/avro/builder/types/configurable_type.rb
+- lib/avro/builder/types/enum_type.rb
+- lib/avro/builder/types/fixed_type.rb
+- lib/avro/builder/types/map_type.rb
+- lib/avro/builder/types/named_type.rb
+- lib/avro/builder/types/specific_type.rb
+- lib/avro/builder/types/type.rb
+- lib/avro/builder/types/type_referencer.rb
+- lib/avro/builder/version.rb
+homepage: https://github.com/salsify/avro-builder.git
+licenses:
+- MIT
+metadata: {}
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Ruby DSL to create Avro schemas
+test_files: []