hashcraft 1.0.0.pre.alpha.1 → 1.0.0.pre.alpha.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dfbb2b3856098765290235f1fd1debd3fbd267cac38235e2aa2cf87fe35dac8
-  data.tar.gz: 41888aa7d9b3f977308d47039a3732d0b5d0973af8ab9bcd45f08ee986408027
+  metadata.gz: c70ff2e1bf5cecc91ae33eba7b1fb5810371ab3f67a4f077e02c0dc8a3b6fac8
+  data.tar.gz: b116b485b82e3cacc55e7a217d3682a06334a970c105eef95db01f054bf44655
 SHA512:
-  metadata.gz: de2140ec7116e7e284e11d7fe11eaa3266b91025f0e2235050492a9eef1bb35ceb88ab7557728acd808516413b25f6a85928e0190a9779a58447f2ef51f78e6f
-  data.tar.gz: 8a150eefc4294b49d65e7fc950d50a5ce01739c212863546624b3775cf00af5dd5fab320573f8f2a93e86beac53773299506d7de1f3a59affc2274bedd5ab716
+  metadata.gz: a03980f411dd97dd6744780fa01a74891f618703faaa3b06c24cd2f088ab387a4127ab17d9c9b0f02c7c746fd0701ee66743d4debee5e4c29f9c8704d03f2cca
+  data.tar.gz: e90a7ea856b01fd8298e30a2eef2c1ad81d0337c819792a0df8108145419caa1fe19502502c0a3df17f1e24b792c435b4e7983030dc61cb2d4f310cbb7a639e3

data/.gitignore

@@ -4,5 +4,4 @@
 /coverage
 Gemfile.lock
 /pkg
-
-
+/doc

data/README.md

@@ -147,7 +147,7 @@ This means there is an available method called api_url that can be called to set
 * **eager**: always assign a value.  When true it will always assign the key a value.
 * **key**: allows for aliasing keys.  If omitted, the key will be the option's method name (api_url as noted above).
 * **meta**: used to store any arbitrary data that can be accessed with transformers.
-* **mutator**: defines the type of the data backing the method, defaulting to property.  When the default property is used then it will simply assign the passed in value.  Other values are: `hash` and `array`.  When hash is used then the passed in value will be merged onto the key's value.  When array is used then the passed in value will be pushed onto the key's value.
+* **mutator**: defines the *type of update* to be made to the underlying value, defaulting to `property`.  When the default, `property`, is used then it will simply assign the passed in value.  Some other options are: `hash` and `array`.  When hash is used then the passed in value will be merged onto the key's value.  When array is used then the passed in value will be pushed onto the key's value.  For other types see the `Hashcraft::MutatorRegistry` file.
 
 ### Internationalization Support
 
@@ -155,7 +155,7 @@ There is currently no first-class support for internationalization, but you can
 
 ### Transformers
 
-Transformers are optional but come into play when you need any additional/special processing of keys and values.  By default, keys and values use the pass-thru transformer (Hashable::Transformers::PassThru) but can be explicitly passed any object that responds to `#transform(value, option)`.
+Transformers are optional but come into play when you need any additional/special processing of keys and values.  By default, keys and values use the pass-thru transformer, `Hashcraft::Transformers::PassThru`, but can be explicitly passed any object that responds to `#transform(value, option)`.
 
 #### Key Transformer Example
 
@@ -171,12 +171,35 @@ Say, for example, we wanted to transform all keys to camel case.  We could creat
   end
 ````
 
-We can then use this when deriving hashes (using the above Grid example):
+We can then use this when deriving hashes (building on the Grid example above):
 
 ````ruby
+class Content < Hashcraft::Base
+  option :property
+end
+
+class Column < Hashcraft::Base
+  option :header
+
+  option :content, craft: Content,
+                   mutator: :array,
+                   key: :contents
+end
+
+class Grid < Hashcraft::Base
+  key_transformer CamelCase.new
+
+  option :api_url,
+         :name
+
+  option :column, craft: Column,
+                  mutator: :array,
+                  key: :columns
+end
+
 config = Grid.new do
   api_url '/patients'
