avro-builder 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5420ca208ea3fd4e3656158ed44ef8270eb0d22a
-  data.tar.gz: 74375f766022da155afa1421c0cd6068aa24e812
+  metadata.gz: 55be55b48ed971e75719a7c77d72002a384ae371
+  data.tar.gz: 164cddb8d0eb7ab54df709751bc0bd3d0b9a4164
 SHA512:
-  metadata.gz: 4a3f0b4e0f8a9107d56d60e85586295b9ca18ae0c0197a646ee917d6ee9f6617148ab47b02cc3ef017e6298dd611bc1cf8e8ff2d08432ead66f1585d0350f7e4
-  data.tar.gz: 6de4bceaee6e27726d62100cece189dc9ef574c2790b23c495a4cc74d6f9852f03805e819edb0d28c63f67ad1d3d0cce7899edc619290b2905aac03cd37b294f
+  metadata.gz: af77d1df17425d13af42225a8c1ca04e99464e1a907c588699159cf0b0b6248e1fa1af1443f1de64ec186680ec03a895547157e1923cef62132d49e69552e16f
+  data.tar.gz: 31bd7491a67a0cd075fbf193aa896cadb27ca0ce9c68851bf1e2aa4b302678ae14c34cc81ae1b327523f4c7d450df8f2eeba1f42cff0b6d491826c21c4785e1c

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.3.1

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # avro-builder changelog
 
+## v0.7.0
+- Only allow `type_name` and `type_namespace` options for naming named types
+  defined inline.
+- Only allow first argument to set name, and `namespace` option for top-level
+  types.
+- Only allow `aliases` attribute to set aliases for top-level types.
+
 ## v0.6.0
 - Support recursive definitions.
 - Coerce aliases to be represented as an array.

data/lib/avro/builder/dsl.rb

@@ -7,6 +7,9 @@ require 'avro/builder/definition_cache'
 require 'avro/builder/type_factory'
 require 'avro/builder/types'
 require 'avro/builder/field'
+require 'avro/builder/record'
+require 'avro/builder/enum'
+require 'avro/builder/fixed'
 require 'avro/builder/file_handler'
 require 'avro/builder/schema_serializer_reference_state'
 
@@ -79,10 +82,11 @@ module Avro
         @cache ||= Avro::Builder::DefinitionCache.new(self)
       end
 
