avromatic 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca2b490c9b6978f339e2f6ea50c5a3476796fcae
-  data.tar.gz: 083c69aace3a37ceb0cce8f4c88fc5e5ade94611
+  metadata.gz: 4d18b7d880de4f22e4615d3d547551953f24bec7
+  data.tar.gz: 8a970619e0c045513276a54544d2c3e061c20fe9
 SHA512:
-  metadata.gz: aa9927585c4e68af3905fd6b54f219bc1b4831c3f2d1b85e600fe8a44ea84367bafd248dc1e007dbdbdd45e39a6aa6b98deef727a587de13a39c48b4fe1384de
-  data.tar.gz: 46086b401b88aedc6ddef32ecd0fb946d5f8767536686cf6807d95631e9095d070b591268eccc162f87f000ca52b17327c52616f741e31dedfa40f30880a00a7
+  metadata.gz: 57486cdd4f3828110aaba56755cf9e75f69c4f3fcfc409f139e2d8e4fc8153e68950b8e98bc2dcc32f0d81a3f42e23d985712235bc4e30cf95f2d20c7a18814a
+  data.tar.gz: a50d377790330e4196597ca6163d4f0f953e686a910b2dd5a58bb2878f88d5eca9dad23e674251677810e9bc0bdb45d2416862b1d05a1a2f104c6d7f70379b7b

data/.overcommit.yml

@@ -0,0 +1,14 @@
+PreCommit:
+  RuboCop:
+    enabled: true
+    required: false
+    on_warn: fail
+
+  HardTabs:
+    enabled: true
+    required: false
+
+CommitMsg:
+  TrailingPeriod:
+    enabled: false
+

data/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_gem:
+  salsify_rubocop: conf/rubocop.yml
+
+Performance/RedundantMerge:
+  MaxKeyValuePairs: 1
+
+Style/RaiseArgs:
+  EnforcedStyle: compact

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # avromatic changelog
 
+## v0.5.0
+- Rename `Avromatic::Model::Decoder` to `MessageDecoder`.
+- Rename `.deserialize` on generated models to `.avro_message_decode`.
+- Add `#avro_raw_key`, `#avro_raw_value` and `.avro_raw_decode` methods to
+  generated models to support encoding and decoding without a schema registry.
+
 ## v0.4.0
 - Allow the specification of a custom type, including conversion to/from Avro,
   for named types.

data/README.md

@@ -29,28 +29,39 @@ Or install it yourself as:
 
 `Avromatic` supports the following configuration:
 
