tag_options 0.9.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb408340ce9d19af1ea31d33d3589bf341cead0595fae98905f183370e27fe5e
-  data.tar.gz: 40f0b893d5a513bf5d4a15a66e984ba2d331cfe674832b408b28a09f3f2da073
+  metadata.gz: 5802916aaa57253843bc9fa02aed005828d4ffa30a8ccf514b9949c5c0859d2d
+  data.tar.gz: 80ee0b00682ee8d94595039cd1569c0152d0dedb225a78672986416118bec6fe
 SHA512:
-  metadata.gz: 88bee13cbc9235499350735d61299f9aa0f06db4227200f07c93708672133b7e7bd378871376fa0c221405aeb8487df85b60b1aede65356ef48383a31ab75529
-  data.tar.gz: f883c852b8704e940e59c43f067aaac197ba1bf6857977b1676a76e5d1b155cbe7aa13e300a4c55dad2bac466b3468cbc787a68869d777398306e7bd9f7cf3bf
+  metadata.gz: f498f2aa015310a8b4d3800dcb435c5b946665f5f53bf54630a80666e3c56f05c54b75788ea84b2d57829d2369404408621a4b2b7adeec1c5668fad2e61ac37a
+  data.tar.gz: 9e04caa1298cec89d34af81daa7c11b51c18020c3bb013aaf7b104de5f1e5c80d545aeaae334929d3c2796d5fa00f31aafb59028b588bf9aefd218278e56bb9c

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [1.1.0] - 2023-03-01
+
+- Switched to inheriting from ActiveSupport::HashWithIndifferentAccess.
+- Added before/after/around initialize callback support.
+
+## [1.0.0] - 2022-06-14
+
+- Rewrote and simplified TagOptions::Hash and supporting classes.
+- BREAKING CHANGES, read documentation for updated usage before updating.
+
 ## [0.9.3] - 2021-11-11
 
 - Added TagOptions::Hash() ease-of-use method

data/README.md

@@ -1,17 +1,22 @@
 # Tag Options
 
