Implement setters and getters

examples/usual/example1/season.rb

@@ -7,11 +7,22 @@ class Season < Datory::Base
  # uuid! :serialId, to: :serial_id
 
  integer! :number
+ string! :code
 
  # many! :episodes, include: Episode
 
  date! :premieredOn, to: :premiered_on
  date? :endedOn, to: :ended_on
+
+ # deserialize
+ getter :code do |attributes:|
+ "s#{attributes.fetch(:number)}"
+ end
+
+ # serialize
+ setter :code do |attributes:|
+ "s#{attributes.fetch(:number)}"
+ end
  end
  end
 end

examples/usual/example2/product.rb

@@ -6,13 +6,24 @@ class Product < Datory::Base
  uuid! :id
 
  string! :title
+ string! :formattedTitle, to: :formatted_title
 
  money! :price
  money? :discount
 
  integer! :quantity, min: 1, max: 10
 
  duration? :installmentDuration, to: :installment_duration
+
+ # deserialize
+ getter :formattedTitle do |attributes:|
+ "The New #{attributes.fetch(:title)} (from getter)"
+ end
+
+ # serialize
+ setter :formatted_title do |attributes:|
+ "The New #{attributes.fetch(:title)} (from setter)"
+ end
  end
  end
 end

examples/usual/example3/language.rb

@@ -6,6 +6,7 @@ class Language < Datory::Base
  uuid! :id
 
  string! :name
+ string? :fullName, to: :full_name
 
  # TODO: Need to prepare this example:
  # {
@@ -32,6 +33,21 @@ class Language < Datory::Base
  one? :lastEOLVersion, to: :last_eol, include: Version
 
  many? :previousVersions, to: :previous, include: Version
+
+ # deserialize
+ getter :fullName do |**|
+ nil
+ end
+
+ # serialize
+ setter :full_name do |attributes:|
+ language_name = attributes.fetch(:name)
+ current_version_name = attributes.dig(:current, :name)
+
+ next language_name if current_version_name.blank?
+
+ "#{language_name} (#{current_version_name})"
+ end
  end
  end
 end

lib/datory/attributes/collection.rb

@@ -18,6 +18,10 @@ def internal_names
  map { |attribute| attribute.to.name }
  end
 
+ def external_names
+ map { |attribute| attribute.from.name }
+ end
+
  def include_class_exist?
  @include_class_exist ||= filter do |attribute| # rubocop:disable Performance/Count
  include_class = attribute.to.include_class

lib/datory/attributes/descriptor.rb

@@ -26,7 +26,10 @@ def describe(service_class_name:, collection_of_attributes:) # rubocop:disable M
  row << attribute.from.type
  row << attribute.to.name
  row << attribute.to.type
- row << (include_class if include_class <= Datory::Base) if collection_of_attributes.include_class_exist?
+
+ if collection_of_attributes.include_class_exist? && !include_class.nil?
+ row << (include_class if include_class.respond_to?(:<=) && include_class <= Datory::Base)
+ end
 
  rows << row
  end

lib/datory/attributes/serialization/model.rb

@@ -12,9 +12,9 @@ def self.to_hash(...)
  new.to_hash(...)
  end
 
- def prepare(data)
+ def prepare(data, collection_of_attributes)
  if data.is_a?(Hash)
- build(data.deep_dup)
+ build(collection_of_attributes, data.deep_dup)
  else
  data
  end
@@ -28,17 +28,34 @@ def to_hash(data)
  end
  end
 
- def build(attributes = {}) # rubocop:disable Metrics/MethodLength
- attributes.each do |key, value|
+ private
+
+ def define_setter(key, value)
+ self.class.send(:attr_accessor, key)
+
+ instance_variable_set(:"@#{key}", value)
+
+ self
+ end
+
+ def build(collection_of_attributes, attributes = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+ additional_attributes = collection_of_attributes.internal_names.difference(attributes.keys).to_h do |key|
+ [key, nil]
+ end
+
+ attributes.merge(additional_attributes).each do |key, value|
  self.class.send(:attr_accessor, key)
 
  instance_variable_set(:"@#{key}", value)
 
  if value.is_a?(Array)
- value.map! { |item| Datory::Attributes::Serialization::Model.prepare(item) }
+ value.map! { |item| Datory::Attributes::Serialization::Model.prepare(item, collection_of_attributes) }
  instance_variable_set(:"@#{key}", value)
  elsif value.is_a?(Hash)
- instance_variable_set(:"@#{key}", Datory::Attributes::Serialization::Model.prepare(value))
+ instance_variable_set(
+ :"@#{key}",
+ Datory::Attributes::Serialization::Model.prepare(value, collection_of_attributes)
+ )
  else
  instance_variable_set(:"@#{key}", value)
  end

lib/datory/attributes/workspace.rb

@@ -5,7 +5,7 @@ module Attributes
  module Workspace
  private
 
- def serialize(model:, collection_of_attributes:)
+ def serialize(model:, collection_of_attributes:, **)
  super
 
  return nil if model.nil? # NOTE: When `one` is optional and not passed
@@ -18,7 +18,7 @@ def serialize(model:, collection_of_attributes:)
  )
  end
 
- def deserialize(incoming_attributes:, collection_of_attributes:)
+ def deserialize(incoming_attributes:, collection_of_attributes:, **)
  super
 
  Deserialization::ServiceBuilder.build!(self, incoming_attributes, collection_of_attributes)

lib/datory/base.rb

@@ -4,6 +4,8 @@ module Datory
  class Base
  include Info::DSL
  include Context::DSL