-end.to_h(key_transformer: CamelCase.new)
+end.to_h
 ````
 
 The resulting `config` value will now be:
@@ -190,12 +213,23 @@ The resulting `config` value will now be:
 Note that this library ships with some basic transformers like the one mentioned above.  If you want to use this then you can simply do this:
 
 ````ruby
+class Grid < Hashcraft::Base
+  key_transformer :camel_case
+
+  option :api_url,
+         :name
+
+  option :column, craft: Column,
+                  mutator: :array,
+                  key: :columns
+end
+
 config = Grid.new do
   api_url '/patients'
-end.to_h(key_transformer: :camel_case)
+end.to_h
 ````
 
-See Hashcraft::TransformerRegistry for a full list of provided transformers.
+See the `Hashcraft::TransformerRegistry` file for a full list of provided transformers.
 
 #### Value Transformer Example
 
@@ -213,10 +247,12 @@ class Localizer
 end
 ````
 
-Building on our Grid example, we could enhance the Column object as such:
+Building on our Grid example, we could enhance the Column object:
 
 ````ruby
 class Column < Hashcraft::Base
+  value_transformer Localizer.new
+
   option :header, meta: { localize: true }
 
   option :content, craft: Content,
@@ -225,7 +261,7 @@ class Column < Hashcraft::Base
 end
 ````
 
-We can then use the new value transformer (Localizer) when deriving hashes (using the above Grid and updated Column example):
+We can then use the new value transformer, `Localizer`, when deriving hashes (building on the above Grid and updated Column example):
 
 ````yaml
 en:
@@ -237,7 +273,7 @@ en:
 config = Grid.new do
   column header: :id
   column header: :first
-end.to_h(value_transformer: Localizer.new)
+end.to_h
 ````
 
 Assuming our en.yml looks like the above example and our locale is set to:en then the resulting `config` value will now be:

data/lib/hashcraft.rb

@@ -10,13 +10,8 @@
 require 'forwardable'
 require 'singleton'
 
-# Monkey-patching core libraries
-require_relative 'hashcraft/core_ext/hash'
-Hash.include Hashcraft::CoreExt::Hash
-
 # General tooling
 require_relative 'hashcraft/generic'
 
+# Main Entrypoint(s)
 require_relative 'hashcraft/base'
-require_relative 'hashcraft/mutator_registry'
-require_relative 'hashcraft/transformer_registry'

data/lib/hashcraft/base.rb

@@ -7,7 +7,6 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'compiler'
 require_relative 'dsl'
 
 module Hashcraft
@@ -17,13 +16,15 @@ module Hashcraft
     extend Forwardable
 
     def_delegators :'self.class',
-                   :option?,
                    :option_set,
-                   :find_option
+                   :find_option,
+                   :key_transformer_to_use,
+                   :value_transformer_to_use
 
     def initialize(opts = {}, &block)
-      @data = make_default_data
+      @data = {}
 
+      load_default_data
       load_opts(opts)
 
       return unless block_given?
@@ -35,36 +36,67 @@ module Hashcraft
       end
     end
 
-    def to_h(key_transformer: nil, value_transformer: nil)
-      Compiler.new(
-        option_set,
-        key_transformer: key_transformer,
-        value_transformer: value_transformer
-      ).evaluate!(data)
+    # Main compilation method.  Once an object is hydrated, you can call this method to get the
+    # materialized hash.
+    def to_h
+      data.each_with_object({}) do |(key, value), memo|
+        method = value.is_a?(Array) ? :evaluate_values! : :evaluate_value!
+
+        send(method, memo, key, value)
+      end
     end
 
     private
 
     attr_reader :data
 
-    def make_default_data
-      option_set.values.each_with_object({}) { |o, memo| o.default!(memo) }
+    def load_default_data
+      option_set.each { |option| default!(option) }
     end
 
     def load_opts(opts)
       (opts || {}).each { |k, v| send(k, v) }
     end
 
