nero 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9822fcc078e4b2c0e9f049da7cf6f37a98a5b9cf607434057f266a393154296e
-  data.tar.gz: b71a5be94f469b564e3a80c80a0545246afbc053f619201f8a0c6c0923a776a4
+  metadata.gz: 4e28a4b8bcd989c20dd60dc592bfb31039314437b3d8ca5df33b79adefd5cb2e
+  data.tar.gz: f6eb0ec1e9ceb041088a7d2b850494e090f08d98f4e8369f82f0608a4449ab69
 SHA512:
-  metadata.gz: 863f2c0fbeb21286a0d0f51219e07351a93489688eb7c49be5c1c720a3e414d8e43129e2c0e4d23c6e44213e8547a03c28df128210026414e9e3e209bb7ef472
-  data.tar.gz: c431e49a4d5d422b554a891973c0e24b7c1810dd922492d56b39ca6157dc70e3110114d7474d0d2ed3b5076f2bea63d8493b2cd9db64c3354ea051022f8887cb
+  metadata.gz: 98dc2c475e0e164f47d1738dbe32d6dfeeba6b531f6db0b396a25d3e29219c312ac0750206fddea1d9ee450e9205425a5f0342c6b5b13d38867a364e1219bed0
+  data.tar.gz: e9daf1ee287679b10d4ea744c41d3f93bf50570394eb261f7c8b3587a1008efe57b58b7957141aeea48229b65efdaa614f23c181fbf08659a0a878a7a944e773

data/CHANGELOG.md

@@ -1,6 +1,42 @@
 ## [Unreleased]
 ...
 
