nd-enum 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14980decd9ccdc766c2e27fc1c224a4dc94aee5bce41069fa574a58abe29f60f
-  data.tar.gz: 908d743ac4486cd835370ec06034661c15fc1b30dc4cf196cf02bdeb03f234ea
+  metadata.gz: 1319016da965b32314532d641038f67316c07087b03f8a0a195786d783307c08
+  data.tar.gz: e88397852614473313ba633c1d3029de0cad1466b9ddfa0787b54e5cc7133eb8
 SHA512:
-  metadata.gz: f02d420631940aec368decfa880ba8f956b7675a40d2ce9a5f7704b838c912f62056b271ad53afb9584c6e9539f17b89371b3992f785d123fc6c4d1f16261417
-  data.tar.gz: 6f194a9f4b8396a46b8198af254648d7bf50c5291245e42afbbfdd06729dc31d621b3b602015a1c338809fc539cc15b62b1ecdbae6466e50691b93b031c370f1
+  metadata.gz: 65596f68728490a34c575fac8191438d85b4490268a5938c725f5ed7c0fbe3e0616679b332971dd8991f0989c34bd41c51b89bdaf1153f822f6446a0714613fc
+  data.tar.gz: c583f3f1e8a655bcf9ba604ef3851cbb27dba1acc7743ea5c158a763c33792e3cd2dc826659b7e53c1ae3380ac045aef60e53e6fd1bff3b9d8e83b315bd37b5f

data/.rspec

@@ -0,0 +1,6 @@
+--format documentation
+--color
+--require spec_helper
+--require mocha
+--require active_record
+--require pry

data/CHANGELOG.md

@@ -0,0 +1,18 @@
+## [Unreleased]
+
+## [0.2.0] - 2022-08-10
+
+- Add initializer
+- Validate translations
+
+## [0.1.2] - 2022-08-08
+
+- Add specs
+
+## [0.1.1] - 2022-08-07
+
+- Fix bugs
+
+## [0.1.0] - 2022-08-07
+
+- Initial release

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nd-enum.gemspec
+gemspec
+
+gem 'rake',        '~> 13.0'
+gem 'rspec',       '~> 3.0'
+gem 'mocha',       '~> 1.13'
+gem 'pry',         '~> 0.13'
+gem 'guard',       '~> 2.18'
+gem 'guard-rspec', '~> 4.7', require: false

data/Gemfile.lock

@@ -0,0 +1,91 @@
+PATH
+  remote: .
+  specs:
+    nd-enum (0.2.0)
+      activerecord (>= 6.0.0)
+      activesupport (>= 6.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.3.1)
+      activesupport (= 7.0.3.1)
+    activerecord (7.0.3.1)
+      activemodel (= 7.0.3.1)
+      activesupport (= 7.0.3.1)
+    activesupport (7.0.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    diff-lcs (1.5.0)
+    ffi (1.15.5)
+    formatador (1.1.0)
+    guard (2.18.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.13.0)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (1.12.0)
+      concurrent-ruby (~> 1.0)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.8)
+    method_source (1.0.0)
+    minitest (5.16.2)
+    mocha (1.14.0)
+    nenv (0.3.0)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+    rb-fsevent (0.11.1)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    shellany (0.0.1)
+    thor (1.2.1)
+    tzinfo (2.0.5)
+      concurrent-ruby (~> 1.0)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  guard (~> 2.18)
+  guard-rspec (~> 4.7)
+  mocha (~> 1.13)
+  nd-enum!
+  pry (~> 0.13)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.3.12

data/Guardfile

