ruby-enum 0.9.0 → 1.1.0

data/lib/ruby-enum/enum/case.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ruby
+  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" },
+    # })
+    module Case
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
+
+      ##
+      # @see Ruby::Enum::Case
+      module ClassMethods
+        class ValuesNotDefinedError < StandardError
+        end
+
+        class NotAllCasesHandledError < StandardError
+        end
+
+        def case(value, cases)
+          validate_cases(cases)
+
+          filtered_cases = cases.select do |values, _proc|
+            values = [values] unless values.is_a?(Array)
+            values.include?(value)
+          end
+
+          return call_proc(cases[:else], value) if filtered_cases.none?
+
+          results = filtered_cases.map { |_values, proc| call_proc(proc, value) }
+
+          # Return the first result if there is only one result
+          results.size == 1 ? results.first : results
+        end
+
+        private
+
+        def call_proc(proc, value)
+          return if proc.nil?
+
+          if proc.arity == 1
+            proc.call(value)
+          else
+            proc.call
+          end
+        end
+
+        def validate_cases(cases)
+          all_values = cases.keys.flatten - [:else]
+          else_defined = cases.key?(:else)
+          superfluous_values = all_values - values
+          missing_values = values - all_values
+
+          raise ValuesNotDefinedError, "Value(s) not defined: #{superfluous_values.join(', ')}" if superfluous_values.any?
+          raise NotAllCasesHandledError, "Not all cases handled: #{missing_values.join(', ')}" if missing_values.any? && !else_defined
+        end
+      end
+    end
+  end
+end

data/lib/ruby-enum/enum/i18n_mock.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Ruby
+  module Enum
+    ##
+    # Mock I18n module in case the i18n gem is not available.
+    module I18nMock
+      def self.load_path
+        []
+      end
+
+      def self.translate(key, _options = {})
+        key
+      end
+    end
+  end
+end
+# :nocov:

data/lib/ruby-enum/enum.rb

@@ -2,6 +2,11 @@
 
 module Ruby
   module Enum
+    class << self
+      # Needed for I18n mock
+      attr_accessor :i18n
+    end
+
     attr_reader :key, :value
 
     def initialize(key, value)
@@ -14,6 +19,9 @@ module Ruby
       base.extend ClassMethods
 
       base.private_class_method(:new)
+
+      base.instance_variable_set(:@_enum_hash, {})
+      base.instance_variable_set(:@_enums_by_value, {})
     end
 
     module ClassMethods
@@ -144,9 +152,7 @@ module Ruby
       end
 
       def to_h
-        Hash[@_enum_hash.map do |key, enum|
-          [key, enum.value]
-        end]
+        @_enum_hash.transform_values(&:value)
       end
 
       private

data/lib/ruby-enum/errors/base.rb

@@ -22,13 +22,13 @@ module Ruby
           @summary = create_summary(key, attributes)
           @resolution = create_resolution(key, attributes)
 
-          "\nProblem:\n  #{@problem}"\
+          "\nProblem:\n  #{@problem}" \
           "\nSummary:\n  #{@summary}" + "\nResolution:\n  #{@resolution}"
         end
 
-        private
+        BASE_KEY = 'ruby.enum.errors.messages' # :nodoc:
 
-        BASE_KEY = 'ruby.enum.errors.messages' #:nodoc:
+        private
 
         # Given the key of the specific error and the options hash, translate the
         # message.
@@ -39,7 +39,7 @@ module Ruby
         #
         # Returns a localized error message string.
         def translate(key, options)
-          ::I18n.translate("#{BASE_KEY}.#{key}", **{ locale: :en }.merge(options)).strip
+          Ruby::Enum.i18n.translate("#{BASE_KEY}.#{key}", locale: :en, **options).strip
         end
 
         # Create the problem.

data/lib/ruby-enum/version.rb

@@ -2,6 +2,6 @@
 
 module Ruby
   module Enum
-    VERSION = '0.9.0'
+    VERSION = '1.1.0'
   end
 end

data/lib/ruby-enum.rb

@@ -1,11 +1,23 @@
 # frozen_string_literal: true
 
-require 'i18n'
-
 require 'ruby-enum/version'
 require 'ruby-enum/enum'
