avro-builder 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a72124e0979079150b62e4ca3f8f6c727b7bb39c
-  data.tar.gz: 158fc532ae1587737c415069bdcbf3ae136deeaa
+  metadata.gz: 28daf07aca9de6893dcd2ca08f78448e2a6df151
+  data.tar.gz: 0e3024fb6bf1caeaa24f65e79dc601802b663164
 SHA512:
-  metadata.gz: 7f40595449fa8ce0db3ef04d35d96bd3dd133484a383ff1873bdb3c5f1061124c5398b17d31f881e479df603f940c7b3068e9112dbf2156b1a8659e537669b09
-  data.tar.gz: 7d363c07489a17ca4142c34e8a7928f5f737fac535553326d6a2c63007d1c3d0f3b6c6034f1879c9eded1281a2d08d5a51cbac3ef0a7057978edf847ba8ef340
+  metadata.gz: a5b7073dd2493279f98724a1c8fc96fadaee310e80109978754e461f4475966f0fdade6137d08055de80f7e9a2a945123937a4fd15f76b683a948b9d91dbb413
+  data.tar.gz: e577b679d984e96cb849b478306b08527f0c831fcdbede83292e760d53ac125d7c622304f80b5d2a190e867ca7a2d34f6bae3e3c27e67f97c713351eefb98dbe

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # avro-builder changelog
 
+## v0.3.0
+- Add support for nested records. This includes the ability to reference a
+  previously defined record as a type.
+
 ## v0.2.0
 - Add support for `:union` type.
 - Make `fixed` syntax more flexible. Both `fixed :f, 7` and `fixed :f, size: 7`

data/README.md

