enumy 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 442bf1f2f59d96452645b89c7050dabc6a40b409a069ef098a7cc7b6b2161db6
-  data.tar.gz: 63c4ea47062fe225c8b06ea89354fcd3c6b7f5207bff4dadaf443288e32054f4
+  metadata.gz: 5ca792d4165a95092a74b557d88a61d7a7a6e0d7315ec1e75e22a3f82505a1ca
+  data.tar.gz: b092cc6b1eb561643dd0da92153921e2683d1dafb1dcd2003e919a7b95d649de
 SHA512:
-  metadata.gz: ae1f353d6694670d47a309ee080bbe1f76728efddec79aeedaeba7e7e852721c034773adb59278c0c81f2b996edea81696991855cb7689fb957b4855a4f191cd
-  data.tar.gz: 351549b732f4a112eff6926cd6cea4a17a82467c3803d85621cb7cba442a5dd014802eb3eda386b61f6057b834e3ba504395099dc2333786219317b7ab4889cc
+  metadata.gz: 4e939f579145cf979a8575cfdf62498aa3ba6917fbf78f6f1c8df5ddd959892ed8dc5c1d1a04f7c96e332a5bbb44bf087b66c8d1044114802dcc8e5d6a0f37d2
+  data.tar.gz: 139d995c55b5f2f8cfe3d8a3d40a5c97a5712ba2678bfef187370c14c4b5ad702f48df6b64c9fa454b2963d17ed7a0013463d6d7aeadb82ea2bcfeb0fb4c79ec

data/CHANGELOG.md