@@ -0,0 +1,70 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Romain Clavel
+
+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,236 @@
+# ND::Enum
+
+This gem allows you to create and use enums easily and quickly in your Rails project.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add nd-enum
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install nd-enum
+
+## Usage
+
+- [Basic usage](#basic-usage)
+- [Configuration](#configuration)
+- [I18n](#i18n)
+  - [Validate translations presence](#validate-translations-presence)
+  - [Enforce translations presence](#enforce-translations-presence)
+- [ActiveRecord Enum](#activerecord-enum)
+
+### Basic usage
+
+Define your enum in an ActiveRecord model:
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin))
+end
+```
+
+It creates a module for your enum that contains one constant per enum value. Say goodbye to [magic strings](https://en.wikipedia.org/wiki/Magic_string)!
+
+In our example, the module is `User::Role`, and the constants are `User::Role::USER` and `User::Role::ADMIN`.
+
+```ruby
+irb(main)> User::Role::USER
+=> "user"
+
+irb(main)> User::Role::ADMIN
+=> "admin"
+
+irb(main)> User::Role.all
+=> ["user", "admin"]
+
+irb(main)> User::Role.length
+=> 2
+
+irb(main)> User::Role[1]
+=> "admin"
+
+irb(main)> User::Role[:user]
+=> "user"
+
+irb(main)> User::Role.include?('foobar')
+=> false
+
+irb(main)> User::Role.include?('user')
+=> true
+```
+
+ND::Enum inheritates from [`Enumerable`](https://ruby-doc.org/core-3.1.2/Enumerable.html), so it is possible to use all `Enumerable` methods on the enum module: `each`, `map`, `find`...
+
+### Configuration
+
+Fine-tune `ND::Enum` behaviour by creating an initializer (for example: `config/initializers/nd_enum.rb`).
+The values shown in the example below are the default values.
+
+```ruby
+ND::Enum.configure do |c|
+  c.default_i18n_scope = :base
+  c.default_i18n_validation_mode = :ignore # Allowed values: ignore, log, enforce
+end
+```
+
+### I18n
+
+Allows to translate your enum values.
+Add to your locale files:
+
+```yaml
+en:
+  users: # Model.table_name
+    role: # attribute
+      base: # default scope
+        user: User
+        admin: Admin
+      foobar: # custom scope
+        user: The user
+        admin: The admin
+```
+
+Then call `t` (or `translate`) method:
+
+```ruby
+irb(main)> User::Role.t(:user) # Or `translate` method (alias)
+=> "translation missing: en.users.role.base.user"
+```
+
+Use a different scope to have several translations for a single value, depending on context:
+
+```ruby
+irb(main)> User::Role.t(:user, :foobar)
+=> "translation missing: en.users.role.foobar.user"
+```
+
+Please note that the default scope (`base`) can be configured using the `default_i18n_scope` initializer option.
+
+#### Validate translations presence
+
+Validate that your enum are translated. By default, this feature is disabled.
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin), i18n: { mode: :log })
+end
+```
+
+It will log the missing translations for each scope & locale. For example:
+
+```
+I, [2022-08-10T21:17:53.931669 #67401]  INFO -- : ND::Enum: User#role scopes=[:base, :short]
+I, [2022-08-10T21:17:53.931669 #67401]  INFO -- : ND::Enum: User#role locale=en missing_keys=[]
+I, [2022-08-10T21:17:53.931669 #67401]  INFO -- : ND::Enum: User#role locale=nl missing_keys=["users.role.base.user", "users.role.short.user"]
+```
+
+This mode can be used as default with the `c.default_i18n_validation_mode = :log` initializer option.
+
+#### Enforce translations presence
+
+Raise an exception when some translations are missing.
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin), i18n: { mode: :enforce })
+end
+```
+
+```
+(irb):1:in `<main>': One or several translations are missing (ND::Enum::MissingTranslationError)
+        from bin/console:15:in `<main>'
+```
+
+This mode can be used as default with the `c.default_i18n_validation_mode = :enforce` initializer option.
+
+### `ActiveRecord` Enum
+
+Add a wrapper to [`ActiveRecord` Enum](https://api.rubyonrails.org/classes/ActiveRecord/Enum.html) by specifying the `db: true` option.
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin), db: true)
+end
+
+# It does exactly the same thing than below, but shorter:
+
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin))
+  enum(role: User::Role.to_h) # Or `enum(role: { user: 'user', admin: 'admin '})`
+end
+```
+
+It allows to use these methods:
+
+```ruby
+user.admin!
+user.admin? # => true
+user.role # => "admin"
+```
+
+And these scopes:
+
+```ruby
+User.admin
+User.not_admin
+
+User.user
+User.not_user
+
+# ...
+```
+
+Disable scope definition by setting `scopes: false` to your enum:
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin), db: { scopes: false })
+end
+```
+
+Set the default enum:
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin), db: { default: :admin })
+end
+```
+
+Add a `prefix` or `suffix` option when you need to define multiple enums with same values. If the passed value is true, the methods are prefixed/suffixed with the name of the enum. It is also possible to supply a custom value:
+
+```ruby
+class User < ApplicationRecord
+  nd_enum(role: %i(user admin), db: { prefix: true })
+
+  # Scopes: `User.role_admin`, `User.role_user` ...
+  # Methods: `User.role_admin!`, `User.role_user!` ...
+
+  nd_enum(role: %i(user admin), db: { suffix: true })
+
+  # Scopes: `User.admin_role`, `User.user_role` ...
+  # Methods: `User.admin_role!`, `User.user_role!` ...
+
+  nd_enum(role: %i(user admin), db: { prefix: 'foobar' })
+
+  # Scopes: `User.foobar_admin`, `User.foobar_user` ...
+  # Methods: `User.foobar_admin!`, `User.foobar_user!` ...
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+Guard is also installed: `bundle exec guard`.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, run `gem bump` (or manually update the version number in `version.rb`), and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rclavel/nd-enum.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/nd/enum/base.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'active_support'
+
+module ND::Enum::Base
+  extend ActiveSupport::Concern
+
+  included do
+    class << self
+      include Enumerable
+      extend Forwardable
+
+      def_delegators :all, :size, :length, :[], :empty?, :last, :index
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def to_h
+        all.map { |value| [value.to_sym, value] }.to_h
+      end
+
+      def [](value)
+        value.is_a?(Integer) ? all[value] : to_h[value.to_sym]
+      end
+
+      def t(value, scope = nil)
+        scope ||= configuration.default_i18n_scope
+        ::I18n.t(value, scope: "#{model.table_name}.#{attribute}.#{scope}")
+      end
+      alias_method :translate, :t
+
+      private
+
+      def configuration
+        ND::Enum.configuration
+      end
+    end
+  end
+end

data/lib/nd/enum/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ND::Enum::Configuration
+  Configuration = Struct.new(:default_i18n_validation_mode, :default_i18n_scope)
+  DEFAULT_CONFIGURATION = {
+    default_i18n_validation_mode: :ignore,
+    default_i18n_scope: :base,
+  }
+
+  def configuration
+    @_configuration ||= Configuration.new(*DEFAULT_CONFIGURATION.values_at(*Configuration.members))
+  end
+
+  def configure
+    yield(configuration)
+  end
+end

data/lib/nd/enum/i18n.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ND::Enum::I18n
+  class << self
+    # TODO: Transform into a nd_enum
+    module Mode
+      LOG = 'log'
+      ENFORCE = 'enforce'
+      IGNORE = 'ignore'
+
+      def self.all
+        [LOG, ENFORCE, IGNORE]
+      end
+    end
+
+    def validate!(options)
+      mode = get_mode_from_options(options)
+      return if mode == Mode::IGNORE
+
+      i18n_scope = build_i18n_scope(options)
+      scopes = get_scopes_from_translations(i18n_scope)
+      missing_keys_by_locale = get_missing_keys_by_locale(options, i18n_scope, scopes)
+
+      log_missing_keys(options, scopes, missing_keys_by_locale)
+
+      if mode == Mode::ENFORCE && missing_keys_by_locale.values.any?(&:present?)
+        raise ND::Enum::MissingTranslationError
+      end
+    end
+
+    private
+
+    def get_mode_from_options(options)
+      case options.dig(:i18n, :validate)
+      when 'log', :log then Mode::LOG
+      when 'enforce', :enforce then Mode::ENFORCE
+      else
+        default_mode = configuration.default_i18n_validation_mode&.to_s
+        Mode.all.include?(default_mode) ? default_mode : Mode::IGNORE
+      end
+    end
+
+    def build_i18n_scope(options)
+      "#{options[:model].table_name}.#{options[:attribute]}"
+    end
+
+    def get_scopes_from_translations(i18n_scope)
+      scopes = %i(base)
+
+      I18n.available_locales.each do |locale|
+        configuration = I18n.t(i18n_scope, locale: locale, default: {})
+        configuration.each_key do |scope|
+          scopes << scope.to_sym unless scopes.include?(scope.to_sym)
+        end
+      end
+
+      scopes
+    end
+
+    def get_missing_keys_by_locale(options, i18n_scope, scopes)
+      I18n.available_locales.each_with_object({}) do |locale, missing_keys_by_locale|
+        missing_keys = []
+
+        scopes.each do |scope|
+          options[:values].each do |value|
+            value_i18n_scope = "#{i18n_scope}.#{scope}.#{value}"
+            next if I18n.exists?(value_i18n_scope, locale: locale)
+
+            missing_keys << value_i18n_scope
+          end
+        end
+
+        missing_keys_by_locale[locale] = missing_keys
+      end
+    end
+
+    def log_missing_keys(options, scopes, missing_keys_by_locale)
+      prefix = "ND::Enum: #{options[:model_name]}##{options[:attribute]}"
+      logger.info("#{prefix} scopes=#{scopes}")
+
+      missing_keys_by_locale.each do |locale, missing_keys|
+        logger.info("#{prefix} locale=#{locale} missing_keys=#{missing_keys}")
+      end
+    end
+
+    def logger
+      @_logger ||= Logger.new(STDOUT)
+    end
+
+    def configuration
+      ND::Enum.configuration
+    end
+  end
+end

data/lib/nd/enum/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ND
+  module Enum
+    VERSION = '0.2.0'
+  end
+end

data/lib/nd/enum.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_record/enum.rb'
+
+require 'active_support'
+require 'active_support/core_ext/string/inflections.rb'
+
+require_relative 'enum/version'
+require_relative 'enum/base'
+require_relative 'enum/configuration'
+require_relative 'enum/i18n'
+
+module ND::Enum
+  extend ActiveSupport::Concern
+
+  included do
+    def self.nd_enum(db: false, i18n: {}, model: self, model_name: nil, **configuration)
+      options = ND::Enum.set_options(binding, model, model_name)
+      enum_module = ND::Enum.define_module(options)
+
+      ND::Enum.define_db_enum(options, enum_module) if options[:db]
+      ND::Enum::I18n.validate!(options)
+
+      const_set(options[:attribute].to_s.camelize, enum_module)
+    end
+  end
+
+  class Error < StandardError; end
+  class MissingTranslationError < Error
+    def message
+      'One or several translations are missing'
+    end
+  end
+
+  class << self
+    include ND::Enum::Configuration
+
+    def set_options(caller_binding, caller_class, caller_class_name)
+      options = caller_class.method(:nd_enum).parameters.each_with_object({}) do |(_, name), options|
+        options[name.to_sym] = caller_binding.local_variable_get(name)
+      end
+      options[:attribute], options[:values] = options.delete(:configuration).to_a.first
+      options[:model] = caller_class
+      options[:model_name] = caller_class_name
+
+      options
+    end
+
+    def define_module(options)
+      Module.new do
+        include ND::Enum::Base
+
+        # Public methods
+
+        define_singleton_method(:all) { options[:values] }
+
+        # Private methods
+
+        define_singleton_method(:options) { options }
+        options.each_key do |name|
+          define_singleton_method(name) { options[name] }
+        end
+
+        [:options, *options.keys].each do |method_name|
+          singleton_class.class_eval { private method_name.to_sym }
+        end
+
+        # Constants
+
+        options[:values].map do |value|
+          const_set(value.to_s.upcase, value.to_s)
+        end
+      end
+    end
+
+    def define_db_enum(options, enum_module)
+      enum_options = options[:db].is_a?(Hash) ? options[:db] : {}
+
+      enum_options[:_prefix] = enum_options.delete(:prefix) if enum_options.key?(:prefix)
+      enum_options[:_suffix] = enum_options.delete(:suffix) if enum_options.key?(:suffix)
+
+      options[:model].enum(options[:attribute] => enum_module.to_h, **enum_options)
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include ND::Enum
+end

data/nd-enum.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'lib/nd/enum/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'nd-enum'
+  spec.version = ND::Enum::VERSION
+  spec.authors = ['Romain Clavel']
+  spec.email = ['romain@clavel.io']
+
+  spec.summary = 'Powerful enum for Rails models.'
+  spec.homepage = 'https://github.com/rclavel/nd-enum'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/rclavel/nd-enum'
+  spec.metadata['changelog_uri'] = 'https://github.com/rclavel/nd-enum/blob/master/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'activesupport', '>= 6.0.0'
+  spec.add_dependency 'activerecord',  '>= 6.0.0'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/nd/enum.rbs

@@ -0,0 +1,6 @@
+module ND
+  module Enum
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -1,22 +1,65 @@
 --- !ruby/object:Gem::Specification
 name: nd-enum
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Romain Clavel
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-08 00:00:00.000000000 Z
-dependencies: []
+date: 2022-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 description:
 email:
 - romain@clavel.io
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nd/enum.rb
+- lib/nd/enum/base.rb
+- lib/nd/enum/configuration.rb
+- lib/nd/enum/i18n.rb
+- lib/nd/enum/version.rb
+- nd-enum.gemspec
+- sig/nd/enum.rbs
 homepage: https://github.com/rclavel/nd-enum
 licenses:
 - MIT