+ include Getters::DSL
+ include Setters::DSL
  include Attributes::DSL
  end
 end

lib/datory/context/callable.rb

@@ -14,7 +14,7 @@ def serialize(model) # rubocop:disable Metrics/MethodLength
  end
  else
  context = send(:new, _datory_to_model: false)
- model = Datory::Attributes::Serialization::Model.prepare(model)
+ model = Datory::Attributes::Serialization::Model.prepare(model, collection_of_attributes)
  _serialize(context, model)
  end
  rescue Datory::Service::Exceptions::Input,
@@ -23,7 +23,7 @@ def serialize(model) # rubocop:disable Metrics/MethodLength
  raise Datory::Exceptions::SerializationError.new(message: e.message)
  end
 
- def deserialize(data) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+ def deserialize(data) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
  prepared_data =
  if data.is_a?(Datory::Base)
  Datory::Attributes::Serialization::Model.to_hash(data)
@@ -40,6 +40,13 @@ def deserialize(data) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
  else
  context = send(:new, _datory_to_model: false)
 
+ additional_attributes =
+ collection_of_attributes.external_names.difference(prepared_data.symbolize_keys.keys).to_h do |key|
+ [key, nil]
+ end
+
+ prepared_data = prepared_data.merge(additional_attributes)
+
  _deserialize(context, **prepared_data)
  end
  rescue Datory::Service::Exceptions::Input,
@@ -96,15 +103,17 @@ def _serialize(context, model)
  context.send(
  :_serialize,
  model: model,
- collection_of_attributes: collection_of_attributes
+ collection_of_attributes: collection_of_attributes,
+ collection_of_setters: collection_of_setters
  )
  end
 
  def _deserialize(context, **attributes)
  context.send(
  :_deserialize,
  incoming_attributes: attributes.symbolize_keys,
- collection_of_attributes: collection_of_attributes
+ collection_of_attributes: collection_of_attributes,
+ collection_of_getters: collection_of_getters
  )
  end
 

lib/datory/context/workspace.rb

@@ -5,6 +5,14 @@ module Context
  module Workspace
  private
 
+ def define_setter(key, value)
+ self.class.send(:attr_accessor, key)
+
+ instance_variable_set(:"@#{key}", value)
+
+ self
+ end
+
  def merge!(attributes)
  attributes.each do |key, value|
  instance_variable_set(:"@#{key}", value)
@@ -19,17 +27,19 @@ def keys
  instance_variables.map { |instance_variable| instance_variable.to_s.sub(/^@/, "").to_sym }
  end
 
- def _serialize(model:, collection_of_attributes:)
+ def _serialize(model:, collection_of_attributes:, collection_of_setters:)
  serialize(
  model: model,
- collection_of_attributes: collection_of_attributes
+ collection_of_attributes: collection_of_attributes,
+ collection_of_setters: collection_of_setters
  )
  end
 
- def _deserialize(incoming_attributes:, collection_of_attributes:)
+ def _deserialize(incoming_attributes:, collection_of_attributes:, collection_of_getters:)
  deserialize(
  incoming_attributes: incoming_attributes,
- collection_of_attributes: collection_of_attributes
+ collection_of_attributes: collection_of_attributes,
+ collection_of_getters: collection_of_getters
  )
  end
 

lib/datory/getters/collection.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datory
+ module Getters
+ class Collection
+ extend Forwardable
+ def_delegators :@collection, :<<, :each, :merge
+
+ def initialize(collection = Set.new)
+ @collection = collection
+ end
+ end
+ end
+end

lib/datory/getters/dsl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datory
+ module Getters
+ module DSL
+ def self.included(base)
+ base.extend(ClassMethods)
+ base.include(Workspace)
+ end
+
+ module ClassMethods
+ def inherited(child)
+ super
+
+ child.send(:collection_of_getters).merge(collection_of_getters)
+ end
+
+ private
+
+ def getter(name)
+ collection_of_getters << Getter.new(name, ->(attributes:) { yield(attributes: attributes) })
+ end
+
+ def collection_of_getters
+ @collection_of_getters ||= Collection.new
+ end
+ end
+ end
+ end
+end

lib/datory/getters/getter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datory
+ module Getters
+ class Getter
+ attr_reader :name, :block
+
+ def initialize(name, block)
+ @name = name
+ @block = block
+ end
+ end
+ end
+end

lib/datory/getters/workspace.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Datory
+ module Getters
+ module Workspace
+ private
+
+ def deserialize(incoming_attributes:, collection_of_attributes:, collection_of_getters:)
+ super
+
+ collection_of_getters.each do |getter|
+ incoming_attributes.merge!(getter.name => getter.block.call(attributes: incoming_attributes))
+ end
+ end
+ end
+ end
+end

lib/datory/setters/collection.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datory
+ module Setters
+ class Collection
+ extend Forwardable
+ def_delegators :@collection, :<<, :each, :merge
+
+ def initialize(collection = Set.new)
+ @collection = collection
+ end
+ end
+ end
+end

lib/datory/setters/dsl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datory
+ module Setters
+ module DSL
+ def self.included(base)
+ base.extend(ClassMethods)
+ base.include(Workspace)
+ end
+
+ module ClassMethods
+ def inherited(child)
+ super
+
+ child.send(:collection_of_setters).merge(collection_of_setters)
+ end
+
+ private
+
+ def setter(name)
+ collection_of_setters << Setter.new(name, ->(attributes:) { yield(attributes: attributes) })
+ end
+
+ def collection_of_setters
+ @collection_of_setters ||= Collection.new
+ end
+ end
+ end
+ end
+end