ruby-enum 1.0.0 → 1.2.0

data/lib/ruby-enum/enum.rb

@@ -19,6 +19,9 @@ module Ruby
       base.extend ClassMethods
 
       base.private_class_method(:new)
+
+      base.instance_variable_set(:@_own_enum_hash, {})
+      base.instance_variable_set(:@_own_enums_by_value, {})
     end
 
     module ClassMethods
@@ -28,9 +31,6 @@ module Ruby
       # [key] Enumerator key.
       # [value] Enumerator value.
       def define(key, value = key)
-        @_enum_hash ||= {}
-        @_enums_by_value ||= {}
-
         validate_key!(key)
         validate_value!(value)
 
@@ -45,18 +45,21 @@ module Ruby
 
       def store_new_instance(key, value)
         new_instance = new(key, value)
-        @_enum_hash[key] = new_instance
-        @_enums_by_value[value] = new_instance
+        _own_enum_hash[key] = new_instance
+        _own_enums_by_value[value] = new_instance
+
+        # Invalidate memoized, merged hashes since this class' own enums changed.
+        @_enum_hash = @_enums_by_value = nil
       end
 
       def const_missing(key)
         raise Ruby::Enum::Errors::UninitializedConstantError, name: name, key: key
       end
 
-      # Iterate over all enumerated values.
+      # Iterate over all enumerated values, including those defined in a superclass.
       # Required for Enumerable mixin
       def each(&block)
-        @_enum_hash.each(&block)
+        _enum_hash.each(&block)
       end
 
       # Attempt to parse an enum key and return the
@@ -74,56 +77,56 @@ module Ruby
         nil
       end
 
-      # Whether the specified key exists in this enum.
+      # Whether the specified key exists in this enum, including those defined in a superclass.
       #
       # === Parameters
       # [k] The string key to check.
       #
       # Returns true if the key exists, false otherwise.
       def key?(k)
-        @_enum_hash.key?(k)
+        _enum_hash.key?(k)
       end
 
-      # Gets the string value for the specified key.
+      # Gets the string value for the specified key, including those defined in a superclass.
       #
       # === Parameters
       # [k] The key symbol to get the value for.
       #
       # Returns the corresponding enum instance or nil.
       def value(k)
-        enum = @_enum_hash[k]
+        enum = _enum_hash[k]
         enum&.value
       end
 
-      # Whether the specified value exists in this enum.
+      # Whether the specified value exists in this enum, including those defined in a superclass.
       #
       # === Parameters
       # [k] The string value to check.
       #
       # Returns true if the value exists, false otherwise.
       def value?(v)
-        @_enums_by_value.key?(v)
+        _enums_by_value.key?(v)
       end
 
-      # Gets the key symbol for the specified value.
+      # Gets the key symbol for the specified value, including those defined in a superclass.
       #
       # === Parameters
       # [v] The string value to parse.
       #
       # Returns the corresponding key symbol or nil.
       def key(v)
-        enum = @_enums_by_value[v]
+        enum = _enums_by_value[v]
         enum&.key
       end
 
-      # Returns all enum keys.
+      # Returns all enum keys, including those defined in a superclass.
       def keys
-        @_enum_hash.values.map(&:key)
+        _enum_hash.values.map(&:key)
       end
 
       # Returns all enum values.
       def values
-        result = @_enum_hash.values.map(&:value)
+        result = _own_enum_hash.values.map(&:value)
 
         if superclass < Ruby::Enum
           superclass.values + result
@@ -132,40 +135,77 @@ module Ruby
         end
       end
 
-      # Iterate over all enumerated values.
+      # Iterate over all enumerated values, including those defined in a superclass.
       # Required for Enumerable mixin
       def each_value(&_block)
-        @_enum_hash.each_value do |v|
+        _enum_hash.each_value do |v|
           yield v.value
         end
       end
 
-      # Iterate over all enumerated keys.
+      # Iterate over all enumerated keys, including those defined in a superclass.
       # Required for Enumerable mixin
       def each_key(&_block)
-        @_enum_hash.each_value do |v|
+        _enum_hash.each_value do |v|
           yield v.key
         end
       end
 
+      # Returns a hash of key:values, including those defined in a superclass.
       def to_h
-        @_enum_hash.transform_values(&:value)
+        _enum_hash.transform_values(&:value)
       end
 
       private
 