-    def respond_to_missing?(method_name, include_private = false)
-      option?(method_name) || super
-    end
+    def evaluate_values!(data, key, values)
+      data[key] ||= []
 
-    def method_missing(method_name, *arguments, &block)
-      if option?(method_name)
-        find_option(method_name).value!(data, arguments.first, &block)
-      else
-        super
+      values.each do |value|
+        data[key] << (value.is_a?(Hashcraft::Base) ? value.to_h : value)
       end
+
+      self
+    end
+
+    def evaluate_value!(data, key, value)
+      data[key] = (value.is_a?(Hashcraft::Base) ? value.to_h : value)
+
+      self
+    end
+
+    def default!(option)
+      return self unless option.eager?
+
+      key   = hash_key(option)
+      value = value_transformer_to_use.transform(option.default.dup, option)
+
+      data[key] = value
+
+      self
+    end
+
+    def value!(option, value, &block)
+      key   = hash_key(option)
+      value = option.craft_value(value, &block)
+      value = value_transformer_to_use.transform(value, option)
+
+      option.value!(data, key, value)
+
+      self
+    end
+
+    def hash_key(option)
+      key_transformer_to_use.transform(option.hash_key, option)
     end
   end
 end

data/lib/hashcraft/dsl.rb

@@ -8,20 +8,54 @@
 #
 
 require_relative 'option'
+require_relative 'transformer_registry'
 
 module Hashcraft
   # The class API used to define options for a craftable class.  Each class stores its own
   # OptionSet instance along with materializing one for its
   # inheritance chain (child has precedence.)
   module Dsl
-    def option?(name)
-      option_set.exist?(name)
+    attr_reader :local_key_transformer,
+                :local_value_transformer
+
+    # DSL Method used to declare what the sub-class should use as a transformer for all keys.
+    # It will follow the typical inheritance chain and find the closest
+    # transformer to use (child-first).
+    def key_transformer(name)
+      tap { @local_key_transformer = TransformerRegistry.resolve(name) }
+    end
+
+    # DSL Method used to declare what the sub-class should use as a transformer for all values.
+    # It will follow the typical inheritance chain and find the closest
+    # transformer to use (child-first).
+    def value_transformer(name)
+      tap { @local_value_transformer = TransformerRegistry.resolve(name) }
+    end
+
+    def key_transformer_to_use # :nodoc:
+      return @key_transformer_to_use if @key_transformer_to_use
+
+      @closest_key_transformer =
+        ancestors.select { |a| a < Base }
+                 .find(&:local_key_transformer)
+                 &.local_key_transformer || Transformers::PassThru.instance
     end
 
-    def find_option(name)
+    def value_transformer_to_use # :nodoc:
+      return @value_transformer_to_use if @value_transformer_to_use
+
+      @closest_value_transformer =
+        ancestors.select { |a| a < Base }
+                 .find(&:local_value_transformer)
+                 &.local_value_transformer || Transformers::PassThru.instance
+    end
+
+    def find_option(name) # :nodoc:
       option_set.find(name)
     end
 
+    # The main class-level DSL method consumed by sub-classes.  This is the entry-point for the
+    # declaration of available options.
     def option(*args)
       opts = args.last.is_a?(Hash) ? args.pop : {}
 
@@ -29,12 +63,22 @@ module Hashcraft
         option = Option.new(key, opts)
 
         local_option_set.add(option)
+
+        method_name = option.name
+
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}(opts = {}, &block)
+            option = find_option('#{method_name}')
+
+            value!(option, opts, &block)
+          end
+        RUBY
       end
 
       self
     end
 
-    def option_set
+    def option_set # :nodoc:
       @option_set ||=
         ancestors
         .reverse
@@ -42,7 +86,7 @@ module Hashcraft
         .each_with_object(Generic::Dictionary.new) { |a, memo| memo.merge!(a.local_option_set) }
     end
 
-    def local_option_set
+    def local_option_set # :nodoc:
       @local_option_set ||= Generic::Dictionary.new(key: :name)
     end
   end

data/lib/hashcraft/generic/dictionary.rb