+require 'ruby-enum/enum/case'
+require 'ruby-enum/enum/i18n_mock'
+
+# Try to load the I18n gem and provide a mock if it is not available.
+begin
+  require 'i18n'
+  Ruby::Enum.i18n = I18n
+rescue LoadError
+  # I18n is not available
+  # :nocov:
+  # Tests for this loading are in the spec_i18n folder
+  Ruby::Enum.i18n = Ruby::Enum::I18nMock
+  # :nocov:
+end
 
-I18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
+Ruby::Enum.i18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
 
 require 'ruby-enum/errors/base'
 require 'ruby-enum/errors/uninitialized_constant_error'

data/ruby-enum.gemspec

@@ -10,10 +10,11 @@ Gem::Specification.new do |s|
   s.email = 'dblock@dblock.org'
   s.platform = Gem::Platform::RUBY
   s.required_rubygems_version = '>= 1.3.6'
+  s.required_ruby_version = '>= 2.7'
   s.files = Dir['**/*']
   s.require_paths = ['lib']
   s.homepage = 'http://github.com/dblock/ruby-enum'
   s.licenses = ['MIT']
   s.summary = 'Enum-like behavior for Ruby.'
-  s.add_dependency 'i18n'
+  s.metadata['rubygems_mfa_required'] = 'true'
 end

data/spec/ruby-enum/enum/case_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Case
+  class Colors
+    include Ruby::Enum
+    include Ruby::Enum::Case
+
+    define :RED, :red
+    define :GREEN, :green
+    define :BLUE, :blue
+  end
+end
+
+RSpec.describe Ruby::Enum::Case do
+  describe '.case' do
+    context 'when all cases are defined' do
+      subject { Case::Colors.case(Case::Colors::RED, cases) }
+
+      let(:cases) do
+        {
+          [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
+          Case::Colors::BLUE => -> { 'blue' }
+        }
+      end
+
+      it { is_expected.to eq('red or green') }
+
+      context 'when the value is nil' do
+        subject { Case::Colors.case(nil, cases) }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when the value is empty' do
+        subject { Case::Colors.case('', cases) }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when the value is the value of the enum' do
+        subject { Case::Colors.case(:red, cases) }
+
+        it { is_expected.to eq('red or green') }
+      end
+
+      context 'when the value is used inside the lambda' do
+        subject { Case::Colors.case(Case::Colors::RED, cases) }
+
+        let(:cases) do
+          {
+            [Case::Colors::RED, Case::Colors::GREEN] => ->(color) { "is #{color}" },
+            Case::Colors::BLUE => -> { 'blue' }
+          }
+        end
+
+        it { is_expected.to eq('is red') }
+      end
+    end
+
+    context 'when there are mutliple matches' do
+      subject do
+        Case::Colors.case(
+          Case::Colors::RED,
+          {
+            [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
+            Case::Colors::RED => -> { 'red' },
+            Case::Colors::BLUE => -> { 'blue' }
+          }
+        )
+      end
+
+      it { is_expected.to eq(['red or green', 'red']) }
+    end
+
+    context 'when not all cases are defined' do
+      it 'raises an error' do
+        expect do
+          Case::Colors.case(
+            Case::Colors::RED,
+            { [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' } }
+          )
+        end.to raise_error(Ruby::Enum::Case::ClassMethods::NotAllCasesHandledError)
+      end
+    end
+
+    context 'when not all cases are defined but :else is specified (default case)' do
+      it 'does not raise an error' do
+        expect do
+          result = Case::Colors.case(
+            Case::Colors::BLUE,
+            {
+              [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
+              else: -> { 'blue' }
+            }
+          )
+
+          expect(result).to eq('blue')
+        end.not_to raise_error
+      end
+    end
+
+    context 'when a superfluous case is defined' do
+      it 'raises an error' do
+        expect do
+          Case::Colors.case(
+            Case::Colors::RED,
+            {
+              [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
+              Case::Colors::BLUE => -> { 'blue' },
+              :something => -> { 'green' }
+            }
+          )
+        end.to raise_error(Ruby::Enum::Case::ClassMethods::ValuesNotDefinedError)
+      end
+    end
+  end
+end