-      def create_named_type(name, type_name, options = {}, &block)
-        create_and_configure_builtin_type(type_name,
+      def create_named_type(name, avro_type_name, options = {}, &block)
+        create_and_configure_builtin_type(avro_type_name,
                                           cache: cache,
-                                          internal: { name: name, namespace: namespace },
+                                          internal: { _name: name,
+                                                      namespace: namespace },
                                           options: options,
                                           &block).tap do |type|
           type.validate!

data/lib/avro/builder/dsl_attributes.rb

@@ -19,10 +19,6 @@ module Avro
         base.extend ClassMethods
       end
 
-      def dsl_attribute?(name)
-        self.class.dsl_attribute_names.include?(name.to_sym)
-      end
-
       module ClassMethods
         # If a block is specified then it is used to define the
         # combined getter/setter method for the DSL attribute.
@@ -60,13 +56,13 @@ module Avro
             end
         end
 
-        private
-
         def add_attribute_name(name)
           dsl_attribute_names << name
           add_option_name(name)
         end
 
+        private
+
         def define_accessor(name)
           ivar = :"@#{name}"
           define_method(name) do |value = nil|
@@ -82,6 +78,10 @@ module Avro
           private(writer)
         end
       end
+
+      def dsl_attribute?(name)
+        self.class.dsl_attribute_names.include?(name.to_sym)
+      end
     end
   end
 end

data/lib/avro/builder/dsl_options.rb

@@ -19,11 +19,17 @@ module Avro
       end
 
       module ClassMethods
-        # A DSL option is only settable as an option, not as method in a block.
-        def dsl_option(name, &block)
+
+        # Defines a private writer with #{dsl_name}= to set an attribute stored in the
+        # instance variable @#{name}.
+        def dsl_option(name, dsl_name:)
           add_option_name(name)
-          define_private_writer(name)
-          define_reader(name, &block)
+          add_attribute_name(dsl_name)
+          aliased_writer = "#{dsl_name}="
+          define_method(aliased_writer) do |value|
+            instance_variable_set("@#{name}", value)
+          end
+          private(aliased_writer)
         end
 
         def dsl_option_names
@@ -35,37 +41,9 @@ module Avro
             end
         end
 
-        private
-
         def add_option_name(name)
           dsl_option_names << name
         end
-
-        def define_private_writer(name)
-          attr_writer(name)
-          private("#{name}=")
-        end
-
-        # Define a accessor method that raises an error if called as a writer.
-        # If the optional block is specified then it is evaluated as the reader.
-        def define_reader(name, &block)
-          if block_given?
-            define_method(name) do |value = nil|
-              value ? unsupported_block_attribute(name, type_name) : instance_eval(&block)
-            end
-          else
-            define_method(name) do |value = nil|
-              value ? unsupported_block_attribute(name, type_name) : instance_variable_get("@#{name}")
-            end
-          end
-        end
-      end
-
-      private
-
-      def unsupported_block_attribute(attribute, type)
-        raise UnsupportedBlockAttributeError.new(attribute: attribute,
-                                                 type: type)
       end
     end
   end

data/lib/avro/builder/enum.rb

@@ -0,0 +1,8 @@
+module Avro
+  module Builder
+
+    class Enum < Avro::Builder::Types::EnumType
+      include Avro::Builder::Types::TopLevel
+    end
+  end
+end

data/lib/avro/builder/errors.rb

@@ -38,16 +38,6 @@ module Avro
       end
     end
 
-    class UnsupportedBlockAttributeError < StandardError
-      def initialize(attribute:, type:, field: nil)
-        target = if field
-                   "field '#{field}' of type :#{type}"
-                 else
-                   "type :#{type}"
-                 end
-        super("'#{attribute}' must be set directly using an option on #{target}, "\
-              'not via a block')
-      end
-    end
+    AttributeError = Class.new(StandardError)
   end
 end

data/lib/avro/builder/field.rb

@@ -17,9 +17,7 @@ module Avro
       # These attributes may be set as options or via a block in the DSL
       dsl_attributes :doc, :default, :order
 
-      attr_reader :name
-
-      def initialize(name:, type_name:, record:, cache:, internal: {}, options: {}, &block)
+      def initialize(name:, avro_type_name:, record:, cache:, internal: {}, options: {}, &block)
         @cache = cache
         @record = record
         @name = name.to_s
@@ -33,14 +31,14 @@ module Avro
           send(key, type_options.delete(key)) if dsl_attribute?(key)
         end
 
-        @type = if builtin_type?(type_name)
-                  create_and_configure_builtin_type(type_name,
+        @type = if builtin_type?(avro_type_name)
+                  create_and_configure_builtin_type(avro_type_name,
                                                     field: self,
                                                     cache: cache,
                                                     internal: internal,
                                                     options: type_options)
                 else
-                  cache.lookup_named_type(type_name, namespace)
+                  cache.lookup_named_type(avro_type_name, namespace)
                 end
 
         # DSL calls must be evaluated after the type has been constructed
@@ -66,9 +64,7 @@ module Avro
       # and return the namespace value from the enclosing record.
       def namespace(value = nil)
         if value
-          raise UnsupportedBlockAttributeError.new(attribute: :namespace,
-                                                   field: @name,
-                                                   type: type.type_name)
+          type.namespace(value)
         else
           record.namespace
         end
@@ -77,9 +73,7 @@ module Avro
       # Delegate setting name explicitly via DSL to type
       def name(value = nil)
         if value
-          raise UnsupportedBlockAttributeError.new(attribute: :name,
-                                                   field: @name,
-                                                   type: type.type_name)
+          type.name(value)
         else
           # Return the name of the field
           @name

data/lib/avro/builder/fixed.rb

@@ -0,0 +1,8 @@
+module Avro
+  module Builder
+
+    class Fixed < Avro::Builder::Types::FixedType
+      include Avro::Builder::Types::TopLevel
+    end
+  end
+end

data/lib/avro/builder/record.rb

@@ -0,0 +1,8 @@
+module Avro
+  module Builder
+
+    class Record < Avro::Builder::Types::RecordType
+      include Avro::Builder::Types::TopLevel
+    end
+  end
+end

data/lib/avro/builder/type_factory.rb

@@ -4,40 +4,43 @@ module Avro
     # This concern is used by classes that create new Type instances.
     module TypeFactory
 
-      COMPLEX_TYPES = Set.new(%w(array enum fixed map record union).map(&:freeze)).freeze
+      NAMED_TYPES = %w(enum fixed record).map(&:freeze).to_set.freeze
+      COMPLEX_TYPES = %w(array enum fixed map record union).map(&:freeze).to_set.freeze
       BUILTIN_TYPES = Avro::Schema::PRIMITIVE_TYPES.union(COMPLEX_TYPES).freeze
 
       private
 
       # Return a new Type instance
-      def create_builtin_type(type_name, field:, cache:)
-        name = type_name.to_s.downcase
+      def create_builtin_type(avro_type_name, field:, cache:)
+        name = avro_type_name.to_s.downcase
         if Avro::Schema::PRIMITIVE_TYPES.include?(name)
           Avro::Builder::Types::Type.new(name, field: field, cache: cache)
+        elsif field.nil? && NAMED_TYPES.include?(name)
+          Avro::Builder.const_get(name.capitalize).new(cache: cache)
         elsif COMPLEX_TYPES.include?(name)
           Avro::Builder::Types.const_get("#{name.capitalize}Type").new(field: field, cache: cache)
         else
-          raise "Invalid builtin type: #{type_name}"
+          raise "Invalid builtin type: #{avro_type_name}"
         end
       end
 
       # Return a new Type instance, including propagating internal state
       # and setting attributes via the DSL
-      def create_and_configure_builtin_type(type_name,
+      def create_and_configure_builtin_type(avro_type_name,
                                             field: nil,
                                             cache: nil,
                                             internal: {},
                                             options: {},
                                             &block)
-        create_builtin_type(type_name, field: field, cache: cache).tap do |type|
+        create_builtin_type(avro_type_name, field: field, cache: cache).tap do |type|
           type.configure_options(internal.merge(options))
           type.cache!
           type.instance_eval(&block) if block_given?
         end
       end
 
-      def builtin_type?(type_name)
-        BUILTIN_TYPES.include?(type_name.to_s)
+      def builtin_type?(avro_type_name)
+        BUILTIN_TYPES.include?(avro_type_name.to_s)
       end
     end
   end

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

@@ -20,7 +20,7 @@ module Avro
 
         def serialize(referenced_state)
           {
-            type: type_name,
+            type: avro_type_name,
             items: items.serialize(referenced_state)
           }
         end

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

@@ -12,7 +12,7 @@ module Avro
 
         # Override initialize so that type name is not required
         def initialize(cache:, field: nil)
-          super(self.class.type_name, cache: cache, field: field)
+          super(self.class.avro_type_name, cache: cache, field: field)
         end
 
         def namespace
@@ -21,9 +21,9 @@ module Avro
 
         module ClassMethods
 
-          # Infer type_name based on class
-          def type_name
-            @type_name ||= name.split('::').last.sub('Type', '').downcase.to_sym
+          # Infer avro_type_name based on class
+          def avro_type_name
+            @avro_type_name ||= name.split('::').last.sub('Type', '').downcase.to_sym
           end
         end
       end

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

@@ -16,7 +16,7 @@ module Avro
 
         def serialize(referenced_state)
           {
-            type: type_name,
+            type: avro_type_name,
             values: values.serialize(referenced_state)
           }
         end

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

@@ -0,0 +1,62 @@
+module Avro
+  module Builder
+    module Types
+
+      # This concern provides error handling for attributes related to naming
+      # that are handled differently at the top-level vs inline.
+      module NamedErrorHandling
+
+        # Errors for attributes specified via block
+
+        def type_name(_value)
+          name_attribute_error!
+        end
+
+        def type_namespace(_value)
+          namespace_attribute_error!
+        end
+
+        private
+
+        # Errors for misnamed options
+
+        def name=(_value)
+          type_name_instead_of_name_error!
+        end
+
+        def namespace=(_value)
+          type_namespace_instead_of_namespace_error!
+        end
+
+        # Methods to raise errors
+
+        def specify_as_type_option_error!(name)
+          raise AttributeError
+            .new("'type_#{name}' must be specified as an option, not via a block")
+        end
+
+        def name_attribute_error!
+          specify_as_type_option_error!(:name)
+        end
+
+        def namespace_attribute_error!
+          specify_as_type_option_error!(:namespace)
+        end
+
+        def type_option_instead_of_option_error!(name)
+          raise AttributeError
+            .new("'type_#{name}' must be specified as an option instead of '#{name}'")
+        end
+
+        def type_name_instead_of_name_error!
+          type_option_instead_of_option_error!(:name)
+        end
+
+        def type_namespace_instead_of_namespace_error!
+          type_option_instead_of_option_error!(:namespace)
+        end
+
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 require 'avro/builder/types/configurable_type'
 require 'avro/builder/namespaceable'
 require 'avro/builder/aliasable'
+require 'avro/builder/types/named_error_handling'
 
 module Avro
   module Builder
@@ -14,13 +15,30 @@ module Avro
         include Avro::Builder::Types::ConfigurableType
         include Avro::Builder::Aliasable
 
-        dsl_option :namespace
-        dsl_option :name do
-          @name || "__#{name_fragment}_#{type_name}"
-        end
+        dsl_option :name, dsl_name: :type_name
+        dsl_option :namespace, dsl_name: :type_namespace
 
         dsl_attribute_alias :type_aliases, :aliases
 
+        # This module most be included after options are defined
+        include Avro::Builder::Types::NamedErrorHandling
+
+        def name(value = nil)
+          if value.nil?
+            @name || "__#{name_fragment}_#{avro_type_name}"
+          else
+            type_name_instead_of_name_error!
+          end
+        end
+
+        def namespace(value = nil)
+          if value.nil?
+            @namespace
+          else
+            type_namespace_instead_of_namespace_error!
+          end
+        end
+
         def validate!
           required_attribute_error!(:name) if field.nil? && @name.nil?
         end
@@ -43,7 +61,7 @@ module Avro
           reference_state.definition_or_reference(fullname) do
             {
               name: name,
-              type: type_name,
+              type: avro_type_name,
               namespace: namespace
             }.merge(overrides).reject { |_, v| v.nil? }
           end
@@ -55,7 +73,7 @@ module Avro
         def to_h(_reference_state, overrides: {})
           {
             name: name,
-            type: type_name,
+            type: avro_type_name,
             namespace: namespace,
             aliases: aliases
           }.merge(overrides).reject { |_, v| v.nil? }

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

@@ -11,7 +11,7 @@ module Avro
         dsl_attribute_alias :type_doc, :doc
 
         def initialize(name = nil, options: {}, cache:, field: nil, &block)
-          @type_name = :record
+          @avro_type_name = :record
           @name = name
           @cache = cache
           @field = field
@@ -25,12 +25,12 @@ module Avro
         end
 
         # Add a required field to the record
-        def required(name, type_name, options = {}, &block)
+        def required(name, avro_type_name, options = {}, &block)
           new_field = Avro::Builder::Field.new(name: name,
-                                               type_name: type_name,
+                                               avro_type_name: avro_type_name,
                                                record: self,
                                                cache: cache,
-                                               internal: { namespace: namespace },
+                                               internal: { type_namespace: namespace },
                                                options: options,
                                                &block)
           add_field(new_field)
@@ -38,12 +38,12 @@ module Avro
 
         # 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)
+        def optional(name, avro_type_name, options = {}, &block)
           new_field = Avro::Builder::Field.new(name: name,
-                                               type_name: type_name,
+                                               avro_type_name: avro_type_name,
                                                record: self,
                                                cache: cache,
-                                               internal: { namespace: namespace,
+                                               internal: { type_namespace: namespace,
                                                            optional_field: true },
                                                options: options,
                                                &block)

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

@@ -0,0 +1,66 @@
+module Avro
+  module Builder
+    module Types
+
+      # This concern is used by types that can be defined at the top-level,
+      # i.e. outside a field.
+      module TopLevel
+
+        def self.included(base)
+          base.add_option_name :_name
+        end
+
+        # Provide a way to set the name internally for a top-level type.
+        def _name=(value)
+          @name = value
+        end
+        private :_name=
+
+        # Namespace is settable as a top-level option
+        attr_writer :namespace
+
+        module TopLevelErrorHandling
+
+          # Options disallowed for top-level types.
+
+          def type_name=(_value)
+            name_attribute_error!
+          end
+
+          def type_namespace=(_value)
+            namespace_instead_of_type_namespace_error!
+          end
+
+          private
+
+          def type_aliases=(_value)
+            raise AttributeError
+              .new("'aliases' must be used instead of 'type_aliases'")
+          end
+          alias_method :type_aliases, :type_aliases=
+
+          def name_attribute_error!
+            raise AttributeError
+                    .new("name must be specified as the first argument for #{avro_type_name}")
+          end
+          alias_method :type_name_instead_of_name_error!, :name_attribute_error!
+          private :type_name_instead_of_name_error!
+
+          def namespace_attribute_error!
+            raise AttributeError
+                    .new("'namespace' must be specified as an option, not via a block")
+          end
+          alias_method :type_namespace_instead_of_namespace_error!, :namespace_attribute_error!
+          private :type_namespace_instead_of_namespace_error!
+
+          def namespace_instead_of_type_namespace_error!
+            raise AttributeError
+              .new("'namespace' must be specified as an option instead of 'type_namespace'")
+          end
+        end
+        include TopLevelErrorHandling
+      end
+
+    end
+  end
+end

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

@@ -8,16 +8,16 @@ module Avro
         include Avro::Builder::DslOptions
         include Avro::Builder::DslAttributes
 
-        attr_reader :type_name
+        attr_reader :avro_type_name
 
-        def initialize(type_name, cache:, field: nil)
-          @type_name = type_name
+        def initialize(avro_type_name, cache:, field: nil)
+          @avro_type_name = avro_type_name
           @cache = cache
           @field = field
         end
 
         def serialize(_reference_state)
-          type_name
+          avro_type_name
         end
 
         def namespace
@@ -57,7 +57,7 @@ module Avro
         private
 
         def required_attribute_error!(attribute_name)
-          raise RequiredAttributeError.new(type: type_name,
+          raise RequiredAttributeError.new(type: avro_type_name,
                                            attribute: attribute_name,
                                            field: field && field.name,
                                            name: @name)

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

@@ -8,11 +8,11 @@ module Avro
       module TypeReferencer
         include Avro::Builder::TypeFactory
 
-        def create_builtin_or_lookup_named_type(type_name)
-          if builtin_type?(type_name)
-            create_builtin_type(type_name, field: field, cache: cache)
+        def create_builtin_or_lookup_named_type(avro_type_name)
+          if builtin_type?(avro_type_name)
+            create_builtin_type(avro_type_name, field: field, cache: cache)
           else
-            cache.lookup_named_type(type_name)
+            cache.lookup_named_type(avro_type_name)
           end
         end
       end

data/lib/avro/builder/types.rb

@@ -9,3 +9,4 @@ require 'avro/builder/types/fixed_type'
 require 'avro/builder/types/array_type'
 require 'avro/builder/types/map_type'
 require 'avro/builder/types/union_type'
+require 'avro/builder/types/top_level'

data/lib/avro/builder/version.rb

@@ -1,5 +1,5 @@
 module Avro
   module Builder
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avro-builder
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Salsify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-25 00:00:00.000000000 Z
+date: 2016-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -133,6 +133,7 @@ files:
 - ".overcommit.yml"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
@@ -148,10 +149,13 @@ files:
 - lib/avro/builder/dsl.rb
 - lib/avro/builder/dsl_attributes.rb
 - lib/avro/builder/dsl_options.rb
+- lib/avro/builder/enum.rb
 - lib/avro/builder/errors.rb
 - lib/avro/builder/field.rb
 - lib/avro/builder/file_handler.rb
+- lib/avro/builder/fixed.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
@@ -161,8 +165,10 @@ files:
 - 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_error_handling.rb
 - lib/avro/builder/types/named_type.rb
 - lib/avro/builder/types/record_type.rb
+- lib/avro/builder/types/top_level.rb
 - lib/avro/builder/types/type.rb
 - lib/avro/builder/types/type_referencer.rb
 - lib/avro/builder/types/union_type.rb
@@ -187,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Ruby DSL to create Avro schemas