avro-builder 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2caec0734e6bf6ba5d83e453fe9d067f9f47fa6
-  data.tar.gz: 79fca4e7bf6c5bc9ad9bbcb2425afb902e1b9026
+  metadata.gz: 6a6a7c469ac63da10199ce29df3e1b6d82e6904a
+  data.tar.gz: aa7a5d4506499cc9a75ce963e54254d6ded16b49
 SHA512:
-  metadata.gz: 73e3846ea11202adb26505a47bc3ec7a7772f10f1ff7560593788926922a9c9b45ece9c49bc2fecb0df48627923b44dcc23603cad25020d7c45314f64fcd191f
-  data.tar.gz: ae4ffe269bbd87c8fdc6f548898eb3fbf3749781604744f8f79deb38133670a5cdc4a5f2dec0347ff94fb568c0e2e2ae5a1411b4d69efecd32db0f4ceff8bd57
+  metadata.gz: 2803b8ebb4bedb1256041eaf4533c2c1309e416fb7152ef3f55e76191e32b1af17608895d42e729b026a1ca0edada181aa779993b4ddfd485dcd594d824c057f
+  data.tar.gz: bba50fb4e40081ab522201c764f90c583e351b3be14b2ec237c850565bc84fad1e12ab42b8f8fc32289286e380f1cd41c2c600a10e5afe3bb316a43726304f67

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # avro-builder changelog
 
+## v0.5.0
+- Support references to named types that are defined inline.
+- Raise an error for duplicate definitions with the same fullname.
+
 ## v0.4.0
 - Add validation for required DSL attributes that are not specified.
 - Allow name to be configured via a block for top-level record, enum, and fixed

data/lib/avro/builder/definition_cache.rb

@@ -0,0 +1,60 @@
+module Avro
+  module Builder
+
+    # This class is used to cache previously defined schema objects
+    # preventing direct access via the DSL.
+    class DefinitionCache
+      def initialize(builder)
+        @builder = builder
+        @schema_objects = {}
+        @schema_names = Set.new
+      end
+
+      # Cache and schema object by name (for convenience) and fullname.
+      # The schema object is only available by name if the unqualified name is unique.
+      def add_schema_object(object)
+        store_by_name(object) if object.namespace
+        store_by_fullname(object)
+      end
+
+      # Lookup an Avro schema object by name, possibly fully qualified by namespace.
+      def lookup_named_type(key, namespace = nil)
+        key_str = Avro::Name.make_fullname(key.to_s, namespace && namespace.to_s)
+        object = schema_objects[key_str]
+
+        if object.nil? && !schema_names.include?(key.to_s)
+          object = builder.import(key)
+        end
+
+        raise DefinitionNotFoundError.new(key) if object.nil? && namespace.nil?
+
+        # Return object or retry without namespace
+        object || lookup_named_type(key, nil)
+      end
+
+      private
+
+      # Schemas are stored by name, provided that the name is unique.
+      # If the unqualified name is ambiguous then it is removed from the cache.
+      # A set of unqualified names is kept to avoid reloading files for
+      # ambiguous references.
+      def store_by_name(object)
+        key = object.name.to_s
+        if schema_objects.key?(key)
+          schema_objects.delete(key)
+        elsif !schema_names.include?(key)
+          schema_objects.store(key, object)
+        end
+        schema_names.add(key)
+      end
+
+      def store_by_fullname(object)
+        key = object.fullname
+        raise DuplicateDefinitionError.new(key, object, schema_objects[key]) if schema_objects.key?(key)
+        schema_objects.store(key, object)
+      end
+
+      attr_reader :schema_objects, :schema_names, :builder
+    end
+  end
+end

data/lib/avro/builder/dsl.rb

@@ -2,6 +2,7 @@ require 'avro'
 require 'avro/builder/errors'
 require 'avro/builder/dsl_attributes'
 require 'avro/builder/namespaceable'
+require 'avro/builder/definition_cache'
 require 'avro/builder/type_factory'
 require 'avro/builder/types'
 require 'avro/builder/field'
@@ -33,8 +34,9 @@ module Avro
       # Imports from the file with specified name fragment.
       def import(name)
         previous_namespace = namespace
-        eval_file(name)
+        result = eval_file(name)
         namespace(previous_namespace)
+        result
       end
 
       ## DSL methods for Types
@@ -48,20 +50,6 @@ module Avro
         create_named_type(name, :fixed, size_option.merge(options), &block)
       end
 