+      # Returns this class' own enum hash, defaulting to an empty hash.
+      #
+      # A subclass that does not `define` any of its own enums does not have
+      # its `@_own_enum_hash` instance variable set, since it's only initialized
+      # in `define` and in the `included` hook.
+      def _own_enum_hash
+        @_own_enum_hash ||= {}
+      end
+
+      # Returns this class' own enums-by-value hash, defaulting to an empty hash.
+      def _own_enums_by_value
+        @_own_enums_by_value ||= {}
+      end
+
+      # Returns the enum hash for this class merged with all of its superclasses,
+      # with keys defined in this class taking precedence over those inherited
+      # from a superclass.
+      def _enum_hash
+        @_enum_hash ||= if superclass < Ruby::Enum
+                          superclass.send(:_enum_hash).merge(_own_enum_hash)
+                        else
+                          _own_enum_hash
+                        end
+      end
+
+      # Returns the enums-by-value hash for this class merged with all of its
+      # superclasses, with values defined in this class taking precedence over
+      # those inherited from a superclass.
+      def _enums_by_value
+        @_enums_by_value ||= if superclass < Ruby::Enum
+                               superclass.send(:_enums_by_value).merge(_own_enums_by_value)
+                             else
+                               _own_enums_by_value
+                             end
+      end
+
       def upper?(s)
         !/[[:upper:]]/.match(s).nil?
       end
 
       def validate_key!(key)
-        return unless @_enum_hash.key?(key)
+        return unless _own_enum_hash.key?(key)
 
         raise Ruby::Enum::Errors::DuplicateKeyError, name: name, key: key
       end
 
       def validate_value!(value)
-        return unless @_enums_by_value.key?(value)
+        return unless _own_enums_by_value.key?(value)
 
         raise Ruby::Enum::Errors::DuplicateValueError, name: name, value: value
       end

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

@@ -26,10 +26,10 @@ module Ruby
           "\nSummary:\n  #{@summary}" + "\nResolution:\n  #{@resolution}"
         end
 
-        private
-
         BASE_KEY = 'ruby.enum.errors.messages' # :nodoc:
 
+        private
+
         # Given the key of the specific error and the options hash, translate the
         # message.
         #

data/lib/ruby-enum/version.rb

@@ -2,6 +2,6 @@
 
 module Ruby
   module Enum
-    VERSION = '1.0.0'
+    VERSION = '1.2.0'
   end
 end

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

@@ -2,55 +2,56 @@
 
 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
+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 { test_enum.case(test_enum::RED, cases) }
+      subject { Case::Colors.case(Case::Colors::RED, cases) }
 
       let(:cases) do
         {
-          [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
-          test_enum::BLUE => -> { 'blue' }
+          [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 { test_enum.case(nil, cases) }
+        subject { Case::Colors.case(nil, cases) }
 
         it { is_expected.to be_nil }
       end
 
       context 'when the value is empty' do
-        subject { test_enum.case('', cases) }
+        subject { Case::Colors.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) }
+        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 { test_enum.case(test_enum::RED, cases) }
+        subject { Case::Colors.case(Case::Colors::RED, cases) }
 
         let(:cases) do
           {
-            [test_enum::RED, test_enum::GREEN] => ->(color) { "is #{color}" },
-            test_enum::BLUE => -> { 'blue' }
+            [Case::Colors::RED, Case::Colors::GREEN] => ->(color) { "is #{color}" },
+            Case::Colors::BLUE => -> { 'blue' }
           }
         end
 
@@ -60,12 +61,12 @@ RSpec.describe Ruby::Enum::Case do
 
     context 'when there are mutliple matches' do
       subject do
-        test_enum.case(
-          test_enum::RED,
+        Case::Colors.case(
+          Case::Colors::RED,
           {
-            [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
-            test_enum::RED => -> { 'red' },
-            test_enum::BLUE => -> { 'blue' }
+            [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
+            Case::Colors::RED => -> { 'red' },
+            Case::Colors::BLUE => -> { 'blue' }
           }
         )
       end
@@ -76,9 +77,9 @@ RSpec.describe Ruby::Enum::Case do
     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' } }
+          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
@@ -87,10 +88,10 @@ RSpec.describe Ruby::Enum::Case do
     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,
+          result = Case::Colors.case(
+            Case::Colors::BLUE,
             {
-              [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
+              [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
               else: -> { 'blue' }
             }
           )
@@ -103,11 +104,11 @@ RSpec.describe Ruby::Enum::Case do
     context 'when a superfluous case is defined' do
       it 'raises an error' do
         expect do
-          test_enum.case(
-            test_enum::RED,
+          Case::Colors.case(
+            Case::Colors::RED,
             {
-              [test_enum::RED, test_enum::GREEN] => -> { 'red or green' },
-              test_enum::BLUE => -> { 'blue' },
+              [Case::Colors::RED, Case::Colors::GREEN] => -> { 'red or green' },
+              Case::Colors::BLUE => -> { 'blue' },
               :something => -> { 'green' }
             }
           )