@@ -8,7 +8,7 @@
 #
 
 module Hashcraft
-  module Generic
+  module Generic # :nodoc: all
     # Dictionary structure defining how we want to organize objects.  Basically a type-insensitive
     # hash where each key is the object's value for the specified key.
     # All keys are #to_s evaluated in order to achieve the type-insensitivity.
@@ -28,8 +28,10 @@ module Hashcraft
         freeze
       end
 
-      def exist?(key)
-        !find(key).nil?
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        values.each(&block)
       end
 
       def find(key)

data/lib/hashcraft/generic/registry.rb

@@ -8,7 +8,7 @@
 #
 
 module Hashcraft
-  module Generic
+  module Generic # :nodoc: all
     # A general data structure that can register and resolve objects by name.
     # It also will act as a pass-thru if a non-string or non-symbol is passed through.
     class Registry
@@ -46,11 +46,7 @@ module Hashcraft
       def resolve(value)
         return value unless lookup?(value)
 
-        mutator = map[value.to_s]
-
-        raise ArgumentError, "registration: #{value} not found" unless mutator
-
-        mutator
+        map[value.to_s] || raise(ArgumentError, "registration: #{value} not found")
       end
 
       private

data/lib/hashcraft/mutator_registry.rb

@@ -7,19 +7,25 @@
 # LICENSE file in the root directory of this source tree.
 #
 
+require_relative 'mutators/always_false'
+require_relative 'mutators/always_true'
 require_relative 'mutators/array'
+require_relative 'mutators/flat_array'
 require_relative 'mutators/hash'
 require_relative 'mutators/property'
 
 module Hashcraft
   # Singleton that knows how to register and retrieve mutator instances.
-  class MutatorRegistry < Generic::Registry
+  class MutatorRegistry < Generic::Registry # :nodoc:
     def initialize
       super(
+        '' => Mutators::Property.instance,
+        'always_false' => Mutators::AlwaysFalse.instance,
+        'always_true' => Mutators::AlwaysTrue.instance,
         'array' => Mutators::Array.instance,
+        'flat_array' => Mutators::FlatArray.instance,
         'hash' => Mutators::Hash.instance,
-        'property' => Mutators::Property.instance,
-        '' => Mutators::Property.instance
+        'property' => Mutators::Property.instance
       )
     end
   end

data/lib/hashcraft/{core_ext/hash.rb → mutators/always_false.rb}

@@ -8,13 +8,13 @@
 #
 
 module Hashcraft
-  module CoreExt
-    # Monkey-patches for the core Hash class.  These will be manually mixed in separately.
-    module Hash
-      unless method_defined?(:symbolize_keys)
-        def symbolize_keys
-          map { |k, v| [k.to_sym, v] }.to_h
-        end
+  module Mutators # :nodoc: all
+    # Set to false, no matter what.
+    class AlwaysFalse
+      include Singleton
+
+      def value!(data, key, _value)
+        tap { data[key] = false }
       end
     end
   end

data/lib/hashcraft/mutators/always_true.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Hashcraft
+  module Mutators # :nodoc: all
+    # Set to true, no matter what.
+    class AlwaysTrue
+      include Singleton
+
+      def value!(data, key, _value)
+        tap { data[key] = true }
+      end
+    end
+  end
+end

data/lib/hashcraft/mutators/array.rb

@@ -8,14 +8,15 @@
 #
 
 module Hashcraft
-  module Mutators
-    # When a hash's key is an arry then this mutator can be used to push a new value on the
+  module Mutators # :nodoc: all
+    # When a hash's key is an array then this mutator can be used to push a new value on the
     # respective array.
     class Array
       include Singleton
 
       def value!(data, key, value)
         data[key] ||= []
+
         data[key] << value
 
         self

data/lib/hashcraft/mutators/flat_array.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Hashcraft
+  module Mutators # :nodoc: all
+    # If the value is an array then concat, if it is not an array then push.
+    class FlatArray
+      include Singleton
+
+      def value!(data, key, value)
+        data[key] ||= []
+
+        # Prefixed Array with double colons to not get confused with our Array mutator class.
+        if value.is_a?(::Array)
+          data[key] += value
+        else
+          data[key] << value
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/hashcraft/mutators/hash.rb