-      # Lookup an Avro schema object by name, possibly fully qualified by namespace.
-      def lookup_named_type(key)
-        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" unless object
-        object
-      end
-
       # Return the last schema object processed as a Hash representing
       # the Avro schema.
       def to_h
@@ -85,28 +73,18 @@ module Avro
 
       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
+      def cache
+        @cache ||= Avro::Builder::DefinitionCache.new(self)
       end
 
       def create_named_type(name, type_name, options = {}, &block)
         create_and_configure_builtin_type(type_name,
-                                          builder: self,
+                                          cache: cache,
                                           internal: { name: name, namespace: namespace },
                                           options: options,
                                           &block).tap do |type|
           type.validate!
-          add_schema_object(type)
+          @last_object = cache.add_schema_object(type)
         end
       end
 

data/lib/avro/builder/errors.rb

@@ -11,5 +11,33 @@ module Avro
         super("attribute :#{attribute} missing for #{location}type :#{type}")
       end
     end
+
+    class DuplicateDefinitionError < StandardError
+      def initialize(key, object, existing_object)
+        super("definition for #{key.inspect} already exists\n"\
+              "existing definition:\n#{to_json(existing_object)}\n"\
+              "new definition:\n#{to_json(object)})")
+      end
+
+      private
+
+      def to_json(object)
+        object.to_h(SchemaSerializerReferenceState.new).to_json
+      end
+    end
+
+    class DefinitionNotFoundError < StandardError
+      def initialize(name)
+        super("definition not found for '#{name.to_s}'.#{suggest_namespace(name)}")
+      end
+
+      private
+
+      def suggest_namespace(name)
+        unless name.to_s.index('.')
+          ' Try specifying the full namespace.'
+        end
+      end
+    end
   end
 end

data/lib/avro/builder/field.rb

@@ -7,18 +7,15 @@ module Avro
     # 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_field)).freeze
 
-      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:, record:, builder:, internal: {}, options: {}, &block)
-        @builder = builder
+      def initialize(name:, type_name:, record:, cache:, internal: {}, options: {}, &block)
+        @cache = cache
         @record = record
         @name = name.to_s
 
@@ -33,15 +30,18 @@ module Avro
         @type = if builtin_type?(type_name)
                   create_and_configure_builtin_type(type_name,
                                                     field: self,
+                                                    cache: cache,
                                                     internal: internal,
                                                     options: options)
                 else
-                  builder.lookup_named_type(type_name)
+                  named_type = true
+                  cache.lookup_named_type(type_name, namespace)
                 end
 
         # DSL calls must be evaluated after the type has been constructed
         instance_eval(&block) if block_given?
         @type.validate!
+        @type.cache! unless named_type
       end
 
       ## Delegate additional DSL calls to the type
@@ -58,6 +58,16 @@ module Avro
         record.name_fragment
       end
 
+      # Delegate setting namespace explicitly via DSL to type
+      # and return the namespace value from the enclosing record.
+      def namespace(value = nil)
+        if value
+          type.namespace(value)
+        else
+          record.namespace
+        end
+      end
+
       # Delegate setting name explicitly via DSL to type
       def name(value = nil)
         if value
@@ -82,6 +92,8 @@ module Avro
 
       private
 
+      attr_accessor :type, :optional_field, :cache, :record
+
       # Optional fields must be serialized as a union -- an array of types.
       def serialized_type(reference_state)
         result = type.serialize(reference_state)

data/lib/avro/builder/type_factory.rb

@@ -10,13 +10,13 @@ module Avro
       private
 
       # Return a new Type instance
-      def create_builtin_type(type_name)
+      def create_builtin_type(type_name, field:, cache:)
         name = type_name.to_s.downcase
         case
         when Avro::Schema::PRIMITIVE_TYPES.include?(name)
-          Avro::Builder::Types::Type.new(name)
+          Avro::Builder::Types::Type.new(name, field: field, cache: cache)
         when COMPLEX_TYPES.include?(name)
-          Avro::Builder::Types.const_get("#{name.capitalize}Type").new
+          Avro::Builder::Types.const_get("#{name.capitalize}Type").new(field: field, cache: cache)
         else
           raise "Invalid builtin type: #{type_name}"
         end
