ruby-enum 0.8.0 → 1.0.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)
@@ -22,7 +27,7 @@ module Ruby
       # === Parameters
       # [key] Enumerator key.
       # [value] Enumerator value.
-      def define(key, value)
+      def define(key, value = key)
         @_enum_hash ||= {}
         @_enums_by_value ||= {}
 
@@ -118,7 +123,13 @@ module Ruby
 
       # Returns all enum values.
       def values
-        @_enum_hash.values.map(&:value)
+        result = @_enum_hash.values.map(&:value)
+
+        if superclass < Ruby::Enum
+          superclass.values + result
+        else
+          result
+        end
       end
 
       # Iterate over all enumerated values.
@@ -138,9 +149,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:
 
         # 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.8.0'
+    VERSION = '1.0.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,118 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Ruby::Enum::Case do
+  test_enum =
+    Class.new do
+      include Ruby::Enum
+      include Ruby::Enum::Case
+
+      define :RED, :red
+      define :GREEN, :green
+      define :BLUE, :blue
+    end
+
+  describe '.case' do
+    context 'when all cases are defined' do
+      subject { test_enum.case(test_enum::RED, cases) }
+
+      let(:cases) do
+        {
+          [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
+          test_enum::BLUE => -> { 'blue' }
+        }
+      end
+
+      it { is_expected.to eq('red or green') }
+
+      context 'when the value is nil' do
+        subject { test_enum.case(nil, cases) }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when the value is empty' do
+        subject { test_enum.case('', cases) }
+
+        it { is_expected.to be_nil }
+      end
+
+      context 'when the value is the value of the enum' do
+        subject { test_enum.case(:red, cases) }
+
+        it { is_expected.to eq('red or green') }
+      end
+
+      context 'when the value is used inside the lambda' do
+        subject { test_enum.case(test_enum::RED, cases) }
+
+        let(:cases) do
+          {
+            [test_enum::RED, test_enum::GREEN] => ->(color) { "is #{color}" },
+            test_enum::BLUE => -> { 'blue' }
+          }
+        end
+
+        it { is_expected.to eq('is red') }
+      end
+    end
+
+    context 'when there are mutliple matches' do
+      subject do
+        test_enum.case(
+          test_enum::RED,
+          {
+            [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
+            test_enum::RED => -> { 'red' },
+            test_enum::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
+          test_enum.case(
+            test_enum::RED,
+            { [test_enum::RED, test_enum::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 = test_enum.case(
+            test_enum::BLUE,
+            {
+              [test_enum::RED, test_enum::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
+          test_enum.case(
+            test_enum::RED,
+            {
+              [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
+              test_enum::BLUE => -> { 'blue' },
+              :something => -> { 'green' }
+            }
+          )
+        end.to raise_error(Ruby::Enum::Case::ClassMethods::ValuesNotDefinedError)
+      end
+    end
+  end
+end

data/spec/ruby-enum/enum_spec.rb

@@ -22,10 +22,28 @@ describe Ruby::Enum do
     expect(Colors::RED).to eq 'red'
     expect(Colors::GREEN).to eq 'green'
   end
-  it 'raises UninitializedConstantError on an invalid constant' do
-    expect { Colors::ANYTHING }.to raise_error Ruby::Enum::Errors::UninitializedConstantError, /The constant Colors::ANYTHING has not been defined./
+
+  context 'when the i18n gem is loaded' do
+    it 'raises UninitializedConstantError on an invalid constant' do
+      expect do
+        Colors::ANYTHING
+      end.to raise_error Ruby::Enum::Errors::UninitializedConstantError, /The constant Colors::ANYTHING has not been defined./
+    end
   end
-  context '#each' do
+
+  context 'when the i18n gem is not loaded' do
+    before do
+      allow(described_class).to receive(:i18n).and_return(Ruby::Enum::I18nMock)
+    end
+
+    it 'raises UninitializedConstantError on an invalid constant' do
+      expect do
+        Colors::ANYTHING
+      end.to raise_error Ruby::Enum::Errors::UninitializedConstantError, /ruby.enum.errors.messages.uninitialized_constant.summary/
+    end
+  end
+
+  describe '#each' do
     it 'iterates over constants' do
       keys = []
       enum_keys = []
@@ -40,7 +58,8 @@ describe Ruby::Enum do
       expect(enum_values).to eq %w[red green]
     end
   end
-  context '#map' do
+
+  describe '#map' do
     it 'maps constants' do
       key_key_values = Colors.map do |key, enum|
         [key, enum.key, enum.value]
@@ -50,103 +69,152 @@ describe Ruby::Enum do
       expect(key_key_values[1]).to eq [:GREEN, :GREEN, 'green']
     end
   end
-  context '#parse' do
+
+  describe '#parse' do
     it 'parses exact value' do
       expect(Colors.parse('red')).to eq(Colors::RED)
     end
+
     it 'is case-insensitive' do
       expect(Colors.parse('ReD')).to eq(Colors::RED)
     end
+
     it 'returns nil for a null value' do
       expect(Colors.parse(nil)).to be_nil
     end
+
     it 'returns nil for an invalid value' do
       expect(Colors.parse('invalid')).to be_nil
     end
   end
-  context '#key?' do
+
+  describe '#key?' do
     it 'returns true for valid keys accessed directly' do
       Colors.keys.each do |key| # rubocop:disable Style/HashEachMethods
-        expect(Colors.key?(key)).to eq(true)
+        expect(Colors.key?(key)).to be(true)
       end
     end
+
     it 'returns true for valid keys accessed via each_keys' do
       Colors.each_key do |key|
-        expect(Colors.key?(key)).to eq(true)
+        expect(Colors.key?(key)).to be(true)
       end
     end
+
     it 'returns false for invalid keys' do
-      expect(Colors.key?(:NOT_A_KEY)).to eq(false)
+      expect(Colors.key?(:NOT_A_KEY)).to be(false)
     end
   end
-  context '#value' do
+
+  describe '#value' do
     it 'returns string values for keys' do
       Colors.each do |key, enum|
         expect(Colors.value(key)).to eq(enum.value)
       end
     end
+
     it 'returns nil for an invalid key' do
       expect(Colors.value(:NOT_A_KEY)).to be_nil
     end
   end
-  context '#value?' do
+
+  describe '#value?' do
     it 'returns true for valid values accessed directly' do
       Colors.values.each do |value| # rubocop:disable Style/HashEachMethods
-        expect(Colors.value?(value)).to eq(true)
+        expect(Colors.value?(value)).to be(true)
       end
     end
+
     it 'returns true for valid values accessed via each_value' do
       Colors.each_value do |value|
-        expect(Colors.value?(value)).to eq(true)
+        expect(Colors.value?(value)).to be(true)
       end
     end
+
     it 'returns false for invalid values' do
-      expect(Colors.value?('I am not a value')).to eq(false)
+      expect(Colors.value?('I am not a value')).to be(false)
     end
   end
-  context '#key' do
+
+  describe '#key' do
     it 'returns enum instances for values' do
-      Colors.each do |_, enum|
+      Colors.each do |_, enum| # rubocop:disable Style/HashEachMethods
         expect(Colors.key(enum.value)).to eq(enum.key)
       end
     end
+
     it 'returns nil for an invalid value' do
       expect(Colors.key('invalid')).to be_nil
     end
   end
-  context '#keys' do
+
+  describe '#keys' do
     it 'returns keys' do
       expect(Colors.keys).to eq(%i[RED GREEN])
     end
   end
-  context '#values' do
+
+  describe '#values' do
     it 'returns values' do
       expect(Colors.values).to eq(%w[red green])
     end
   end
-  context '#to_h' do
+
+  describe '#to_h' do
     it 'returns a hash of key:values' do
       expect(Colors.to_h).to eq(RED: 'red', GREEN: 'green')
     end
   end
 
-  context 'on duplicate keys' do
-    it 'raises DuplicateKeyError' do
-      expect do
-        Colors.class_eval do
-          define :RED, 'some'
-        end
-      end.to raise_error Ruby::Enum::Errors::DuplicateKeyError, /The constant Colors::RED has already been defined./
+  context 'when a duplicate key is used' do
+    context 'when the i18n gem is loaded' do
+      it 'raises DuplicateKeyError' do
+        expect do
+          Colors.class_eval do
+            define :RED, 'some'
+          end
+        end.to raise_error Ruby::Enum::Errors::DuplicateKeyError, /The constant Colors::RED has already been defined./
+      end
+    end
+
+    context 'when the i18n gem is not loaded' do
+      before do
+        allow(described_class).to receive(:i18n).and_return(Ruby::Enum::I18nMock)
+      end
+
+      it 'raises DuplicateKeyError' do
+        expect do
+          Colors.class_eval do
+            define :RED, 'some'
+          end
+        end.to raise_error Ruby::Enum::Errors::DuplicateKeyError, /ruby.enum.errors.messages.duplicate_key.message/
+      end
     end
   end
 
-  context 'on duplicate values' do
-    it 'raises a DuplicateValueError' do
-      expect do
-        Colors.class_eval do
-          define :Other, 'red'
-        end
-      end.to raise_error Ruby::Enum::Errors::DuplicateValueError, /The value red has already been defined./
+  context 'when a duplicate value is used' do
+    context 'when the i18n gem is loaded' do
+      it 'raises a DuplicateValueError' do
+        expect do
+          Colors.class_eval do
+            define :Other, 'red'
+          end
+        end.to raise_error Ruby::Enum::Errors::DuplicateValueError, /The value red has already been defined./
+      end
+    end
+
+    context 'when the i18n gem is not loaded' do
+      before do
+        allow(described_class).to receive(:i18n).and_return(Ruby::Enum::I18nMock)
+      end
+
+      it 'raises a DuplicateValueError' do
+        expect do
+          Colors.class_eval do
+            define :Other, 'red'
+          end
+        end.to raise_error Ruby::Enum::Errors::DuplicateValueError, /ruby.enum.errors.messages.duplicate_value.summary/
+      end
     end
   end
 
@@ -176,17 +244,49 @@ describe Ruby::Enum do
     it 'contains its own enums' do
       expect(FirstSubclass::ORANGE).to eq 'orange'
     end
+
     it 'parent class should not have enums defined in child classes' do
       expect { Colors::ORANGE }.to raise_error Ruby::Enum::Errors::UninitializedConstantError
     end
-    context 'Given a 2 level depth subclass' do
+
+    context 'when defining a 2 level depth subclass' do
       subject { SecondSubclass }
+
       it 'contains its own enums and all the enums defined in the parent classes' do
         expect(subject::RED).to eq 'red'
         expect(subject::GREEN).to eq 'green'
         expect(subject::ORANGE).to eq 'orange'
         expect(subject::PINK).to eq 'pink'
       end
+
+      describe '#values' do
+        subject { SecondSubclass.values }
+
+        it 'contains the values from all of the parent classes' do
+          expect(subject).to eq(%w[red green orange pink])
+        end
+      end
+    end
+
+    describe '#values' do
+      subject { FirstSubclass.values }
+
+      it 'contains the values from the parent class' do
+        expect(subject).to eq(%w[red green orange])
+      end
+    end
+  end
+
+  describe 'default value' do
+    class Default
+      include Ruby::Enum
+      define :KEY
+    end
+
+    subject { Default::KEY }
+
+    it 'equals the key' do
+      expect(subject).to eq(:KEY)
     end
   end
 
@@ -195,17 +295,26 @@ describe Ruby::Enum do
       include Ruby::Enum
       define :created, 'Created'
       define :published, 'Published'
+      define :undefined
     end
     subject { States }
+
     it 'behaves like an enum' do
       expect(subject.created).to eq 'Created'
       expect(subject.published).to eq 'Published'
+      expect(subject.undefined).to eq :undefined
 
       expect(subject.key?(:created)).to be true
       expect(subject.key('Created')).to eq :created
 
       expect(subject.value?('Created')).to be true
       expect(subject.value(:created)).to eq 'Created'
+
+      expect(subject.key?(:undefined)).to be true
+      expect(subject.key(:undefined)).to eq :undefined
+
+      expect(subject.value?(:undefined)).to be true
+      expect(subject.value(:undefined)).to eq :undefined
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,10 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'rubygems'
+
+require 'simplecov'
+SimpleCov.start
+
 require 'rspec'
 require 'ruby-enum'
 

data/spec_i18n/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+gemspec path: '../', name: 'ruby-enum'
+
+# This Gemfile should not include any gem that has i18n as a dependency.
+gem 'rake'
+gem 'rspec', '~> 3.0'