Class: Avro::Builder::Field

Inherits:
Object
  • Object
show all
Includes:
Aliasable, AnonymousTypes, DslAttributes, DslOptions
Defined in:
lib/avro/builder/field.rb

Overview

This class represents a field in a record. A field must be initialized with a type.

Constant Summary collapse

INTERNAL_ATTRIBUTES =
i(optional_field).to_set.freeze

Constants included from TypeFactory

TypeFactory::BUILTIN_TYPES, TypeFactory::COMPLEX_TYPES, TypeFactory::NAMED_TYPES

Instance Method Summary collapse

Methods included from AnonymousTypes

#array, #map, #type, #union

Methods included from Aliasable

included

Methods included from DslAttributes

#dsl_attribute?, included

Methods included from DslOptions

#dsl_option?, included

Constructor Details

#initialize(name:, avro_type_or_name:, record:, cache:, internal: {}, options: {}, &block) ⇒ Field


20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# File 'lib/avro/builder/field.rb', line 20

def initialize(name:, avro_type_or_name:, record:, cache:, internal: {}, options: {}, &block)
  @cache = cache
  @record = record
  @name = name.to_s

  internal.each do |key, value|
    send("#{key}=", value) if INTERNAL_ATTRIBUTES.include?(key)
  end

  type_options = options.dup
  options.keys.each do |key|
    send(key, type_options.delete(key)) if dsl_attribute?(key)
  end

  # Find existing Type or build a new instance of a builtin Type using
  # the supplied block
  @field_type = type_lookup(avro_type_or_name, namespace) do |avro_type_name|
    create_and_configure_builtin_type(avro_type_name,
                                      field: self,
                                      cache: cache,
                                      internal: internal,
                                      validate_type: false,
                                      options: type_options)
  end

  # DSL calls must be evaluated after the type has been constructed
  instance_eval(&block) if block_given?
  @field_type.validate!
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(id, *args, &block) ⇒ Object


56
57
58
# File 'lib/avro/builder/field.rb', line 56

def method_missing(id, *args, &block)
  field_type.dsl_respond_to?(id) ? field_type.send(id, *args, &block) : super
end

Instance Method Details

#name(value = nil) ⇒ Object

Delegate setting name explicitly via DSL to type


75
76
77
78
79
80
81
82
# File 'lib/avro/builder/field.rb', line 75

def name(value = nil)
  if value
    field_type.name(value)
  else
    # Return the name of the field
    @name
  end
end

#name_fragmentObject


60
61
62
# File 'lib/avro/builder/field.rb', line 60

def name_fragment
  record.name_fragment
end

#namespace(value = nil) ⇒ Object

Delegate setting namespace explicitly via DSL to type and return the namespace value from the enclosing record.


66
67
68
69
70
71
72
# File 'lib/avro/builder/field.rb', line 66

def namespace(value = nil)
  if value
    field_type.namespace(value)
  else
    record.namespace
  end
end

#respond_to_missing?(id, _include_all) ⇒ Boolean

Delegate additional DSL calls to the type


52
53
54
# File 'lib/avro/builder/field.rb', line 52

def respond_to_missing?(id, _include_all)
  field_type.dsl_respond_to?(id) || super
end

#serialize(reference_state) ⇒ Object


84
85
86
87
88
89
90
91
92
93
94
95
# File 'lib/avro/builder/field.rb', line 84

def serialize(reference_state)
  # TODO: order is not included here
  {
    name: name,
    type: serialized_type(reference_state),
    doc: doc,
    default: default,
    aliases: aliases
  }.reject { |_, v| v.nil? }.tap do |result|
    result.merge!(default: nil) if optional_field
  end
end