-* schema_registry: An `AvroTurf::SchemaRegistry` object used to store Avro schemas 
-  so that they can be referenced by id. Either `schema_registry` or 
-  `registry_url` must be configured. See [Confluent Schema Registry](http://docs.confluent.io/2.0.1/schema-registry/docs/intro.html).
-* registry_url: URL for the schema registry. The schema registry is used to store
-  Avro schemas so that they can be referenced by id.  Either `schema_registry` or 
-  `registry_url` must be configured.
-* schema_store: The schema store is used to load Avro schemas from the filesystem.
+#### Model Generation
+
+* **schema_store**: A schema store is required to load Avro schemas from the filesystem.
   It should be an object that responds to `find(name, namespace = nil)` and
   returns an `Avro::Schema` object. An `AvroTurf::SchemaStore` can be used.
-* messaging: An `AvroTurf::Messaging` object to be shared by all generated models.
+  The `schema_store` is unnecessary if models are generated directly from 
+  `Avro::Schema` objects. See [Models](#models).
+  
+#### Using a Schema Registry/Messaging API
+ 
+The configuration options below are required when using a schema registry 
+(see [Confluent Schema Registry](http://docs.confluent.io/2.0.1/schema-registry/docs/intro.html))
+and the [Messaging API](#messaging-api).
+  
+* **schema_registry**: An `AvroTurf::SchemaRegistry` object used to store Avro schemas 
+  so that they can be referenced by id. Either `schema_registry` or 
+  `registry_url` must be configured.
+* **registry_url**: URL for the schema registry. Either `schema_registry` or 
+  `registry_url` must be configured.
+* **messaging**: An `AvroTurf::Messaging` object to be shared by all generated models.
   The `build_messaging!` method may be used to create a `Messaging` instance based
   on the other configuration values.
-* logger: The logger to use for the schema registry client.
+* **logger**: The logger to use for the schema registry client.
 * [Custom Types](#custom-types)
 
-Example:
+Example using a schema registry:
 
 ```ruby
 Avromatic.configure do |config|
   config.schema_store = AvroTurf::SchemaStore.new(path: 'avro/schemas')
   config.registry_url = Rails.configuration.x.avro_schema_registry_url
   config.build_messaging!
+end
 ```
 
 ### Models
@@ -136,51 +147,95 @@ inbound or outbound value is nil.
 If a custom type is registered for a record-type field, then any `to_avro` 
 method/Proc should return a Hash with string keys for encoding using Avro.
 
-#### Encode/Decode
+### Encoding and Decoding
+
+`Avromatic` provides two different interfaces for encoding the key (optional)
+and value associated with a model.
+
+#### Manually Managed Schemas
+
+The attributes for the value schema used to define a model can be encoded using:
+
+```ruby
+encoded_value = model.avro_raw_value
+```
+
+In order to decode this data, a copy of the value schema is required.
+
+If a model also has an Avro schema for a key, then the key attributes can be
+encoded using:
+
+```ruby
+encoded_key = model.avro_raw_key
+```
+
+If attributes were encoded using the same schema(s) used to define a model, then
+the data can be decoded to create a new model instance:
+
+```ruby
+MyModel.avro_raw_decode(key: encoded_key, value: encoded_value)
+```
+
+If the attributes where encoded using a different version of the model's schemas,
+then a new model instance can be created by also providing the schemas used to 
+encode the data:
+
+```ruby
+MyModel.avro_raw_decode(key: encoded_key,
+                        key_schema: writers_key_schema,
+                        value: encoded_value,
+                        value_schema: writers_value_schema)
+```
+
+#### Messaging API
+
+The other interface for encoding and decoding attributes uses the
+`AvroTurf::Messaging` API. This interface leverages a schema registry and
+prefixes the encoded data with an id to identify the schema. In this approach,
+a schema registry is used to ensure that the correct schemas are available during
+decoding.
 
-Models can be encoded using Avro leveraging a schema registry to encode a schema
-id at the beginning of the value.
+The attributes for the value schema can be encoded with a schema id prefix using:
 
 ```ruby
-model.avro_message_value
+message_value = model.avro_message_value
 ```
 
-If a model has an Avro schema for a key, then the key can also be encoded
-prefixed with a schema id.
+If a model has an Avro schema for a key, then those attributes can also be encoded
+prefixed with a schema id:
 
 ```ruby
-model.avro_message_key
+message_key = model.avro_message_key
 ```
 
-A model instance can be created from an Avro-encoded value and an Avro-encoded
-optional key:
+A model instance can be created from a key and value encoded in this manner:
 
 ```ruby
-MyTopic.deserialize(message_key, message_value)
+MyTopic.avro_message_decode(message_key, message_value)
 ```
 
 Or just a value if only one schema is used:
 
 ```ruby
-MyValue.deserialize(message_value)
+MyValue.avro_message_decode(message_value)
 ```
 
-#### Decoder
+#### Avromatric::Model::MessageDecoder
 
-A stream of messages encoded from various models can be deserialized using
-`Avromatic::Model::Decoder`. The decoder must be initialized with the list
-of models to decode:
+A stream of messages encoded from various models using the messaging approach
+can be decoded using `Avromatic::Model::MessageDecoder`. The decoder must be 
+initialized with the list of models to decode:
 
 ```ruby
-decoder = Avromatic::Model::Decoder.new(MyModel1, MyModel2)
+decoder = Avromatic::Model::MessageDecoder.new(MyModel1, MyModel2)
 
-decoder.decode(model1_key, model1_value)
+decoder.decode(model1_messge_key, model1_message_value)
 # => instance of MyModel1
-decoder.decode(model2_value)
+decoder.decode(model2_message_value)
 # => instance of MyModel2
 ```
 
-#### Validations
+### Validations
 
 The following validations are supported:
 
@@ -188,7 +243,7 @@ The following validations are supported:
 - The value for an enum type field is in the declared set of values.
 - Presence of a value for required fields.
 
-#### Unsupported/Future
+### Unsupported/Future
 
 The following types/features are not supported for generated models:
 

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "avro/builder"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'avro/builder'
 
 RSpec::Core::RakeTask.new(:spec)
 
@@ -19,4 +19,4 @@ namespace :avro do
   end
 end
 
-task :default => :spec
+task default: :spec

data/avromatic.gemspec

@@ -4,33 +4,35 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'avromatic/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "avromatic"
+  spec.name          = 'avromatic'
   spec.version       = Avromatic::VERSION
-  spec.authors       = ["Salsify Engineering"]
-  spec.email         = ["engineering@salsify.com"]
+  spec.authors       = ['Salsify Engineering']
+  spec.email         = ['engineering@salsify.com']
 
-  spec.summary       = %q{Generate Ruby models from Avro schemas}
+  spec.summary       = 'Generate Ruby models from Avro schemas'
   spec.description   = spec.summary
-  spec.homepage      = "https://github.com/salsify/avromatic.git"
-  spec.license       = "MIT"
+  spec.homepage      = 'https://github.com/salsify/avromatic.git'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency "avro", ">= 1.7.7"
-  spec.add_runtime_dependency "virtus"
-  spec.add_runtime_dependency "activesupport"
-  spec.add_runtime_dependency "activemodel"
-  spec.add_runtime_dependency "avro_turf"
+  spec.add_runtime_dependency 'avro', '>= 1.7.7'
+  spec.add_runtime_dependency 'virtus'
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'activemodel'
+  spec.add_runtime_dependency 'avro_turf'
 
-  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 "simplecov"
-  spec.add_development_dependency "webmock"
-  spec.add_development_dependency "avro-builder", ">= 0.3.2"
+  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 'simplecov'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'avro-builder', '>= 0.3.2'
   # For FakeSchemaRegistryServer
-  spec.add_development_dependency "sinatra"
+  spec.add_development_dependency 'sinatra'
+  spec.add_development_dependency 'salsify_rubocop', '~> 0.40.0'
+  spec.add_development_dependency 'overcommit'
 end

data/lib/avromatic/model/attributes.rb

@@ -30,15 +30,17 @@ module Avromatic
         private
 
         def check_for_field_conflicts!
-          (key_avro_field_names & value_avro_field_names).each_with_object([]) do |name, conflicts|
-              if schema_fields_differ?(name)
-                conflicts << "Field '#{name}' has a different type in each schema: "\
-                             "value #{value_avro_fields_by_name[name]}, "\
-                             "key #{key_avro_fields_by_name[name]}"
-              end
-          end.tap do |conflicts|
-            raise conflicts.join("\n") if conflicts.any?
-          end
+          conflicts =
+            (key_avro_field_names & value_avro_field_names).each_with_object([]) do |name, msgs|
+              next unless schema_fields_differ?(name)
+              msgs << "Field '#{name}' has a different type in each schema: "\
+                      "value #{value_avro_fields_by_name[name]}, "\
+                      "key #{key_avro_fields_by_name[name]}"
+            end
+
+          raise conflicts.join("\n") if conflicts.any?
+
+          conflicts
         end
 
         # The Avro::Schema::Field#== method is lame. It just compares

data/lib/avromatic/model/builder.rb

@@ -5,7 +5,8 @@ require 'avromatic/model/configuration'
 require 'avromatic/model/value_object'
 require 'avromatic/model/configurable'
 require 'avromatic/model/attributes'
-require 'avromatic/model/serialization'
+require 'avromatic/model/raw_serialization'
+require 'avromatic/model/messaging_serialization'
 
 module Avromatic
   module Model
@@ -41,7 +42,8 @@ module Avromatic
           Avromatic::Model::Configurable,
           Avromatic::Model::Attributes,
           Avromatic::Model::ValueObject,
-          Avromatic::Model::Serialization
+          Avromatic::Model::RawSerialization,
+          Avromatic::Model::MessagingSerialization
         ]
       end
 

data/lib/avromatic/model/{decoder.rb → message_decoder.rb}

@@ -3,9 +3,10 @@ require 'avro_turf/schema_registry'
 module Avromatic
   module Model
 
-    # This class is used to decode Avro messages to their corresponding models.
-    class Decoder
-      MAGIC_BYTE = [0].pack("C").freeze
+    # This class is used to decode messages encoded using Avro to their
+    # corresponding models.
+    class MessageDecoder
+      MAGIC_BYTE = [0].pack('C').freeze
 
       class UnexpectedKeyError < StandardError
         def initialize(schema_key)
@@ -13,16 +14,16 @@ module Avromatic
         end
       end
 
-       class MagicByteError < StandardError
-         def initialize(magic_byte)
-           super("Expected data to begin with a magic byte, got '#{magic_byte}'")
-         end
-       end
+      class MagicByteError < StandardError
+        def initialize(magic_byte)
+          super("Expected data to begin with a magic byte, got '#{magic_byte}'")
+        end
+      end
 
       class DuplicateKeyError < StandardError
         def initialize(*models)
           super("Multiple models #{models} have the same key "\
-                "'#{Avromatic::Model::Decoder.model_key(models.first)}'")
+                "'#{Avromatic::Model::MessageDecoder.model_key(models.first)}'")
         end
       end
 
@@ -63,7 +64,7 @@ module Avromatic
 
       def deserialize(model_key, message_key, message_value)
         raise UnexpectedKeyError.new(model_key) unless model_map.key?(model_key)
-        model_map[model_key].deserialize(message_key, message_value)
+        model_map[model_key].avro_message_decode(message_key, message_value)
       end
 
       def schema_name_for_data(data)

data/lib/avromatic/model/messaging_serialization.rb

@@ -0,0 +1,62 @@
+require 'avro_turf/messaging'
+
+module Avromatic
+  module Model
+
+    # This concern adds support for serialization based on AvroTurf::Messaging.
+    # This serialization leverages a schema registry to prefix encoded values
+    # with an id for the schema.
+    module MessagingSerialization
+      extend ActiveSupport::Concern
+
+      delegate :avro_messaging, to: :class
+      private :avro_messaging
+
+      module Encode
+        def avro_message_value
+          avro_messaging.encode(
+            value_attributes_for_avro,
+            schema_name: value_avro_schema.fullname
+          )
+        end
+
+        def avro_message_key
+          raise 'Model has no key schema' unless key_avro_schema
+          avro_messaging.encode(
+            key_attributes_for_avro,
+            schema_name: key_avro_schema.fullname
+          )
+        end
+      end
+      include Encode
+
+      # This module provides methods to decode an Avro-encoded value and
+      # an optional Avro-encoded key as a new model instance.
+      module Decode
+
+        # If two arguments are specified then the first is interpreted as the
+        # message key and the second is the message value. If there is only one
+        # arg then it is used as the message value.
+        def avro_message_decode(*args)
+          message_key, message_value = args.size > 1 ? args : [nil, args.first]
+          key_attributes = message_key &&
+            avro_messaging.decode(message_key, schema_name: key_avro_schema.fullname)
+          value_attributes = avro_messaging
+            .decode(message_value, schema_name: avro_schema.fullname)
+
+          new(value_attributes.merge!(key_attributes || {}))
+        end
+      end
+
+      module ClassMethods
+        # The messaging object acts as an intermediary talking to the schema
+        # registry and using returned/specified schemas to decode/encode.
+        def avro_messaging
+          Avromatic.messaging
+        end
+
+        include Decode
+      end
+    end
+  end
+end

data/lib/avromatic/model/raw_serialization.rb

@@ -0,0 +1,111 @@
+require 'avromatic/model/passthrough_serializer'
+
+module Avromatic
+  module Model
+
+    # This module provides serialization support for encoding directly to Avro
+    # without dependency on a schema registry.
+    module RawSerialization
+      extend ActiveSupport::Concern
+
+      module Encode
+        delegate :avro_serializer, :datum_writer, :datum_reader, to: :class
+        private :avro_serializer, :datum_writer, :datum_reader
+
+        def avro_raw_value
+          avro_raw_encode(value_attributes_for_avro, :value)
+        end
+
+        def avro_raw_key
+          raise 'Model has no key schema' unless key_avro_schema
+          avro_raw_encode(key_attributes_for_avro, :key)
+        end
+
+        protected
+
+        def value_attributes_for_avro
+          avro_hash(value_avro_field_names)
+        end
+
+        private
+
+        def key_attributes_for_avro
+          avro_hash(key_avro_field_names)
+        end
+
+        def avro_hash(fields)
+          attributes.slice(*fields).each_with_object(Hash.new) do |(key, value), result|
+            result[key.to_s] = if value.is_a?(Avromatic::Model::Attributes)
+                                 value.value_attributes_for_avro
+                               else
+                                 avro_serializer[key].call(value)
+                               end
+          end
+        end
+
+        def avro_raw_encode(data, key_or_value = :value)
+          stream = StringIO.new
+          encoder = Avro::IO::BinaryEncoder.new(stream)
+          datum_writer[key_or_value].write(data, encoder)
+          stream.string
+        end
+      end
+      include Encode
+
+      module Decode
+
+        # Create a new instance based on an encoded value and optional encoded key.
+        # If supplied then the key_schema and value_schema are used as the writer's
+        # schema for the corresponding value. The model's schemas are always used
+        # as the reader's schemas.
+        def avro_raw_decode(key: nil, value:, key_schema: nil, value_schema: nil)
+          key_attributes = key && decode_avro_datum(key, key_schema, :key)
+          value_attributes = decode_avro_datum(value, value_schema, :value)
+
+          new(value_attributes.merge!(key_attributes || {}))
+        end
+
+        private
+
+        def decode_avro_datum(data, schema = nil, key_or_value = :value)
+          stream = StringIO.new(data)
+          decoder = Avro::IO::BinaryDecoder.new(stream)
+          reader = schema ? custom_datum_reader(schema, key_or_value) : datum_reader[key_or_value]
+          reader.read(decoder)
+        end
+
+        def custom_datum_reader(schema, key_or_value)
+          Avro::IO::DatumReader.new(schema, send("#{key_or_value}_avro_schema"))
+        end
+      end
+
+      module ClassMethods
+
+        # Store a hash of Procs by field name (as a symbol) to convert
+        # the value before Avro serialization.
+        # Returns the default PassthroughSerializer if a key is not present.
+        def avro_serializer
+          @avro_serializer ||= Hash.new(PassthroughSerializer)
+        end
+
+        def datum_writer
+          @datum_writer ||= begin
+                              hash = { value: Avro::IO::DatumWriter.new(value_avro_schema) }
+                              hash[:key] = Avro::IO::DatumWriter.new(key_avro_schema) if key_avro_schema
+                              hash
+                            end
+        end
+
+        def datum_reader
+          @datum_reader ||= begin
+            hash = { value: Avro::IO::DatumReader.new(value_avro_schema) }
+            hash[:key] = Avro::IO::DatumReader.new(key_avro_schema) if key_avro_schema
+            hash
+          end
+        end
+
+        include Decode
+      end
+    end
+  end
+end

data/lib/avromatic/model/value_object.rb

@@ -14,11 +14,11 @@ module Avromatic
       end
 
       def inspect
-        "#<#{self.class.name} #{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ') }>"
+        "#<#{self.class.name} #{attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
       end
 
       def to_s
-        "#<%s:0x00%x>" % [self.class.name, object_id.abs * 2]
+        format('#<%s:0x00%x>', self.class.name, object_id.abs * 2)
       end
     end
   end

data/lib/avromatic/model.rb

@@ -1,5 +1,5 @@
 require 'avromatic/model/builder'
-require 'avromatic/model/decoder'
+require 'avromatic/model/message_decoder'
 require 'avromatic/model/type_registry'
 
 module Avromatic

data/lib/avromatic/version.rb

@@ -1,3 +1,3 @@
 module Avromatic
-  VERSION = "0.4.0"
+  VERSION = '0.5.0'.freeze
 end

data/lib/avromatic.rb

@@ -21,7 +21,8 @@ module Avromatic
   def self.build_schema_registry
     raise 'Avromatic must be configured with a registry_url' unless registry_url
     AvroTurf::CachedSchemaRegistry.new(
-      AvroTurf::SchemaRegistry.new(registry_url, logger: logger))
+      AvroTurf::SchemaRegistry.new(registry_url, logger: logger)
+    )
   end
 
   def self.build_messaging
@@ -29,7 +30,8 @@ module Avromatic
     AvroTurf::Messaging.new(
       registry: schema_registry || build_schema_registry,
       schema_store: schema_store,
-      logger: logger)
+      logger: logger
+    )
   end
 
   def self.build_messaging!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avromatic
 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-17 00:00:00.000000000 Z
+date: 2016-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: avro
@@ -178,6 +178,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: salsify_rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.40.0
+- !ruby/object:Gem::Dependency
+  name: overcommit
+  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: Generate Ruby models from Avro schemas
 email:
 - engineering@salsify.com
@@ -186,7 +214,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".overcommit.yml"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
@@ -203,10 +233,11 @@ files:
 - lib/avromatic/model/configurable.rb
 - lib/avromatic/model/configuration.rb
 - lib/avromatic/model/custom_type.rb
-- lib/avromatic/model/decoder.rb
+- lib/avromatic/model/message_decoder.rb
+- lib/avromatic/model/messaging_serialization.rb
 - lib/avromatic/model/null_custom_type.rb
 - lib/avromatic/model/passthrough_serializer.rb
-- lib/avromatic/model/serialization.rb
+- lib/avromatic/model/raw_serialization.rb
 - lib/avromatic/model/type_registry.rb
 - lib/avromatic/model/value_object.rb
 - lib/avromatic/railtie.rb

data/lib/avromatic/model/serialization.rb

@@ -1,86 +0,0 @@
-require 'avro_turf/messaging'
-require 'avromatic/model/passthrough_serializer'
-
-module Avromatic
-  module Model
-
-    # This concern adds support for serialization to a model
-    # generated from Avro schema(s).
-    module Serialization
-      extend ActiveSupport::Concern
-
-      delegate :messaging, to: :Avromatic
-
-      module Encode
-        def avro_message_value
-          messaging.encode(
-            value_attributes_for_avro,
-            schema_name: value_avro_schema.fullname)
-        end
-
-        def avro_message_key
-          raise 'Model has no key schema' unless key_avro_schema
-          messaging.encode(
-            key_attributes_for_avro,
-            schema_name: key_avro_schema.fullname)
-        end
-
-        protected
-
-        def value_attributes_for_avro
-          avro_hash(value_avro_field_names)
-        end
-
-        private
-
-        delegate :avro_serializer, to: :class
-
-        def key_attributes_for_avro
-          avro_hash(key_avro_field_names)
-        end
-
-        def avro_hash(fields)
-          attributes.slice(*fields).each_with_object(Hash.new) do |(key, value), result|
-            result[key.to_s] = if value.is_a?(Avromatic::Model::Attributes)
-                                 value.value_attributes_for_avro
-                               else
-                                 avro_serializer[key].call(value)
-                               end
-          end
-        end
-      end
-      include Encode
-
-      # This module provides methods to deserialize an Avro-encoded value and
-      # an optional Avro-encoded key as a new model instance.
-      module Decode
-
-        # If two arguments are specified then the first is interpreted as the
-        # message key and the second is the message value. If there is only one
-        # arg then it is used as the message value.
-        def deserialize(*args)
-          message_key, message_value = args.size > 1 ? args : [nil, args.first]
-          key_attributes = message_key && messaging.decode(message_key, schema_name: key_avro_schema.fullname)
-          value_attributes = messaging.decode(message_value, schema_name: avro_schema.fullname)
-
-          new(value_attributes.merge!(key_attributes || {}))
-        end
-      end
-
-      module ClassMethods
-        # The messaging object acts as an intermediary talking to the schema
-        # registry and using returned/specified schemas to decode/encode.
-        delegate :messaging, to: :Avromatic
-
-        include Decode
-
-        # Store a hash of Procs by field name (as a symbol) to convert
-        # the value before Avro serialization.
-        # Returns the default PassthroughSerializer if a key is not present.
-        def avro_serializer
-          @avro_serializer ||= Hash.new(PassthroughSerializer)
-        end
-      end
-    end
-  end
-end