# frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'ruby-enum/version'
          
        
      
        

          

            1
            

            

            require 'ruby-enum/enum'
          
        
      
        

          

            1
            

            

            require 'ruby-enum/enum/case'
          
        
      
        

          

            1
            

            

            require 'ruby-enum/enum/i18n_mock'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Try to load the I18n gem and provide a mock if it is not available.
          
        
      
        

          

            
            

            

            begin
          
        
      
        

          

            1
            

            

              require 'i18n'
          
        
      
        

          

            1
            

            

              Ruby::Enum.i18n = I18n
          
        
      
        

          

            
            

            

            rescue LoadError
          
        
      
        

          

            
            

            

              # I18n is not available
          
        
      
        

          

            
            skipped

            

              # :nocov:
          
        
      
        

          

            
            skipped

            

              # Tests for this loading are in the spec_i18n folder
          
        
      
        

          

            
            skipped

            

              Ruby::Enum.i18n = Ruby::Enum::I18nMock
          
        
      
        

          

            
            skipped

            

              # :nocov:
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            Ruby::Enum.i18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'ruby-enum/errors/base'
          
        
      
        

          

            1
            

            

            require 'ruby-enum/errors/uninitialized_constant_error'
          
        
      
        

          

            1
            

            

            require 'ruby-enum/errors/duplicate_key_error'
          
        
      
        

          

            1
            

            

            require 'ruby-enum/errors/duplicate_value_error'
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ruby
          
        
      
        

          

            1
            

            

              module Enum
          
        
      
        

          

            1
            

            

                class << self
          
        
      
        

          

            
            

            

                  # Needed for I18n mock
          
        
      
        

          

            1
            

            

                  attr_accessor :i18n
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                attr_reader :key, :value
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def initialize(key, value)
          
        
      
        

          

            11
            

            

                  @key = key
          
        
      
        

          

            11
            

            

                  @value = value
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                def self.included(base)
          
        
      
        

          

            5
            

            

                  base.extend Enumerable
          
        
      
        

          

            5
            

            

                  base.extend ClassMethods
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            5
            

            

                  base.private_class_method(:new)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                module ClassMethods
          
        
      
        

          

            
            

            

                  # Define an enumerated value.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # === Parameters
          
        
      
        

          

            
            

            

                  # [key] Enumerator key.
          
        
      
        

          

            
            

            

                  # [value] Enumerator value.
          
        
      
        

          

            1
            

            

                  def define(key, value = key)
          
        
      
        

          

            15
            

            

                    @_enum_hash ||= {}
          
        
      
        

          

            15
            

            

                    @_enums_by_value ||= {}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            15
            

            

                    validate_key!(key)
          
        
      
        

          

            13
            

            

                    validate_value!(value)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            11
            

            

                    store_new_instance(key, value)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            11
            

            

                    if upper?(key.to_s)
          
        
      
        

          

            8
            

            

                      const_set key, value
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            6
            

            

                      define_singleton_method(key) { value }
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def store_new_instance(key, value)
          
        
      
        

          

            11
            

            

                    new_instance = new(key, value)
          
        
      
        

          

            11
            

            

                    @_enum_hash[key] = new_instance
          
        
      
        

          

            11
            

            

                    @_enums_by_value[value] = new_instance
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def const_missing(key)
          
        
      
        

          

            4
            

            

                    raise Ruby::Enum::Errors::UninitializedConstantError, name: name, key: key
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Iterate over all enumerated values.
          
        
      
        

          

            
            

            

                  # Required for Enumerable mixin
          
        
      
        

          

            1
            

            

                  def each(&block)
          
        
      
        

          

            8
            

            

                    @_enum_hash.each(&block)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Attempt to parse an enum key and return the
          
        
      
        

          

            
            

            

                  # corresponding value.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # === Parameters
          
        
      
        

          

            
            

            

                  # [k] The key string to parse.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # Returns the corresponding value or nil.
          
        
      
        

          

            1
            

            

                  def parse(k)
          
        
      
        

          

            4
            

            

                    k = k.to_s.upcase
          
        
      
        

          

            4
            

            

                    each do |key, enum|
          
        
      
        

          

            6
            

            

                      return enum.value if key.to_s.upcase == k
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                    nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Whether the specified key exists in this enum.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # === Parameters
          
        
      
        

          

            
            

            

                  # [k] The string key to check.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # Returns true if the key exists, false otherwise.
          
        
      
        

          

            1
            

            

                  def key?(k)
          
        
      
        

          

            7
            

            

                    @_enum_hash.key?(k)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Gets the string value for the specified key.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # === Parameters
          
        
      
        

          

            
            

            

                  # [k] The key symbol to get the value for.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # Returns the corresponding enum instance or nil.
          
        
      
        

          

            1
            

            

                  def value(k)
          
        
      
        

          

            5
            

            

                    enum = @_enum_hash[k]
          
        
      
        

          

            5
            

            

                    enum&.value
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Whether the specified value exists in this enum.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # === Parameters
          
        
      
        

          

            
            

            

                  # [k] The string value to check.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # Returns true if the value exists, false otherwise.
          
        
      
        

          

            1
            

            

                  def value?(v)
          
        
      
        

          

            7
            

            

                    @_enums_by_value.key?(v)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Gets the key symbol for the specified value.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # === Parameters
          
        
      
        

          

            
            

            

                  # [v] The string value to parse.
          
        
      
        

          

            
            

            

                  #
          
        
      
        

          

            
            

            

                  # Returns the corresponding key symbol or nil.
          
        
      
        

          

            1
            

            

                  def key(v)
          
        
      
        

          

            5
            

            

                    enum = @_enums_by_value[v]
          
        
      
        

          

            5
            

            

                    enum&.key
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Returns all enum keys.
          
        
      
        

          

            1
            

            

                  def keys
          
        
      
        

          

            2
            

            

                    @_enum_hash.values.map(&:key)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Returns all enum values.
          
        
      
        

          

            1
            

            

                  def values
          
        
      
        

          

            25
            

            

                    result = @_enum_hash.values.map(&:value)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            25
            

            

                    if superclass < Ruby::Enum
          
        
      
        

          

            3
            

            

                      superclass.values + result
          
        
      
        

          

            
            

            

                    else
          
        
      
        

          

            22
            

            

                      result
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Iterate over all enumerated values.
          
        
      
        

          

            
            

            

                  # Required for Enumerable mixin
          
        
      
        

          

            1
            

            

                  def each_value(&_block)
          
        
      
        

          

            1
            

            

                    @_enum_hash.each_value do |v|
          
        
      
        

          

            2
            

            

                      yield v.value
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Iterate over all enumerated keys.
          
        
      
        

          

            
            

            

                  # Required for Enumerable mixin
          
        
      
        

          

            1
            

            

                  def each_key(&_block)
          
        
      
        

          

            1
            

            

                    @_enum_hash.each_value do |v|
          
        
      
        

          

            2
            

            

                      yield v.key
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def to_h
          
        
      
        

          

            1
            

            

                    @_enum_hash.transform_values(&:value)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def upper?(s)
          
        
      
        

          

            11
            

            

                    !/[[:upper:]]/.match(s).nil?
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def validate_key!(key)
          
        
      
        

          

            15
            

            

                    return unless @_enum_hash.key?(key)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                    raise Ruby::Enum::Errors::DuplicateKeyError, name: name, key: key
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  def validate_value!(value)
          
        
      
        

          

            13
            

            

                    return unless @_enums_by_value.key?(value)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                    raise Ruby::Enum::Errors::DuplicateValueError, name: name, value: value
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ruby
          
        
      
        

          

            1
            

            

              module Enum
          
        
      
        

          

            
            

            

                ##
          
        
      
        

          

            
            

            

                # Adds a method to an enum class that allows for exhaustive matching on a value.
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # @example
          
        
      
        

          

            
            

            

                # class Color
          
        
      
        

          

            
            

            

                #   include Ruby::Enum
          
        
      
        

          

            
            

            

                #   include Ruby::Enum::Case
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                #   define :RED, :red
          
        
      
        

          

            
            

            

                #   define :GREEN, :green
          
        
      
        

          

            
            

            

                #   define :BLUE, :blue
          
        
      
        

          

            
            

            

                #   define :YELLOW, :yellow
          
        
      
        

          

            
            

            

                # end
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # Color.case(Color::RED, {
          
        
      
        

          

            
            

            

                #   [Color::RED, Color::GREEN] => -> { "red or green" },
          
        
      
        

          

            
            

            

                #   Color::BLUE => -> { "blue" },
          
        
      
        

          

            
            

            

                #   Color::YELLOW => -> { "yellow" },
          
        
      
        

          

            
            

            

                # })
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # Reserves the :else key for a default case:
          
        
      
        

          

            
            

            

                # Color.case(Color::RED, {
          
        
      
        

          

            
            

            

                #   [Color::RED, Color::GREEN] => -> { "red or green" },
          
        
      
        

          

            
            

            

                #   else: -> { "blue or yellow" },
          
        
      
        

          

            
            

            

                # })
          
        
      
        

          

            1
            

            

                module Case
          
        
      
        

          

            1
            

            

                  def self.included(klass)
          
        
      
        

          

            1
            

            

                    klass.extend(ClassMethods)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  ##
          
        
      
        

          

            
            

            

                  # @see Ruby::Enum::Case
          
        
      
        

          

            1
            

            

                  module ClassMethods
          
        
      
        

          

            1
            

            

                    class ValuesNotDefinedError < StandardError
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    class NotAllCasesHandledError < StandardError
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def case(value, cases)
          
        
      
        

          

            9
            

            

                      validate_cases(cases)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                      filtered_cases = cases.select do |values, _proc|
          
        
      
        

          

            15
            

            

                        values = [values] unless values.is_a?(Array)
          
        
      
        

          

            15
            

            

                        values.include?(value)
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            7
            

            

                      return call_proc(cases[:else], value) if filtered_cases.none?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                      results = filtered_cases.map { |_values, proc| call_proc(proc, value) }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Return the first result if there is only one result
          
        
      
        

          

            4
            

            

                      results.size == 1 ? results.first : results
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def call_proc(proc, value)
          
        
      
        

          

            8
            

            

                      return if proc.nil?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            6
            

            

                      if proc.arity == 1
          
        
      
        

          

            1
            

            

                        proc.call(value)
          
        
      
        

          

            
            

            

                      else
          
        
      
        

          

            5
            

            

                        proc.call
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    def validate_cases(cases)
          
        
      
        

          

            9
            

            

                      all_values = cases.keys.flatten - [:else]
          
        
      
        

          

            9
            

            

                      else_defined = cases.key?(:else)
          
        
      
        

          

            9
            

            

                      superfluous_values = all_values - values
          
        
      
        

          

            9
            

            

                      missing_values = values - all_values
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            9
            

            

                      raise ValuesNotDefinedError, "Value(s) not defined: #{superfluous_values.join(', ')}" if superfluous_values.any?
          
        
      
        

          

            8
            

            

                      raise NotAllCasesHandledError, "Not all cases handled: #{missing_values.join(', ')}" if missing_values.any? && !else_defined
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            skipped

            

            # :nocov:
          
        
      
        

          

            
            skipped

            

            module Ruby
          
        
      
        

          

            
            skipped

            

              module Enum
          
        
      
        

          

            
            skipped

            

                ##
          
        
      
        

          

            
            skipped

            

                # Mock I18n module in case the i18n gem is not available.
          
        
      
        

          

            
            skipped

            

                module I18nMock
          
        
      
        

          

            
            skipped

            

                  def self.load_path
          
        
      
        

          

            
            skipped

            

                    []
          
        
      
        

          

            
            skipped

            

                  end
          
        
      
        

          

            
            skipped

            

            
          
        
      
        

          

            
            skipped

            

                  def self.translate(key, _options = {})
          
        
      
        

          

            
            skipped

            

                    key
          
        
      
        

          

            
            skipped

            

                  end
          
        
      
        

          

            
            skipped

            

                end
          
        
      
        

          

            
            skipped

            

              end
          
        
      
        

          

            
            skipped

            

            end
          
        
      
        

          

            
            skipped

            

            # :nocov:
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ruby
          
        
      
        

          

            1
            

            

              module Enum
          
        
      
        

          

            1
            

            

                module Errors
          
        
      
        

          

            1
            

            

                  class Base < StandardError
          
        
      
        

          

            
            

            

                    # Problem occurred.
          
        
      
        

          

            1
            

            

                    attr_reader :problem
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Summary of the problem.
          
        
      
        

          

            1
            

            

                    attr_reader :summary
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Suggested problem resolution.
          
        
      
        

          

            1
            

            

                    attr_reader :resolution
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Compose the message.
          
        
      
        

          

            
            

            

                    # === Parameters
          
        
      
        

          

            
            

            

                    # [key] Lookup key in the translation table.
          
        
      
        

          

            
            

            

                    # [attributes] The objects to pass to create the message.
          
        
      
        

          

            1
            

            

                    def compose_message(key, attributes = {})
          
        
      
        

          

            8
            

            

                      @problem = create_problem(key, attributes)
          
        
      
        

          

            8
            

            

                      @summary = create_summary(key, attributes)
          
        
      
        

          

            8
            

            

                      @resolution = create_resolution(key, attributes)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            8
            

            

                      "\nProblem:\n  #{@problem}" \
          
        
      
        

          

            
            

            

                      "\nSummary:\n  #{@summary}" + "\nResolution:\n  #{@resolution}"
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    private
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    BASE_KEY = 'ruby.enum.errors.messages' # :nodoc:
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Given the key of the specific error and the options hash, translate the
          
        
      
        

          

            
            

            

                    # message.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # === Parameters
          
        
      
        

          

            
            

            

                    # [key] The key of the error in the locales.
          
        
      
        

          

            
            

            

                    # [options] The objects to pass to create the message.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # Returns a localized error message string.
          
        
      
        

          

            1
            

            

                    def translate(key, options)
          
        
      
        

          

            24
            

            

                      Ruby::Enum.i18n.translate("#{BASE_KEY}.#{key}", locale: :en, **options).strip
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Create the problem.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # === Parameters
          
        
      
        

          

            
            

            

                    # [key] The error key.
          
        
      
        

          

            
            

            

                    # [attributes] The attributes to interpolate.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # Returns the problem.
          
        
      
        

          

            1
            

            

                    def create_problem(key, attributes)
          
        
      
        

          

            8
            

            

                      translate("#{key}.message", attributes)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Create the summary.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # === Parameters
          
        
      
        

          

            
            

            

                    # [key] The error key.
          
        
      
        

          

            
            

            

                    # [attributes] The attributes to interpolate.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # Returns the summary.
          
        
      
        

          

            1
            

            

                    def create_summary(key, attributes)
          
        
      
        

          

            8
            

            

                      translate("#{key}.summary", attributes)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Create the resolution.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # === Parameters
          
        
      
        

          

            
            

            

                    # [key] The error key.
          
        
      
        

          

            
            

            

                    # [attributes] The attributes to interpolate.
          
        
      
        

          

            
            

            

                    #
          
        
      
        

          

            
            

            

                    # Returns the resolution.
          
        
      
        

          

            1
            

            

                    def create_resolution(key, attributes)
          
        
      
        

          

            8
            

            

                      translate("#{key}.resolution", attributes)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ruby
          
        
      
        

          

            1
            

            

              module Enum
          
        
      
        

          

            1
            

            

                module Errors
          
        
      
        

          

            
            

            

                  # Error raised when a duplicate enum key is found
          
        
      
        

          

            1
            

            

                  class DuplicateKeyError < Base
          
        
      
        

          

            1
            

            

                    def initialize(attrs)
          
        
      
        

          

            2
            

            

                      super(compose_message('duplicate_key', attrs))
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ruby
          
        
      
        

          

            1
            

            

              module Enum
          
        
      
        

          

            1
            

            

                module Errors
          
        
      
        

          

            
            

            

                  # Error raised when a duplicate enum value is found
          
        
      
        

          

            1
            

            

                  class DuplicateValueError < Base
          
        
      
        

          

            1
            

            

                    def initialize(attrs)
          
        
      
        

          

            2
            

            

                      super(compose_message('duplicate_value', attrs))
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Ruby
          
        
      
        

          

            1
            

            

              module Enum
          
        
      
        

          

            1
            

            

                module Errors
          
        
      
        

          

            1
            

            

                  class UninitializedConstantError < Base
          
        
      
        

          

            1
            

            

                    def initialize(attrs)
          
        
      
        

          

            4
            

            

                      super(compose_message('uninitialized_constant', attrs))
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            class Colors
          
        
      
        

          

            1
            

            

              include Ruby::Enum
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              define :RED, 'red'
          
        
      
        

          

            1
            

            

              define :GREEN, 'green'
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            class FirstSubclass < Colors
          
        
      
        

          

            1
            

            

              define :ORANGE, 'orange'
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            class SecondSubclass < FirstSubclass
          
        
      
        

          

            1
            

            

              define :PINK, 'pink'
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe Ruby::Enum do
          
        
      
        

          

            1
            

            

              it 'returns an enum value' do
          
        
      
        

          

            1
            

            

                expect(Colors::RED).to eq 'red'
          
        
      
        

          

            1
            

            

                expect(Colors::GREEN).to eq 'green'
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'when the i18n gem is loaded' do
          
        
      
        

          

            1
            

            

                it 'raises UninitializedConstantError on an invalid constant' do
          
        
      
        

          

            1
            

            

                  expect do
          
        
      
        

          

            1
            

            

                    Colors::ANYTHING
          
        
      
        

          

            
            

            

                  end.to raise_error Ruby::Enum::Errors::UninitializedConstantError, /The constant Colors::ANYTHING has not been defined./
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'when the i18n gem is not loaded' do
          
        
      
        

          

            1
            

            

                before do
          
        
      
        

          

            1
            

            

                  allow(described_class).to receive(:i18n).and_return(Ruby::Enum::I18nMock)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'raises UninitializedConstantError on an invalid constant' do
          
        
      
        

          

            1
            

            

                  expect do
          
        
      
        

          

            1
            

            

                    Colors::ANYTHING
          
        
      
        

          

            
            

            

                  end.to raise_error Ruby::Enum::Errors::UninitializedConstantError, /ruby.enum.errors.messages.uninitialized_constant.summary/
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#each' do
          
        
      
        

          

            1
            

            

                it 'iterates over constants' do
          
        
      
        

          

            1
            

            

                  keys = []
          
        
      
        

          

            1
            

            

                  enum_keys = []
          
        
      
        

          

            1
            

            

                  enum_values = []
          
        
      
        

          

            1
            

            

                  Colors.each do |key, enum|
          
        
      
        

          

            2
            

            

                    keys << key
          
        
      
        

          

            2
            

            

                    enum_keys << enum.key
          
        
      
        

          

            2
            

            

                    enum_values << enum.value
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  expect(keys).to eq %i[RED GREEN]
          
        
      
        

          

            1
            

            

                  expect(enum_keys).to eq %i[RED GREEN]
          
        
      
        

          

            1
            

            

                  expect(enum_values).to eq %w[red green]
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#map' do
          
        
      
        

          

            1
            

            

                it 'maps constants' do
          
        
      
        

          

            1
            

            

                  key_key_values = Colors.map do |key, enum|
          
        
      
        

          

            2
            

            

                    [key, enum.key, enum.value]
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  expect(key_key_values.count).to eq 2
          
        
      
        

          

            1
            

            

                  expect(key_key_values[0]).to eq [:RED, :RED, 'red']
          
        
      
        

          

            1
            

            

                  expect(key_key_values[1]).to eq [:GREEN, :GREEN, 'green']
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#parse' do
          
        
      
        

          

            1
            

            

                it 'parses exact value' do
          
        
      
        

          

            1
            

            

                  expect(Colors.parse('red')).to eq(Colors::RED)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'is case-insensitive' do
          
        
      
        

          

            1
            

            

                  expect(Colors.parse('ReD')).to eq(Colors::RED)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns nil for a null value' do
          
        
      
        

          

            1
            

            

                  expect(Colors.parse(nil)).to be_nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns nil for an invalid value' do
          
        
      
        

          

            1
            

            

                  expect(Colors.parse('invalid')).to be_nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#key?' do
          
        
      
        

          

            1
            

            

                it 'returns true for valid keys accessed directly' do
          
        
      
        

          

            1
            

            

                  Colors.keys.each do |key| # rubocop:disable Style/HashEachMethods
          
        
      
        

          

            2
            

            

                    expect(Colors.key?(key)).to be(true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns true for valid keys accessed via each_keys' do
          
        
      
        

          

            1
            

            

                  Colors.each_key do |key|
          
        
      
        

          

            2
            

            

                    expect(Colors.key?(key)).to be(true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns false for invalid keys' do
          
        
      
        

          

            1
            

            

                  expect(Colors.key?(:NOT_A_KEY)).to be(false)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#value' do
          
        
      
        

          

            1
            

            

                it 'returns string values for keys' do
          
        
      
        

          

            1
            

            

                  Colors.each do |key, enum|
          
        
      
        

          

            2
            

            

                    expect(Colors.value(key)).to eq(enum.value)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns nil for an invalid key' do
          
        
      
        

          

            1
            

            

                  expect(Colors.value(:NOT_A_KEY)).to be_nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#value?' do
          
        
      
        

          

            1
            

            

                it 'returns true for valid values accessed directly' do
          
        
      
        

          

            1
            

            

                  Colors.values.each do |value| # rubocop:disable Style/HashEachMethods
          
        
      
        

          

            2
            

            

                    expect(Colors.value?(value)).to be(true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns true for valid values accessed via each_value' do
          
        
      
        

          

            1
            

            

                  Colors.each_value do |value|
          
        
      
        

          

            2
            

            

                    expect(Colors.value?(value)).to be(true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns false for invalid values' do
          
        
      
        

          

            1
            

            

                  expect(Colors.value?('I am not a value')).to be(false)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#key' do
          
        
      
        

          

            1
            

            

                it 'returns enum instances for values' do
          
        
      
        

          

            1
            

            

                  Colors.each do |_, enum| # rubocop:disable Style/HashEachMethods
          
        
      
        

          

            2
            

            

                    expect(Colors.key(enum.value)).to eq(enum.key)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'returns nil for an invalid value' do
          
        
      
        

          

            1
            

            

                  expect(Colors.key('invalid')).to be_nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#keys' do
          
        
      
        

          

            1
            

            

                it 'returns keys' do
          
        
      
        

          

            1
            

            

                  expect(Colors.keys).to eq(%i[RED GREEN])
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#values' do
          
        
      
        

          

            1
            

            

                it 'returns values' do
          
        
      
        

          

            1
            

            

                  expect(Colors.values).to eq(%w[red green])
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#to_h' do
          
        
      
        

          

            1
            

            

                it 'returns a hash of key:values' do
          
        
      
        

          

            1
            

            

                  expect(Colors.to_h).to eq(RED: 'red', GREEN: 'green')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'when a duplicate key is used' do
          
        
      
        

          

            1
            

            

                context 'when the i18n gem is loaded' do
          
        
      
        

          

            1
            

            

                  it 'raises DuplicateKeyError' do
          
        
      
        

          

            1
            

            

                    expect do
          
        
      
        

          

            1
            

            

                      Colors.class_eval do
          
        
      
        

          

            1
            

            

                        define :RED, 'some'
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end.to raise_error Ruby::Enum::Errors::DuplicateKeyError, /The constant Colors::RED has already been defined./
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when the i18n gem is not loaded' do
          
        
      
        

          

            1
            

            

                  before do
          
        
      
        

          

            1
            

            

                    allow(described_class).to receive(:i18n).and_return(Ruby::Enum::I18nMock)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'raises DuplicateKeyError' do
          
        
      
        

          

            1
            

            

                    expect do
          
        
      
        

          

            1
            

            

                      Colors.class_eval do
          
        
      
        

          

            1
            

            

                        define :RED, 'some'
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end.to raise_error Ruby::Enum::Errors::DuplicateKeyError, /ruby.enum.errors.messages.duplicate_key.message/
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'when a duplicate value is used' do
          
        
      
        

          

            1
            

            

                context 'when the i18n gem is loaded' do
          
        
      
        

          

            1
            

            

                  it 'raises a DuplicateValueError' do
          
        
      
        

          

            1
            

            

                    expect do
          
        
      
        

          

            1
            

            

                      Colors.class_eval do
          
        
      
        

          

            1
            

            

                        define :Other, 'red'
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end.to raise_error Ruby::Enum::Errors::DuplicateValueError, /The value red has already been defined./
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when the i18n gem is not loaded' do
          
        
      
        

          

            1
            

            

                  before do
          
        
      
        

          

            1
            

            

                    allow(described_class).to receive(:i18n).and_return(Ruby::Enum::I18nMock)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'raises a DuplicateValueError' do
          
        
      
        

          

            1
            

            

                    expect do
          
        
      
        

          

            1
            

            

                      Colors.class_eval do
          
        
      
        

          

            1
            

            

                        define :Other, 'red'
          
        
      
        

          

            
            

            

                      end
          
        
      
        

          

            
            

            

                    end.to raise_error Ruby::Enum::Errors::DuplicateValueError, /ruby.enum.errors.messages.duplicate_value.summary/
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'Given a class that has not defined any enums' do
          
        
      
        

          

            1
            

            

                class EmptyEnums
          
        
      
        

          

            1
            

            

                  include Ruby::Enum
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                it do
          
        
      
        

          

            2
            

            

                  expect { EmptyEnums::ORANGE }.to raise_error Ruby::Enum::Errors::UninitializedConstantError
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              context 'when a constant is redefined in a global namespace' do
          
        
      
        

          

            1
            

            

                before do
          
        
      
        

          

            1
            

            

                  RED = 'black'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                it { expect(Colors::RED).to eq 'red' }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'Subclass behavior' do
          
        
      
        

          

            1
            

            

                it 'contains the enums defined in the parent class' do
          
        
      
        

          

            1
            

            

                  expect(FirstSubclass::GREEN).to eq 'green'
          
        
      
        

          

            1
            

            

                  expect(FirstSubclass::RED).to eq 'red'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'contains its own enums' do
          
        
      
        

          

            1
            

            

                  expect(FirstSubclass::ORANGE).to eq 'orange'
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'parent class should not have enums defined in child classes' do
          
        
      
        

          

            2
            

            

                  expect { Colors::ORANGE }.to raise_error Ruby::Enum::Errors::UninitializedConstantError
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when defining a 2 level depth subclass' do
          
        
      
        

          

            2
            

            

                  subject { SecondSubclass }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'contains its own enums and all the enums defined in the parent classes' do
          
        
      
        

          

            1
            

            

                    expect(subject::RED).to eq 'red'
          
        
      
        

          

            1
            

            

                    expect(subject::GREEN).to eq 'green'
          
        
      
        

          

            1
            

            

                    expect(subject::ORANGE).to eq 'orange'
          
        
      
        

          

            1
            

            

                    expect(subject::PINK).to eq 'pink'
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  describe '#values' do
          
        
      
        

          

            2
            

            

                    subject { SecondSubclass.values }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    it 'contains the values from all of the parent classes' do
          
        
      
        

          

            1
            

            

                      expect(subject).to eq(%w[red green orange pink])
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                describe '#values' do
          
        
      
        

          

            2
            

            

                  subject { FirstSubclass.values }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'contains the values from the parent class' do
          
        
      
        

          

            1
            

            

                    expect(subject).to eq(%w[red green orange])
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'default value' do
          
        
      
        

          

            1
            

            

                class Default
          
        
      
        

          

            1
            

            

                  include Ruby::Enum
          
        
      
        

          

            1
            

            

                  define :KEY
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            2
            

            

                subject { Default::KEY }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'equals the key' do
          
        
      
        

          

            1
            

            

                  expect(subject).to eq(:KEY)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'non constant definitions' do
          
        
      
        

          

            1
            

            

                class States
          
        
      
        

          

            1
            

            

                  include Ruby::Enum
          
        
      
        

          

            1
            

            

                  define :created, 'Created'
          
        
      
        

          

            1
            

            

                  define :published, 'Published'
          
        
      
        

          

            1
            

            

                  define :undefined
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            2
            

            

                subject { States }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                it 'behaves like an enum' do
          
        
      
        

          

            1
            

            

                  expect(subject.created).to eq 'Created'
          
        
      
        

          

            1
            

            

                  expect(subject.published).to eq 'Published'
          
        
      
        

          

            1
            

            

                  expect(subject.undefined).to eq :undefined
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  expect(subject.key?(:created)).to be true
          
        
      
        

          

            1
            

            

                  expect(subject.key('Created')).to eq :created
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  expect(subject.value?('Created')).to be true
          
        
      
        

          

            1
            

            

                  expect(subject.value(:created)).to eq 'Created'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  expect(subject.key?(:undefined)).to be true
          
        
      
        

          

            1
            

            

                  expect(subject.key(:undefined)).to eq :undefined
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  expect(subject.value?(:undefined)).to be true
          
        
      
        

          

            1
            

            

                  expect(subject.value(:undefined)).to eq :undefined
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe Ruby::Enum do
          
        
      
        

          

            1
            

            

              it 'has a version' do
          
        
      
        

          

            1
            

            

                expect(Ruby::Enum::VERSION).not_to be_nil
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end