sourced-component 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/env.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# Run with: bundle exec ruby examples/env.rb
+# Override any variable, ex: APP_PORT=9000 APP_DEBUG=false bundle exec ruby examples/env.rb
+
+require 'date'
+require 'bundler/setup'
+require 'sourced/component'
+
+T = Sourced::Component::T
+
+# Sample ENV, unless already set
+ENV['USER_NAME'] ||= 'Ismael'
+ENV['USER_DOB'] ||= '1977-11-29'
+ENV['USER_EMAIL'] ||= 'ismael@example.com'
+ENV['APP_HOST'] ||= 'localhost'
+ENV['APP_PORT'] ||= '3000'
+ENV['APP_DEBUG'] ||= 'true'
+
+# Declared types. ENV values are strings, decoded into these types with Plumb::Codec::Forms
+User = T::Data[name: String, dob: Date]
+AppSettings = T::Data[
+  host: String,
+  port: Integer,
+  debug: T::Boolean,
+  workers: T::Integer.default(2) # no APP_WORKERS in ENV: uses the default
+]
+Shell = T::Data[user: String, home: String]
+
+App = Sourced::Component.new
+
+App.declare('user.email', T::Email)
+App.declare('app.port', Integer)
+App.declare('user.info', User)
+App.declare('app.settings', AppSettings)
+App.declare('shell', Shell)
+
+# Single variables, decoded into each declared type
+App.env('USER_EMAIL' => 'user.email', 'APP_PORT' => 'app.port')
+
+# Variables matching a regex, collected into a hash with the match removed,
+# and downcased: USER_NAME => name, USER_DOB => dob
+App.env(:downcase, /^USER_/ => 'user.info', /^APP_/ => 'app.settings')
+
+# All variables, downcased: picks up the system's USER and HOME.
+# This is why collecting with a regex matters for anything that isn't meant to read system variables.
+App.env(:downcase, 'shell')
+
+App.start!
+
+puts "== Components\n\n"
+%w[user.email app.port user.info app.settings shell].each do |key|
+  value = App[key]
+  puts "#{key}: #{(value.respond_to?(:to_h) ? value.to_h : value).inspect}"
+end
+
+puts "\n== Component\n\n"
+puts App.ordered_nodes.map(&:inspect)
+
+# Missing or invalid variables fail the boot, naming each variable
+puts "\n== Missing variables\n\n"
+
+Broken = Sourced::Component.new
+Broken.declare('payments.settings', T::Data[api_key: String, region: String])
+Broken.declare('payments.webhook', T::String[/\Ahttps:/])
+Broken.env(:downcase, /^PAYMENTS_/ => 'payments.settings')
+Broken.env('PAYMENTS_WEBHOOK_URL' => 'payments.webhook')
+
+begin
+  Broken.start!
+  puts "payments.settings: #{Broken['payments.settings'].to_h.inspect}"
+  puts "payments.webhook: #{Broken['payments.webhook'].inspect}"
+rescue Plumb::ParseError => e
+  puts "boot failed: #{e.class}\n#{e.message}\n\n"
+  puts 'try: PAYMENTS_API_KEY=abc PAYMENTS_REGION=eu PAYMENTS_WEBHOOK_URL=https://example.com bundle exec ruby examples/env.rb'
+end
+
+App.teardown!

