# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/array"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/binding"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/data"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/date_time"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/hash"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/io"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/module"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/object"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/pathname"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/string"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/string_io"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/struct"
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/symbol"
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/shared/many"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Array primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Array
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Array do
          
        
      
        

          

            
              1
            

            
              
            

                  import_methods Shared::Many
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def combinatorial?(other) = !other.empty? && size == union(other).size
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              15
            

            
              
            

                  def compress = compact.delete_if { |element| element.respond_to?(:empty?) && element.empty? }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def compress!
          
        
      
        

          

            
              20
            

            
              
            

                    delete_if { |element| element.respond_to?(:empty?) && element.empty? }
          
        
      
        

          

            
              4
            

            
              
            

                    compact!
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def excluding(*elements) = self - elements.flatten
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def including(*elements) = self + elements.flatten
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def intersperse(*elements) = product([elements]).tap(&:pop).flatten.push(last)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def maximum(key) = map(&key).max
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              7
            

            
              
                
                  then: 1
                
              
                
                  else: 5
                
              
            

                  def mean = size.zero? ? 0 : sum(0.0) / size
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def minimum(key) = map(&key).min
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              7
            

            
              
            

                  def pad(value, max = size) = dup.fill(value, size..(max - 1))
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def pick(*keys)
          
        
      
        

          

            
              4
            

            
              
                
                  then: 1
                
              
                
                  else: 3
                
              
            

                    return if empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              5
            

            
              
                
                  then: 1
                
              
                
                  else: 2
                
              
            

                    keys.many? ? keys.map { |key| first[key] } : first[keys.first]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def pluck(*keys)
          
        
      
        

          

            
              5
            

            
              
                
                  then: 2
                
              
                
                  else: 3
                
              
            

                    return dup if empty?
          
        
      
        

          

            
              3
            

            
              
                
                  then: 1
                
              
                
                  else: 2
                
              
            

                    return [] if keys.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
                
                  then: 1
                
              
            

                    if keys.many?
          
        
      
        

          

            
              10
            

            
              
            

                      map { |element| keys.map { |key| element[key] } }
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

                    else
          
        
      
        

          

            
              1
            

            
              
            

                      key = keys.first
          
        
      
        

          

            
              4
            

            
              
            

                      map { |element| element[key] }
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def replace_at(index, *elements)
          
        
      
        

          

            
              7
            

            
              
            

                    delete_at index
          
        
      
        

          

            
              7
            

            
              
            

                    insert(index, *elements)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def ring(&) = [last, *self, first].each_cons(3, &)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def supplant target, *replacements
          
        
      
        

          

            
              9
            

            
              
            

                    index(target).then do |position|
          
        
      
        

          

            
              9
            

            
              
            

                      delete_at position
          
        
      
        

          

            
              9
            

            
              
            

                      insert position, *replacements
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def supplant_if target, *replacements
          
        
      
        

          

            
              17
            

            
              
                
                  then: 6
                
              
                
                  else: 8
                
              
            

                    each { |item| supplant target, *replacements if item == target }
          
        
      
        

          

            
              3
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def to_sentence conjunction = "and", delimiter: ", "
          
        
      
        

          

            
              11
            

            
              
                
                  when: 6
                
              
            

                    case length
          
        
      
        

          

            
              11
            

            
              
                
                  when: 1
                
              
            

                      when (3..) then "#{self[..-2].join delimiter}#{delimiter}#{conjunction} #{last}"
          
        
      
        

          

            
              1
            

            
              
                
                  else: 4
                
              
            

                      when 2 then join " #{conjunction} "
          
        
      
        

          

            
              4
            

            
              
            

                      else join
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def to_usage conjunction = "and", delimiter: ", "
          
        
      
        

          

            
              4
            

            
              
            

                    map(&:inspect).to_sentence conjunction, delimiter:
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Binding class.
          
        
      
        

          

            
              1
            

            
              
            

              module Binding
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Binding do
          
        
      
        

          

            
              1
            

            
              
            

                  alias_method :[], :local_variable_get
          
        
      
        

          

            
              1
            

            
              
            

                  alias_method :[]=, :local_variable_set
          
        
      
        

          

            
              1
            

            
              
            

                  alias_method :local?, :local_variable_defined?
          
        
      
        

          

            
              1
            

            
              
            

                  alias_method :locals, :local_variables
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/shared/diff"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Struct primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Data
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Data do
          
        
      
        

          

            
              1
            

            
              
            

                  import_methods Shared::Diff
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "date"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the DateTime primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module DateTime
          
        
      
        

          

            
              1
            

            
              
            

                refine ::DateTime.singleton_class do
          
        
      
        

          

            
              1
            

            
              
            

                  def utc = now.new_offset(0)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/shared/many"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Hash primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Hash
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Hash.singleton_class do
          
        
      
        

          

            
              5
            

            
              
            

                  def infinite = new { |nascence, lacuna| nascence[lacuna] = new(&nascence.default_proc) }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  def with_default(value) = new { |nascence, lacuna| nascence[lacuna] = value }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Hash do
          
        
      
        

          

            
              1
            

            
              
            

                  import_methods Shared::Many
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              14
            

            
              
            

                  def compress = compact.delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def compress!
          
        
      
        

          

            
              19
            

            
              
            

                    delete_if { |_key, value| value.respond_to?(:empty?) && value.empty? }
          
        
      
        

          

            
              4
            

            
              
            

                    compact!
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_merge other
          
        
      
        

          

            
              12
            

            
              
            

                    clazz = self.class
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              12
            

            
              
            

                    merge other do |_key, this_value, other_value|
          
        
      
        

          

            
              14
            

            
              
                
                  then: 6
                
              
            

                      if this_value.is_a?(clazz) && other_value.is_a?(clazz)
          
        
      
        

          

            
              6
            

            
              
            

                        this_value.deep_merge other_value
          
        
      
        

          

            

            
              
                
                  else: 8
                
              
            

                      else
          
        
      
        

          

            
              8
            

            
              
            

                        other_value
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_merge!(other) = replace(deep_merge(other))
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_stringify_keys = recurse(&:stringify_keys)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_stringify_keys! = replace(deep_stringify_keys)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_symbolize_keys = recurse(&:symbolize_keys)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_symbolize_keys! = replace(deep_symbolize_keys)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def diff other
          
        
      
        

          

            
              5
            

            
              
                
                  then: 3
                
              
                
                  else: 2
                
              
            

                    return differences_from other if other.is_a?(self.class) && keys.sort! == other.keys.sort!
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              7
            

            
              
            

                    each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def fetch_deep(*keys, default: NilClass, &)
          
        
      
        

          

            
              10
            

            
              
            

                    keys.reduce fallback(keys.shift, default, &) do |value, key|
          
        
      
        

          

            
              13
            

            
              
                
                  else: 12
                
              
                
                  then: 1
                
              
            

                      unless value.is_a?(::Hash) || (value.is_a?(::Array) && key.is_a?(::Integer))
          
        
      
        

          

            
              1
            

            
              
            

                        fail KeyError, "Unable to find #{key.inspect} in #{value.inspect}."
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              12
            

            
              
                
                  then: 11
                
              
                
                  else: 1
                
              
            

                      default == NilClass ? value.fetch(key, &) : value.fetch(key, default)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def fetch_value(key, *default, &)
          
        
      
        

          

            
              6
            

            
              
                
                  then: 1
                
              
                
                  else: 1
                
              
            

                    fetch(key, *default, &) || (yield if block_given?) || default.first
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def flatten_keys prefix: nil, delimiter: "_"
          
        
      
        

          

            
              28
            

            
              
            

                    reduce({}) do |accumulator, (key, value)|
          
        
      
        

          

            
              38
            

            
              
                
                  then: 18
                
              
                
                  else: 20
                
              
            

                      flat_key = prefix ? :"#{prefix}#{delimiter}#{key}" : key
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              38
            

            
              
                
                  else: 14
                
              
                
                  then: 24
                
              
            

                      next accumulator.merge flat_key => value unless value.is_a? ::Hash
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              28
            

            
              
            

                      accumulator.merge(recurse { value.flatten_keys prefix: flat_key, delimiter: })
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def flatten_keys!(prefix: nil, delimiter: "_") = replace flatten_keys(prefix:, delimiter:)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def recurse &block
          
        
      
        

          

            
              29
            

            
              
                
                  else: 28
                
              
                
                  then: 1
                
              
            

                    return self unless block
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              28
            

            
              
            

                    transform = yield self
          
        
      
        

          

            
              61
            

            
              
                
                  then: 4
                
              
                
                  else: 29
                
              
            

                    transform.each { |key, value| transform[key] = value.recurse(&block) if value.is_a? ::Hash }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def stringify_keys = transform_keys(&:to_s)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def stringify_keys! = transform_keys!(&:to_s)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def symbolize_keys = transform_keys(&:to_sym)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def symbolize_keys! = transform_keys!(&:to_sym)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def transform_value(key, &) = dup.transform_value!(key, &)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def transform_value! key
          
        
      
        

          

            
              10
            

            
              
                
                  then: 6
                
              
                
                  else: 4
                
              
            

                    block_given? && key?(key) ? merge!(key => yield(self[key])) : self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def transform_with(**) = dup.transform_with!(**)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def transform_with!(**operations)
          
        
      
        

          

            
              14
            

            
              
                
                  then: 6
                
              
                
                  else: 2
                
              
            

                    operations.each { |key, function| self[key] = function.call self[key] if key? key }
          
        
      
        

          

            
              6
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def use &block
          
        
      
        

          

            
              3
            

            
              
                
                  else: 2
                
              
                
                  then: 1
                
              
            

                    return [] unless block
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                    block.parameters
          
        
      
        

          

            
              4
            

            
              
            

                         .map { |(_type, key)| self[key] || self[key.to_s] }
          
        
      
        

          

            
              2
            

            
              
            

                         .then { |values| yield values }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def differences_from other
          
        
      
        

          

            
              11
            

            
              
            

                    result = merge(other.to_h) { |_, one, two| [one, two].uniq }
          
        
      
        

          

            
              11
            

            
              
            

                    result.select { |_, diff| diff.size == 2 }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def fallback(key, default, &)
          
        
      
        

          

            
              10
            

            
              
                
                  then: 8
                
              
                
                  else: 2
                
              
            

                    default == NilClass ? fetch(key, &) : fetch(key, default)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/shared/reread"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the IO primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module IO
          
        
      
        

          

            
              1
            

            
              
            

                refine ::IO.singleton_class do
          
        
      
        

          

            
              1
            

            
              
            

                  def void
          
        
      
        

          

            
              7
            

            
              
            

                    new(sysopen(File::NULL, "w+")).then do |io|
          
        
      
        

          

            
              7
            

            
              
                
                  else: 1
                
              
                
                  then: 6
                
              
            

                      return io unless block_given?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                      yield io
          
        
      
        

          

            
              1
            

            
              
            

                      io.tap(&:close)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                refine ::IO do
          
        
      
        

          

            
              1
            

            
              
            

                  import_methods Shared::Reread
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def redirect other
          
        
      
        

          

            
              5
            

            
              
                
                  else: 3
                
              
                
                  then: 2
                
              
            

                    return self unless block_given?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              3
            

            
              
            

                    backup = dup
          
        
      
        

          

            
              3
            

            
              
            

                    reopen other
          
        
      
        

          

            
              3
            

            
              
            

                    yield self
          
        
      
        

          

            
              3
            

            
              
            

                    reopen backup
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
            

                  def squelch(&) = self.class.void.then { |void| redirect(void, &) }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Symbol primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Module
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Module do
          
        
      
        

          

            
              1
            

            
              
            

                  def pseudonym prefix, suffix = object_id, delimiter: "-"
          
        
      
        

          

            
              5
            

            
              
            

                    set_temporary_name "#{prefix}#{delimiter}#{suffix}"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Object class.
          
        
      
        

          

            
              1
            

            
              
            

              module Object
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Object do
          
        
      
        

          

            
              1
            

            
              
            

                  def in? other
          
        
      
        

          

            
              18
            

            
              
                
                  when: 2
                
              
            

                    case other
          
        
      
        

          

            
              2
            

            
              
                
                  when: 10
                
              
            

                      when Range then other.cover? self
          
        
      
        

          

            
              10
            

            
              
                
                  else: 6
                
              
            

                      when ::Array, Enumerable, ::Hash, Set, ::String then other.include? self
          
        
      
        

          

            
              6
            

            
              
            

                      else fail NoMethodError, "`#{self.class}#include?` must be implemented."
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def to_proc
          
        
      
        

          

            
              2
            

            
              
                
                  then: 1
                
              
                
                  else: 1
                
              
            

                    return method(:call).to_proc if respond_to? :call
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    fail NoMethodError, "`#{self.class}#call` must be implemented."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "pathname"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Pathname primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Pathname
          
        
      
        

          

            
              1
            

            
              
            

                refine Kernel do
          
        
      
        

          

            
              1
            

            
              
            

                  def Pathname object
          
        
      
        

          

            
              41
            

            
              
                
                  else: 40
                
              
                
                  then: 1
                
              
            

                    return super(String(object)) unless object
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              40
            

            
              
            

                    super
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Pathname.singleton_class do
          
        
      
        

          

            
              1
            

            
              
            

                  def home = new ENV.fetch("HOME", "")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
            

                  def require_tree(root) = new(root).files("**/*.rb").each { |path| require path.to_s }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def root = new(File::SEPARATOR)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Pathname do
          
        
      
        

          

            
              1
            

            
              
            

                  def change_dir
          
        
      
        

          

            
              7
            

            
              
                
                  then: 3
                
              
            

                    if block_given?
          
        
      
        

          

            
              6
            

            
              
            

                      Dir.chdir(self) { |path| yield Pathname(path) }
          
        
      
        

          

            

            
              
                
                  else: 4
                
              
            

                    else
          
        
      
        

          

            
              4
            

            
              
            

                      Dir.chdir self and self
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def clear = children.each(&:rmtree) && self
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def copy to
          
        
      
        

          

            
              5
            

            
              
                
                  then: 2
                
              
                
                  else: 3
                
              
            

                    destination = to.directory? ? to.join(basename) : to
          
        
      
        

          

            
              5
            

            
              
            

                    ::IO.copy_stream self, destination
          
        
      
        

          

            
              3
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def deep_touch(...)
          
        
      
        

          

            
              8
            

            
              
            

                    warn "`#{self.class}##{__method__}` is deprecated, use `#touch_deep` instead.",
          
        
      
        

          

            

            
              
            

                         category: :deprecated
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              8
            

            
              
            

                    touch_deep(...)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def delete = super && self
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def delete_prefix(pattern) = parent.join %(#{name.sub(/\A#{pattern}/, "")}#{extname})
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def delete_suffix(pattern) = parent.join %(#{name.sub(/#{pattern}\z/, "")}#{extname})
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def directories pattern = "*", flag: File::FNM_SYSCASE
          
        
      
        

          

            
              5
            

            
              
            

                    glob(pattern, flag).select(&:directory?)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              8
            

            
              
                
                  then: 2
                
              
                
                  else: 5
                
              
            

                  def empty = file? ? (truncate(0) and self) : rmtree.make_dir
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def extensions = basename.to_s.split(/(?=\.)+/).tap(&:shift)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def files(pattern = "*", flag: File::FNM_SYSCASE) = glob(pattern, flag).select(&:file?)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def gsub(pattern, replacement) = self.class.new(to_s.gsub(pattern, replacement))
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def make_ancestors
          
        
      
        

          

            
              20
            

            
              
            

                    dirname.mkpath
          
        
      
        

          

            
              20
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              18
            

            
              
                
                  then: 1
                
              
                
                  else: 16
                
              
            

                  def make_dir = exist? ? self : (mkdir and self)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def name = basename extname
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def puts(content) = write "#{content}\n"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def relative_parent(root_dir) = relative_path_from(root_dir).parent
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              6
            

            
              
                
                  then: 2
                
              
                
                  else: 3
                
              
            

                  def remove_dir = exist? ? (rmdir and self) : self
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
                
                  then: 2
                
              
                
                  else: 1
                
              
            

                  def rewrite = read.then { |content| write yield(content) if block_given? }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def touch at = Time.now
          
        
      
        

          

            
              68
            

            
              
                
                  then: 21
                
              
                
                  else: 47
                
              
            

                    exist? ? utime(at, at) : write("")
          
        
      
        

          

            
              67
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def touch_deep(...) = make_ancestors.touch(...)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def write content, offset: nil, **options
          
        
      
        

          

            
              67
            

            
              
            

                    super content, offset, **options
          
        
      
        

          

            
              65
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            
              1
            

            
              
            

              module Shared
          
        
      
        

          

            

            
              
            

                # Provides functionality for knowing the difference between two whole value objects.
          
        
      
        

          

            
              1
            

            
              
            

                module Diff
          
        
      
        

          

            
              1
            

            
              
            

                  def diff other
          
        
      
        

          

            
              6
            

            
              
                
                  then: 4
                
              
            

                    if other.is_a? self.class
          
        
      
        

          

            
              16
            

            
              
            

                      to_h.merge(other.to_h) { |_, one, two| [one, two].uniq }
          
        
      
        

          

            
              12
            

            
              
            

                          .select { |_, diff| diff.size == 2 }
          
        
      
        

          

            

            
              
                
                  else: 2
                
              
            

                    else
          
        
      
        

          

            
              8
            

            
              
            

                      to_h.each.with_object({}) { |(key, value), diff| diff[key] = [value, nil] }
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            
              1
            

            
              
            

              module Shared
          
        
      
        

          

            

            
              
            

                # Provides functionality for knowing whether an enumerable has many elements or not.
          
        
      
        

          

            
              1
            

            
              
            

                module Many
          
        
      
        

          

            
              1
            

            
              
            

                  def many?
          
        
      
        

          

            
              13
            

            
              
                
                  else: 2
                
              
                
                  then: 11
                
              
            

                    return size > 1 unless block_given?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              8
            

            
              
                
                  then: 4
                
              
                
                  else: 2
                
              
            

                    total = reduce(0) { |count, item| yield(item) ? count + 1 : count }
          
        
      
        

          

            
              2
            

            
              
            

                    total > 1
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            
              1
            

            
              
            

              module Shared
          
        
      
        

          

            

            
              
            

                # Provides functionality for I/O object rewinding.
          
        
      
        

          

            
              1
            

            
              
            

                module Reread
          
        
      
        

          

            
              1
            

            
              
            

                  def reread(length = nil, buffer: nil) = tap(&:rewind).read(length, buffer)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the String primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module String
          
        
      
        

          

            
              1
            

            
              
            

                DELIMITERS = %r([a-z][A-Z]|\s*-\s*|\s*/\s*|\s*:+\s*|\s*_\s*|\s+)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                refine ::String do
          
        
      
        

          

            
              1
            

            
              
            

                  def blank? = empty? || match?(/\A[[:space:]]*\z/)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def camelcase
          
        
      
        

          

            
              24
            

            
              
                
                  else: 20
                
              
                
                  then: 4
                
              
            

                    return up unless match? DELIMITERS
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              40
            

            
              
            

                    split(%r(\s*-\s*|\s*/\s*|\s*:+\s*)).then { |parts| combine parts, :up, "::" }
          
        
      
        

          

            
              20
            

            
              
            

                                                       .then { |text| text.split(/\s*_\s*|\s+/) }
          
        
      
        

          

            
              20
            

            
              
            

                                                       .then { |parts| combine parts, :up }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              64
            

            
              
                
                  then: 1
                
              
                
                  else: 62
                
              
            

                  def down = empty? ? self : first.downcase + self[1, size]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def falsey? = !truthy?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def first maximum = 0
          
        
      
        

          

            
              205
            

            
              
                
                  then: 1
                
              
                
                  else: 204
                
              
            

                    return self if empty?
          
        
      
        

          

            
              204
            

            
              
                
                  then: 202
                
              
                
                  else: 2
                
              
            

                    return self[0] if maximum.zero?
          
        
      
        

          

            
              2
            

            
              
                
                  then: 1
                
              
                
                  else: 1
                
              
            

                    return "" if maximum.negative?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    self[..(maximum - 1)]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def indent multiplier = 1, pad: "  "
          
        
      
        

          

            
              6
            

            
              
                
                  then: 1
                
              
                
                  else: 5
                
              
            

                    multiplier.negative? ? self : (pad * multiplier) + self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def last minimum = 0
          
        
      
        

          

            
              4
            

            
              
                
                  then: 1
                
              
                
                  else: 3
                
              
            

                    return self if empty?
          
        
      
        

          

            
              3
            

            
              
                
                  then: 1
                
              
                
                  else: 2
                
              
            

                    return self[size - 1] if minimum.zero?
          
        
      
        

          

            
              2
            

            
              
                
                  then: 1
                
              
                
                  else: 1
                
              
            

                    return "" if minimum.negative?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                    self[(minimum + 1)..]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
                
                  then: 2
                
              
                
                  else: 6
                
              
            

                  def pluralize(suffix, count = 0, replace: /$/) = count.abs == 1 ? self : sub(replace, suffix)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  then: 6
                
              
                
                  else: 3
                
              
            

                  def singularize(suffix, count = 1, replace: "") = count.abs == 1 ? sub(suffix, replace) : self
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def snakecase
          
        
      
        

          

            
              22
            

            
              
                
                  else: 20
                
              
                
                  then: 2
                
              
            

                    return downcase unless match? DELIMITERS
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              40
            

            
              
            

                    split(%r(\s*-\s*|\s*/\s*|\s*:+\s*)).then { |parts| combine parts, :down, "/" }
          
        
      
        

          

            
              20
            

            
              
            

                                                       .then { |text| text.split(/(?=[A-Z])|\s*_\s*|\s+/) }
          
        
      
        

          

            
              20
            

            
              
            

                                                       .then { |parts| combine parts, :down, "_" }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def squish = gsub(/[[:space:]]+/, " ").tap(&:strip!)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def titleize
          
        
      
        

          

            
              23
            

            
              
                
                  else: 21
                
              
                
                  then: 2
                
              
            

                    return capitalize unless match? DELIMITERS
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              42
            

            
              
            

                    split(/(?=[A-Z])|\s*_\s*|\s*-\s*|\s+/).then { |parts| combine parts, :up, " " }
          
        
      
        

          

            
              21
            

            
              
            

                                                          .then { |text| text.split %r(\s*/\s*|\s*:+\s*) }
          
        
      
        

          

            
              21
            

            
              
            

                                                          .then { |parts| combine parts, :up, "/" }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def trim_end to, delimiter = nil, trailer: "..."
          
        
      
        

          

            
              21
            

            
              
                
                  then: 4
                
              
                
                  else: 17
                
              
            

                    return dup if length <= to
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              17
            

            
              
            

                    offset = to - trailer.length
          
        
      
        

          

            
              17
            

            
              
                
                  then: 4
                
              
                
                  else: 13
                
              
            

                    maximum = delimiter ? rindex(delimiter, offset) || offset : offset
          
        
      
        

          

            
              17
            

            
              
            

                    "#{self[...maximum]}#{trailer}"
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def truthy? = %w[true yes on t y 1].include? downcase.strip
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def truncate(...)
          
        
      
        

          

            
              11
            

            
              
            

                    warn "`#{self.class}##{__method__}` is deprecated, use `#trim_end` instead.",
          
        
      
        

          

            

            
              
            

                         category: :deprecated
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              11
            

            
              
            

                    trim_end(...)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # rubocop:disable Naming/PredicateMethod
          
        
      
        

          

            
              1
            

            
              
            

                  def to_bool
          
        
      
        

          

            
              11
            

            
              
            

                    warn "`#{self.class}##{__method__}` is deprecated, use `#truthy?` or `#falsey?` instead.",
          
        
      
        

          

            

            
              
            

                         category: :deprecated
          
        
      
        

          

            
              11
            

            
              
            

                    truthy?
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                  # rubocop:enable Naming/PredicateMethod
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              142
            

            
              
                
                  then: 2
                
              
                
                  else: 139
                
              
            

                  def up = empty? ? self : first.upcase + self[1, size]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

                  # :reek:UtilityFunction
          
        
      
        

          

            
              1
            

            
              
            

                  def combine parts, method, delimiter = ""
          
        
      
        

          

            
              122
            

            
              
            

                    parts.reduce "" do |result, part|
          
        
      
        

          

            
              196
            

            
              
                
                  then: 93
                
              
                
                  else: 103
                
              
            

                      next part.public_send method if result.empty?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              103
            

            
              
            

                      "#{result}#{delimiter}#{part.__send__ method}"
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/shared/reread"
          
        
      
        

          

            
              1
            

            
              
            

            require "stringio"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the StringIO primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module StringIO
          
        
      
        

          

            
              1
            

            
              
            

                refine ::StringIO do
          
        
      
        

          

            
              1
            

            
              
            

                  import_methods Shared::Reread
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  alias_method :to_s, :string
          
        
      
        

          

            
              1
            

            
              
            

                  alias_method :to_str, :string
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "refinements/shared/diff"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Struct primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Struct
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Struct do
          
        
      
        

          

            
              1
            

            
              
            

                  import_methods Shared::Diff
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def merge(...)
          
        
      
        

          

            
              8
            

            
              
            

                    warn "`#{self.class}##{__method__}` is deprecated, use `#with` instead.",
          
        
      
        

          

            

            
              
            

                         category: :deprecated
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              8
            

            
              
            

                    with(...)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def merge!(...)
          
        
      
        

          

            
              34
            

            
              
            

                    warn "`#{self.class}##{__method__}` is deprecated, use `#with!` instead.",
          
        
      
        

          

            

            
              
            

                         category: :deprecated
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              34
            

            
              
            

                    with!(...)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def transmute(...) = dup.transmute!(...)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def transmute! object, **key_map
          
        
      
        

          

            
              14
            

            
              
            

                    mapping = key_map.invert
          
        
      
        

          

            
              14
            

            
              
            

                    merge! object.to_h.slice(*mapping.keys).transform_keys!(mapping)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def with(...) = dup.with!(...)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  def with! object = nil
          
        
      
        

          

            
              220
            

            
              
            

                    to_h.merge!(**object.to_h).each { |key, value| self[key] = value }
          
        
      
        

          

            
              56
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Refinements
          
        
      
        

          

            

            
              
            

              # Provides additional enhancements to the Symbol primitive.
          
        
      
        

          

            
              1
            

            
              
            

              module Symbol
          
        
      
        

          

            
              1
            

            
              
            

                refine ::Symbol do
          
        
      
        

          

            
              1
            

            
              
            

                  def call(*positionals, **keywords, &)
          
        
      
        

          

            
              18
            

            
              
            

                    proc { |receiver| receiver.public_send(self, *positionals, **keywords, &) }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end