nero 0.5.0 → 0.7.0.rc2

data/lib/nero/rails.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "rails/credentials_tag"
+require_relative "rails/duration_tag"
+require_relative "rails/string_inquirer_tag"
+
+module Nero
+  module Rails
+    module ParserExtension
+      def initialize(environ: ENV, root: nil, &block)
+        super(environ:, root:)
+        add_tag("credentials", Nero::Rails::CredentialsTag.new(::Rails.application.credentials))
+        add_tag("path/rails_root", RootPathTag.new(containing: "config.ru"))
+        add_tag("secret_key_base", ->(_, **) { ::Rails.application.secret_key_base })
+        add_tag("str/inquirer", Nero::Rails::StringInquirerTag.new)
+        add_tag("duration", Nero::Rails::DurationTag.new)
+        block&.call(self)
+      end
+    end
+  end
+end
+
+Nero::Parser.prepend(Nero::Rails::ParserExtension)
+
+module Nero
+  module Rails
+    module DefaultEnv
+      def config_for(file, env: ::Rails.env, **opts, &block)
+        super(file, env:, **opts, &block)
+      end
+    end
+  end
+end
+
+Nero.singleton_class.prepend(Nero::Rails::DefaultEnv)

data/lib/nero/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "rails"
+
+module Nero
+  # @private
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/nero/ref.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nero
+  class Ref
+    attr_reader :path
+
+    def initialize(path) = @path = path.split(".")
+  end
+end

data/lib/nero/ref_tag.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nero
+  class RefTag < BaseTag
+    def resolve(args, context:)
+      Ref.new(args[0].to_s)
+    end
+  end
+end

data/lib/nero/result.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nero
+  class Result
+    attr_reader :value, :errors
+
+    def initialize(value, errors = [])
+      @value = value
+      @errors = errors
+    end
+
+    def ok? = errors.empty?
+
+    def value!
+      raise ParseError, errors unless ok?
+      value
+    end
+  end
+end

data/lib/nero/root_path_tag.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nero
+  class RootPathTag < BaseTag
+    def initialize(containing:)
+      @containing = containing
+    end
+
+    def resolve(args, context:)
+      relative_path = args[0]&.then { |p| p.empty? ? nil : p }
+      dir = context.dir
+
+      loop do
+        if File.exist?(File.join(dir, @containing))
+          return relative_path ? Pathname.new(File.join(dir, relative_path)) : Pathname.new(dir)
+        end
+        parent = File.dirname(dir)
+        if parent == dir
+          context.add_error("could not find #{@containing} in any ancestor of #{context.dir}")
+          return nil
+        end
+        dir = parent
+      end
+    end
+  end
+end

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.5.0"
+  VERSION = "0.7.0.rc2"
 end

data/lib/nero/visitor.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nero
+  class Visitor < ::Psych::Visitors::ToRuby
+    def self.build(tags, ctx)
+      visitor = create
+      visitor.instance_variable_set(:@nero_tags, tags)
+      visitor.instance_variable_set(:@nero_ctx, ctx)
+      visitor
+    end
+
+    def visit_Psych_Nodes_Scalar(o)
+      handler = find_nero_tag(o.tag)
+      return super unless handler
+
+      o.tag = nil
+      handler.resolve([super], context: @nero_ctx)
+    end
+
+    def visit_Psych_Nodes_Sequence(o)
+      handler = find_nero_tag(o.tag)
+      return super unless handler
+
+      o.tag = nil
+      args = super
+      contains_ref?(args) ? Deferred.new(handler, args) : handler.resolve(args, context: @nero_ctx)
+    end
+
+    def visit_Psych_Nodes_Mapping(o)
+      handler = find_nero_tag(o.tag)
+      return super unless handler
+
+      o.tag = nil
+      args = super
+      contains_ref?(args) ? Deferred.new(handler, args) : handler.resolve(args, context: @nero_ctx)
+    end
+
+    private
+
+    def find_nero_tag(tag)
+      return nil unless tag&.start_with?("!")
+      @nero_tags[tag[1..]]
+    end
+
+    def contains_ref?(value)
+      case value
+      when Ref, Deferred then true
+      when Hash then value.values.any? { |v| contains_ref?(v) }
+      when Array then value.any? { |v| contains_ref?(v) }
+      else false
+      end
+    end
+  end
+end

data/lib/nero.rb

@@ -1,416 +1,42 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
-loader = Zeitwerk::Loader.for_gem
-loader.setup
-
-require "uri"
-require "yaml"
 require "pathname"
+require "psych"
+require "set"
+
+require_relative "nero/version"
+require_relative "nero/error"
+require_relative "nero/result"
+require_relative "nero/context"
+require_relative "nero/ref"
+require_relative "nero/deferred"
+require_relative "nero/base_tag"
+require_relative "nero/proc_tag"
+require_relative "nero/ref_tag"
+require_relative "nero/env_tag"
+require_relative "nero/root_path_tag"
+require_relative "nero/format_tag"
+require_relative "nero/visitor"
+require_relative "nero/parser"
 
-# TODO fail on unknown tag
-# TODO show missing env's at once
-# TODO raise when missing arg(s) for tag
 module Nero