@@ -26,13 +26,11 @@ module Avro
       # and setting attributes via the DSL
       def create_and_configure_builtin_type(type_name,
                                             field: nil,
-                                            builder: nil,
+                                            cache: nil,
                                             internal: {},
                                             options: {},
                                             &block)
-        create_builtin_type(type_name).tap do |type|
-          type.field = field
-          type.builder = builder
+        create_builtin_type(type_name, field: field, cache: cache).tap do |type|
           type.configure_options(internal.merge(options))
           type.instance_eval(&block) if block_given?
         end

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

@@ -11,11 +11,12 @@ module Avro
         end
 
         # Override initialize so that type name is not required
-        def initialize
+        def initialize(cache:, field: nil)
+          super(self.class.type_name, cache: cache, field: field)
         end
 
-        def type_name
-          self.class.type_name
+        def namespace
+          field.namespace
         end
 
         module ClassMethods

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

@@ -26,6 +26,10 @@ module Avro
           required_attribute_error!(:name) if field.nil? && @name.nil?
         end
 
+        def cache!
+          cache.add_schema_object(self)
+        end
+
         # Named types that do not have an explicit name are assigned
         # a named based on the field and its nesting.
         def name_fragment

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

@@ -7,11 +7,14 @@ module Avro
 
         dsl_attributes :doc
 
-        def initialize(name = nil, options = {})
+        def initialize(name = nil, options: {}, cache:, field: nil, &block)
+          @type_name = :record
           @name = name
-          options.each do |key, value|
-            send(key, value)
-          end
+          @cache = cache
+          @field = field
+
+          configure_options(options)
+          instance_eval(&block) if block_given?
         end
 
         # Add a required field to the record
@@ -19,7 +22,7 @@ module Avro
           new_field = Avro::Builder::Field.new(name: name,
                                                type_name: type_name,
                                                record: self,
-                                               builder: builder,
+                                               cache: cache,
                                                internal: { namespace: namespace },
                                                options: options,
                                                &block)
@@ -32,7 +35,7 @@ module Avro
           new_field = Avro::Builder::Field.new(name: name,
                                                type_name: type_name,
                                                record: self,
-                                               builder: builder,
+                                               cache: cache,
                                                internal: { namespace: namespace,
                                                            optional_field: true },
                                                options: options,
@@ -43,7 +46,7 @@ module Avro
         # Adds fields from the record with the specified name to the current
         # record.
         def extends(name)
-          fields.merge!(builder.lookup_named_type(name).duplicated_fields)
+          fields.merge!(cache.lookup_named_type(name, namespace).duplicated_fields)
         end
 
         def to_h(reference_state = SchemaSerializerReferenceState.new)
@@ -79,12 +82,6 @@ module Avro
         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

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

@@ -8,10 +8,11 @@ module Avro
         include Avro::Builder::DslAttributes
 
         attr_reader :type_name
-        attr_accessor :field, :builder
 
-        def initialize(type_name)
+        def initialize(type_name, cache:, field: nil)
           @type_name = type_name
+          @cache = cache
+          @field = field
         end
 
         def serialize(_reference_state)
@@ -36,6 +37,11 @@ module Avro
         def validate!
         end
 
+        # Subclasses should override this method if the type definition should
+        # be cached for reuse.
+        def cache!
+        end
+
         private
 
         def required_attribute_error!(attribute_name)
@@ -51,6 +57,10 @@ module Avro
             required_attribute_error!(attribute_name)
           end
         end
+
+        private
+
+        attr_accessor :field, :cache
       end
     end
   end

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

@@ -8,15 +8,11 @@ module Avro
       module TypeReferencer
         include Avro::Builder::TypeFactory
 
-        def builder
-          (!field.nil? && field.builder) || super
-        end
-
         def create_builtin_or_lookup_named_type(type_name)
           if builtin_type?(type_name)
-            create_builtin_type(type_name)
+            create_builtin_type(type_name, field: field, cache: cache)
           else
-            builder.lookup_named_type(type_name)
+            cache.lookup_named_type(type_name)
           end
         end
       end

data/lib/avro/builder/version.rb

@@ -1,5 +1,5 @@
 module Avro
   module Builder
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro-builder
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Salsify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -113,6 +113,7 @@ files:
 - bin/console
 - bin/setup
 - lib/avro/builder.rb
+- lib/avro/builder/definition_cache.rb
 - lib/avro/builder/dsl.rb
 - lib/avro/builder/dsl_attributes.rb
 - lib/avro/builder/errors.rb