# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/builder"
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/registry"
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/sanitizers/data"
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/sanitizers/struct"
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/sanitizers/type"
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/transformers/redactor"
          
        
      
        

          

            
              1
            

            
              
            

            require "inspectable/transformers/typer"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # Main namespace.
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            
              1
            

            
              
            

              extend Registry
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

              INSPECTOR = -> value { value.inspect }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

              CONTAINER = {
          
        
      
        

          

            
              1
            

            
              
            

                registry: self,
          
        
      
        

          

            

            
              
            

                class: Sanitizers::Type.new,
          
        
      
        

          

            

            
              
            

                data: Sanitizers::Data.new,
          
        
      
        

          

            

            
              
            

                struct: Sanitizers::Struct.new
          
        
      
        

          

            

            
              
            

              }.freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.[](*, **) = Builder.new(*, **)
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            

            
              
            

              # Provides custom object inspection behavior.
          
        
      
        

          

            
              1
            

            
              
            

              class Builder < Module
          
        
      
        

          

            
              1
            

            
              
            

                def initialize *excludes, container: CONTAINER, **transformers
          
        
      
        

          

            
              12
            

            
              
            

                  super()
          
        
      
        

          

            
              12
            

            
              
            

                  @excludes = excludes
          
        
      
        

          

            
              12
            

            
              
            

                  @container = container
          
        
      
        

          

            
              12
            

            
              
            

                  @transformers = resolve transformers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              11
            

            
              
            

                  validate
          
        
      
        

          

            
              10
            

            
              
            

                  define_inspect
          
        
      
        

          

            
              10
            

            
              
            

                  freeze
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def included descendant
          
        
      
        

          

            
              9
            

            
              
            

                  descendant.define_singleton_method :method_added do |name|
          
        
      
        

          

            
              6
            

            
              
                
                  else: 1
                
              
                
                  then: 5
                
              
            

                    return super(name) unless name == :instance_variables_to_inspect
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    fail NoMethodError, "Defining method :instance_variables_to_inspect is disabled."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
                
                  when: 8
                
              
            

                  case descendant
          
        
      
        

          

            
              8
            

            
              
                
                  else: 1
                
              
            

                    when Class, Struct, Data then super
          
        
      
        

          

            
              1
            

            
              
            

                    else fail TypeError, "Use Class, Struct, or Data."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :excludes, :container, :transformers
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def resolve transformers
          
        
      
        

          

            
              12
            

            
              
            

                  transformers.each.with_object({}) do |(variable, object), collection|
          
        
      
        

          

            
              8
            

            
              
            

                    collection[variable] = acquire object
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def acquire object
          
        
      
        

          

            
              8
            

            
              
                
                  when: 2
                
              
            

                  case object
          
        
      
        

          

            
              2
            

            
              
                
                  when: 5
                
              
            

                    when Proc then object
          
        
      
        

          

            
              5
            

            
              
                
                  else: 1
                
              
            

                    when Symbol then container.fetch(:registry).transformers[object]
          
        
      
        

          

            
              1
            

            
              
            

                    else fail TypeError, "Invalid transformer: #{object.inspect}. Use Proc or Symbol."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def validate
          
        
      
        

          

            
              11
            

            
              
                
                  else: 1
                
              
                
                  then: 10
                
              
            

                  return unless excludes.empty? && transformers.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  fail ArgumentError, "Excludes or transformers are required."
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_inspect renderer: method(:render)
          
        
      
        

          

            
              10
            

            
              
            

                  define_method :inspect do
          
        
      
        

          

            
              7
            

            
              
            

                    klass = self.class
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              7
            

            
              
                
                  then: 1
                
              
                
                  else: 6
                
              
            

                    if klass < Struct then renderer.call self, :struct
          
        
      
        

          

            
              6
            

            
              
                
                  then: 1
                
              
                
                  else: 5
                
              
            

                    elsif klass < Data then renderer.call self, :data
          
        
      
        

          

            
              5
            

            
              
                
                  then: 4
                
              
                
                  else: 1
                
              
            

                    elsif klass.is_a? Class then renderer.call self, :class
          
        
      
        

          

            
              1
            

            
              
            

                    else renderer.call self, :unknown
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def render instance, type
          
        
      
        

          

            
              8
            

            
              
            

                  container.fetch(type) { fail TypeError, "Unknown type. Use Class, Struct, or Data." }
          
        
      
        

          

            
              6
            

            
              
            

                           .then { |sanitizer| sanitizer.call(instance, *excludes, **transformers) }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            

            
              
            

              # Provides global regsitry for further customization.
          
        
      
        

          

            
              1
            

            
              
            

              module Registry
          
        
      
        

          

            
              1
            

            
              
            

                def self.extended descendant
          
        
      
        

          

            
              7
            

            
              
            

                  descendant.add_transformer(:redact, Inspectable::Transformers::Redactor)
          
        
      
        

          

            

            
              
            

                            .add_transformer(:type, Inspectable::Transformers::Typer)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def add_transformer key, function
          
        
      
        

          

            
              18
            

            
              
            

                  transformers[key.to_sym] = function
          
        
      
        

          

            
              18
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def transformers = @transformers ||= {}
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            
              1
            

            
              
            

              module Sanitizers
          
        
      
        

          

            

            
              
            

                # Excludes and transforms data members.
          
        
      
        

          

            
              1
            

            
              
            

                class Data
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize pattern: "#<data%<class>s %<body>s>", inspector: INSPECTOR
          
        
      
        

          

            
              6
            

            
              
            

                    @pattern = pattern
          
        
      
        

          

            
              6
            

            
              
            

                    @inspector = inspector
          
        
      
        

          

            
              6
            

            
              
            

                    freeze
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call instance, *excludes, **transformers
          
        
      
        

          

            
              5
            

            
              
            

                    format pattern,
          
        
      
        

          

            
              5
            

            
              
                
                  then: 1
                
              
                
                  else: 4
                
              
            

                           class: instance.class.name.then { " #{it}" if it },
          
        
      
        

          

            

            
              
            

                           body: exclude_and_transform(instance, excludes, transformers).chomp(", ")
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :pattern, :inspector
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def exclude_and_transform instance, excludes, transformers
          
        
      
        

          

            
              5
            

            
              
            

                    (instance.members - excludes).reduce(+"") do |body, member|
          
        
      
        

          

            
              6
            

            
              
            

                      value = instance.public_send member
          
        
      
        

          

            
              6
            

            
              
            

                      transformer = transformers.fetch member, inspector
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              6
            

            
              
                
                  else: 5
                
              
                
                  then: 1
                
              
            

                      fail ArgumentError, "Invalid transformer registered for: #{member}." unless transformer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              5
            

            
              
            

                      body << "#{member}=#{transformer.call value}, "
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            
              1
            

            
              
            

              module Sanitizers
          
        
      
        

          

            

            
              
            

                # Excludes and transforms struct members.
          
        
      
        

          

            
              1
            

            
              
            

                class Struct
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize pattern: "#<struct%<class>s %<body>s>", inspector: Inspectable::INSPECTOR
          
        
      
        

          

            
              6
            

            
              
            

                    @pattern = pattern
          
        
      
        

          

            
              6
            

            
              
            

                    @inspector = inspector
          
        
      
        

          

            
              6
            

            
              
            

                    freeze
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call instance, *excludes, **transformers
          
        
      
        

          

            
              5
            

            
              
            

                    format pattern,
          
        
      
        

          

            
              5
            

            
              
                
                  then: 1
                
              
                
                  else: 4
                
              
            

                           class: instance.class.name.then { " #{it}" if it },
          
        
      
        

          

            

            
              
            

                           body: exclude_and_transform(instance, excludes, transformers).chomp(", ")
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :pattern, :inspector
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def exclude_and_transform instance, excludes, transformers
          
        
      
        

          

            
              5
            

            
              
            

                    (instance.members - excludes).reduce(+"") do |body, member|
          
        
      
        

          

            
              6
            

            
              
            

                      transformer = transformers.fetch member, inspector
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              6
            

            
              
                
                  else: 5
                
              
                
                  then: 1
                
              
            

                      fail ArgumentError, "Invalid transformer registered for: #{member}." unless transformer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              5
            

            
              
            

                      body << "#{member}=#{transformer.call instance[member]}, "
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            
              1
            

            
              
            

              module Sanitizers
          
        
      
        

          

            

            
              
            

                # Excludes and transforms object types.
          
        
      
        

          

            
              1
            

            
              
            

                class Type
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize pattern: "#<%<class>s:%<id>#018x %<body>s>", inspector: INSPECTOR
          
        
      
        

          

            
              5
            

            
              
            

                    @pattern = pattern
          
        
      
        

          

            
              5
            

            
              
            

                    @inspector = inspector
          
        
      
        

          

            
              5
            

            
              
            

                    freeze
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call instance, *excludes, **transformers
          
        
      
        

          

            
              10
            

            
              
            

                    variables = instance.instance_variables - excludes.map { :"@#{it}" }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              7
            

            
              
            

                    format pattern,
          
        
      
        

          

            

            
              
            

                           class: instance.class,
          
        
      
        

          

            

            
              
            

                           id: object_id << 1,
          
        
      
        

          

            

            
              
            

                           body: exclude_and_transform(instance, variables, transformers).chomp(", ")
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  attr_reader :pattern, :inspector
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def exclude_and_transform instance, variables, transformers
          
        
      
        

          

            
              7
            

            
              
            

                    variables.reduce(+"") do |body, variable|
          
        
      
        

          

            
              11
            

            
              
            

                      key = variable.to_s.delete_prefix("@").to_sym
          
        
      
        

          

            
              11
            

            
              
            

                      transformer = transformers.fetch key, inspector
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              11
            

            
              
                
                  else: 10
                
              
                
                  then: 1
                
              
            

                      fail ArgumentError, "Invalid transformer registered for: #{key}." unless transformer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

                      body << "#{variable}=#{transformer.call instance.instance_variable_get(variable)}, "
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            
              1
            

            
              
            

              module Transformers
          
        
      
        

          

            

            
              
            

                # Redacts sensitive information.
          
        
      
        

          

            
              1
            

            
              
            

                module Redactor
          
        
      
        

          

            
              1
            

            
              
            

                  module_function
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              7
            

            
              
                
                  then: 5
                
              
                
                  else: 1
                
              
            

                  def call(value) = ("[REDACTED]".inspect if value)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Inspectable
          
        
      
        

          

            
              1
            

            
              
            

              module Transformers
          
        
      
        

          

            

            
              
            

                # Answers object's type.
          
        
      
        

          

            
              1
            

            
              
            

                module Typer
          
        
      
        

          

            
              1
            

            
              
            

                  module_function
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def call(value) = value.class.name
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end