-  class Error < StandardError; end
-
-  module Resolvable
-    def try_resolve(ctx, object)
-      if object.respond_to?(:resolve)
-        object.resolve(**ctx)
-      else
-        object
-      end
-    end
-
-    def gen_resolve_tryer(ctx)
-      method(:try_resolve).curry.call(ctx)
-    end
-
-    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 \
-    :deep_resolve,
-    :gen_resolve_tryer,
-    :try_resolve
-
-  class Configuration
-    attr_reader :tags, :config_dir
-
-    def config_dir=(dir)
-      @config_dir = Pathname(dir).expand_path
-    end
-
-    def add_tag(name, klass: BaseTag, &block)
-      klass, klass_options = klass
-
-      (@tags ||= {})[name] = {klass:}.tap do |h|
-        h[:block] = block if block
-        h[:options] = klass_options if klass_options
-      end
-    end
-  end
-
-  def self.configuration
-    @configuration ||= Configuration.new
-  end
-
-  def self.configure
-    yield configuration if block_given?
-  end
-
-  class BaseTag
-    include Resolvable
-
-    attr_reader :coder, :options, :ctx
-
-    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
-
-    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
-
-    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
-
-  # 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
-
-    def coercer
-      return unless @coerce
-
-      @coercer ||= case @coerce
-      when Symbol then @coerce.to_proc
-      else
-        @coerce
-      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
-
-    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/
-
-      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
+  def self.parse(yaml, **opts, &block)
+    Parser.new(**opts, &block).parse(yaml).value!
   end
 
-  # 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
+  def self.parse_file(path, env: nil, root: nil, &block)
+    root ||= env&.to_s
+    Parser.new(root: root, &block).parse_file(path).value!
   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("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("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("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
-          sprintf(*tag.args)
-        end
-      end
-    end
-  end
-  private_class_method :add_default_tags!
-
-  def self.reset_configuration!
-    @configuration = nil
-
-    configure do |config|
-      config.config_dir = Pathname.pwd
-    end
-
-    add_default_tags!
-  end
-  reset_configuration!
-
-  def self.yaml_options
-    {
-      permitted_classes: [Symbol] + configuration.tags.values.map { _1[:klass] },
-      aliases: true
-    }
-  end
-  private_class_method :yaml_options
-
-  def self.load_config(file, root: nil, env: nil, resolve: true)
-    root ||= env
-    add_tags!
-
-    config_file = resolve_file(file)
-
-    if config_file.exist?
-      process_yaml(yaml_load_file(config_file, yaml_options), root:, config_file:, resolve:)
-    else
-      raise "Can't find file #{config_file}"
-    end
-  end
-
-  def self.resolve_file(file)
-    case file
+  def self.config_for(file, env: nil, root: nil, &block)
+    root ||= env&.to_s
+    path = case file
     when Pathname then file
-    # TODO expand full path
-    else
-      configuration.config_dir / "#{file}.yml"
-    end
-  end
-  private_class_method :resolve_file
-
-  def self.load(raw, root: nil, env: nil, resolve: true)
-    root ||= env
-    add_tags!
-
-    process_yaml(yaml_load(raw, yaml_options), root:, resolve:)
-  end
-
-  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:)
-
-    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)
-    else
-      YAML.load_file(file, **opts)
-    end
-  end
-  private_class_method :yaml_load_file
-
-  def self.yaml_load(file, opts = {})
-    if Psych::VERSION < "4"
-      YAML.load(file)
-    else
-      YAML.load(file, **opts)
-    end
-  end
-  private_class_method :yaml_load
-
-  def self.add_tags!
-    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
-      []
+    else Pathname.new("config") / "#{file}.yml"
     end
+    parse_file(path.expand_path, root: root, &block)
   end
-  private_class_method :collect_tags
 end
 
-loader.eager_load if ENV.key?("CI")
+require_relative "nero/railtie" if defined?(Rails::Railtie)

data/rakelib/gem.rake

@@ -1,4 +1,5 @@
 namespace :gem do
+  desc "Write new version to version.rb"
   task "write_version", [:version] do |_task, args|
     if args[:version]
       version = args[:version].split("=").last
@@ -8,18 +9,11 @@ namespace :gem do
         ruby -pi -e 'gsub(/VERSION = ".*"/, %{VERSION = "#{version}"})' #{version_file}
       CMD
       Bundler.ui.confirm "Version #{version} written to #{version_file}."
+
+      system("bundle install", exception: true)
+      Bundler.ui.confirm "Gemfile.lock updated."
     else
       Bundler.ui.warn "No version provided, keeping version.rb as is."
     end
   end
-
-  desc "Build [version]"
-  task "build", [:version] => %w[write_version] do
-    Rake::Task["build"].invoke
-  end
-
-  desc "Build and push [version] to rubygems"
-  task "release", [:version] => %w[build] do
-    Rake::Task["release:rubygem_push"].invoke
-  end
 end

data/rakelib/yard.rake

@@ -0,0 +1,12 @@
+require "yard"
+
+YARD::Rake::YardocTask.new(:docs) do |t|
+  # Options defined in `.yardopts` are read first, then merged with
+  # options defined here.
+  #
+  # It's recommended to define options in `.yardopts` instead of here,
+  # as `.yardopts` can be read by external YARD tools, like the
+  # hot-reload YARD server `yard server --reload`.
+
+  # t.options += ['--title', "Something custom"]
+end