briefly 0.1.0 → 0.2.0

data/lib/briefly/rescues.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Briefly
+  # An ordered list of facade-wide and global +rescue_from+ registrations, queried at dispatch time.
+  # A shortcut's own handlers live on the {Briefly::Shortcut}, not here — this holds only the
+  # unscoped handlers a single shortcut cannot voice.
+  #
+  # Entries are stored oldest-first and matched newest-first, so the most recent registration for a
+  # given error class wins. Reads are lock-free against a frozen array; writes rebind it under a
+  # mutex, because rebinding alone would drop concurrent registrations.
+  class Rescues
+    # A single registration.
+    Entry = Struct.new(:klass, :handler)
+
+    def initialize
+      @entries = [].freeze
+      @mutex = Mutex.new
+    end
+
+    # @api private
+    # @param klass [Class] matched against the raised error and its subclasses
+    # @param handler [Proc] called with +(error, shortcut_name)+
+    # @return [self]
+    def add(klass, handler)
+      @mutex.synchronize { @entries = [*@entries, Entry.new(klass, handler)].freeze }
+      self
+    end
+
+    # @api private
+    # @param error [Exception]
+    # @return [Proc, nil] the most recently registered handler whose class matches +error+, or +nil+
+    def handler_for(error) = @entries.reverse_each.find { |entry| error.is_a?(entry.klass) }&.handler
+
+    # @api private
+    # @return [Integer] how many registrations the registry holds
+    def size = @entries.size
+
+    # Drops every registration. Reach it as +Briefly.rescues.clear+ to reset globally registered
+    # handlers between test examples, so a handler from one example cannot leak into the next.
+    #
+    # @return [self]
+    def clear
+      @mutex.synchronize { @entries = [].freeze }
+      self
+    end
+  end
+end

data/lib/briefly/shortcut.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Briefly
+  # One shortcut — and the object {Briefly::Builder#shortcut} hands back so you can refine it. A
+  # declaration's memoization and its scoped error handlers both live here, on the shortcut itself, so
+  # refining after a redeclaration affects the declaration you named, exactly as its body and aliases do.
+  #
+  #   shortcut(:catalog) { Catalog.load }.memoize
+  #   shortcut(:redis) { REDIS_POOL }.rescue_from(Redis::BaseError) { nil }
+  #
+  # The name, aliases, body and location are internal; {#memoize} and {#rescue_from} are its public
+  # refinement surface. It holds no {Briefly::Builder} reference — both refinements are self-contained.
+  class Shortcut
+    # @api private
+    # @return [Symbol] the primary method name
+    attr_reader :canonical
+
+    # @api private
+    # @return [Array<Symbol>] additional method names delegating to the same body and memo cell
+    attr_reader :aliases
+
+    # @api private
+    # @return [Proc] the implementation, bound to the facade at call time
+    attr_reader :body
+
+    # @api private
+    # @return [Symbol] the private singleton method the body compiles to
+    attr_reader :raw_name
+
+    # @api private
+    # @return [Array<Array(Class, Proc)>] this shortcut's own error handlers, oldest first
+    attr_reader :rescues
+
+    # The +[file, line]+ the compiled methods report. {Briefly::Builder#shortcut} resolves it — the body's
+    # own location, or the +shortcut+ call site for a location-less Proc like +&:upcase+ — and
+    # {Briefly::Builder#namespace} overwrites it: its child-returning proc literal lives in +builder.rb+,
+    # and a namespace that pointed there would reintroduce, for namespaces, the lie this field exists to
+    # remove.
+    #
+    # @api private
+    # @return [Array(String, Integer)]
+    attr_accessor :source_location
+
+    # @param canonical [Symbol]
+    # @param aliases [Array<Symbol>]
+    # @param body [Proc]
+    # @param source_location [Array(String, Integer)]
+    def initialize(canonical, aliases, body, source_location)
+      @canonical = canonical
+      @aliases = aliases
+      @body = body
+      @raw_name = Candor.body_name(canonical)
+      @memoized = false
+      @rescues = []
+      @source_location = source_location
+    end
+
+    # Builder copies the facade's shortcuts before mutating them, so an aborted pass cannot leave the
+    # live facade half-configured. Hash#dup would share these arrays.
+    #
+    # @param other [Briefly::Shortcut]
+    # @return [void]
+    def initialize_copy(other)
+      super
+      @aliases = other.aliases.dup
+      @rescues = other.rescues.dup
+    end
+
+    # Memoizes the value: computed once, cached for the process lifetime. A body that takes any
+    # argument is refused at build time (in {Briefly::Builder#compile!}); the compiled method takes none.
+    #
+    # @return [self]
+    def memoize
+      @memoized = true
+      self
+    end
+
+    # @api private
+    # @return [Boolean]
+    def memoized? = @memoized
+
+    # Registers an error handler scoped to this shortcut. The handler's return value becomes the
+    # shortcut's value; it is +call+ed with +(error, shortcut_name)+, never bound to the facade. Later
+    # registrations for the same error class win.
+    #
+    # @param error_class [Class] matched against the raised error and its subclasses
+    # @yield [error, shortcut_name] the recovery block
+    # @return [self]
+    def rescue_from(error_class, &handler)
+      Briefly.send(:validate_rescue!, error_class, handler)
+      @rescues << [error_class, handler]
+      self
+    end
+
+    # @api private
+    # @param error [Exception]
+    # @return [Proc, nil] this shortcut's most recently registered handler whose class matches, or +nil+
+    def handler_for(error) = @rescues.reverse_each.find { |klass, _| error.is_a?(klass) }&.last
+
+    # @api private
+    # @return [Array<Symbol>] canonical name followed by every alias
+    def names = [@canonical, *@aliases]
+  end
+end

data/lib/briefly/version.rb

@@ -2,5 +2,5 @@
 
 module Briefly
   # The gem version.
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/briefly.rb

@@ -4,8 +4,8 @@ require "candor"
 
 require "briefly/version"
 require "briefly/errors"
-require "briefly/definition"
-require "briefly/error_registry"
+require "briefly/shortcut"
+require "briefly/rescues"
 require "briefly/facade"
 require "briefly/builder"
 
@@ -18,7 +18,7 @@ require "briefly/builder"
 module Briefly
   autoload :Rails, "briefly/rails"
 
-  @errors = ErrorRegistry.new
+  @rescues = Rescues.new
 
   # The packs this gem ships, under the short names +use+ accepts. Values are constant paths, never
   # constants: naming +Briefly::Rails::DB+ here would resolve it at load and defeat the autoload above.
@@ -28,6 +28,7 @@ module Briefly
     "rails/env" => "Briefly::Rails::Env",
     "rails/view" => "Briefly::Rails::View",
     "rails/db" => "Briefly::Rails::DB",
+    "rails/instrument" => "Briefly::Rails::Instrument",
     "rails/reload" => "Briefly::Rails::Reload"
   }
 
@@ -36,7 +37,7 @@ module Briefly
     #
     # @yield [] the shortcut declarations
     # @return [Briefly::Facade]
-    def define(&) = Facade.new.configure(&)
+    def define(&) = Facade.new.briefly.configure(&)
 
     # Registers a pack under a short name, so +use "myapp/redis"+ resolves it. Re-registering a name
     # overrides it. There is no inflection and no path guessing: this table is the only source of truth.
@@ -79,16 +80,32 @@ module Briefly
     # @yield [error, shortcut_name] the recovery block; its return value becomes the shortcut's value
     # @return [self]
     def rescue_from(error_class, &handler)
+      validate_rescue!(error_class, handler)
+      @rescues.add(error_class, handler)
+      self
+    end
+
+    # The one +rescue_from+ argument check, shared by the global verb here, the facade-wide verb
+    # ({Briefly::Builder#rescue_from}) and the per-shortcut form ({Briefly::Shortcut#rescue_from}), so
+    # the error class must come first, a block is required, and the message never diverges between them.
+    # Private, so it stays off +Briefly+'s public surface; the two cross-class callers reach it with
+    # +Briefly.send(:validate_rescue!, ...)+, the same +send+-to-internal seam {Briefly::Facade::Control} uses.
+    #
+    # @api private
+    # @param error_class [Object] must be a Class
+    # @param handler [Proc, nil] must be present
+    # @return [void]
+    # @raise [ArgumentError] if +error_class+ is not a Class, or no block was given
+    def validate_rescue!(error_class, handler)
       unless error_class.is_a?(Class)
         raise ArgumentError, "rescue_from expects the error class first, got #{error_class.inspect}"
       end
-      raise ArgumentError, "rescue_from(#{error_class}) requires a block" unless handler
 
-      @errors.add(error_class, nil, handler)
-      self
+      raise ArgumentError, "rescue_from(#{error_class}) requires a block" unless handler
     end
+    private :validate_rescue!
 
-    # @return [Briefly::ErrorRegistry] the global registry
-    attr_reader :errors
+    # @return [Briefly::Rescues] the global registry
+    attr_reader :rescues
   end
 end

data/lib/generators/briefly/install/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Briefly
+  # Namespace for briefly's Rails generators, discovered by `rails generate`.
+  module Generators
+    # Writes +config/initializers/briefly.rb+: a working +Briefly.define { use "rails" }+ facade plus a
+    # commented, concern-grouped map of every shortcut the +rails+ pack installs. Re-run it to update —
+    # Rails prompts before overwriting, so the map refreshes after a gem upgrade.
+    #
+    #   rails generate briefly:install          # => App    = Briefly.define { use "rails" }
+    #   rails generate briefly:install Facade   # => Facade = Briefly.define { use "rails" }
+    #
+    # +::Rails+ is fully qualified throughout: a bare +Rails+ here would resolve to {Briefly::Rails},
+    # the pack, not the framework. There is deliberately no +sig/+ entry: generators load only under
+    # railties, outside the gem's typed runtime surface.
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      argument :name, type: :string, default: "App", banner: "ConstantName"
+
+      # @return [void]
+      def create_initializer
+        template "briefly.rb.tt", "config/initializers/briefly.rb"
+      end
+    end
+  end
+end

data/lib/generators/briefly/install/templates/briefly.rb.tt

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# briefly — a terse, curated facade over your app's most reached-for objects.
+# Re-run `rails g briefly:install` after upgrading to refresh the map below. It rewrites this whole
+# file (Rails shows a diff first), so keep any shortcuts you add here under version control.
+<%= name %> = Briefly.define do
+  use "rails"
+
+  # Your own shortcuts go here (a body can call the other shortcuts). `shortcut` returns the shortcut
+  # you refine: chain `.memoize` to compute once, or `.rescue_from(Error) { fallback }` to recover — in
+  # any order. `rescue_from` on its own line stays for facade-wide handlers.
+  # shortcut(:redis)    { REDIS_POOL }
+  # shortcut(:stripe)   { Stripe::Client.new(x.stripe_key) }
+  # shortcut(:payments) { config_for(:payments) }.memoize    # compute once (cleared on reload)
+  # shortcut(:cache)    { Redis.new }.rescue_from(Redis::CannotConnectError) { NullCache.new }
+end
+
+# --- What `use "rails"` gives you (call as `<%= name %>.<shortcut>`), by concern ---
+#
+#   config   <%= name %>.config, <%= name %>.c -> Rails.configuration
+#            <%= name %>.config_x, <%= name %>.x -> Rails.configuration.x
+#            <%= name %>.root -> Rails.root
+#            <%= name %>.cache -> Rails.cache
+#            <%= name %>.logger, <%= name %>.log -> Rails.logger
+#            <%= name %>.credentials, <%= name %>.cred -> Rails.application.credentials
+#            <%= name %>.error -> Rails.error (.report(e) / .handle { })
+#            <%= name %>.config_for(:key, env:) -> Rails.application.config_for (env: optional)
+#
+#   env      <%= name %>.env -> Rails.env
+#            <%= name %>.production?, <%= name %>.prod?  <%= name %>.development?, <%= name %>.dev?  <%= name %>.test?  <%= name %>.local?
+#
+#   view     <%= name %>.helpers, <%= name %>.h -> ApplicationController.helpers
+#            <%= name %>.routes, <%= name %>.r -> Rails.application.routes.url_helpers
+#            <%= name %>.renderer -> ApplicationController.renderer
+#            <%= name %>.render(:tmpl, locals:) -> renderer.render
+#
+#   notify   <%= name %>.instrument(event, payload) { } -> ActiveSupport::Notifications
+#
+#   db       <%= name %>.db.connection { |c| }, <%= name %>.db.conn { |c| } -> yields a connection, auto-releases
+#            <%= name %>.db.transaction { }, <%= name %>.db.txn { } -> wraps the block in a transaction
+#            <%= name %>.db.select(sql, id: 1) / select(sql, 1) -> a read (SELECT); named or positional binds
+#            <%= name %>.db.query(sql, id: 1) / query(sql, 1) -> arbitrary SQL (writes, DDL); same binds
+#            <%= name %>.db.connected_to(role:, shard:, prevent_writes:) { }
+#            <%= name %>.db.reading { }, <%= name %>.db.writing { } -> run the block under a role
+#
+# Facades are cheap and share no state — add another for a separate concern:
+#   Db = Briefly.define { use "rails/db" }

data/sig/briefly/builder.rbs

@@ -1,28 +1,38 @@
 module Briefly
   # Receives the DSL. Blocks are `instance_eval`'d here, never on the facade.
   class Builder
+    # A validated `compile!` pass, ready for a `Facade` to install.
+    class Plan < ::Struct[untyped]
+      attr_accessor defs: Hash[Symbol, Shortcut]
+      attr_accessor rescue_entries: Array[Briefly::rescue_entry]
+      attr_accessor children: Hash[Symbol, Facade]
+      attr_accessor child_plans: Array[[ Facade, Plan ]]
+
+      def self.new: (Hash[Symbol, Shortcut] defs, Array[Briefly::rescue_entry] rescue_entries, Hash[Symbol, Facade] children, Array[[ Facade, Plan ]] child_plans) -> Plan
+    end
+
     @facade: Facade
-    @defs: Hash[Symbol, Definition]
+    @defs: Hash[Symbol, Shortcut]
     @children: Hash[Symbol, Facade]
-    @errors: Array[Briefly::error_entry]
+    @rescues: Array[Briefly::rescue_entry]
 
     # One collected namespace pass per name, held until `compile!` has validated the whole tree.
     @pending: Hash[Symbol, Builder]
 
     attr_reader facade: Facade
 
-    def initialize: (Facade facade, Hash[Symbol, Definition] defs, Hash[Symbol, Facade] children) -> void
+    def initialize: (Facade facade, Hash[Symbol, Shortcut] defs, Hash[Symbol, Facade] children) -> void
     def use: (pack_ref pack, **untyped opts) -> self
     def namespace: (Symbol name) { (?) [self: Builder] -> void } -> Symbol
-    def shortcut: (Symbol canonical, *Symbol aliases) { (?) [self: Facade] -> untyped } -> Symbol
-    def memoize: (Symbol name, **untyped opts) -> Symbol
-    def rescue_from: (Class error_class, *(Symbol | Array[Symbol]) names) { (StandardError, Symbol) -> untyped } -> self
-    def compile!: () -> Briefly::plan
+    def shortcut: (Symbol canonical, *Symbol aliases) ?{ (?) [self: Facade] -> untyped } -> Shortcut
+    def rescue_from: (Class error_class, *Symbol names) { (StandardError, Symbol) -> untyped } -> self
+    def compile!: () -> Plan
 
     private
 
+    def source_location_for: (Proc body) -> [ String, Integer ]
     def validate_name!: (untyped name) -> void
     def purge: (Array[Symbol] names, except: Symbol) -> void
-    def fetch: (Symbol name) -> Definition
+    def fetch: (Symbol name) -> Shortcut
   end
 end

data/sig/briefly/facade.rbs

@@ -5,32 +5,46 @@ module Briefly
     # Names a shortcut may not take.
     RESERVED: Array[Symbol]
 
-    @__defs: Hash[Symbol, Definition]
+    @__defs: Hash[Symbol, Shortcut]
     @__aliases: Hash[Symbol, Symbol]
     @__memos: Hash[Symbol, untyped]
     @__monitor: Monitor
-    @__errors: ErrorRegistry
-    @__public: Array[Symbol]
+    @__rescues: Rescues
+    @__installed: Array[Symbol]
     @__children: Hash[Symbol, Facade]
 
     def initialize: () -> void
-    def shortcuts: () -> Array[Symbol]
-    def shortcut?: (Symbol name) -> bool
-    def clear_memos!: () -> self
-    def reset!: () -> self
-    def configure: () ?{ (?) [self: Builder] -> void } -> self
+    def briefly: () -> Control
     def inspect: () -> String
     def to_s: () -> String
 
+    # The management surface, forwarded to the facade's private `__`-prefixed methods. Mutators return
+    # the facade; readers return their values.
+    class Control
+      @facade: Facade
+
+      def initialize: (Facade facade) -> void
+      def shortcuts: () -> Array[Symbol]
+      def shortcut?: (Symbol name) -> bool
+      def clear_memos!: () -> Facade
+      def configure: () ?{ (?) [self: Builder] -> void } -> Facade
+      def inspect: () -> String
+      def to_s: () -> String
+    end
+
     private
 
+    def __shortcuts: () -> Array[Symbol]
+    def __shortcut?: (Symbol name) -> bool
+    def __clear_memos!: () -> self
+    def __configure: () ?{ (?) [self: Builder] -> void } -> self
     def __prepare: () -> Builder
-    def __commit: (Briefly::plan plan) -> self
-    def __install: (Hash[Symbol, Definition] defs, Array[Briefly::error_entry] error_entries) -> self
+    def __commit: (Builder::Plan plan) -> self
+    def __install: (Hash[Symbol, Shortcut] defs, Array[Briefly::rescue_entry] rescue_entries) -> self
     def __remove_methods: (Array[Symbol] names) -> void
-    def __define: (Definition defn) -> void
+    def __define: (Shortcut defn) -> void
     def __call: (Symbol name, *untyped, **untyped) ?{ (?) -> untyped } -> untyped
     def __memo: (Symbol name) { () -> untyped } -> untyped
-    def __handle: (StandardError error, Symbol name) -> untyped
+    def __handle: (StandardError error, Shortcut defn) -> untyped
   end
 end

data/sig/briefly/rails.rbs

@@ -1,8 +1,8 @@
 module Briefly
   # Shortcut pack for Rails applications. Loaded only when `Briefly::Rails` is referenced.
   #
-  # An umbrella over `Config`, `Env`, `View` and `Reload`, plus `DB` under the `db` namespace. Each
-  # nested pack exposes `install` and nothing else.
+  # An umbrella over `Config`, `Env`, `View`, `Instrument` and `Reload`, plus `DB` under the `db`
+  # namespace. Each nested pack exposes `install` and nothing else.
   module Rails
     def self?.install: (Builder builder) -> Builder
 
@@ -21,6 +21,11 @@ module Briefly
       def self?.install: (Builder builder) -> Builder
     end
 
+    # ActiveSupport::Notifications instrumentation.
+    module Instrument
+      def self?.install: (Builder builder) -> Builder
+    end
+
     # One database, reached through one Active Record class. `base` is a constant path resolved on
     # every call, so a reloaded class is never captured.
     module DB

data/sig/briefly/rescues.rbs

@@ -0,0 +1,21 @@
+module Briefly
+  # An ordered list of facade-wide and global `rescue_from` registrations, queried at dispatch time.
+  class Rescues
+    # A single registration.
+    class Entry < ::Struct[untyped]
+      attr_accessor klass: Class
+      attr_accessor handler: Briefly::handler
+
+      def self.new: (Class klass, Briefly::handler handler) -> Entry
+    end
+
+    @entries: Array[Entry]
+    @mutex: Thread::Mutex
+
+    def initialize: () -> void
+    def add: (Class klass, Briefly::handler handler) -> self
+    def handler_for: (Exception error) -> Briefly::handler?
+    def size: () -> Integer
+    def clear: () -> self
+  end
+end

data/sig/briefly/{definition.rbs → shortcut.rbs}

@@ -1,10 +1,12 @@
 module Briefly
-  # One shortcut declaration: its canonical name, its aliases, its body, and whether it memoizes.
-  class Definition
+  # One shortcut, and the object `Builder#shortcut` returns so you can refine it. Its memoization and
+  # its own error handlers live here; `#memoize` and `#rescue_from` are the public refinement surface.
+  class Shortcut
     attr_reader canonical: Symbol
     attr_reader aliases: Array[Symbol]
     attr_reader body: Proc
     attr_reader raw_name: Symbol
+    attr_reader rescues: Array[[ Class, Briefly::handler ]]
 
     # The `[file, line]` the compiled methods report; `Builder#namespace` overwrites it.
     attr_accessor source_location: [ String, Integer ]
@@ -12,9 +14,11 @@ module Briefly
     @memoized: bool
 
     def initialize: (Symbol canonical, Array[Symbol] aliases, Proc body, [ String, Integer ] source_location) -> void
-    def initialize_copy: (Definition other) -> void
-    def memoize!: () -> void
+    def initialize_copy: (Shortcut other) -> void
+    def memoize: () -> self
     def memoized?: () -> bool
+    def rescue_from: (Class error_class) { (StandardError, Symbol) -> untyped } -> self
+    def handler_for: (Exception error) -> Briefly::handler?
     def names: () -> Array[Symbol]
   end
 end

data/sig/briefly.rbs

@@ -9,7 +9,7 @@ module Briefly
   class Error < StandardError
   end
 
-  # Raised when `memoize` or `rescue_from` names a shortcut that does not exist.
+  # Raised when a bodiless `shortcut` names a shortcut that does not exist.
   class UnknownShortcutError < Error
   end
 
@@ -24,13 +24,8 @@ module Briefly
   # A recovery block. Its return value becomes the shortcut's return value.
   type handler = ^(StandardError error, Symbol shortcut_name) -> untyped
 
-  # A registered error handler, before `ErrorRegistry` receives it.
-  type error_entry = [ Class, Array[Symbol]?, handler ]
-
-  # A validated `configure` pass, ready to install: definitions, error handlers, namespace children,
-  # and one `[child, plan]` pair per namespace this pass collected. Recursive, so RBS types the tail
-  # as `untyped`.
-  type plan = [ Hash[Symbol, Definition], Array[error_entry], Hash[Symbol, Facade], Array[[ Facade, untyped ]] ]
+  # A facade-wide rescue handler, before `Rescues` receives it.
+  type rescue_entry = [ Class, handler ]
 
   # A pack is any object responding to `#install(builder)`. Options are optional: Ruby drops an empty
   # `**` splat, so a pack that takes none needs no `**opts` parameter.
@@ -44,7 +39,7 @@ module Briefly
   # A registry entry: a pack, or a constant path resolved on first use.
   type pack_entry = _Pack | String
 
-  self.@errors: ErrorRegistry
+  self.@rescues: Rescues
   self.@packs: Hash[String, pack_entry]
 
   # Shortcuts are compiled at runtime, so RBS cannot see them. Declare the ones you rely on in