@@ -0,0 +1,102 @@
+## [Unreleased]
+
+## 0.10.0 - 2026-09-10
+
+### Added
+
+- Add `enum_select` Rails helpers — a plain ActionView helper and a `FormBuilder` mixin — for rendering `<select>` inputs from an enum class [17](https://gitlab.com/BevanHolborn/enumy/-/issues/17)
+
+### Changed
+
+- **BREAKING CHANGE**: `Enumy::Model#has_enum` now accepts `class_name:` instead of `enum_class:`, accepting a Class/Module directly or a String/Symbol resolved to a constant, and defaulting to the attribute name when omitted [15](https://gitlab.com/BevanHolborn/enumy/-/issues/15)
+
+### Fixed
+
+- `Enumy::Enum.define` no longer raises `DuplicateEnumInstanceError` when the same source location redefines a key [16](https://gitlab.com/BevanHolborn/enumy/-/issues/16)
+- `Enumy::Rails::Model#has_enum` no longer relies on `classify`/`safe_constantize` round-tripping when a Class is passed directly as `class_name:` [15](https://gitlab.com/BevanHolborn/enumy/-/issues/15)
+- The packaged gem now ships `README.md`, `LICENSE.txt`, `CHANGELOG.md`, and every file under `lib/` (not just `.rb` files), instead of only `.rb` files under `lib/` [14](https://gitlab.com/BevanHolborn/enumy/-/issues/14)
+
+## 0.9.0 - 2026-09-08
+
+### Fixed
+
+- Make `EnumSerializer#klass` public to avoid a Rails 8.2 deprecation warning [18](https://gitlab.com/BevanHolborn/enumy/-/issues/18)
+
+## 0.8.0 - 2025-11-29
+
+### Added
+
+- Added support for using Ruby only enums as an attribute on objects [13](https://gitlab.com/BevanHolborn/enumy/-/issues/13)
+
+### Changed
+
+- **BREAKING CHANGE**: Rename `Enumy::RailsEnum` to `Enumy::Rails::Enum` [13](https://gitlab.com/BevanHolborn/enumy/-/issues/13)
+- Updated rake test script to properly set up the dummy Rails app [13](https://gitlab.com/BevanHolborn/enumy/-/issues/13)
+
+### Fixed
+
+- Fix `Enumy::Enum` referencing the `ActiveModel` `attributes` method in `inspect` [13](https://gitlab.com/BevanHolborn/enumy/-/issues/13)
+- Fix `Enumy::Rails::Model` referencing the removed `Enumy::Base` instead of `Enumy::Enum` [13](https://gitlab.com/BevanHolborn/enumy/-/issues/13)
+
+## 0.7.0 - 2025-11-25
+
+### Added
+
+- Add support for Enums in non-Rails Ruby applications [6](https://gitlab.com/BevanHolborn/enumy/-/issues/6)
+
+### Changed
+
+- **BREAKING CHANGE**: Rename `Enumy::Base` to `Enumy::RailsEnum` [6](https://gitlab.com/BevanHolborn/enumy/-/issues/6)
+
+## 0.6.0 - 2025-06-24
+
+### Changed
+
+- Only require files for Rails initializers if they are supported [10](https://gitlab.com/BevanHolborn/enumy/-/issues/10)
+- For Enumy::Base methods that wrap String methods for the `key`, follow the same name as the String method [9](https://gitlab.com/BevanHolborn/enumy/-/issues/9)
+- Add CI/CD stage for Rspec tests [12](https://gitlab.com/BevanHolborn/enumy/-/issues/12)
+
+## 0.5.1 - 2025-06-23
+
+### Changed
+
+- Change the minimum Ruby version to 2.7.0 [8](https://gitlab.com/BevanHolborn/enumy/-/issues/8)
+
+## 0.5.0 - 2025-06-23
+
+### Changed
+
+- `Enumy::Base#name` now returns the I18n translation for the `key` attributes [7](https://gitlab.com/BevanHolborn/enumy/-/issues/7)
+
+### Added
+
+- `Enumy::Base#title`: Return the titleized `key` attribute [7](https://gitlab.com/BevanHolborn/enumy/-/issues/7)
+
+## 0.4.0 - 2025-04-17
+
+### Changed
+
+- Downgrade Dockerfile ruby version to 3.1 [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Explicitly cast key to string in the ActiveJob serializer [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Explicitly define the serialize? method in the ActiveJob serializer [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Serialize invalid Enum keys to nil [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Only register the ActiveJob serializer if the Rails version supports it [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Applied proper module scoping across the project [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Moved the Dummy app to /spec. It is now regenerated with each test run. [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Gemspec dependencies [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+
+### Added
+
+- Rake [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Rspec Tests [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- DuplicateEnumInstanceError for clearer errors [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Additional safety checks in Enumy::Base#find_by [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+- Changelog [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+
+### Removed
+
+- Various unused Dockerfile dependencies [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)
+
+### Fixed
+
+- Enumy::Model#assert_valid_enum_type! referencing a value on a nil object [5](https://gitlab.com/BevanHolborn/enumy/-/issues/5)

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Bevan Holborn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,286 @@
+# Enumy
+
+Rich Enumeration objects in Ruby and Rails.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+    - [Enums](#enums)
+    - [Attributes](#attributes)
+    - [Customization](#customization)
+- [Rails Integration](#rails-integration)
+    - [Enums](#enums-1)
+    - [Attributes](#attributes-1)
+    - [Associating Enums with Models](#associating-enums-with-models)
+        - [Migrations](#migrations)
+        - [Usage](#usage-1)
+        - [Additional Methods](#additional-methods)
+    - [Form Helpers](#form-helpers)
+- [License](#license)
+- [Contributing](#contributing)
+
+
+## Installation
+
+```ruby
+bundle add enumy
+```
+
+## Enums
+
+Create a class that inherits from `Enumy::Enum` and define your enums as follows:
+
+```ruby
+class RoleType < Enumy::Enum
+  define FREE = self.new(:free)
+  define PAID = self.new(:paid)
+  define ADMIN = self.new(:admin)
+end
+```
+
+```ruby
+RoleType.all # => [RoleType::FREE, RoleType::PAID, RoleType::ADMIN]
+
+RoleType.find(:free) #=> RoleType::FREE
+RoleType.find(:invalid) #=> raises EnumNotFoundError
+
+RoleType.find_by(key: :paid) # => RoleType::PAID
+RoleType.find_by(key: :invalid) # => nil
+```
+
+### Attributes
+
+All enums have a required, unique `key` attribute by default.
+You can add additional attributes as needed the same way you would with a regular PORO
+
+```ruby
+class RoleType < Enumy::Enum
+  
+  attr_reader :color
+
+  def initialize(key, color:)
+    super(key)
+    @color  = color 
+  end
+  
+  define FREE = self.new(:free, color: :blue)
+  define PAID = self.new(:paid, color: :purple)
+  define ADMIN = self.new(:admin, color: :red)
+end
+```
+
+```ruby
+RoleType::FREE.key #=> :free
+RoleType::FREE.color #=> :blue
+
+RoleType.find_by(color: :purple) # => RoleType::PAID
+RoleType.find_by(key: :admin, color: :gray) # => nil
+```
+
+### Customization
+
+Because Enums are POROs, you can add methods to them as needed:
+
+```ruby
+class RoleType < Enumy::Enum
+  
+  attr_reader :color
+
+  def initialize(key, color:)
+    super(key)
+    @color  = color 
+  end
+  
+  define FREE = self.new(:free, color: :blue)
+  define PAID = self.new(:paid, color: :purple)
+  define ADMIN = self.new(:admin, color: :red)
+  
+  def admin?
+    self == ADMIN
+  end
+  
+  class << self
+    
+    def customer
+      [FREE, PAID]
+    end
+    
+  end
+end
+```
+
+```ruby
+RoleType::ADMIN.admin? # => true
+RoleType::FREE.admin?  # => false
+RoleType.customer # => [RoleType::FREE, RoleType::PAID]
+```
+
+## Rails integration
+
+Enumy integrates with Rails applications to leverage ActiveModel as well as provide a way to associate enums with models.
+
+Run the generator, which will set up an application enum and add the required concern to ApplicationRecord.
+```ruby
+rails generate enumy:install
+```
+
+Rails enums usually live in `app/enums`. Create a class that inherits from `ApplicationEnum` and define your enum as follows:
+
+```ruby
+class RoleType < ApplicationEnum
+  define FREE = self.new(:free)
+  define PAID = self.new(:paid)
+  define ADMIN = self.new(:admin)
+end
+```
+
+```ruby
+RoleType.all # => [RoleType::FREE, RoleType::PAID, RoleType::ADMIN]
+
+RoleType.find(:free) #=> RoleType::FREE
+RoleType.find(:invalid) #=> raises EnumNotFoundError
+
+RoleType.find_by(key: :paid) # => RoleType::PAID
+RoleType.find_by(key: :invalid) # => nil
+```
+
+So far it's exactly the same as a regular enum.
+
+### Attributes
+
+All enums have a required, unique `key` attribute by default.
+Because this is a ActiveModel backed PORO, you can add additional attributes simply as follows:
+
+```ruby
+class RoleType < ApplicationEnum
+  
+  attribute :color
+  
+  define FREE = self.new(:free, color: :blue)
+  define PAID = self.new(:paid, color: :purple)
+  define ADMIN = self.new(:admin, color: :red)
+end
+```
+
+```ruby
+RoleType::FREE.key #=> :free
+RoleType::FREE.color #=> :blue
+
+RoleType.find_by(color: :purple) # => RoleType::PAID
+RoleType.find_by(key: :admin, color: :gray) # => nil
+```
+
+### Additional methods
+
+In addition to the standard Enumy methods, the Rails implementation supports the following Rails-specific methods:
+
+**titleize**  
+Returns the titleized version of the enum's key.
+
+**human_attribute_name**  
+Looks up human-readable attribute names for the enum using I18n translations.
+The lookup path is `enum.attributes.models.{enum_class_name}.{enum_key}.{attribute_name}`.
+
+**name**  
+An alias for human_attribute_name(:key)
+
+**model_name**  
+Returns an ActiveModel::Name instance for the enum class
+
+### Associating enums with models
+
+Enums can be associated with ActiveRecord models using the `has_enum` method provided by Enumy.
+
+Enable this by including the `Enumy::Model` concern in your `ApplicationRecord`:
+
+```ruby
+class ApplicationRecord
+  include Enumy::Rails::Model
+end
+```
+
+Then in any model, you can define an enum association as follows:
+
+```ruby
+class User < ApplicationRecord  
+  has_enum :role_type
+end
+```
+
+`has_enum` requires a name (e.g. `has_enum :role_type`)  
+You can also the following kwargs:
+ - `class_name`: The enum class to use (e.g. class_name: "RoleType"). If not set, it is derived from the name
+ - `optional`: If true, the enum can be `nil`. If false, validations are added - `validates :role_type, presence: true, inclusion: { in: RoleType.all }`
+ - `default`: Sets a default enum value (e.g. default: RoleType::FREE).
+
+
+#### Migrations
+
+Enumy stores the key of the enum in the model's table, and then attaches the enum to the model when it is loaded into memory.
+This means that a table column is required when adding an enum to a model:
+
+```ruby
+class AddRoleTypeToUsers < ActiveRecord::Migration
+  def change
+    add_column :users, :role_type, :string
+  end
+end
+```
+
+#### Usage
+
+With the enum set up on your model you can use it as follows:
+
+```ruby
+user = User.new(role_type: RoleType::FREE)
+user.role_type # => RoleType::FREE
+
+user.role_type = RoleType::PAID
+user.role_type # => RoleType::PAID
+
+User.where(role_type: RoleType::ADMIN) # SELECT * FROM users WHERE role_type = 'admin' 
+```
+
+### Form helpers
+
+Enumy provides two helpers for rendering `<select>` inputs from an enum class. Neither is auto-registered, so include them where you need them:
+
+```ruby
+module ApplicationHelper
+  include Enumy::Rails::Helpers::FormHelper
+end
+```
+
+```ruby
+class ApplicationFormBuilder < ActionView::Helpers::FormBuilder
+  include Enumy::Rails::Helpers::FormBuilder
+end
+```
+
+**`enum_select`** is a plain ActionView helper, following the same `object`/`method`/`collection` convention as Rails' own `select`/`collection_select`:
+
+```ruby
+enum_select(:user, :role_type, RoleType.all)
+```
+
+`collection` is required — the plain helper has no model context to derive one from. It also accepts the following kwargs:
+ - `value_method`: The method (or callable) used to compute each option's value. Defaults to `:key`
+ - `text_method`: The method (or callable) used to compute each option's text. Defaults to `:name`
+ - `options`: Passed through to the underlying `select` tag
+ - `html_options`: Passed through to the underlying `select` tag
+
+**`f.enum_select`** is a FormBuilder method that delegates to the plain helper above:
+
+```ruby
+f.enum_select(:role_type)
+f.enum_select(:role_type, RoleType.customer)
+```
+
+`collection` is an optional second positional argument. When omitted, it's derived from the field's declared `has_enum` class (`RoleType.all`) — this requires `:role_type` to have been set up with `has_enum` on the model. It also accepts `options` and `html_options`, both passed through unchanged.
+
+## License
+This project is licensed under the MIT License. See the LICENSE file for details.
+
+## Contributing
+Contributions are welcome! Please open issues or submit merge requests via GitLab.

data/lib/enumy/enum.rb

@@ -28,10 +28,14 @@ module Enumy
       def define(enum)
         raise ArgumentError, "Expected an object of type `Enumy::Enum`, got #{enum.class.name}" unless enum.is_a?(Enumy::Enum)
 
-        if instances[enum.key]
-          raise Errors::DuplicateEnumInstanceError, "Enum `#{enum.key.to_s.upcase}` is using a duplicate key `#{enum.key}` for Enum '#{enum.class.name}'."
+        call_site = caller_locations(1..1).first
+        existing_location = definition_locations[enum.key]
+
+        if instances[enum.key] && !locations_match?(existing_location, call_site)
+          raise Errors::DuplicateEnumInstanceError.new(enum, existing_location, call_site)
         else
           instances[enum.key] = enum
+          definition_locations[enum.key] = call_site
         end
       end
 
@@ -59,6 +63,14 @@ module Enumy
         @instances ||= {}
       end
 
+      def definition_locations
+        @definition_locations ||= {}
+      end
+
+      def locations_match?(location_a, location_b)
+        !location_a.nil? && location_a.path == location_b.path && location_a.lineno == location_b.lineno
+      end
+
     end
 
   end

data/lib/enumy/errors.rb

@@ -3,7 +3,16 @@ module Enumy
 
     class EnumNotFoundError < StandardError; end
     class InvalidEnumClassError < NameError; end
-    class DuplicateEnumInstanceError < ArgumentError; end
+    class DuplicateEnumInstanceError < ArgumentError
+      def initialize(enum, existing_location, conflicting_location)
+        message = <<~MESSAGE.chomp
+          Enum `#{enum.key.to_s.upcase}` is using a duplicate key `#{enum.key}` for Enum '#{enum.class.name}'.
+          First defined at #{existing_location.path}:#{existing_location.lineno}, redefined at #{conflicting_location.path}:#{conflicting_location.lineno}.
+        MESSAGE
+
+        super(message)
+      end
+    end
 
     class KeyMissingError < ArgumentError
       def initialize(enum)

data/lib/enumy/model.rb

@@ -4,8 +4,9 @@ require 'enumy/errors'
 module Enumy
   module Model
 
-    def has_enum(name, enum_class:, **options)
-      assert_valid_enum_type!(enum_class)
+    def has_enum(name, class_name: name, **options)
+      enum_class = resolve_enum_class(class_name)
+      assert_valid_enum_type!(enum_class, class_name)
       define_enum_methods(name, enum_class, default: options[:default])
     end
 
@@ -38,9 +39,37 @@ module Enumy
       end
     end
 
-    def assert_valid_enum_type!(enum_class)
-      raise Errors::InvalidEnumClassError, "`#{enum_class}` is not a constant" unless enum_class.is_a?(Module)
-      raise Errors::InvalidEnumClassError, "`#{enum_class.name}` does not inherit from `#{Enumy::Enum.name}`" unless enum_class.ancestors.include?(Enumy::Enum)
+    def resolve_enum_class(class_name)
+      if class_name.is_a?(Module)
+        class_name
+      else
+        resolve_constant(class_name)
+      end
+    end
+
+    def resolve_constant(class_name)
+      constant_name = class_name.to_s.split('::').map do |namespace_segment|
+        namespace_segment.split('_').map { |word| word[0].upcase + word[1..] }.join
+      end.join('::')
+
+      constant = Object.const_get(constant_name)
+
+      if constant.is_a?(Module)
+        constant
+      else
+        nil
+      end
+
+    rescue NameError
+      nil
+    end
+
+    def assert_valid_enum_type!(enum_class, class_name)
+      if enum_class.nil?
+        raise Errors::InvalidEnumClassError, "Could not resolve class `#{class_name}`"
+      elsif !enum_class.ancestors.include?(Enumy::Enum)
+        raise Errors::InvalidEnumClassError, "`#{class_name}` does not inherit from `#{Enumy::Enum.name}`"
+      end
     end
 
   end

data/lib/enumy/rails/generators/enumy/install/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Generates an ApplicationEnum class and extends ApplicationRecord as a starting point for your application.
+
+Example:
+  bin/rails generate enumy:install
+
+  This will create:
+    app/enums/application_enum.rb
+
+  This will modify:
+      app/models/application_record.rb

data/lib/enumy/rails/helpers/form_builder.rb

@@ -0,0 +1,12 @@
+module Enumy
+  module Rails
+    module Helpers
+      module FormBuilder
+        def enum_select(method, collection = nil, options: {}, html_options: {})
+          collection ||= @object.class.public_send("#{method}_class").all
+          @template.enum_select(@object_name, method, collection, options: options, html_options: html_options)
+        end
+      end
+    end
+  end
+end

data/lib/enumy/rails/helpers/form_helper.rb

@@ -0,0 +1,11 @@
+module Enumy
+  module Rails
+    module Helpers
+      module FormHelper
+        def enum_select(object, method, collection, value_method: :key, text_method: :name, options: {}, html_options: {})
+          collection_select(object, method, collection, value_method, text_method, options, html_options)
+        end
+      end
+    end
+  end
+end

data/lib/enumy/rails/model.rb

@@ -5,15 +5,34 @@ module Enumy
   module Rails
     module Model
       def has_enum(name, class_name: name, **options)
-        enum_class = class_name.to_s.classify.safe_constantize
+        enum_class = resolve_enum_class(class_name)
 
         assert_valid_enum_type!(enum_class, class_name)
         define_enum_attributes(name, enum_class, default: options[:default])
         define_enum_validations(name, enum_class) unless options[:optional]
+        define_enum_class_reader(name, enum_class)
       end
 
       private
 
+      def define_enum_class_reader(name, enum_class)
+        define_singleton_method("#{name}_class") { enum_class }
+      end
+
+      def resolve_enum_class(class_name)
+        if class_name.is_a?(Module)
+          class_name
+        else
+          constant = class_name.to_s.classify.safe_constantize
+
+          if constant.is_a?(Module)
+            constant
+          else
+            nil
+          end
+        end
+      end
+
       def define_enum_attributes(name, enum_class, **options)
         attribute name, ActiveModel::Type::Enum.new(enum_class), default: -> { options[:default] }
       end
@@ -24,9 +43,9 @@ module Enumy
 
       def assert_valid_enum_type!(enum_class, class_name)
         if enum_class.nil?
-          raise Errors::InvalidEnumClassError, "Could not resolve class `#{class_name.to_s.classify}`"
+          raise Errors::InvalidEnumClassError, "Could not resolve class `#{class_name}`"
         elsif !enum_class.ancestors.include?(Enumy::Enum)
-          raise Errors::InvalidEnumClassError, "`#{enum_class.name}` does not inherit from `#{Enumy::Enum.name}`"
+          raise Errors::InvalidEnumClassError, "`#{class_name}` does not inherit from `#{Enumy::Enum.name}`"
         end
       end
     end

data/lib/enumy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Enumy
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/lib/enumy.rb

@@ -7,5 +7,7 @@ if defined?(Rails)
   require 'enumy/rails/model'
   require 'enumy/rails/generators/enumy/install/install_generator'
   require 'enumy/rails/active_model/type/enum'
+  require 'enumy/rails/helpers/form_helper'
+  require 'enumy/rails/helpers/form_builder'
   require 'enumy/rails/railtie'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enumy
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Bevan Holborn
@@ -56,6 +56,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
 - lib/enumy.rb
 - lib/enumy/enum.rb
 - lib/enumy/errors.rb
@@ -63,8 +66,11 @@ files:
 - lib/enumy/rails/active_job/serializers/enum_serializer.rb
 - lib/enumy/rails/active_model/type/enum.rb
 - lib/enumy/rails/enum.rb
+- lib/enumy/rails/generators/enumy/install/USAGE
 - lib/enumy/rails/generators/enumy/install/install_generator.rb
 - lib/enumy/rails/generators/enumy/install/templates/app/enums/application_enum.rb
+- lib/enumy/rails/helpers/form_builder.rb
+- lib/enumy/rails/helpers/form_helper.rb
 - lib/enumy/rails/initializer_interceptor.rb
 - lib/enumy/rails/model.rb
 - lib/enumy/rails/railtie.rb