Inherit keys, key?, value?, key, value, to_h, parse and each from superclass

Follow-up to #49/#58. values already merged enums from a superclass
chain, but keys, key?, value?, key, value, to_h, parse and each only
looked at a class' own enums, silently ignoring any enums defined in
a superclass.

Introduces _enum_hash/_enums_by_value that merge a class' own enums
with those of its superclass chain (subclass definitions take
precedence over the same key/value defined in a superclass), and uses
them for all read methods. define/duplicate validation continues to
use the class' own enums only (_own_enum_hash/_own_enums_by_value), so
a subclass may still redefine a key or value already used by a
superclass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: dblock

CHANGELOG.md

@@ -1,6 +1,7 @@
 ### 1.2.0 (Next)
 
 * [#49](https://github.com/dblock/ruby-enum/issues/49): Fixed `NoMethodError` on `keys`, `values`, `key?`, `value?`, `key`, `value`, `to_h`, `parse` and `each` when a subclass defines no enums of its own - [@dblock](https://github.com/dblock).
+* [#49](https://github.com/dblock/ruby-enum/issues/49): `keys`, `key?`, `value?`, `key`, `value`, `to_h`, `parse` and `each` now include enums defined in a superclass, matching the existing behavior of `values` - [@dblock](https://github.com/dblock).
 * Your contribution here.
 
 ### 1.1.0 (2026/6/20)

lib/ruby-enum/enum.rb

@@ -20,8 +20,8 @@ def self.included(base)
 
       base.private_class_method(:new)
 
-      base.instance_variable_set(:@_enum_hash, {})
-      base.instance_variable_set(:@_enums_by_value, {})
+      base.instance_variable_set(:@_own_enum_hash, {})
+      base.instance_variable_set(:@_own_enums_by_value, {})
     end
 
     module ClassMethods
@@ -45,15 +45,15 @@ def define(key, value = key)
 
       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
       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)
@@ -74,7 +74,7 @@ def parse(k)
         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.
@@ -84,7 +84,7 @@ def 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.
@@ -95,7 +95,7 @@ def value(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.
@@ -105,7 +105,7 @@ def value?(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.
@@ -116,14 +116,14 @@ def key(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)
       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,22 +132,23 @@ def values
         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|
           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|
           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)
       end
@@ -157,29 +158,51 @@ def to_h
       # 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 `@_enum_hash` instance variable set, since it's only initialized
+      # its `@_own_enum_hash` instance variable set, since it's only initialized
       # in `define` and in the `included` hook.
-      def _enum_hash
-        @_enum_hash ||= {}
+      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
+        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

spec/ruby-enum/enum_spec.rb

@@ -66,6 +66,13 @@ class SubclassWithNoOwnDefines < Colors
       expect(enum_keys).to eq %i[RED GREEN]
       expect(enum_values).to eq %w[red green]
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'iterates over the enums defined in the parent class too' do
+        keys = FirstSubclass.map { |key, _enum| key }
+        expect(keys).to eq %i[RED GREEN ORANGE]
+      end
+    end
   end
 
   describe '#map' do
@@ -95,6 +102,12 @@ class SubclassWithNoOwnDefines < Colors
     it 'returns nil for an invalid value' do
       expect(Colors.parse('invalid')).to be_nil
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'parses a value defined in the parent class' do
+        expect(FirstSubclass.parse('red')).to eq('red')
+      end
+    end
   end
 
   describe '#key?' do
@@ -113,6 +126,12 @@ class SubclassWithNoOwnDefines < Colors
     it 'returns false for invalid keys' do
       expect(Colors.key?(:NOT_A_KEY)).to be(false)
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'returns true for keys inherited from the parent class' do
+        expect(FirstSubclass.key?(:RED)).to be(true)
+      end
+    end
   end
 
   describe '#value' do
@@ -125,6 +144,12 @@ class SubclassWithNoOwnDefines < Colors
     it 'returns nil for an invalid key' do
       expect(Colors.value(:NOT_A_KEY)).to be_nil
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'returns the value for a key inherited from the parent class' do
+        expect(FirstSubclass.value(:RED)).to eq('red')
+      end
+    end
   end
 
   describe '#value?' do
@@ -143,6 +168,12 @@ class SubclassWithNoOwnDefines < Colors
     it 'returns false for invalid values' do
       expect(Colors.value?('I am not a value')).to be(false)
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'returns true for values inherited from the parent class' do
+        expect(FirstSubclass.value?('red')).to be(true)
+      end
+    end
   end
 
   describe '#key' do
@@ -155,12 +186,24 @@ class SubclassWithNoOwnDefines < Colors
     it 'returns nil for an invalid value' do
       expect(Colors.key('invalid')).to be_nil
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'returns the key for a value inherited from the parent class' do
+        expect(FirstSubclass.key('red')).to eq(:RED)
+      end
+    end
   end
 
   describe '#keys' do
     it 'returns keys' do
       expect(Colors.keys).to eq(%i[RED GREEN])
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'includes keys from the parent class' do
+        expect(FirstSubclass.keys).to eq(%i[RED GREEN ORANGE])
+      end
+    end
   end
 
   describe '#values' do
@@ -197,6 +240,12 @@ class SubclassWithNoOwnDefines < Colors
     it 'returns a hash of key:values' do
       expect(Colors.to_h).to eq(RED: 'red', GREEN: 'green')
     end
+
+    context 'when a subclass defines its own enums' do
+      it 'includes key:values from the parent class' do
+        expect(FirstSubclass.to_h).to eq(RED: 'red', GREEN: 'green', ORANGE: 'orange')
+      end
+    end
   end
 
   context 'when a duplicate key is used' do
@@ -354,15 +403,15 @@ class EmptyEnums
         expect(SubclassWithNoOwnDefines.values).to eq(%w[red green])
       end
 
-      it 'does not raise when calling keys, key?, value?, key, value, to_h, parse or each' do
-        expect(SubclassWithNoOwnDefines.keys).to eq([])
-        expect(SubclassWithNoOwnDefines.key?(:RED)).to be false
-        expect(SubclassWithNoOwnDefines.value?('red')).to be false
-        expect(SubclassWithNoOwnDefines.key('red')).to be_nil
-        expect(SubclassWithNoOwnDefines.value(:RED)).to be_nil
-        expect(SubclassWithNoOwnDefines.to_h).to eq({})
-        expect(SubclassWithNoOwnDefines.parse('red')).to be_nil
-        expect(SubclassWithNoOwnDefines.each.to_a).to eq([])
+      it 'inherits the parent class enums for keys, key?, value?, key, value, to_h, parse and each' do
+        expect(SubclassWithNoOwnDefines.keys).to eq(%i[RED GREEN])
+        expect(SubclassWithNoOwnDefines.key?(:RED)).to be true
+        expect(SubclassWithNoOwnDefines.value?('red')).to be true
+        expect(SubclassWithNoOwnDefines.key('red')).to eq :RED
+        expect(SubclassWithNoOwnDefines.value(:RED)).to eq 'red'
+        expect(SubclassWithNoOwnDefines.to_h).to eq(RED: 'red', GREEN: 'green')
+        expect(SubclassWithNoOwnDefines.parse('red')).to eq 'red'
+        expect(SubclassWithNoOwnDefines.each.map { |key, _enum| key }).to eq(%i[RED GREEN])
       end
     end
   end