data/examples/tree.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+# Run with: bundle exec ruby examples/tree.rb (Ctrl-C to stop), or RUN_FOR=2 bundle exec ruby examples/tree.rb
+
+require 'bundler/setup'
+require 'sourced/component'
+require 'logger'
+
+T = Sourced::Component::T
+
+class FakeDB
+  attr_reader :name, :logger
+
+  def initialize(name, logger:)
+    @name = name
+    @logger = logger
+  end
+
+  def connect = logger.info("#{name}: connect")
+  def disconnect = logger.info("#{name}: disconnect")
+  def insert(job) = logger.info("#{name}: insert #{job}")
+end
+
+# A long-running component: processes jobs in a background thread.
+# Start hooks run while holding the root's lock, so #start spawns the thread and returns.
+class Worker
+  def initialize(db, logger:)
+    @db = db
+    @logger = logger
+    @queue = Queue.new
+    @thread = nil
+  end
+
+  def <<(job)
+    @queue << job
+    self
+  end
+
+  def start
+    @thread = Thread.new do
+      while (job = @queue.pop) != :stop
+        @db.insert(job)
+      end
+    end
+    @logger.info('worker: started')
+  end
+
+  # Process what's queued, then stop
+  def stop
+    return unless @thread
+
+    @queue << :stop
+    @thread.join
+    @logger.info('worker: stopped')
+  end
+end
+
+# Another long-running component: pushes a job to the worker on an interval
+class Ticker
+  def initialize(worker, interval:, logger:, &job)
+    @worker = worker
+    @interval = interval
+    @logger = logger
+    @job = job
+    @thread = nil
+  end
+
+  def start
+    @thread = Thread.new do
+      loop do
+        sleep @interval
+        @worker << @job.call
+      end
+    end
+    @logger.info("ticker: every #{@interval}s")
+  end
+
+  def stop
+    @thread&.kill&.join
+    @logger.info('ticker: stopped')
+  end
+end
+
+# ---- A library, with its own root component ------------------------------------
+
+Library = Sourced::Component.new
+Library.declare('logger', T::Interface[:info]) { Logger.new($stdout, progname: 'sourced') }
+Library.declare('db', FakeDB)
+Library.component!('db', ['logger']) do
+  build { |logger| FakeDB.new('sourced-db', logger:) }
+  start { |db, _| db.connect }
+  teardown { |db| db.disconnect }
+end
+
+# ---- An app, mounting it -----------------------------------------------------------
+
+App = Sourced::Component.new
+App.declare('logger', T::Interface[:info]) { Logger.new($stdout, progname: 'app') }
+App.mount('sourced', Library)
+
+# Re-implement the library's db, with the app's own logger. Deps are relative to App
+App.component!('sourced.db', ['logger']) do
+  build { |logger| FakeDB.new('app-db', logger:) }
+  start { |db, _| db.connect }
+  teardown { |db| db.disconnect }
+end
+
+# Nested declarations: App owns 'cache' and 'cache.redis', so it can keep declaring under them
+App.declare('cache.redis', String)
+App.declare('cache.redis.pool', Integer)
+
+# Configs: components with only a build step. config! is a singleton
+App.config!('cache.redis') { 'redis://localhost' }
+App.config!('cache.redis.pool', ['sourced.settings.retries']) { |retries| retries + 2 }
+
+# A dynamic config, built on each read
+counter = 0
+App.declare('request_id', String)
+App.config('request_id') { "req-#{counter += 1}" }
+
+# The library can still declare more after being mounted; App's index picks them up
+Library.declare('settings.retries', Integer) { 3 }
+
+# The library's classes inject from the library's own root component.
+# Defined before the component is built: values are read on instantiation
+class Dispatcher
+  include Library.inject('db', 'settings.retries')
+
+  def dispatch(event) = db.insert(event)
+end
+
+# Long-running components. The ticker depends on the worker, so it starts after it and is torn down before it
+App.declare('worker', Worker)
+App.component!('worker', ['sourced.db', 'logger']) do
+  build { |db, logger| Worker.new(db, logger:) }
+  start { |worker, _| worker.start }
+  teardown { |worker| worker.stop }
+end
+
+App.declare('ticker', Ticker)
+App.component!('ticker', ['worker', 'logger']) do
+  # Read the dynamic request_id on each tick: a fresh value every time
+  build { |worker, logger| Ticker.new(worker, interval: 0.5, logger:) { "job #{App['request_id']}" } }
+  start { |ticker, _| ticker.start }
+  teardown { |ticker| ticker.stop }
+end
+
+puts '== Ownership'
+begin
+  App.declare('sourced.extra', String)
+rescue Sourced::Component::OwnershipError => e
+  puts "App.declare('sourced.extra') => #{e.class}: #{e.message}"
+end
+
+puts "\n== Index"
+puts App.index.keys.join(', ')
+
+# Lifecycle events go to the root's notifier, for every component in the tree
+App.notifier.subscribe('components.built') do |event|
+  puts format('built %-26s (%.3fms)', event.payload.key, event.payload.duration * 1000)
+end
+App.notifier.subscribe('components.failed') do |event|
+  puts "failed #{event.payload.key} (#{event.payload.stage}): #{event.payload.error_class}: #{event.payload.error_message}"
+end
+App.notifier.subscribe('components.torn_down') do |event|
+  puts format('torn_down %-26s (%.3fms)', event.payload.key, event.payload.duration * 1000)
+end
+
+puts "\n== Boot"
+begin
+  Library.start!
+rescue Sourced::Component::SubcomponentError => e
+  puts "Library.start! => #{e.class}: #{e.message}"
+end
+App.start!
+puts App.ordered_nodes.map(&:inspect)
+
+puts "\n== Tree\n\n"
+puts App.tree
+puts App.tree.to_mermaid
+
+puts "\n== Graph (paste into https://mermaid.live)\n\n"
+puts App.graph.to_mermaid
+
+puts "\n== Read"
+puts "App['sourced.db'].name      => #{App['sourced.db'].name}"
+puts "Library['db'].name          => #{Library['db'].name} (the app's override, seen by the library)"
+puts "same object                 => #{App['sourced.db'].equal?(Library['db'])}"
+puts "Library['db'].logger        => #{Library['db'].logger.progname}"
+puts "Dispatcher.new.db.name      => #{Dispatcher.new.db.name} (injected from the library's component)"
+puts "Dispatcher.new.retries      => #{Dispatcher.new.retries}"
+puts "Dispatcher.new(db: ...).db  => #{Dispatcher.new(db: :fake).db}"
+puts "App['sourced.settings.retries'] => #{App['sourced.settings.retries']}"
+puts "App['cache.redis.pool']     => #{App['cache.redis.pool']}"
+puts "App['request_id'] x2        => #{App['request_id']}, #{App['request_id']}"
+begin
+  App['cache']
+rescue Sourced::Component::UndeclaredComponentError => e
+  puts "App['cache'] => #{e.class}: #{e.message}"
+end
+
+begin
+  App.declare('late', String)
+rescue Sourced::Component::LockedComponentError => e
+  puts "App.declare('late') => #{e.class}: #{e.message}"
+end
+
+# Run until Ctrl-C or SIGTERM, or for RUN_FOR seconds, ex. RUN_FOR=2 bundle exec ruby examples/tree.rb
+# Components run in their own threads, so the main thread only waits. Teardown always runs.
+run_for = ENV['RUN_FOR']&.to_f
+puts "\n== Running #{run_for ? "for #{run_for}s" : '(Ctrl-C to stop)'}"
+trap('TERM') { Thread.main.raise(Interrupt) }
+begin
+  run_for ? sleep(run_for) : sleep
+rescue Interrupt
+  puts
+ensure
+  puts "\n== Teardown"
+  App.teardown!
+  puts "App: #{App.boot_status}, worker: #{App.node('worker').status}, sourced.db: #{App.node('sourced.db').status}"
+end