@@ -141,6 +141,58 @@ record :my_record_with_named do
 end
 ```
 
+### Nested Records
+
+Nested records may be created by referring to the name of the previously
+defined record or using the field type `:record`.
+
+```ruby
+record :sub_rec do
+  required :i, :int
+end
+
+record :top_rec do
+  required :sub, :sub_rec
+end
+```
+
+Definining a subrecord inline:
+
+```ruby
+record :my_rec do
+  required :nested, :record do
+    required :s, :string
+  end
+end
+```
+
+Nested record types defined without an explicit name are given a generated
+name based on the name of the field and record that they are nested within.
+In the example above, the nested record type would have the generated name
+`__my_rec_nested_record`:
+
+```json
+{
+  "type": "record",
+  "name": "my_rec",
+  "fields": [
+    {
+      "name": "nested",
+      "type": {
+        "type": "record",
+        "name": "__my_rec_nested_record",
+        "fields": [
+          {
+            "name": "s",
+            "type": "string"
+          }
+        ]
+      }
+    }
+  ]
+}
+```
+
 ### Unions
 
 A union may be specified within a record using `required` and `optional` with

data/lib/avro/builder/dsl.rb

@@ -4,7 +4,6 @@ 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'
 
@@ -85,6 +84,8 @@ module Avro
       def to_json(validate: true, pretty: true)
         hash = to_h
         (pretty ? JSON.pretty_generate(hash) : hash.to_json).tap do |json|
+          # Uncomment the next line to debug:
+          # puts json
           # Parse the schema to validate before returning
           ::Avro::Schema.parse(json) if validate
         end
@@ -111,10 +112,11 @@ module Avro
       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
+        Avro::Builder::Types::RecordType
+          .new(name, options.merge(namespace: namespace)).tap do |record|
+            record.builder = builder
+            record.instance_eval(&block)
+          end
       end
 
       def eval_file(name)

data/lib/avro/builder/field.rb

@@ -10,15 +10,16 @@ module Avro
       include Avro::Builder::Namespaceable
       include Avro::Builder::TypeFactory
 
-      INTERNAL_ATTRIBUTES = Set.new(%i(optional)).freeze
+      INTERNAL_ATTRIBUTES = Set.new(%i(optional_field)).freeze
 
-      attr_accessor :type, :optional, :builder
+      attr_accessor :type, :optional_field, :builder, :record
 
       # 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)
+      def initialize(name:, type_name:, record:, builder:, internal: {}, options: {}, &block)
         @builder = builder
+        @record = record
         @name = name.to_s
 
         internal.each do |key, value|
@@ -42,8 +43,12 @@ module Avro
         super || type.respond_to?(id, include_all)
       end
 
-      def method_missing(id, *args)
-        type.respond_to?(id) ? type.send(id, *args) : super
+      def method_missing(id, *args, &block)
+        type.respond_to?(id) ? type.send(id, *args, &block) : super
+      end
+
+      def name_fragment
+        record.name_fragment
       end
 
       # Delegate setting name explicitly via DSL to type
@@ -68,10 +73,10 @@ module Avro
 
       private
 
-      # Optional types must be serialized as a union -- an array of types.
+      # Optional fields must be serialized as a union -- an array of types.
       def serialized_type(reference_state)
         result = type.serialize(reference_state)
-        optional ? type.class.union_with_null(result) : result
+        optional_field ? type.class.union_with_null(result) : result
       end
     end
   end

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

@@ -12,10 +12,21 @@ module Avro
         include Avro::Builder::Namespaceable
         include Avro::Builder::Types::ConfigurableType
 
-        dsl_attributes :name, :namespace, :aliases
+        dsl_attributes :namespace, :aliases
 
-        def generated_name
-          name || "__#{field.name}_#{type_name}"
+        dsl_attribute :name do |value = nil|
+          if value
+            @name = value
+          else
+            @name || "__#{name_fragment}_#{type_name}"
+          end
+        end
+
+        # Named types that do not have an explicit name are assigned
+        # a named based on the field and its nesting.
+        def name_fragment
+          [field && field.name_fragment,
+           @name || (field && field.name)].compact.join('_')
         end
 
         # As a type for a field
@@ -24,7 +35,7 @@ module Avro
         def serialize(reference_state, overrides: {})
           reference_state.definition_or_reference(fullname) do
             {
-              name: generated_name,
+              name: name,
               type: type_name,
               namespace: namespace
             }.merge(overrides).reject { |_, v| v.nil? }

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

@@ -0,0 +1,91 @@
+module Avro
+  module Builder
+    module Types
+    # This class represents a record in an Avro schema. Records may be defined
+    # at the top-level or as the type for a field in a record.
+      class RecordType < Avro::Builder::Types::NamedType
+
+        dsl_attributes :doc
+
+        def initialize(name = nil, 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,
+                                               record: self,
+                                               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,
+                                               record: self,
+                                               builder: builder,
+                                               internal: { namespace: namespace,
+                                                           optional_field: 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
+        alias_method :serialize, :to_h
+
+        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
+
+        # A record may be defined as a top-level schema or as the
+        # type for a field.
+        def builder
+          super || field.builder
+        end
+      end
+    end
+  end
+end

data/lib/avro/builder/types.rb

@@ -3,6 +3,7 @@ require 'avro/builder/types/specific_type'
 require 'avro/builder/types/configurable_type'
 require 'avro/builder/types/type_referencer'
 require 'avro/builder/types/named_type'
+require 'avro/builder/types/record_type'
 require 'avro/builder/types/enum_type'
 require 'avro/builder/types/fixed_type'
 require 'avro/builder/types/array_type'

data/lib/avro/builder/version.rb

@@ -1,5 +1,5 @@
 module Avro
   module Builder
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro-builder
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Salsify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-18 00:00:00.000000000 Z
+date: 2016-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -117,7 +117,6 @@ files:
 - 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
@@ -127,6 +126,7 @@ files:
 - 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/record_type.rb
 - lib/avro/builder/types/specific_type.rb
 - lib/avro/builder/types/type.rb
 - lib/avro/builder/types/type_referencer.rb

data/lib/avro/builder/record.rb

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