@@ -8,7 +8,7 @@
 #
 
 module Hashcraft
-  module Mutators
+  module Mutators # :nodoc: all
     # When a hash's key a Hash then this mutator can be used to merge a new value on the
     # respective hash.
     class Hash

data/lib/hashcraft/mutators/property.rb

@@ -8,16 +8,14 @@
 #
 
 module Hashcraft
-  module Mutators
+  module Mutators # :nodoc: all
     # When a hash key can be simply assigned to (like a property) then this mutator can be used to
     # simply do the assignment.
     class Property
       include Singleton
 
       def value!(data, key, value)
-        data[key] = value
-
-        self
+        tap { data[key] = value }
       end
     end
   end

data/lib/hashcraft/option.rb

@@ -7,6 +7,8 @@
 # LICENSE file in the root directory of this source tree.
 #
 
+require_relative 'mutator_registry'
+
 module Hashcraft
   # Defines a method and corresponding attribute for a craftable class.
   class Option
@@ -17,46 +19,47 @@ module Hashcraft
                 :mutator,
                 :name
 
-    def initialize(name, opts = {})
+    alias eager? eager
+
+    def initialize(name, opts = {}) # :nodoc:
       raise ArgumentError, 'name is required' if name.to_s.empty?
 
-      @craft          = opts[:craft]
-      @default        = opts[:default]
-      @eager          = opts[:eager] || false
-      @internal_meta  = (opts[:meta] || {}).symbolize_keys
-      @key            = opts[:key].to_s
-      @mutator        = MutatorRegistry.resolve(opts[:mutator])
-      @name           = name.to_s
+      @craft         = opts[:craft]
+      @default       = opts[:default]
+      @eager         = opts[:eager] || false
+      @internal_meta = symbolize_keys(opts[:meta] || {})
+      @key           = opts[:key].to_s
+      @mutator       = MutatorRegistry.resolve(opts[:mutator])
+      @name          = name.to_s
 
       freeze
     end
 
+    def value!(data, key, value) # :nodoc:
+      mutator.value!(data, key, value)
+    end
+
+    # Options are sent into transformers as arguments.  Leverage the meta key for an option
+    # to store any additional data that you may need in transformers.  This method provides a
+    # quick message-based entry point into inspecting the meta key's value.
     def meta(key)
       internal_meta[key.to_s.to_sym]
     end
 
-    def default!(data)
-      return self unless eager
-
-      data[name] = default
-
-      self
+    def hash_key # :nodoc:
+      key.empty? ? name : key
     end
 
-    def value!(data, value, &block)
-      value = craft_value(value, &block)
-
-      mutator.value!(data, name, value)
-
-      self
+    def craft_value(value, &block) # :nodoc:
+      craft ? craft.new(value, &block) : value
     end
 
     private
 
     attr_reader :internal_meta
 
-    def craft_value(value, &block)
-      craft ? craft.new(value, &block) : value
+    def symbolize_keys(hash)
+      hash.map { |k, v| [k.to_sym, v] }.to_h
     end
   end
 end

data/lib/hashcraft/transformer_registry.rb

@@ -13,13 +13,13 @@ require_relative 'transformers/pass_thru'
 
 module Hashcraft
   # Singleton that knows how to register and retrieve transformer instances.
-  class TransformerRegistry < Generic::Registry
+  class TransformerRegistry < Generic::Registry # :nodoc:
     def initialize
       super(
+        '' => Transformers::PassThru.instance,
         'camel_case' => Transformers::CamelCase.instance,
         'pascal_case' => Transformers::PascalCase.instance,
-        'pass_thru' => Transformers::PassThru.instance,
-        '' => Transformers::PassThru.instance
+        'pass_thru' => Transformers::PassThru.instance
       )
     end
   end

data/lib/hashcraft/transformers/camel_case.rb