data/lib/sourced/component/dsl.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sourced
+  class Component
+    # Lifecycle hooks a component can implement, in the order they run
+    HOOKS = %i[prepare build start stop teardown].freeze
+
+    CallableInterface = Plumb::Types::Interface[:call]
+
+    # Records lifecycle hooks from a component block
+    class DSL
+      attr_reader :hooks
+
+      def initialize
+        @hooks = HOOKS.to_h { |name| [name, []] }
+      end
+
+      HOOKS.each do |name|
+        define_method(name) do |callable = nil, &block|
+          @hooks[name] << CallableInterface.parse(callable || block)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/sourced/component/env_provider.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Sourced
+  class Component
+    # Builds a component from ENV, decoding values into the node's type with Plumb::Codec::Forms,
+    # the codec for string input (ex. '30' => 30, '1977-11-29' => Date).
+    #   ENVProvider.new('USER_EMAIL')         # a single variable
+    #   ENVProvider.new(/^USER_/)             # matching variables into a hash, with the match removed: USER_NAME => NAME
+    #   ENVProvider.new(/^USER_/, :downcase)  # ... and modified: USER_NAME => name
+    #   ENVProvider.new                       # all variables into a hash, same as ENVProvider.new(ENVProvider::ALL)
+    # A component provider (see Component#component!), and what Component#env uses:
+    #   comp.component!('user.email', ENVProvider.new('USER_EMAIL'))
+    #   comp.component!('everything', ENVProvider) # all variables
+    class ENVProvider
+      T = Plumb::Types
+
+      # Raised when ENV variables are missing or invalid, naming each variable.
+      # A Plumb::ParseError, like any other type mismatch.
+      Error = Class.new(Plumb::ParseError)
+
+      # Matches every variable, without removing anything from their names
+      ALL = /\A/
+
+      # Applied to collected variable names, in order, after the match is removed
+      MODIFIERS = { downcase: :downcase.to_proc }.freeze
+
+      # The provider interface, collecting all variables
+      def self.builder_for(node) = new.builder_for(node)
+
+      def self.error_text(error) = error.is_a?(::String) ? error : error.inspect
+
+      # Whether a type accepts a hash, from what it consumes: Any, Hash types and Data structs,
+      # or a union or wrapper (ex. nullable, default) with a branch that does.
+      def self.takes_hash?(type)
+        type = type.input_type if type.respond_to?(:input_type)
+        return true if type.is_a?(Plumb::AnyClass) || type.subtype_of?(T::Hash)
+
+        case type
+        when Plumb::Disjunction, Plumb::Policy then type.children.any? { |child| takes_hash?(child) }
+        when Plumb::And then takes_hash?(type.children.first)
+        else false
+        end
+      end
+
+      attr_reader :source, :modifiers
+
+      # source: a variable name, or a regex to collect variables with
+      # modifiers: ex. :downcase. Only when collecting with a regex
+      def initialize(source = ALL, *modifiers)
+        case source
+        when ::String
+          if modifiers.any?
+            raise ArgumentError, "ENV modifiers (#{modifiers.join(', ')}) can only be used when collecting variables with a regex"
+          end
+        when ::Regexp
+          unknown = modifiers - MODIFIERS.keys
+          if unknown.any?
+            raise ArgumentError, "unknown ENV modifiers: #{unknown.join(', ')}. Supported: #{MODIFIERS.keys.join(', ')}"
+          end
+        else
+          raise ArgumentError, "an ENV source must be a variable name or a regex, got #{source.inspect}"
+        end
+
+        @source = source.dup.freeze
+        @modifiers = modifiers.uniq.freeze
+      end
+
+      # Regex sources collect variables into a hash, so the node's type must take one
+      def check!(node)
+        return self if source.is_a?(::String) || ENVProvider.takes_hash?(node.type)
+
+        raise ArgumentError, "#{node.path}: ENV variables matching #{source.inspect} are collected into a hash, " \
+                             "but #{node.type.inspect} doesn't take one. Declare a Hash or Data struct type, " \
+                             "or map a single variable, ex. env('VAR_NAME' => '#{node.path}')"
+      end
+
+      # The provider interface: a callable that reads and decodes ENV for a node, to use as its build step.
+      # Checks the node's type first.
+      def builder_for(node)
+        check!(node)
+        # Any (no declared type) takes raw strings. Codec::Forms can't decode into it
+        type = node.type
+        decoder = type.is_a?(Plumb::AnyClass) ? type : Plumb::Codec::Forms >> type
+        if source.is_a?(::String)
+          VariableBuilder.new(node, source, decoder)
+        else
+          # Collected names are strings. Codec::Forms decodes them into the type's keys (ex. 'name' => :name)
+          CollectionBuilder.new(node, source, modifiers, decoder)
+        end
+      end
+
+      def inspect = "#<#{self.class} #{[source.inspect, *modifiers].join(' ')}>"
+
+      # Builds from a single variable. Reads ENV on each call.
+      class VariableBuilder
+        def initialize(node, name, decoder)
+          @node = node
+          @name = name
+          @decoder = decoder
+        end
+
+        # ex. invalid ENV for user.email: USER_EMAIL is invalid: Must match /.../
+        # Values are left out, as ENV often holds secrets.
+        def call(*_)
+          result = @decoder.resolve(ENV[@name])
+          return result.value if result.valid?
+
+          detail = ENV.key?(@name) ? "is invalid: #{ENVProvider.error_text(result.errors)}" : 'is missing'
+          raise Error, "invalid ENV for #{@node.path}: #{@name} #{detail}"
+        end
+      end
+
+      # Builds from the variables matching a regex, collected into a hash. Reads ENV on each call.
+      class CollectionBuilder
+        def initialize(node, regex, modifiers, decoder)
+          @node = node
+          @regex = regex
+          @modifiers = modifiers.map { |name| MODIFIERS.fetch(name) }
+          @decoder = decoder
+        end
+
+        def call(*_)
+          vars, names = collect
+          result = @decoder.resolve(vars)
+          raise Error, error_message(result.errors, vars, names) unless result.valid?
+
+          result.value
+        end
+
+        # Matching variables, as { collected name => value }, and { collected name => ENV name }.
+        # The match is removed from names, then modifiers are applied. Names left empty are skipped.
+        private def collect
+          ENV.each_with_object([{}, {}]) do |(name, value), (vars, names)|
+            next unless @regex.match?(name)
+
+            collected = @modifiers.reduce(name.sub(@regex, '')) { |n, modifier| modifier.call(n) }
+            next if collected.empty?
+
+            vars[collected] = value
+            names[collected] = name
+          end
+        end
+
+        # ex.
+        #   invalid ENV for user.info:
+        #     USER_DOB is invalid: Must match /\A\d{4}-\d{2}-\d{2}\z/
+        #     email is missing from ENV variables matching /^USER_/
+        # Values are left out, as ENV often holds secrets.
+        private def error_message(errors, vars, names)
+          return "invalid ENV for #{@node.path}: #{ENVProvider.error_text(errors)}" unless errors.is_a?(::Hash)
+
+          lines = errors.map do |attribute, error|
+            attribute = attribute.to_s
+            if names.key?(attribute)
+              "  #{names[attribute]} is invalid: #{ENVProvider.error_text(error)}"
+            else
+              line = "  #{attribute} is missing from ENV variables matching #{@regex.inspect}"
+              near = vars.keys.find { |collected| collected.casecmp?(attribute) }
+              near ? "#{line} (found #{names[near]}, try :downcase)" : line
+            end
+          end
+          ["invalid ENV for #{@node.path}:", *lines].join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/sourced/component/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sourced
+  class Component
+    ComponentError = Class.new(StandardError)
+    DeclarationOverrideError = Class.new(ComponentError)
+    OwnershipError = Class.new(ComponentError)
+    LockedComponentError = Class.new(ComponentError)
+    SubcomponentError = Class.new(ComponentError)
+    UndeclaredComponentError = Class.new(ComponentError)
+    UnimplementedComponentError = Class.new(ComponentError)
+    MissingDependencyError = Class.new(ComponentError)
+    CircularDependencyError = Class.new(ComponentError)
+    NotBuiltError = Class.new(ComponentError)
+    TornDownError = Class.new(ComponentError)
+    NotStartedError = Class.new(ComponentError)
+    InjectionError = Class.new(ComponentError)
+  end
+end