+## [0.5.0] - 2025-03-20
+
+- tag-classes  
+  Added [`Nero::BaseTag`](https://rubydoc.info/github/eval/nero/main/Nero/BaseTag) that is the basis of all existing tags.  
+  This means that building upon existing tags is easier and custom tags can be more powerful.
+  
+  Create new tags can be done in 3 ways:  
+  By block (as before, but slightly changed interface):
+  ```ruby
+  Nero.configure do |nero|
+    nero.add_tag("foo") do |tag|
+      # tag of type Nero::BaseTag
+    end
+  end
+  ```
+  By re-using existing tags via options:
+  ```ruby
+  nero.add_tag("env/upcase", klass: Nero::EnvTag[coerce: :upcase])
+  ```
+  Finally, by subclassing [Nero::BaseTag](https://rubydoc.info/github/eval/nero/main/Nero/BaseTag). See the section ["custom tags"](https://github.com/eval/nero?tab=readme-ov-file#custom-tags) from the README.
+  
+- `!env/float` and `!env/float?`  
+- `!env/git_root` and `!env/rails_root`  
+  Construct a path relative to some root-path:
+  ```yaml
+  asset_path: !path/rails_root [ public/assets ]
+  ```
+  Easy to use for your own tags:
+  ```ruby
+  config.add_tag("path/project_root", klass: Nero::PathRootTag[containing: '.git']) do |path|
+    # possible post-processing
+  end
+  ```
+- [#2](https://github.com/eval/nero/pull/2) Add irb to gemfile (@dlibanori)
+- [#3](https://github.com/eval/nero/pull/3) Fix missing require (@dlibanori)
+
 ## [0.4.0] - 2025-02-15
 
 - Add `!ref`-tag:

data/README.md

@@ -11,14 +11,24 @@ Additionally, it allows you to create your own.
 development:
   # env-var with default value
   secret: !env [SECRET, "dummy"]
+
   # optional env-var with coercion
   debug?: !env/bool? DEBUG
+
 production:
-  # required env-var (only when getting the production-root)
+  # required env-var (not required during development)
   secret: !env SECRET
-  # int coercion
+
+  # coercion
   max_threads: !env/integer [MAX_THREADS, 5]
-  # something custom
+
+  # refer to other keys
+  min_threads: !env/integer [MIN_THREADS, !ref max_threads ]
+
+  # descriptive names
+  asset_folder: !path/rails_root [ public/assets ]
+
+  # easy to add custom tags
   cache_ttl: !duration [2, hours]
 ```
 
@@ -26,7 +36,7 @@ production:
 
 * 💎 declarative YAML-tags for e.g. requiring and coercing env-vars
 * 🛠️ add custom tags
-* 🛤️ `Rails.application.config_for` stand-in
+* 🛤️ `Rails.application.config_for` drop-in
 * ♻️ Zeitwerk-only dependency
 
 ## Installation
@@ -42,6 +52,8 @@ bundle add nero
 > [!WARNING]  
 > It's early days - the API and included tags will certainly change. Check the CHANGELOG when upgrading.
 
+### loading a config
+
 Given the following config:
 ```yaml
 # config/settings.yml
@@ -76,6 +88,17 @@ Nero.load_config("config/settings", root: :production)
 # ...with ENV {"SECRET" => "s3cr3t", "MAX_THREADS" => "3"}
 #=> {secret: "s3cr3t", max_threads: 3}
 ```
+> [!TIP]  
+> The following configuration would make `Nero.load_config` a drop-in replacement for [Rails.application.config_for](https://api.rubyonrails.org/classes/Rails/Application.html#method-i-config_for):
+```ruby
+Nero.configure do |config|
+  config.config_dir = Rails.root / "config"
+end
+
+Nero.load_config(:settings, env: Rails.env)
+```
+
+### built-in tags
 
 The following tags are provided:
 - `!env KEY`, `!env? KEY`  
@@ -90,10 +113,11 @@ The following tags are provided:
   secret: !env? SECRET
   ```
 - to coerce env-values:
-  - `env/integer`, `env/integer?`:  
+  - `env/integer`, `env/integer?`, `env/float`, `env/float?`:  
     ```yaml
     port: !env/integer [PORT, 3000]
     threads: !env/integer? THREADS # nil when not provided
+    threshold: !env/float CUTOFF
     ```
   - `env/bool`, `env/bool?`:  
     ```yaml
@@ -104,6 +128,11 @@ The following tags are provided:
     # ...or false:
     debug?: !env/bool? DEBUG
     ```
+> [!TIP]  
+> Make all env-var's optional by providing `ENV["NERO_ENV_ALL_OPTIONAL"]`, e.g.
+```shell
+$ env NERO_ENV_ALL_OPTIONAL=1 SECRET_KEY_BASE_DUMMY=1 rails asset:precompile
+```
 - `!path`  
   Create a [Pathname](https://rubyapi.org/3.4/o/pathname):
   ```yaml
@@ -113,6 +142,15 @@ The following tags are provided:
     - !env PROJECT_ROOT
     - /public/assets
   ```
+- `!path/git_root`, `!path/rails_root`  
+  Create a Pathname relative to some root-path.  
+  The root-path is expected to be an existing ancestor folder of the yaml-config being parsed.  
+  It's found by traversing up and checking for the presence of specific files/folders, e.g. '.git' (`!path/git_root`) or 'config.ru' (`!path/rails_root`).  
+  While the root-path needs to exist, the resulting Pathname doesn't need to.
+  ```yaml
+  project_root: !path/git_root
+  config_folder: !path/rails_root [ config ]
+  ```
 - `!uri`  
   Create a [URI](https://rubyapi.org/3.4/o/uri):
   ```yaml
@@ -139,7 +177,7 @@ The following tags are provided:
   Include values from elsewhere:
   ```yaml
   # simple
-  min_threads: !env [MIN_THREADS, !ref [max_threads]]
+  min_threads: !env/integer [MIN_THREADS, !ref [max_threads]]
   max_threads: 5
   
   # oauth_callback -refs-> base.url -refs-> base.host
@@ -158,39 +196,93 @@ The following tags are provided:
     max_threads: !env[MAX_THREADS, !ref[dev, max_threads]]
   ```
   NOTE future version should raise properly over ref-ing a non-existing path.
-  
 
-Add one yourself:
-```ruby
-Nero.configure do |nero|
-  nero.add_tag("foo") do |coder|
-    # coder.type is one of :scalar, :seq or :map
-    # e.g. respective YAML:
-    # ---
-    # !foo bar
-    # ---
-    # !foo
-    #   - bar
-    # ---
-    # !foo
-    #   bar: baz
-    #
-    # Find the value in the respective attribute, e.g. `coder.scalar`:
-    coder.scalar.upcase
-
-    # NOTE when needing just one argument, supporting both scalar and seq allows for chaining:
-    # a: !my/inc 4 # scalar suffices
-    # ...but when chaining, a seq is required:
-    # a: !my/inc [!my/square 2]
-  end
-
-  # Other configuration options:
-  #
-  # `config_dir` (default: Pathname.pwd) - path used for expanding non-Pathnames passed to `load_config`, e.g.
-  # `Nero.load_config(:app)` loads file `Pathname.pwd / "app.yml"`.
-  nero.config_dir = Rails.root / "config"
-end
-```
+### custom tags
+
+Three ways to do this:
+
+1. a block  
+    ```ruby
+    Nero.configure do |nero|
+      nero.add_tag("upcase") do |tag|
+        # `tag` is a `Nero::BaseTag`.
+        # In YAML args are provided as scalar, seq or map:
+        # ---
+        # k: !upcase bar
+        # ---
+        # k: !upcase [bar] # equivalent to:
+        # k: !upcase
+        #   - bar
+        # ---
+        # k: !upcase
+        #   bar: baz
+        #
+        # Find these args via `tag.args` (Array or Hash):
+        case tag.args
+        when Hash
+          tag.args.each_with_object({}) {|(k,v), acc| acc[k] = v.upcase }
+        else
+          tag.args.map(&:upcase)
+        end
+
+        # NOTE though you might just need one argument, it's helpful to accept a seq nonetheless
+        # as it allows for chaining:
+        # a: !my/inc 4 # scalar suffices
+        # ...but when chaining, it comes as a seq:
+        # a: !my/inc [!my/square 2]
+      end
+    end
+    ```
+1. re-use existing tag-class  
+   You can add an existing tag under a better fitting name this way.  
+   Also: some tag-classes have options that allow for simple customizations (like `coerce` below):
+    ```ruby
+    Nero.configure do |nero|
+      nero.add_tag("env/upcase", klass: Nero::EnvTag[coerce: :upcase])
+
+      # Alias for path/git_root:
+      nero.add_tag("path/project_root", klass: Nero::PathRootTag[containing: '.git'])
+    end
+    ```
+1. custom class  
+   ```ruby
+   class RotTag < Nero::BaseTag
+     # Configure:
+     # ```
+     # config.add_tag("rot/12", klass: RotTag[n: 12])
+     # config.add_tag("rot/10", klass: RotTag[n: 10]) do |secret|
+     #   "#{secret} (try breaking this!)"
+     # end
+     # ```
+     #
+     # Usage in YAML:
+     # ```
+     # secret: !rot/12 some message
+     # very_secret: !rot/10 [ !env [ MSG, some message ] ]
+     # ```
+     # => {secret: "EAyq yqEEmsq", very_secret: "Cywo woCCkqo (try breaking this!)"}
+   
+     # By overriding `init_options` we can restrict/require options,
+     # provide default values and do any other setup.  
+     # By default an option is available via `options[:foo]`.
+     def init_options(n: 10)
+       super # no specific assignments, so available via `options[:n]`.
+     end
+
+     def chars
+       @chars ||= (('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a)
+     end
+
+     def resolve(**) # currently no keywords are passed, but `**` allows for future ones.
+       # Here we actually do the work: get the args, rotate strings and delegate to the block.
+       # `args` are the resolved nested args (so e.g. `!env MSG` is already resolved).
+       # `config` is the tag's config, and contains e.g. the block.
+       block = config.fetch(:block, :itself.to_proc)
+       # String#tr replaces any character from the first collection with the same position in the other:
+       args.join.tr(chars.join, chars.rotate(options[:n]).join).then(&block)
+     end
+   end
+   ```
 
 ## Development
 

data/lib/nero/version.rb

@@ -3,5 +3,5 @@
 module Nero
   # NOTE this is written upon release via:
   # $ rake gem:build[version=0.3.0]
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/nero.rb

@@ -4,8 +4,9 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.setup
 
-require "uri" # why needed?
+require "uri"
 require "yaml"
+require "pathname"
 
 # TODO fail on unknown tag
 # TODO show missing env's at once
@@ -16,7 +17,7 @@ module Nero
   module Resolvable
     def try_resolve(ctx, object)
       if object.respond_to?(:resolve)
-        object.resolve(ctx)
+        object.resolve(**ctx)
       else
         object
       end
@@ -29,6 +30,15 @@ module Nero
     def deep_resolve(object, **ctx)
       Util.deep_transform_values(object, &gen_resolve_tryer(ctx))
     end
+
+    def resolve_nested!(coder, ctx = {})
+      case coder.type
+      when :seq
+        coder.seq.map!(&gen_resolve_tryer(ctx))
+      when :map
+        coder.map = deep_resolve(coder.map, **ctx)
+      end
+    end
   end
   extend Resolvable
   private_class_method \
@@ -36,37 +46,23 @@ module Nero
     :gen_resolve_tryer,
     :try_resolve
 
-  class TagResolver
-    include Resolvable
+  class Configuration
+    attr_reader :tags, :config_dir
 
-    def init_with(coder)
-      @coder = coder
+    def config_dir=(dir)
+      @config_dir = Pathname(dir).expand_path
     end
 
-    def resolve(ctx)
-      resolve_nested!(ctx)
-      ctx[:tags][@coder.tag].call(@coder, ctx)
-    end
+    def add_tag(name, klass: BaseTag, &block)
+      klass, klass_options = klass
 
-    def resolve_nested!(ctx)
-      case @coder.type
-      when :seq
-        @coder.seq.map!(&gen_resolve_tryer(ctx))
-      when :map
-        @coder.map = deep_resolve(@coder.map, **ctx)
+      (@tags ||= {})[name] = {klass:}.tap do |h|
+        h[:block] = block if block
+        h[:options] = klass_options if klass_options
       end
     end
   end
 
-  class Configuration
-    attr_reader :tags
-    attr_accessor :config_dir
-
-    def add_tag(name, &block)
-      (@tags ||= {})["!#{name}"] = block
-    end
-  end
-
   def self.configuration
     @configuration ||= Configuration.new
   end
@@ -75,92 +71,221 @@ module Nero
     yield configuration if block_given?
   end
 
-  # helpers for configuration
-  # module TagHelpers
-  #  def to_boolean(s)
-  #  end
-  # end
+  class BaseTag
+    include Resolvable
 
-  def self.add_default_tags!
-    # extend TagHelpers
+    attr_reader :coder, :options, :ctx
 
-    configure do |config|
-      config.add_tag("ref") do |coder, ctx|
-        # validate: non-empty coder.seq, only strs, path must exists in ctx[:config]
+    def self.[](**options)
+      [self, options]
+    end
+
+    # used by YAML
+    def init_with(coder)
+      @coder = coder
+    end
+
+    def init(ctx:, options:)
+      init_ctx(ctx)
+      init_options(**options)
+    end
+
+    def init_ctx(ctx)
+      @ctx = ctx
+    end
+
+    def init_options(**options)
+      @options = options
+    end
 
-        path = coder.seq.map(&:to_sym)
-        deep_resolve(ctx[:config].dig(*path), **ctx)
+    def tag_name
+      coder.tag[1..]
+    end
+
+    def args
+      @args ||= begin
+        resolve_nested!(coder, {})
+        case coder.type
+        when :map then Util.deep_symbolize_keys(coder.map)
+        else
+          Array(coder.public_send(coder.type))
+        end
       end
+    end
 
-      config.add_tag("env/integer") do |coder|
-        Integer(env_fetch(*(coder.scalar || coder.seq), all_optional: "999"))
+    def config
+      ctx.dig(:tags, tag_name)
+    end
+
+    def resolve(**)
+      if (block = config[:block])
+        if block.parameters.map(&:last).include?(:coder)
+          # legacy
+          block.call(coder, ctx)
+        else
+          block.call(self)
+        end
+      else
+        args
       end
+    end
+  end
 
-      config.add_tag("env/integer?") do |coder|
-        Integer(ENV[coder.scalar]) if ENV[coder.scalar]
+  # Requires an env-var to be available and coerces the value.
+  # When tag-name ends with "?", the env-var is optional.
+  #
+  # Given config:
+  # config.add_tag("env/upcase", klass: Nero::EnvTag[coerce: :upcase])
+  # config.add_tag("env/upcase?", klass: Nero::EnvTag[coerce: :upcase])
+
+  # Then YAML => result:
+  # "--- env/upcase [MSG, Hello World]" => "HELLO WORLD"
+  # "--- env/upcase MSG" => raises when not ENV.has_key? "MSG"
+  # "--- env/upcase? MSG" => nil
+  #
+  # Args supported:
+  # - scalar
+  #  name of env-var, e.g. `!env HOME`
+  # - seq
+  #  name of env-var and fallback, e.g. `!env [HOME, /root]`
+
+  # Options:
+  # - coerce - symbol or proc to be applied to value of env-var.
+  #   when using coerce, the block is ignoerd.
+  #
+  class EnvTag < BaseTag
+    def resolve(**)
+      if coercer
+        coercer.call(env_value) unless env_value.nil?
+      elsif ctx.dig(:tags, tag_name, :block)
+        super
+      else
+        env_value
       end
+    end
 
-      config.add_tag("env/bool") do |coder|
-        re_true = /y|Y|yes|Yes|YES|true|True|TRUE|on|On|ON/
-        re_false = /n|N|no|No|NO|false|False|FALSE|off|Off|OFF/
-
-        coerce = ->(s) do
-          case s
-          when TrueClass, FalseClass then s
-          when re_true then true
-          when re_false then false
-          else
-            raise "bool value should be one of y(es)/n(o), on/off, true/false (got #{s.inspect})"
-          end
-        end
+    def coercer
+      return unless @coerce
 
-        coerce[env_fetch(*(coder.scalar || coder.seq), all_optional: "false")]
+      @coercer ||= case @coerce
+      when Symbol then @coerce.to_proc
+      else
+        @coerce
       end
+    end
 
-      config.add_tag("env/bool?") do |coder|
-        re_true = /y|Y|yes|Yes|YES|true|True|TRUE|on|On|ON/
-        re_false = /n|N|no|No|NO|false|False|FALSE|off|Off|OFF/
-
-        coerce = ->(s) do
-          case s
-          when TrueClass, FalseClass then s
-          when re_true then true
-          when re_false then false
-          else
-            raise "bool value should be one of y(es)/n(o), on/off, true/false (got #{s.inspect})"
-          end
-        end
+    def init_options(coerce: nil)
+      @coerce = coerce
+    end
+
+    def optional
+      tag_name.end_with?("?") || !!ENV["NERO_ENV_ALL_OPTIONAL"]
+    end
+    alias_method :optional?, :optional
 
-        ENV[coder.scalar] ? coerce[ENV[coder.scalar]] : false
+    def env_value
+      self.class.env_value(*args, optional:)
+    end
+
+    def self.env_value(k, fallback = nil, optional: false)
+      if fallback.nil? && !optional
+        ENV.fetch(k)
+      else
+        ENV.fetch(k, fallback)
       end
+    end
+
+    def self.coerce_bool(v)
+      return false unless v
+
+      re_true = /y|Y|yes|Yes|YES|true|True|TRUE|on|On|ON/
+      re_false = /n|N|no|No|NO|false|False|FALSE|off|Off|OFF/
 
-      config.add_tag("env") do |coder|
-        env_fetch(*(coder.scalar || coder.seq))
+      case v
+      when TrueClass, FalseClass then v
+      when re_true then true
+      when re_false then false
+      else
+        raise "bool value should be one of y(es)/n(o), on/off, true/false (got #{v.inspect})"
       end
+    end
+  end
 
-      config.add_tag("env?") do |coder|
-        fetch_args = coder.scalar ? [coder.scalar, nil] : coder.seq
-        ENV.fetch(*fetch_args)
+  # Construct path relative to some root-path.
+  # Root-paths are expected to be ancestors of the yaml-file being parsed.
+  # They are found by traversing up and checking for specific files/folders, e.g. '.git' or 'Gemfile'.
+  # Any argument is appended to the root-path, constructing a path-instance that may exist.
+  class PathRootTag < BaseTag
+    # Config:
+    # config.add_tag("path/git_root", klass: PathRootTag[containing: ".git"])
+    # config.add_tag("path/rails_root", klass: PathRootTag[containing: "Gemfile"])
+    #
+    # YAML:
+    # project_root: !path/git_root
+    # config_path: !path/git_root [ config ]
+    def init_options(containing:)
+      super
+    end
+
+    def resolve(**)
+      # TODO validate upfront
+      raise <<~ERR unless root_path
+        #{tag_name}: failed to find root-path (ie an ancestor of #{ctx[:yaml_file]} containing #{options[:containing].inspect}).
+      ERR
+      root_path.join(*args).then(&config.fetch(:block, :itself.to_proc))
+    end
+
+    def root_path
+      find_up(ctx[:yaml_file], options[:containing])
+    end
+
+    def find_up(path, containing)
+      (path = path.parent) until path.root? || (path / containing).exist?
+      path unless path.root?
+    end
+  end
+
+  def self.add_default_tags!
+    configure do |config|
+      config.add_tag("ref") do |tag|
+        # validate: non-empty coder.seq, only strs, path must exists in ctx[:config]
+
+        path = tag.args.map(&:to_sym)
+        deep_resolve(tag.ctx[:yaml].dig(*path), **{})
       end
 
-      config.add_tag("path") do |coder|
-        Pathname.new(coder.scalar || coder.seq.join("/"))
+      config.add_tag("env", klass: EnvTag)
+      config.add_tag("env?", klass: EnvTag)
+      config.add_tag("env/float", klass: EnvTag[coerce: :to_f])
+      config.add_tag("env/float?", klass: EnvTag[coerce: :to_f])
+
+      config.add_tag("env/integer", klass: EnvTag[coerce: :to_i])
+      config.add_tag("env/integer?", klass: EnvTag[coerce: :to_i])
+
+      config.add_tag("env/bool", klass: EnvTag) do |tag|
+        EnvTag.coerce_bool(tag.env_value)
+      end
+      config.add_tag("env/bool?", klass: EnvTag) do |tag|
+        EnvTag.coerce_bool(tag.env_value)
       end
 
-      config.add_tag("uri") do |coder|
-        URI(coder.scalar || coder.seq.join)
+      config.add_tag("path") do |tag|
+        Pathname.new(tag.args.join("/"))
       end
+      config.add_tag("path/git_root", klass: PathRootTag[containing: ".git"])
+      config.add_tag("path/rails_root", klass: PathRootTag[containing: "config.ru"])
 
-      config.add_tag("str/format") do |coder|
-        case coder.type
-        when :seq
-          sprintf(*coder.seq)
-        when :map
-          m = Util.deep_symbolize_keys(coder.map)
-          fmt = m.delete(:fmt)
-          sprintf(fmt, m)
+      config.add_tag("uri") do |tag|
+        URI.join(*tag.args.join)
+      end
+
+      config.add_tag("str/format") do |tag|
+        case tag.args
+        when Hash
+          fmt = tag.args.delete(:fmt)
+          sprintf(fmt, tag.args)
         else
-          coder.scalar
+          sprintf(*tag.args)
         end
       end
     end
@@ -178,28 +303,24 @@ module Nero
   end
   reset_configuration!
 
-  def self.env_fetch(k, fallback = nil, all_optional: "dummy")
-    fallback ||= all_optional if ENV["NERO_ENV_ALL_OPTIONAL"]
-
-    fallback.nil? ? ENV.fetch(k) : ENV.fetch(k, fallback)
+  def self.yaml_options
+    {
+      permitted_classes: [Symbol] + configuration.tags.values.map { _1[:klass] },
+      aliases: true
+    }
   end
-  private_class_method :env_fetch
-
-  @yaml_options = {
-    permitted_classes: [Symbol, TagResolver],
-    aliases: true
-  }
+  private_class_method :yaml_options
 
-  def self.load_config(file, root: nil, env: nil)
+  def self.load_config(file, root: nil, env: nil, resolve: true)
     root ||= env
     add_tags!
 
-    file = resolve_file(file)
+    config_file = resolve_file(file)
 
-    if file.exist?
-      process_yaml(yaml_load_file(file, @yaml_options), root:)
+    if config_file.exist?
+      process_yaml(yaml_load_file(config_file, yaml_options), root:, config_file:, resolve:)
     else
-      raise "Can't find file #{file}"
+      raise "Can't find file #{config_file}"
     end
   end
 
@@ -213,22 +334,37 @@ module Nero
   end
   private_class_method :resolve_file
 
-  def self.load(raw, root: nil, env: nil)
+  def self.load(raw, root: nil, env: nil, resolve: true)
     root ||= env
     add_tags!
 
-    process_yaml(yaml_load(raw, @yaml_options), root:)
+    process_yaml(yaml_load(raw, yaml_options), root:, resolve:)
   end
 
-  def self.process_yaml(yaml, root: nil)
+  def self.process_yaml(yaml, root: nil, resolve: true, config_file: nil)
+    config_file ||= (Pathname.pwd / __FILE__)
+
     unresolved = Util.deep_symbolize_keys(yaml).then do
       root ? _1[root.to_sym] : _1
     end
+    ctx = {tags: configuration.tags, yaml: unresolved, yaml_file: config_file}
+    init_tags!(collect_tags(unresolved), ctx:)
 
-    deep_resolve(unresolved, tags: configuration.tags, config: unresolved)
+    return unresolved unless resolve
+
+    # NOTE originally ctx was passed at this point. Maybe delete this.
+    deep_resolve(unresolved, **{})
   end
   private_class_method :process_yaml
 
+  def self.init_tags!(tags, ctx:)
+    tags.each do |tag|
+      options = ctx.dig(:tags, tag.tag_name, :options) || {}
+      tag.init(ctx:, options:)
+    end
+  end
+  private_class_method :init_tags!
+
   def self.yaml_load_file(file, opts = {})
     if Psych::VERSION < "4"
       YAML.load_file(file)
@@ -248,11 +384,33 @@ module Nero
   private_class_method :yaml_load
 
   def self.add_tags!
-    configuration.tags.keys.each do
-      YAML.add_tag(_1, TagResolver)
+    configuration.tags.each do |tag_name, tag|
+      YAML.add_tag("!#{tag_name}", tag[:klass])
     end
   end
   private_class_method :add_tags!
+
+  def self.collect_tags(obj)
+    case obj
+    when Hash
+      obj.each_value.flat_map { collect_tags(_1) }.compact
+    when Nero::BaseTag
+      [obj] +
+        case obj.coder.type
+        when :seq
+          collect_tags(obj.coder.seq)
+        when :map
+          collect_tags(obj.coder.map)
+        else
+          []
+        end
+    when Array
+      obj.flat_map { collect_tags(_1) }.compact
+    else
+      []
+    end
+  end
+  private_class_method :collect_tags
 end
 
 loader.eager_load if ENV.key?("CI")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: nero
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Gert Goet
 bindir: exe
 cert_chain: []
-date: 2025-02-15 00:00:00.000000000 Z
+date: 2025-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk