claude-agent-sdk 0.36.0 → 1.0.0

data/lib/claude_agent_sdk/testing/session_store_conformance.rb

@@ -5,7 +5,7 @@ require_relative '../session_summary'
 
 module ClaudeAgentSDK
   # Test helpers shipped in the gem for third-party SessionStore adapter authors.
-  module Testing # rubocop:disable Metrics/ModuleLength
+  module Testing # rubocop:disable Metrics/ModuleLength -- the whole conformance suite in one module
     # Raised by run_session_store_conformance when a behavioral contract fails.
     class ConformanceError < StandardError; end
 
@@ -100,7 +100,7 @@ module ClaudeAgentSDK
 
     # -- Required: append + load -------------------------------------------
 
-    def check_append_and_load(fresh, has_list_sessions) # rubocop:disable Metrics/MethodLength
+    def check_append_and_load(fresh, has_list_sessions) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- linear assertion script
       # 1. append then load returns same entries in same order.
       store = fresh.call
       store.append(key, [entry('uuid' => 'b', 'n' => 1), entry('uuid' => 'a', 'n' => 2)])
@@ -165,7 +165,7 @@ module ClaudeAgentSDK
 
     # -- Optional: list_sessions -------------------------------------------
 
-    def check_list_sessions(fresh)
+    def check_list_sessions(fresh) # rubocop:disable Metrics/AbcSize -- linear assertion script
       # 7. list_sessions returns session_ids for project.
       store = fresh.call
       store.append({ 'project_key' => 'proj', 'session_id' => 'a' }, [entry('n' => 1)])
@@ -197,7 +197,7 @@ module ClaudeAgentSDK
 
     # -- Optional: list_session_summaries ----------------------------------
 
-    def check_list_session_summaries(fresh, has_list_sessions, has_delete) # rubocop:disable Metrics/MethodLength
+    def check_list_session_summaries(fresh, has_list_sessions, has_delete) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- linear assertion script
       # 14. persisted fold output round-trips through fold_session_summary.
       store = fresh.call
       summ_key = { 'project_key' => 'proj', 'session_id' => 'summ-sess' }
@@ -236,8 +236,10 @@ module ClaudeAgentSDK
       # Subagent appends must NOT affect the main session's summary.
       store.append(summ_key.merge('subpath' => 'subagents/agent-1'),
                    [entry('timestamp' => '2024-01-01T00:00:09.000Z', 'customTitle' => 'subagent')])
-      after_sub = summaries_by_id(store, 'proj', ['summ-sess'],
-                                  'list_session_summaries must still return one row per session after a subagent append')
+      after_sub = summaries_by_id(
+        store, 'proj', ['summ-sess'],
+        'list_session_summaries must still return one row per session after a subagent append'
+      )
       assert_eq(after_sub['summ-sess']['data'], summ['data'], 'subagent appends must not change the main summary')
       assert_eq(store.list_session_summaries('never-appended-project'), [], 'unknown project must list no summaries')
 
@@ -249,7 +251,7 @@ module ClaudeAgentSDK
 
     # -- Optional: delete --------------------------------------------------
 
-    def check_delete(fresh, has_list_subkeys, has_list_sessions) # rubocop:disable Metrics/MethodLength
+    def check_delete(fresh, has_list_subkeys, has_list_sessions) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity -- linear assertion script
       # 9. delete main then load returns nil (delete of never-written is a no-op).
       store = fresh.call
       store.delete('project_key' => 'proj', 'session_id' => 'never-written')
@@ -308,7 +310,7 @@ module ClaudeAgentSDK
 
     # -- Optional: list_subkeys --------------------------------------------
 
-    def check_list_subkeys(fresh)
+    def check_list_subkeys(fresh) # rubocop:disable Metrics/AbcSize -- linear assertion script
       # 12. list_subkeys returns subpaths (scoped to the session).
       store = fresh.call
       store.append(key, [entry('n' => 1)])
@@ -317,7 +319,8 @@ module ClaudeAgentSDK
       store.append({ 'project_key' => key['project_key'], 'session_id' => 'other-sess',
                      'subpath' => 'subagents/agent-x' }, [entry('n' => 1)])
       subkeys = store.list_subkeys(key)
-      assert_eq(subkeys.sort, ['subagents/agent-1', 'subagents/agent-2'], "list_subkeys must return this session's subpaths")
+      assert_eq(subkeys.sort, ['subagents/agent-1', 'subagents/agent-2'],
+                "list_subkeys must return this session's subpaths")
       assert(!subkeys.include?('subagents/agent-x'), "list_subkeys must not leak another session's subkeys")
 
       # 13. list_subkeys excludes the main transcript.
@@ -381,7 +384,8 @@ module ClaudeAgentSDK
       return if actual == expected
 
       raise ConformanceError,
-            "SessionStore conformance failed: #{message}\n  expected: #{expected.inspect}\n  actual:   #{actual.inspect}"
+            "SessionStore conformance failed: #{message}\n  " \
+            "expected: #{expected.inspect}\n  actual:   #{actual.inspect}"
     end
 
     private_class_method :check_callback_scheduling_declaration, :check_append_and_load, :check_list_sessions,

data/lib/claude_agent_sdk/transcript_mirror_batcher.rb

@@ -44,6 +44,8 @@ module ClaudeAgentSDK
   # may remain permanently HALF-applied in the store. The drop is surfaced
   # (MirrorErrorMessage, batches_dropped?); the local transcript remains the
   # source of truth.
+  #
+  # @api private
   class TranscriptMirrorBatcher
     # Eager-flush thresholds (exposed for tests).
     MAX_PENDING_ENTRIES = 500