data/lib/sourced/component/events.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'sourced/message'
+
+module Sourced
+  class Component
+    # The parent class of all lifecycle events published to a component's notifier.
+    # Events are Sourced::Message structs, so they build their own registry
+    # (Component::Event.registry), and can be serialized with Sourced::Message codecs.
+    #
+    # Every event's payload carries the process, thread and fiber it was published from:
+    #   event.type            # => 'components.built'
+    #   event.created_at      # => Time
+    #   event.payload.pid     # => 12345
+    #   event.payload.key     # => 'sourced.db' (component events)
+    #
+    # Payloads only hold JSON-friendly values: Sourced::Message's registry is shared by
+    # every message type in the process, so these events are compiled by any
+    # Sourced::Message::JSONCodec. That's why failures carry the error's class, message
+    # and backtrace, rather than the exception itself.
+    class Event < Sourced::Message
+      # Define an event type, with the runtime ids every event carries
+      def self.define(type_str, &block)
+        super(type_str) do
+          attribute :pid, Integer
+          attribute :thread_id, Integer
+          attribute :fiber_id, Integer
+          class_eval(&block) if block
+        end
+      end
+    end
+
+    # Each event class has a #type string, which can be used to subscribe to it,
+    # ex. notifier.subscribe('components.built') { |event| ... }
+    # Events::RootEvent and Events::ComponentEvent can be used to subscribe to all events of a kind.
+    module Events
+      # Events about the whole tree, published by its root
+      class RootEvent < Event; end
+
+      # Events about a component, with its full path as the payload's key
+      class ComponentEvent < Event
+        def self.define(type_str, &block)
+          super(type_str) do
+            attribute :key, String
+            class_eval(&block) if block
+          end
+        end
+      end
+
+      Completed = proc { attribute :duration, Float }
+      Failed = proc do
+        attribute :stage, Symbol # :prepare, :build, :start, :stop or :teardown
+        attribute :error_class, String
+        attribute :error_message, String
+        attribute :backtrace, Plumb::Types::Array[String]
+      end
+
+      RootPreparing = RootEvent.define('root.preparing')
+      RootPrepared = RootEvent.define('root.prepared', &Completed)
+      RootBuilding = RootEvent.define('root.building')
+      RootBuilt = RootEvent.define('root.built', &Completed)
+      RootStarting = RootEvent.define('root.starting')
+      RootStarted = RootEvent.define('root.started', &Completed)
+      RootTearingDown = RootEvent.define('root.tearing_down')
+      RootTornDown = RootEvent.define('root.torn_down', &Completed)
+      RootFailed = RootEvent.define('root.failed', &Failed)
+
+      ComponentDeclared = ComponentEvent.define('components.declared') do
+        attribute :type_name, String
+      end
+      ComponentImplemented = ComponentEvent.define('components.implemented') do
+        attribute :mode, Symbol
+        attribute :deps, Plumb::Types::Array[String] # relative to the implementer
+        attribute :implementer, Plumb::Types::String.nullable # the implementer's full path. nil for the root
+        attribute :override, Plumb::Types::Boolean # whether it replaced a previous implementation
+      end
+      ComponentDeferred = ComponentEvent.define('components.deferred') do
+        attribute :deferrer, Plumb::Types::String.nullable # the full path of the component that deferred it. nil for the root
+      end
+      ComponentPreparing = ComponentEvent.define('components.preparing')
+      ComponentPrepared = ComponentEvent.define('components.prepared', &Completed)
+      ComponentBuilding = ComponentEvent.define('components.building')
+      ComponentBuilt = ComponentEvent.define('components.built', &Completed)
+      ComponentStarting = ComponentEvent.define('components.starting')
+      ComponentStarted = ComponentEvent.define('components.started', &Completed)
+      ComponentStopping = ComponentEvent.define('components.stopping')
+      ComponentStopped = ComponentEvent.define('components.stopped', &Completed)
+      ComponentTearingDown = ComponentEvent.define('components.tearing_down')
+      ComponentTornDown = ComponentEvent.define('components.torn_down', &Completed)
+      ComponentFailed = ComponentEvent.define('components.failed', &Failed)
+    end
+
+    # Lifecycle stages, the status each one moves to, and their events
+    STAGES = { prepare: :prepared, build: :built, start: :started, stop: :stopped, teardown: :torn_down }.freeze
+
+    ROOT_EVENTS = {
+      prepare: [Events::RootPreparing, Events::RootPrepared],
+      build: [Events::RootBuilding, Events::RootBuilt],
+      start: [Events::RootStarting, Events::RootStarted],
+      teardown: [Events::RootTearingDown, Events::RootTornDown]
+    }.freeze
+
+    COMPONENT_EVENTS = {
+      prepare: [Events::ComponentPreparing, Events::ComponentPrepared],
+      build: [Events::ComponentBuilding, Events::ComponentBuilt],
+      start: [Events::ComponentStarting, Events::ComponentStarted],
+      stop: [Events::ComponentStopping, Events::ComponentStopped],
+      teardown: [Events::ComponentTearingDown, Events::ComponentTornDown]
+    }.freeze
+  end
+end