@@ -53,5 +48,7 @@ module Briefly
   def self.register: (String | Symbol name, pack_entry pack) -> Module
   def self.pack: (String | Symbol name) -> _Pack
   def self.rescue_from: (Class error_class) { (StandardError, Symbol) -> untyped } -> Module
-  def self.errors: () -> ErrorRegistry
+  def self.rescues: () -> Rescues
+
+  private def self.validate_rescue!: (untyped error_class, Proc? handler) -> void
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: briefly
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Leonid Svyatov
@@ -40,20 +40,26 @@ files:
 - briefly.gemspec
 - lib/briefly.rb
 - lib/briefly/builder.rb
-- lib/briefly/definition.rb
-- lib/briefly/error_registry.rb
 - lib/briefly/errors.rb
 - lib/briefly/facade.rb
 - lib/briefly/rails.rb
+- lib/briefly/rails/config.rb
 - lib/briefly/rails/db.rb
+- lib/briefly/rails/env.rb
+- lib/briefly/rails/instrument.rb
 - lib/briefly/rails/reload.rb
+- lib/briefly/rails/view.rb
+- lib/briefly/rescues.rb
+- lib/briefly/shortcut.rb
 - lib/briefly/version.rb
+- lib/generators/briefly/install/install_generator.rb
+- lib/generators/briefly/install/templates/briefly.rb.tt
 - sig/briefly.rbs
 - sig/briefly/builder.rbs
-- sig/briefly/definition.rbs
-- sig/briefly/error_registry.rbs
 - sig/briefly/facade.rbs
 - sig/briefly/rails.rbs
+- sig/briefly/rescues.rbs
+- sig/briefly/shortcut.rbs
 - sig/manifest.yaml
 homepage: https://github.com/svyatov/briefly
 licenses:

data/lib/briefly/definition.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Briefly
-  # One shortcut declaration: its canonical name, its aliases, its body, and whether it memoizes.
-  #
-  # @api private
-  class Definition
-    # @return [Symbol] the primary method name
-    attr_reader :canonical
-
-    # @return [Array<Symbol>] additional method names delegating to the same body and memo cell
-    attr_reader :aliases
-
-    # @return [Proc] the implementation, bound to the facade at call time
-    attr_reader :body
-
-    # @return [Symbol] the private singleton method the body compiles to
-    attr_reader :raw_name
-
-    # The +[file, line]+ the compiled methods report. {Briefly::Builder#shortcut} resolves it — the body's
-    # own location, or the +shortcut+ call site for a bodiless-of-location Proc like +&:upcase+ — and
-    # {Briefly::Builder#namespace} overwrites it: its child-returning proc literal lives in +builder.rb+,
-    # and a namespace that pointed there would reintroduce, for namespaces, the lie this field exists to
-    # remove.
-    #
-    # @return [Array(String, Integer)]
-    attr_accessor :source_location
-
-    # @param canonical [Symbol]
-    # @param aliases [Array<Symbol>]
-    # @param body [Proc]
-    # @param source_location [Array(String, Integer)]
-    def initialize(canonical, aliases, body, source_location)
-      @canonical = canonical
-      @aliases = aliases
-      @body = body
-      @raw_name = Candor.body_name(canonical)
-      @memoized = false
-      @source_location = source_location
-    end
-
-    # Builder copies the facade's definitions before mutating them, so an aborted pass cannot
-    # leave the live facade half-configured. Hash#dup would share this array.
-    #
-    # @param other [Briefly::Definition]
-    # @return [void]
-    def initialize_copy(other)
-      super
-      @aliases = other.aliases.dup
-    end
-
-    # Marks the value as computed once and cached. A redeclared shortcut is a fresh, unmemoized
-    # Definition, so there is no un-memoize.
-    #
-    # @return [void]
-    def memoize! = @memoized = true
-
-    # @return [Boolean]
-    def memoized? = @memoized
-
-    # @return [Array<Symbol>] canonical name followed by every alias
-    def names = [@canonical, *@aliases]
-  end
-end