-Simple library for manipulating options passed to the Rails `tag`, `content_tag`, and other tag helpers.
+[![Test](https://github.com/wamonroe/tag_options/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/wamonroe/tag_options/actions/workflows/test.yml)
 
-This library provides a simple class to make authoring resuable helpers and [View Components](https://viewcomponent.org)
-easier when you want to allow for the input of properties on HTML elements, but also need to add/set your own.
+Simple library for manipulating options passed to the Rails `tag`,
+`content_tag`, and other tag helpers.
 
-`TagOptions::Hash` is an object that normalizes the options passed to Rails helper, while providing helpful methods
-to manipulate the values of HTML properties:
+This library provides a simple class to make authoring resuable helpers and
+[View Components](https://viewcomponent.org) easier when you want to allow for
+the input of properties on HTML elements, but also need to add/set your own.
+
+`TagOptions::Hash` is an object that normalizes the options passed to Rails
+helper, while providing helpful methods to manipulate the values of HTML
+properties:
 
 ```ruby
 def external_link_to(name, url, options={})
   options = TagOptions::Hash.new(options)
-  options.combine_with_class!('external-link')
+  options.at(:class).combine!("external-link")
   link_to(name, url, options)
 end
 ```
@@ -19,7 +24,7 @@ end
 Called with:
 
 ```ruby
-external_link_to('Example', 'https://example.com', class: 'ml-2')
+external_link_to("Example", "https://example.com", class: "ml-2")
 ```
 
 Would render:
@@ -30,24 +35,24 @@ Would render:
 
 ## Table of Contents
 
-- [Installation](#installation)
-- [Configuration](#configuration)
-- [General Usage](#general-usage)
-  - [combine_with!](#combinewith)
-  - [override!](#override)
-- [Conditional Usage](#conditional-usage)
-- [Custom Property Handling](#custom-property-handling)
-- [Development](#development)
-- [Contributing](#contributing)
-- [To Do](#to-do)
-- [License](#license)
+- [Tag Options](#tag-options)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [General Usage](#general-usage)
+    - [combine!](#combine)
+    - [set!](#set)
+  - [Conditional Usage](#conditional-usage)
+  - [Custom Property Resolvers](#custom-property-resolvers)
+  - [Development](#development)
+  - [Contributing](#contributing)
+  - [License](#license)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tag_options'
+gem "tag_options"
 ```
 
 And then execute:
@@ -56,33 +61,6 @@ And then execute:
 bundle install
 ```
 
-## Configuration
-
-Generate an initializer to customize the default configuration:
-
-```sh
-rails generate arc_options:install
-```
-
-```ruby
-TagOptions.configure do |config|
-  # fallback_property_handler
-  #
-  # Defines the default behavior of how values are treated on HTML properties. `TagOptions::PropertyHandler::Generic`
-  # allows for multiple, unique, values seperated by spaces.
-  config.fallback_property_handler = 'TagOptions::PropertyHandler::Generic'
-
-  # property_handlers
-  #
-  # Allows of the custom handling of HTML properties that match the defined property handler. Properties are handled by
-  # the first matching property handler.
-  config.property_handlers = [
-    'TagOptions::PropertyHandler::Singular',
-    'TagOptions::PropertyHandler::Style'
-  ]
-end
-```
-
 ## General Usage
 
 Initialize a `TagOptions::Hash` directly or by passing an existing `Hash`.
@@ -91,155 +69,137 @@ Initialize a `TagOptions::Hash` directly or by passing an existing `Hash`.
 TagOptions::Hash.new
 => {}
 
-hash = {class: 'flex'}
+hash = {class: "flex"}
 TagOptions::Hash.new(hash)
 => {:class=>"flex"}
 ```
 
-### combine_with!
+### combine!
 
-Combine HTML attributes with an existing `TagOptions::Hash` using `combine_with!`
+Combine HTML attributes with an existing `TagOptions::Hash` by chaining `at` and
+`combine!`
 
 ```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: 'mt-1')
+options = TagOptions::Hash.new(class: "flex")
+options.at(:class).combine!("mt-1")
 => {:class=>"flex mt-1"}
 ```
 
 Values can also be specified as arrays.
 
 ```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: ['mt-1', 'mx-2'])
+options = TagOptions::Hash.new(class: "flex")
+options.at(:class).combine!(["mt-1", "mx-2"])
 => {:class=>"flex mt-1 mx-2"}
 ```
 
 HTML attributes are only added if they don't already exist.
 
 ```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: 'flex flex-col')
+options = TagOptions::Hash.new(class: "flex")
+options.at(:class).combine!("flex flex-col")
 => {:class=>"flex flex-col"}
 ```
 
-You can also combine multiple HTML attributes in one operation.
+You can also combine values on nested hashes.
 
 ```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: 'mt-1', 'data-controller': 'dropdown')
-=> {:class=>"flex mt-1", :"data-controller"=>"dropdown"}
+options = TagOptions::Hash.new(class: "flex", data: {controller: "dropdown"})
+options.at(:data, :controller).combine!("toggle")
+=> {:class=>"flex", :data=>{:controller=>"dropdown toggle"}
 ```
 
-Dash seperated HTML attributes, such as `data-controller` can also be specified as nested hashes.
+If a nested hash doesn't already exist it will be automatically added.
 
 ```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: 'mt-1', data: { controller: 'dropdown' })
-=> {:class=>"flex mt-1", :"data-controller"=>"dropdown"}
+options = TagOptions::Hash.new(class: "flex")
+options.at(:data, :controller).combine!("dropdown")
+=> {:class=>"flex", :data=>{:controller=>"dropdown"}
 ```
 
-Dash seperated HTML attributes can also be specified using underscores.
-
-```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: 'mt-1', data_controller: 'dropdown')
-=> {:class=>"flex mt-1", :"data-controller"=>"dropdown"}
-```
+### set!
 
-For ease of use, you can also combine values into a single HTML attribute using `combine_with_<attribute>!`, where
-`<attribute>` is the name of the HTML attribute. Dash seperated HTML attributes should be specified using underscores.
+Chaining `at` and `set!` functions nearly the same as `combine!` with all same
+usage patterns. The major difference is that the set method will override any
+existing values.
 
 ```ruby
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with_class! 'mt-1'
-options.combine_with_data_controller! 'dropdown'
-=> {:class=>"flex mt-1", :"data-controller"=>"dropdown"}
+options = TagOptions::Hash.new(class: "flex")
+options.at(:class).set!("block")
+=> {:class=>"block"}
 ```
 
-### override!
-
-The method `override!` functions nearly the same as `combine_with!` with all same usage patterns, including ease of
-use methods, such as `override_class!`. The major difference is that the override methods will not combine specified
-values with existing values. Any specified values will override any existing values.
-
 ## Conditional Usage
 
-Both the `combine_with!` and `override!` allow for values to be conditionally added to HTML attributes using an argument
-array. Where the values are added unconditionally and key/value pairs have their key added _IF_ the value is true.
+Both the `combine!` and `set!` allow for values to be conditionally added to
+HTML attributes using an argument array. Where the values are added
+unconditionally and key/value pairs have their key added _IF_ the value is true.
 
 ```ruby
 # assuming `centered?` returns `true`
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with!(class: ['mt-1', 'mx-auto': centered?, 'mx-2': !centered?])
+options = TagOptions::Hash.new(class: "flex")
+options.at(:class).combine!("mt-1", "mx-auto": centered?, "mx-2": !centered?)
 => {:class=>"flex mt-1 mx-auto"}
 ```
 
-The syntax of the `combine_with_<attribute>!` and `override_<attribute>!` ease of use method allow for values and
-conditional values to be combined more naturally using a more typical argument pattern.
+## Custom Property Resolvers
 
-```ruby
-# assuming `centered?` returns `true`
-options = TagOptions::Hash.new(class: 'flex')
-options.combine_with_class!('mt-1', 'mx-auto': centered?, 'mx-2': !centered?)
-=> {:class=>"flex mt-1 mx-auto"}
-```
+Chaining `at` to `combine!` or `set!` processes HTML properties similar to
+`class`.
 
-## Custom Property Handling
+- Multiple are allowed
+- Multiple values are seperated by a space
+- Duplicate values are not added
 
-Tag Options ships with several property handlers enabled by default.
+Tag Options also ships with a special `style` resolver, which can be used by
+pass `as: :style` to `at`.
 
-- `TagOptions::PropertyHandler::Generic` - Processes all HTML properties that don't match another property handler.
-  Handles HTML properties similar to `class`.
-  - Multiple unique values are allowed
-  - Multiple values are seperated by a space
-- `TagOptions::PropertyHandler::Singular` - Processes `id`, `role`, and `aria-*` properties.
-  - Both `combine_with!` and `override!` function the same on these attributes.
-  - The last specified/resolved value is assigned to the property.
-- `TagOptions::PropertyHandler::Style` - Processes the `style` property. Allows for the parsing of HTML style property.
-  - Multiple values are allowed
-  - Values must be specified as `property: value;`
-  - The `combine_with!` method will overwrite an existing style property if it exists, but leave the reamining style
-    properties untouched.
-  - The `override!` method will overwrite all existing style properties.
-
-Tag Options also ships with an optional property handler for sorting Tailwind CSS classes inspired by/based on the
-VS Code extension [Headwind](https://github.com/heybourn/headwind). To enable this optional property handler,
-[generate a configuration](#configuration) and then add it as a property handler:
+- Multiple values are allowed
+- Values must be specified as `property: value;`
+- Duplicate `property: value;` pairs are not added
+- The `combine!` method will overwrite an existing style property if it exists,
+  add properties that don't exist, and leave the remaining properties untouched.
+- The `set!` method will overwrite all existing style properties.
 
 ```ruby
-require 'tag_options/property_handler/tailwind_css'
+options = TagOptions::Hash.new(style: "display: block; margin-left: 0;")
+options.at(:style, as: :style).combine!("display: flex; margin-right: 0;")
+=> {:style=>"display: flex; margin-left: 0; margin-right: 0;"}
+```
+
+A `TagOptions::Resolver` class is available if you wish to implement your own
+custom handlers. For examples on doing so, see the [built-in
+handlers](https://github.com/wamonroe/tag_options/tree/main/lib/tag_options/resolvers).
 
+To register a custom handler:
+
+```ruby
+# config/initializers/tag_options.rb
 TagOptions.configure do |config|
-  config.property_handlers = [
-    'TagOptions::PropertyHandler::TailwindCSS',
-    'TagOptions::PropertyHandler::Singular',
-    'TagOptions::PropertyHandler::Style'
-  ]
+  config.register_resolver :custom, "MyCustomResolver"
 end
 ```
 
-A `TagOptions::PropertyHandler::Base` class is available if you wish to implement your own custom handlers. For
-examples on doing so, see the
-[built-in handlers](https://github.com/wamonroe/tag_options/tree/main/lib/tag_options/property_handler).
-
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/test` to run the tests. You can
-also run:
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`bin/rspec` to run the tests. You can also run:
 
 - `bin/console` for an interactive prompt that will allow you to experiment
 - `bin/rubocop` to run RuboCop to check the code style and formatting
-- `bin/update_tailwindcss` to update the sort order from the latest [Headwind](https://github.com/heybourn/headwind)
-  configuration.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the
-version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version,
-push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To build this gem on your local machine, run `bundle exec rake build`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/wamonroe/tag_options.
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/wamonroe/tag_options.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT
+License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
+require "bundler/setup"
 
-require 'bundler/gem_tasks'
-require 'rake/testtask'
+require "bundler/gem_tasks"
+require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
   t.verbose = false
 end
 

data/lib/tag_options/configuration.rb

@@ -1,4 +1,6 @@
-# frozen_string_literal: true
+require "tag_options/resolvers/default"
+require "tag_options/resolvers/style"
+require "tag_options/errors/resolver_error"
 
 module TagOptions
   class << self
@@ -11,24 +13,25 @@ module TagOptions
     def configure
       yield(configuration)
     end
-
-    def reset_configuration
-      @configuration = TagOptions::Configuration.new
-    end
   end
 
   class Configuration
-    attr_writer :fallback_property_handler, :property_handlers
+    def initialize
+      @resolvers = {
+        default: "TagOptions::Resolvers::Default",
+        style: "TagOptions::Resolvers::Style"
+      }
+    end
 
-    def fallback_property_handler
-      @fallback_property_handler ||= 'TagOptions::PropertyHandler::Generic'
+    def resolver(name)
+      unless (resolver_name = @resolvers[name])
+        raise TagOptions::Errors::ResolverError, name
+      end
+      Object.const_get(resolver_name)
     end
 
-    def property_handlers
-      @property_handlers ||= [
-        'TagOptions::PropertyHandler::Singular',
-        'TagOptions::PropertyHandler::Style'
-      ]
+    def register_resolver(name, class_name)
+      @resolvers[name] = class_name
     end
   end
 end

data/lib/tag_options/error.rb

@@ -0,0 +1,4 @@
+module TagOptions
+  class Error < StandardError
+  end
+end

data/lib/tag_options/errors/not_hash_error.rb

@@ -0,0 +1,12 @@
+require "tag_options/error"
+
+module TagOptions
+  module Errors
+    class NotHashError < Error
+      def initialize(key, *keys, type:)
+        hash_path = [key, *keys].join("=>")
+        super("unsupport type `#{type}` is already located at #{hash_path}")
+      end
+    end
+  end
+end

data/lib/tag_options/errors/resolver_error.rb

@@ -0,0 +1,11 @@
+require "tag_options/error"
+
+module TagOptions
+  module Errors
+    class ResolverError < Error
+      def initialize(name)
+        super("a resolver named `#{name}` has not been registered")
+      end
+    end
+  end
+end

data/lib/tag_options/hash.rb

@@ -1,140 +1,40 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string'
-require 'active_support/core_ext/array'
-require 'forwardable'
-require 'tag_options/property_handler/resolve_value'
+require "active_support/callbacks"
+require "active_support/core_ext/hash/indifferent_access"
+require "tag_options/hash_at"
+require "tag_options/errors/not_hash_error"
 
 module TagOptions
-  class Hash
-    extend Forwardable
-
-    def_delegators :@data, :inspect, :to_h, :to_hash, :to_s, :stringify_keys, :<, :<=, :==, :>, :>=
-
-    # Hashes passed into the initializer are automatically flattened, with nested keys seperated by dashes. For example,
-    # `data: { controller: 'dropdown' }`` becomes `'data-controller': 'dropdown'`.
-    def initialize(hash={})
-      @data = {}
-      flatten_hash(hash).each do |property, value|
-        self[property] = value
-      end
-    end
-
-    # []
-    # Underscores in a property name is automatically coverted to dashes. Properties can be specified as strings or
-    # symbols, both return the same value.
-    def [](property)
-      @data[normalize_property(property)]
-    end
-
-    # []=
-    # Hashes assigned to a property are automatically flatten, with nested keys seperated by dashes. Underscores in a
-    # property name are automatically converted to dashes. Propertiess can be specified as strings or symbols, both will
-    # assign the value to the same property.
-    def []=(property, value)
-      if value.is_a?(::Hash)
-        flatten_hash({ property => value }).each do |flat_property, flat_value|
-          store(flat_property, flat_value)
+  class Hash < ActiveSupport::HashWithIndifferentAccess
+    include ActiveSupport::Callbacks
+    define_callbacks :initialize
+
+    def initialize(hash = {})
+      run_callbacks :initialize do
+        hash.each do |key, value|
+          self[key] = value.is_a?(::Hash) ? self.class.new(value) : value
         end
-      else
-        store(property, value)
       end
     end
 
-    # combine_with!
-    # Allows you to combine values with multiple HTML attributes in one operation. Passed keys should be the HTML
-    # property to combine the values with. The values can be specified as single string (e.g. `class: 'flex'`) or as an
-    # argument array (e.g. `class: ['flex', 'mt-2', 'flex-col':  layout_column?]`). Hashes in an argument array have
-    # their keys combined only their value is true. Nested keys will automatically be flattened and combine with the
-    # associated property (e.g. `data: { controller: 'dropdown' }` would be combined with `data-controller`).
-    #
-    #   #combine_with!(
-    #     class: ['flex', 'mt-2', 'flex-col': layout_column?],
-    #     data: {
-    #       controller: ['dropdown', 'navbar': navbar?]
-    #     }
-    #   )
-    #
-    # TagOptions::Hash also responses to combine_with_<name>!, where `<name>` is the name of the HTML attribute to
-    # combine the passed argument array with. If `<name>` is specified with a value containing underscores, the HTML
-    # attribute is converted to dashes, for example: `combine_with_data_controller!` will result in the argument array
-    # being combined with existing values in `data-controller`.
-    def combine_with!(hash={})
-      flatten_hash(hash).each do |property, args|
-        store(property, self[property], *args)
-      end
-      self
+    def at(key, *nested_keys, as: :default)
+      TagOptions::HashAt.new(opt_hash: self, keys: [key, *nested_keys], as: as)
     end
 
-    # override!
-    # Allows you to override values on multiple HTML properties in one operation. Passed keys should be the HTML
-    # properties to override the values of. The values can be passed as single string (e.g. `class: 'flex'`) or as an
-    # argument array (e.g. `class: ['flex', 'mt-2', 'flex-col':  layout_column?]`). Hashes in an argument array have
-    # their keys added only if their value is true. Nested keys will automatically be flattened and override the value
-    # at the associated property (e.g. `data: { controller: 'dropdown' }` would override values at `data-controller`).
-    #
-    #   #override!(
-    #     class: ['flex', 'mt-2', 'flex-col': layout_column?],
-    #     data: {
-    #       controller: ['dropdown', 'navbar': navbar?]
-    #     }
-    #   )
-    #
-    # TagOptions::Hash also responses to override_<name>!, where `<name>` is the name of the HTML attribute to override
-    # the passed argument array on. If `<name>` is specified with a value containing underscores, the resulting HTML
-    # attribute is automatically nested, for example `override_data_controller!` will result in the argument array
-    # overriding the existing values in `data-controller`.
-    def override!(hash={})
-      flatten_hash(hash).each do |property, args|
-        store(property, *args)
-      end
-      self
+    def dig(*keys)
+      keys.size.zero? ? self : super
     end
 
-  private
-
-    def action_matcher
-      /\A(?<action>combine_with|override)_(?<property>.*)!\z/
-    end
-
-    def flatten_hash(hash)
-      hash.each_with_object({}) do |(property, value), result|
-        if value.is_a?(::Hash)
-          flatten_hash(value).map do |nested_property, nested_value|
-            result["#{property}-#{nested_property}".to_sym] = nested_value
-          end
-        else
-          result[property] = value
+    def populate!(*keys)
+      populated_keys = []
+      data = self
+      keys.each do |key|
+        data[key] ||= TagOptions::Hash.new
+        data = data[key]
+        unless data.is_a?(TagOptions::Hash)
+          raise TagOptions::Errors::NotHashError.new(populated_keys, type: data.class)
         end
       end
-    end
-
-    def method_missing(method_name, *args, &block)
-      match_data = action_matcher.match(method_name.to_s)
-      if match_data
-        public_send("#{match_data['action']}!", { match_data['property'] => args }, &block)
-      else
-        super
-      end
-    end
-
-    def store(property, *values)
-      property = normalize_property(property)
-      conditions = values.extract_options!
-      value = resolve_value(property, *values, **conditions)
-      value.empty? ? @data.delete(property) : @data[property] = value
-    end
-
-    def resolve_value(property, *values, **conditions)
-      TagOptions::PropertyHandler::ResolveValue.call(property, *values, **conditions)
-    end
-
-    def normalize_property(property)
-      property.to_s.downcase.dasherize.to_sym
-    end
-
-    def respond_to_missing?(method_name, include_private=false)
-      action_matcher.match?(method_name.to_s) || super
+      self
     end
   end
 end

data/lib/tag_options/hash_at.rb

@@ -0,0 +1,30 @@
+require "tag_options/configuration"
+
+module TagOptions
+  class HashAt
+    def initialize(opt_hash:, keys:, as:)
+      @opt_hash = opt_hash
+      @keys = keys[..-2]
+      @value_key = keys[-1]
+      @resolver = TagOptions.configuration.resolver(as)
+    end
+
+    def combine!(*values, **conditions)
+      @opt_hash.populate!(*@keys)
+      current_value = @opt_hash.dig(*@keys, @value_key)
+      set_value! @resolver.call(current_value, *values, **conditions)
+    end
+
+    def set!(*values, **conditions)
+      @opt_hash.populate!(*@keys)
+      set_value! @resolver.call(*values, **conditions)
+    end
+
+    private
+
+    def set_value!(value)
+      @opt_hash.dig(*@keys)[@value_key] = value
+      @opt_hash
+    end
+  end
+end