data/lib/claude_agent_sdk/types/attributes.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module ClaudeAgentSDK
+  # Attribute declarations and the rules #[], #[]=, .new and the camelCase
+  # readers follow (issue #126). Loaded by base.rb right after Type itself,
+  # before any subclass declares an attribute.
+  class Type
+    LENIENT_KEY = :__claude_agent_sdk_lenient_attributes
+    private_constant :LENIENT_KEY
+
+    class << self
+      # attr_accessor / attr_reader / attr_writer also declare the names as
+      # attributes (see .attribute_names). Inherited by subclasses.
+      #
+      # @api private
+      def attr_accessor(*names)
+        declare_attributes(*names)
+        super
+      end
+
+      # @api private
+      def attr_reader(*names)
+        declare_attributes(*names)
+        super
+      end
+
+      # @api private
+      def attr_writer(*names)
+        declare_attributes(*names)
+        super
+      end
+
+      private
+
+      def own_attribute_names
+        @own_attribute_names ||= Set.new
+      end
+    end
+
+    # Declares hand-written readers or writers (a method not generated by
+    # attr_*, such as a backward-compatible reader) as attributes, so #[],
+    # #[]= and the camelCase readers reach them.
+    #
+    # @api private
+    def self.declare_attributes(*names)
+      names.each { |name| own_attribute_names << name.to_s }
+    end
+
+    # Whether +name+ (snake_case String) is a declared attribute of this
+    # class or an ancestor.
+    #
+    # @api private
+    def self.attribute?(name)
+      own_attribute_names.include?(name) || (superclass <= Type && superclass.attribute?(name))
+    end
+
+    # Whether +method_name+ (a normalized reader, writer or predicate:
+    # `session_id`, `session_id=`, `fork_session?`) accesses a declared
+    # attribute.
+    #
+    # @api private
+    def self.attribute_method?(method_name)
+      attribute?(method_name.delete_suffix('=').delete_suffix('?'))
+    end
+
+    # Per-class caches of the names, exactly as callers spell them (:sessionId,
+    # 'session_id', ...), that reached a declared attribute: name => method.
+    # Hits skip name normalization and the checks below. Only positives are
+    # cached: the registry only grows, so they never go stale (an answer that
+    # depends on user-defined methods is never cached). Bounded by attributes
+    # x spellings. Replaced, never mutated, so readers need no lock.
+    #
+    # @api private
+    def self.cached_attribute_reader(name)
+      @attribute_readers&.[](name)
+    end
+
+    # @api private
+    def self.cached_attribute_writer(name)
+      @attribute_writers&.[](name)
+    end
+
+    # @api private
+    def self.cache_attribute_reader(name, method_name)
+      @attribute_readers = (@attribute_readers || {}).merge(name => method_name).freeze
+    end
+
+    # @api private
+    def self.cache_attribute_writer(name, method_name)
+      @attribute_writers = (@attribute_writers || {}).merge(name => method_name).freeze
+    end
+
+    # Every declared attribute name (snake_case), sorted.
+    #
+    # @api private
+    def self.attribute_names
+      inherited = superclass <= Type ? superclass.attribute_names : []
+      (inherited | own_attribute_names.to_a).sort
+    end
+
+    # Declares a type the user constructs and passes IN (option values, hook
+    # matchers and outputs, permission results and updates). Constructing
+    # one directly (.new or #[]=) with a key that is not an attribute raises
+    # ArgumentError — a typo would otherwise be dropped silently (0.37 warned
+    # here; 1.0 raises). A read-only attribute (the +type+,
+    # +hook_event_name+ or +behavior+ discriminator a type sets itself, which
+    # its own #to_h emits) is accepted and ignored. Types the SDK parses from
+    # CLI output stay lenient so a newer CLI's extra fields never break an
+    # older SDK; so does every construction through .from_hash or .wrap.
+    # Inherited by subclasses.
+    #
+    # @api private
+    def self.strict_attributes
+      @strict_attributes = true
+    end
+
+    # @api private
+    def self.strict_attributes?
+      @strict_attributes || (superclass <= Type && superclass.strict_attributes?)
+    end
+
+    # Runs the block with the strict-attribute check off on this fiber, for
+    # the SDK's own parse paths (CLI payloads and their nested values).
+    def self.lenient
+      previous = Thread.current[LENIENT_KEY]
+      Thread.current[LENIENT_KEY] = true
+      yield
+    ensure
+      Thread.current[LENIENT_KEY] = previous
+    end
+    private_class_method :lenient
+
+    private
+
+    # Allow camelCase attribute access
+    def method_missing(method_name, ...)
+      target = self.class.cached_attribute_reader(method_name)
+      return public_send(target, ...) if target
+
+      normalized = normalize_name(method_name)
+      if normalized != method_name.to_s && respond_to?(normalized)
+        if self.class.attribute_method?(normalized)
+          self.class.cache_attribute_reader(method_name, normalized.to_sym)
+          return public_send(normalized, ...)
+        end
+        return public_send(normalized, ...) if user_defined_method?(normalized)
+      end
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      normalized = normalize_name(method_name)
+      (normalized != method_name.to_s && respond_to?(normalized) && attribute_method?(normalized)) || super
+    end
+
+    def assign_attributes(attributes)
+      unless attributes.respond_to?(:each_pair)
+        raise ArgumentError,
+              "When assigning attributes, you must pass a hash as an argument, #{attributes.inspect} passed."
+      end
+
+      return if attributes.empty?
+
+      attributes.each_pair { |name, value| assign_attribute(name, value) }
+    end
+
+    def assign_attribute(name, value)
+      writer = self.class.cached_attribute_writer(name)
+      return public_send(writer, value) if writer
+
+      normalized = normalize_name(name)
+      setter = :"#{normalized}="
+      if respond_to?(setter)
+        if self.class.attribute?(normalized)
+          self.class.cache_attribute_writer(name, setter)
+          return public_send(setter, value)
+        end
+        return public_send(setter, value) if user_defined_method?(setter.to_s)
+      end
+      return unless self.class.strict_attributes? && !Thread.current[LENIENT_KEY] && !self.class.attribute?(normalized)
+      return if respond_to?(normalized) && user_defined_method?(normalized)
+
+      unknown_attribute(name)
+    end
+
+    def read_attribute(name)
+      reader = self.class.cached_attribute_reader(name)
+      return public_send(reader) if reader
+
+      getter = normalize_name(name)
+      return unless respond_to?(getter)
+
+      if self.class.attribute_method?(getter)
+        self.class.cache_attribute_reader(name, getter.to_sym)
+        public_send(getter)
+      elsif user_defined_method?(getter)
+        public_send(getter)
+      end
+    end
+
+    # Whether a normalized reader, writer or predicate name belongs to an
+    # attribute: a declared one (`session_id`, `session_id=`,
+    # `fork_session?`), or a method user code defined on its own subclass, a
+    # module it includes, or the object itself. Only methods the SDK, Ruby or
+    # another gem defines at Type or above (to_h, freeze, to_json, ...) are
+    # not attributes.
+    def attribute_method?(method_name)
+      self.class.attribute_method?(method_name) || user_defined_method?(method_name)
+    end
+
+    # Not memoized: user code can define methods at any time.
+    def user_defined_method?(method_name)
+      owner = method(method_name).owner
+      return false if sdk_module?(owner)
+
+      ancestors = self.class.ancestors
+      index = ancestors.index(owner)
+      index.nil? || index < ancestors.index(Type)
+    rescue NameError
+      false
+    end
+
+    def sdk_module?(mod)
+      name = mod.name
+      !name.nil? && (name == 'ClaudeAgentSDK' || name.start_with?('ClaudeAgentSDK::'))
+    end
+
+    # A key that is not an attribute, on a strict type: a typo the user
+    # would otherwise never see.
+    def unknown_attribute(name)
+      klass = self.class
+      raise ArgumentError, "#{klass.name || klass.inspect}: unknown attribute #{name.inspect} " \
+                           "(known: #{klass.attribute_names.join(', ')})"
+    end
+  end
+end