@@ -8,7 +8,7 @@
 #
 
 module Hashcraft
-  module Transformers
+  module Transformers # :nodoc: all
     # Transform snake-cased to camel-cased string. Example:
     #   date_of_birth => dateOfBirth
     #   DATE_OF_BIRTH => dateOfBirth

data/lib/hashcraft/transformers/pascal_case.rb

@@ -8,7 +8,7 @@
 #
 
 module Hashcraft
-  module Transformers
+  module Transformers # :nodoc: all
     # Transform snake-cased to pascal-cased string. Example:
     #   date_of_birth => DateOfBirth
     #   DATE_OF_BIRTH => DateOfBirth

data/lib/hashcraft/transformers/pass_thru.rb

@@ -8,7 +8,7 @@
 #
 
 module Hashcraft
-  module Transformers
+  module Transformers # :nodoc: all
     # Default transformer, simply returns the value passed in.
     class PassThru
       include Singleton

data/lib/hashcraft/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Hashcraft
-  VERSION = '1.0.0-alpha.1'
+  VERSION = '1.0.0-alpha.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashcraft
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.alpha.1
+  version: 1.0.0.pre.alpha.6
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-01 00:00:00.000000000 Z
+date: 2020-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard-rspec
@@ -132,14 +132,15 @@ files:
 - hashcraft.gemspec
 - lib/hashcraft.rb
 - lib/hashcraft/base.rb
-- lib/hashcraft/compiler.rb
-- lib/hashcraft/core_ext/hash.rb
 - lib/hashcraft/dsl.rb
 - lib/hashcraft/generic.rb
 - lib/hashcraft/generic/dictionary.rb
 - lib/hashcraft/generic/registry.rb
 - lib/hashcraft/mutator_registry.rb
+- lib/hashcraft/mutators/always_false.rb
+- lib/hashcraft/mutators/always_true.rb
 - lib/hashcraft/mutators/array.rb
+- lib/hashcraft/mutators/flat_array.rb
 - lib/hashcraft/mutators/hash.rb
 - lib/hashcraft/mutators/property.rb
 - lib/hashcraft/option.rb

data/lib/hashcraft/compiler.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Copyright (c) 2020-present, Blue Marble Payroll, LLC
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-#
-
-module Hashcraft
-  # This class understands how to traverse an option chain and output a hash.
-  class Compiler
-    attr_reader :key_transformer, :option_set, :value_transformer
-
-    def initialize(option_set, key_transformer: nil, value_transformer: nil)
-      raise ArgumentError, 'option_set is required' unless option_set
-
-      @option_set        = option_set
-      @key_transformer   = TransformerRegistry.resolve(key_transformer)
-      @value_transformer = TransformerRegistry.resolve(value_transformer)
-
-      freeze
-    end
-
-    def evaluate!(data)
-      data.each_with_object({}) do |(key, value), memo|
-        option = option_set.find(key)
-
-        evaluate_single!(memo, option, value)
-      end
-    end
-
-    private
-
-    attr_reader :data
-
-    def evaluate_single!(data, option, value)
-      key             = option.key.empty? ? option.name : option.key
-      transformed_key = key_transformer.transform(key, option)
-
-      method = value.is_a?(Array) ? :evaluate_values! : :evaluate_value!
-
-      send(method, option, data, transformed_key, value)
-
-      self
-    end
-
-    def evaluate_values!(option, data, key, values)
-      data[key] ||= []
-
-      values.each do |value|
-        data[key] <<
-          if value.is_a?(Hashcraft::Base)
-            value.to_h(
-              key_transformer: key_transformer,
-              value_transformer: value_transformer
-            )
-          else
-            value_transformer.transform(value, option)
-          end
-      end
-
-      self
-    end
-
-    def evaluate_value!(option, data, key, value)
-      data[key] =
-        if value.is_a?(Hashcraft::Base)
-          value.to_h(
-            key_transformer: key_transformer,
-            value_transformer: value_transformer
-          )
-        else
-          value_transformer.transform(value, option)
-        end
-
-      self
-    end
-  end
-end