data/lib/claude_agent_sdk/types/base.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+module ClaudeAgentSDK
+  # Base class for all types.
+  class Type
+    # Lenient, like every parse path: never warns or raises on an unknown key.
+    def self.wrap(object)
+      return object if object.is_a?(self)
+      return nil if object.nil?
+
+      lenient { new(object) }
+    end
+
+    # Lenient, like every parse path: never warns or raises on an unknown key.
+    def self.from_hash(hash)
+      return unless hash.is_a?(Hash)
+
+      lenient { new(hash) }
+    end
+
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+      super()
+    end
+
+    def [](name)
+      read_attribute(name)
+    end
+
+    def []=(name, value)
+      assign_attribute(name, value)
+    end
+
+    # Subclasses should override this to return a hash representation of the object.
+    def to_h
+      {}
+    end
+
+    # The copy hook used wherever ClaudeAgentOptions are copied (dup_with and
+    # the configured-defaults merge). Identity by default: most Type instances
+    # are messages or callback payloads that never live inside options, and a
+    # user-supplied object that does (an observer, a store adapter) must stay
+    # the same object. Option VALUE types include OptionValue to opt in to
+    # copying, so a per-session change to e.g. sandbox rules can never reach
+    # another session or the configured defaults.
+    #
+    # @api private
+    def dup_for_options
+      self
+    end
+
+    # Mixed into the mutable value types that ClaudeAgentOptions holds
+    # (SandboxSettings, SystemPromptPreset, AgentDefinition, ...). The copy
+    # recurses into the value's own state with Type.deep_dup_for_options, so
+    # nested containers and nested value types (SandboxSettings#network) are
+    # copied too while identity leaves (McpSdkServerConfig#instance, the
+    # callables in HookMatcher#hooks) stay shared. #dup never copies frozen
+    # state, so a copy of a frozen value (the configured-defaults snapshot) is
+    # mutable.
+    #
+    # @api private
+    module OptionValue
+      def dup_for_options
+        copy = dup
+        copy.instance_variables.each do |ivar|
+          copy.instance_variable_set(ivar, Type.deep_dup_for_options(copy.instance_variable_get(ivar)))
+        end
+        copy
+      end
+    end
+
+    # Recurse into Hash/Array containers and option value types, and copy
+    # mutable (unfrozen) Strings — a caller-built prompt, model or
+    # allowed_tools entry is as much shared state as an Array, and `str <<
+    # 'x'` on one copy would otherwise change every other. A frozen String
+    # (any literal under frozen_string_literal) is immutable and keeps
+    # identity. Every other leaf keeps object identity (observer factories,
+    # callbacks, SDK MCP server instances must not be duped). Rebuild
+    # containers via dup.clear (never Hash#to_h / Array#map) to preserve
+    # container SUBCLASSES: to_h flattens e.g. Rails'
+    # HashWithIndifferentAccess into a plain Hash, silently breaking symbol
+    # lookups on the copy (config[:type] == 'sdk' → nil). Hash keys: Ruby
+    # already stores a dup'd, frozen copy of an unfrozen plain String key, but
+    # not of a String SUBCLASS key, so those are copied (and frozen, as keys
+    # should be) here. A compare_by_identity Hash is left keyed by the
+    # caller's objects: copying a key would break the caller's own lookups.
+    #
+    # @api private
+    def self.deep_dup_for_options(value)
+      case value
+      when Hash
+        copy = value.dup.clear
+        value.each { |k, v| copy[option_hash_key(k, value)] = deep_dup_for_options(v) }
+        copy
+      when Array
+        copy = value.dup.clear
+        value.each { |v| copy << deep_dup_for_options(v) }
+        copy
+      when Type then value.dup_for_options
+      when String then value.frozen? ? value : value.dup # #dup keeps subclass and encoding
+      else value
+      end
+    end
+
+    def self.option_hash_key(key, hash)
+      return key unless key.is_a?(String) && !key.frozen? && !hash.compare_by_identity?
+
+      key.dup.freeze
+    end
+    private_class_method :option_hash_key
+
+    # Bounded, human-oriented #inspect listing the non-nil instance variables
+    # in definition order:
+    #
+    #   #<ClaudeAgentSDK::ResultMessage subtype="success" num_turns=3 ...>
+    #
+    # Messages carry whole transcripts, tool payloads and usage maps, so the
+    # output is bounded rather than faithful: long Strings are truncated,
+    # long Arrays/Hashes abbreviated, and nesting past INSPECT_MAX_DEPTH (or
+    # a reference cycle) collapses to a placeholder. Other objects keep their
+    # own #inspect (truncated) unless they only have Kernel#inspect, which
+    # dumps every ivar recursively — those (SDK MCP server instances, store
+    # adapters, observers) show as `#<ClassName>`. For display only: nothing
+    # sent to the CLI goes through #inspect or #to_s (wire output uses #to_h).
+    def inspect
+      inspect_with(0, {}.compare_by_identity)
+    end
+
+    # Object#to_s ignores instance variables, so `puts message` would print
+    # only a class name and an address. Types with a natural textual form
+    # (UserMessage, AssistantMessage, TextBlock, ResultMessage, SystemMessage)
+    # override this.
+    def to_s
+      inspect
+    end
+
+    # Declares attributes that carry credentials (env vars, auth headers).
+    # Objects get logged, so #inspect shows them filtered; #to_h and
+    # everything sent to the CLI are unaffected. Inherited by subclasses.
+    #
+    # @api private
+    def self.inspect_filtered(*names)
+      @inspect_filtered_attributes = (inspect_filtered_attributes + names.map(&:to_s)).uniq.freeze
+    end
+
+    # @api private
+    def self.inspect_filtered_attributes
+      @inspect_filtered_attributes || (superclass <= Type ? superclass.inspect_filtered_attributes : [].freeze)
+    end
+
+    INSPECT_MAX_STRING = 80
+    INSPECT_MAX_ITEMS = 5
+    INSPECT_MAX_DEPTH = 2
+    private_constant :INSPECT_MAX_STRING, :INSPECT_MAX_ITEMS, :INSPECT_MAX_DEPTH
+
+    protected
+
+    # `seen` holds the Types/containers on the current rendering path (not
+    # every one rendered so far), so a shared-but-acyclic value still renders
+    # in full wherever it appears.
+    #
+    # @api private
+    def inspect_with(depth, seen)
+      return "#<#{inspect_class_name} …>" if depth > INSPECT_MAX_DEPTH || seen.key?(self)
+
+      seen[self] = true
+      begin
+        attributes = inspect_attributes.map do |name, value|
+          " #{name}=#{inspect_bounded(value, depth + 1, seen)}"
+        end
+        "#<#{inspect_class_name}#{attributes.join}>"
+      ensure
+        seen.delete(self)
+      end
+    end
+
+    private
+
+    # [name, value] pairs rendered by #inspect. Subclasses override to hide
+    # redundant state or redact secrets — never by mutating the object.
+    def inspect_attributes
+      filtered = self.class.inspect_filtered_attributes
+      instance_variables.filter_map do |ivar|
+        value = instance_variable_get(ivar)
+        next if value.nil?
+
+        name = ivar.to_s.delete_prefix('@')
+        [name, filtered.include?(name) ? inspect_filter(value) : value]
+      end
+    end
+
+    # A credential-bearing Hash keeps its keys (useful when debugging which
+    # variables are set) with every value replaced; anything else is replaced
+    # outright. Builds a new Hash; the object itself is never touched.
+    def inspect_filter(value)
+      value.respond_to?(:each_key) ? value.each_key.to_h { |key| [key, '[FILTERED]'] } : '[FILTERED]'
+    end
+
+    def inspect_class_name
+      self.class.name || self.class.inspect
+    end
+
+    def inspect_bounded(value, depth, seen)
+      case value
+      when Type then value.inspect_with(depth, seen)
+      when String then inspect_truncated(value)
+      when Array then inspect_container(value, '[', ']', depth, seen) { |item| inspect_bounded(item, depth + 1, seen) }
+      when Hash
+        inspect_container(value, '{', '}', depth, seen) do |key, item|
+          "#{inspect_hash_key(key, depth + 1, seen)}#{inspect_bounded(item, depth + 1, seen)}"
+        end
+      when Proc, Method, UnboundMethod then inspect_callable(value)
+      else inspect_leaf(value)
+      end
+    end
+
+    def inspect_container(value, open, close, depth, seen, &)
+      return "#{open}#{close}" if value.empty?
+      return "#{open}…(#{value.size})#{close}" if depth > INSPECT_MAX_DEPTH || seen.key?(value)
+
+      seen[value] = true
+      begin
+        parts = value.first(INSPECT_MAX_ITEMS).map(&)
+        parts << "…(+#{value.size - INSPECT_MAX_ITEMS} more)" if value.size > INSPECT_MAX_ITEMS
+        "#{open}#{parts.join(', ')}#{close}"
+      ensure
+        seen.delete(value)
+      end
+    end
+
+    # Rendered by hand rather than via Hash#inspect, whose format differs
+    # between Ruby 3.3 (`{:a=>1}`) and 3.4 (`{a: 1}`).
+    def inspect_hash_key(key, depth, seen)
+      return "#{key.name}: " if key.is_a?(Symbol) && key.inspect.match?(/\A:\w+[?!]?\z/)
+
+      "#{inspect_bounded(key, depth, seen)} => "
+    end
+
+    def inspect_truncated(string)
+      return string.inspect if string.length <= INSPECT_MAX_STRING
+
+      "#{string[0, INSPECT_MAX_STRING].inspect}…(+#{string.length - INSPECT_MAX_STRING} chars)"
+    end
+
+    # Callbacks (can_use_tool, hooks, callback_wrapper, ...) are user-supplied:
+    # render them from source_location rather than their own #inspect, which
+    # a subclass may override (and raise from) and which embeds an absolute
+    # path — `#<Proc(lambda) permissions.rb:17>`, `#<Method Policy#call>`.
+    def inspect_callable(value)
+      label = if value.is_a?(Proc)
+                value.lambda? ? 'Proc(lambda)' : 'Proc'
+              else
+                "#{value.class.name} #{value.owner.name || value.owner.inspect}##{value.name}"
+              end
+      file, line = value.source_location
+      rendered = file ? "#<#{label} #{File.basename(file)}:#{line}>" : "#<#{label}>"
+      inspect_truncated_text(rendered)
+    rescue StandardError
+      inspect_leaf(value)
+    end
+
+    def inspect_truncated_text(rendered)
+      return rendered if rendered.length <= INSPECT_MAX_STRING
+
+      "#{rendered[0, INSPECT_MAX_STRING]}…(+#{rendered.length - INSPECT_MAX_STRING} chars)"
+    end
+
+    # Printing must never raise (it runs inside loggers and `puts`), so an
+    # object whose #inspect raises, or a BasicObject without one, falls back
+    # to a placeholder.
+    def inspect_leaf(value)
+      return "#<#{value.class}>" if kernel_inspect_only?(value)
+
+      inspect_truncated_text(value.inspect)
+    rescue StandardError
+      begin
+        "#<#{value.class}>"
+      rescue StandardError
+        '#<?>'
+      end
+    end
+
+    def kernel_inspect_only?(value)
+      Kernel.instance_method(:method).bind_call(value, :inspect).owner == Kernel
+    rescue TypeError # not a Kernel object: BasicObject, Delegator
+      false
+    end
+
+    def normalize_name(name)
+      name = name.to_s.dup
+      name.gsub!(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, '_')
+      name.tr!('-', '_')
+      name.downcase!
+      name
+    end
+
+    FALSE_VALUES = [
+      false, 0,
+      '0', :'0',
+      'f', :f,
+      'F', :F,
+      'false', :false, # rubocop:disable Lint/BooleanSymbol
+      'FALSE', :FALSE,
+      'off', :off,
+      'OFF', :OFF
+    ].to_set.freeze
+
+    private_constant :FALSE_VALUES
+
+    def coerce_boolean(value)
+      return if value.nil?
+
+      if value == ''
+        nil
+      else
+        !FALSE_VALUES.include?(value)
+      end
+    end
+  end
+end
+
+require_relative 'attributes'