taylors_enum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 22eddc0a8e5096da1be305ffcaf244c99e9cd53f502acf7d5d3827d64ceb5781
+  data.tar.gz: 9dcbda215ceb54dc6aef75950ad45dfa8da07e20c88ac456f1aac22804f0c5e6
+SHA512:
+  metadata.gz: 7c8cd3171a1e074a18550b8055ba93cb008f636ac9d350dddbe7387a9e4d5848fc00565aeff7fb6a9382fffa3afa555e7f1e27033de0ebc53cbb525677390a7f
+  data.tar.gz: d672df8ce78450646179c625f27e596a74e9118f64140db5addf70b6c1d933049a3d368a143742222c9f5b15e8b7a5d076582b09a8c64de286e06de35701f4c5

data/.rubocop.yml

@@ -0,0 +1,58 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: true
+  EnforcedStyle: comma
+
+Style/TrailingCommaInArguments:
+  Enabled: true
+  EnforcedStyleForMultiline: comma
+
+Style/StderrPuts:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+  EnforcedStyle: indented
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-06-03
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in taylors_enum.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+
+gem 'minitest', '~> 5.0'
+
+gem 'rubocop', '~> 1.21'

data/Gemfile.lock

@@ -0,0 +1,72 @@
+PATH
+  remote: .
+  specs:
+    taylors_enum (0.1.0)
+      activesupport (>= 4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.3)
+      activesupport (= 7.0.3)
+    activerecord (7.0.3)
+      activemodel (= 7.0.3)
+      activesupport (= 7.0.3)
+    activesupport (7.0.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    pg (1.2.3)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.5.0)
+    rexml (3.2.5)
+    rubocop (1.30.0)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.18.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.18.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  activerecord (>= 4.2)
+  minitest (~> 5.0)
+  pg (~> 1.2.0)
+  pry
+  pry-byebug (~> 3.9.0)
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+  taylors_enum!
+
+BUNDLED WITH
+   2.3.11

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 PJ
+
+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,176 @@
+# TaylorsEnum
+
+TaylorsEnum is a gem that builds on top of ActiveRecord's built in [enums](https://api.rubyonrails.org/v5.2.4.4/classes/ActiveRecord/Enum.html#method-i-enum). Specifically, it will:
+
+###### - Define additional methods to make it clearer which values exist in Rails-land, and which in the database
+In Rails:
+```
+class Album < ActiveRecord::Base
+  self.table_name = 'albums'
+  enum name: %w[debut fearless speak_now red nineteen_eighty_nine reputation lover folklore evermore]
+end
+
+[1] pry(#<TestDefault>)> Album.names
+=> {"debut"=>0, "fearless"=>1, "speak_now"=>2, "red"=>3, "nineteen_eighty_nine"=>4, "reputation"=>5, "lover"=>6, "folklore"=>7, "evermore"=>8}
+```
+
+With TaylorsEnum:
+```
+class AlbumBase < Album
+  taylors_enum name: %w[debut fearless speak_now red nineteen_eighty_nine reputation lover folklore evermore]
+end
+
+[2] pry(#<TestDefault>)> AlbumBase.name_rails_values
+=> ["debut", "fearless", "speak_now", "red", "nineteen_eighty_nine", "reputation", "lover", "folklore", "evermore"]
+[3] pry(#<TestDefault>)> AlbumBase.name_database_values
+=> ["debut", "fearless", "speak_now", "red", "nineteen_eighty_nine", "reputation", "lover", "folklore", "evermore"]
+
+```
+
+
+###### - Define constants for each value provided
+```
+class AlbumBase < Album
+  taylors_enum name: %w[debut fearless speak_now red nineteen_eighty_nine reputation lover folklore evermore]
+end
+
+[5] pry(#<TestDefault>)> AlbumBase::FOLKLORE
+=> "folklore"
+[6] pry(#<TestDefault>)> AlbumBase::EVERMORE
+=> "evermore"
+# etc.
+
+```
+
+###### - Enables support for all the enum goodness when enumerating classes for Single Table Inheritance
+```
+module SingleTableInheritanceAlbums
+  class SingleTableInheritanceAlbum < ActiveRecord::Base
+    self.table_name = 'single_table_inheritance_albums'
+
+    taylors_enum type: %w[
+      SingleTableInheritanceAlbums::Debut
+      SingleTableInheritanceAlbums::Fearless
+      SingleTableInheritanceAlbums::SpeakNow
+      SingleTableInheritanceAlbums::Red
+      SingleTableInheritanceAlbums::NineteenEightyNine
+      SingleTableInheritanceAlbums::Reputation
+      SingleTableInheritanceAlbums::Lover
+      SingleTableInheritanceAlbums::Folklore
+      SingleTableInheritanceAlbums::Evermore
+    ], single_table_inheritance: true
+  end
+
+  class Debut < SingleTableInheritanceAlbum; end
+  class Fearless < SingleTableInheritanceAlbum; end
+  class SpeakNow < SingleTableInheritanceAlbum; end
+  class Red < SingleTableInheritanceAlbum; end
+  class NineteenEightyNine < SingleTableInheritanceAlbum; end
+  class Reputation < SingleTableInheritanceAlbum; end
+  class Lover < SingleTableInheritanceAlbum; end
+  class Folklore < SingleTableInheritanceAlbum; end
+  class Evermore < SingleTableInheritanceAlbum; end
+end
+
+[5] pry(#<TestSingleTableInheritance>)> album = ::SingleTableInheritanceAlbums::Debut.create
+=> #<SingleTableInheritanceAlbums::Debut:0x000000010581a708 id: 2, type: "SingleTableInheritanceAlbums::Debut", created_at: 2022-06-04 14:34:24.951932 UTC, updated_at: 2022-06-04 14:34:24.951932 UTC>
+[6] pry(#<TestSingleTableInheritance>)> album.type
+=> "SingleTableInheritanceAlbums::Debut"
+[7] pry(#<TestSingleTableInheritance>)> album.debut?
+=> true
+[8] pry(#<TestSingleTableInheritance>)> album.fearless!
+=> true
+[9] pry(#<TestSingleTableInheritance>)> album.debut?
+=> false
+[10] pry(#<TestSingleTableInheritance>)> album.fearless?
+=> true
+[11] pry(#<TestSingleTableInheritance>)> album.type
+=> "SingleTableInheritanceAlbums::Fearless"
+[12] pry(#<TestSingleTableInheritance>)> ::SingleTableInheritanceAlbums::SingleTableInheritanceAlbum.fearless
+=> [#<SingleTableInheritanceAlbums::Fearless:0x00000001059821e0 id: 1, type: "SingleTableInheritanceAlbums::Fearless", created_at: 2022-06-04 14:33:55.178418 UTC, updated_at: 2022-06-04 14:33:55.178418 UTC>,
+ #<SingleTableInheritanceAlbums::Fearless:0x0000000105981a10 id: 2, type: "SingleTableInheritanceAlbums::Fearless", created_at: 2022-06-04 14:34:24.951932 UTC, updated_at: 2022-06-04 14:34:50.616316 UTC>]
+[13] pry(#<TestSingleTableInheritance>)> ::SingleTableInheritanceAlbums::SingleTableInheritanceAlbum.fearless.to_sql
+=> "SELECT \"single_table_inheritance_albums\".* FROM \"single_table_inheritance_albums\" WHERE \"single_table_inheritance_albums\".\"type\" = 'SingleTableInheritanceAlbums::Fearless'"
+```
+
+###### - Enables support for all the enum goodness when enumerating classes for Polymorphic Associations
+Note: this excludes the `<attribute>!` method to update a value, as, as I write this, I can't conceive of a scenario in which you'd want to update just the type, and not also the ID, of an associated object. If you want to do this, you can still do this manually via the `ActiveRecord#update` method.
+
+```
+class Award < ActiveRecord::Base
+  self.table_name = 'awards'
+  belongs_to :awardable, polymorphic: true
+  taylors_enum awardable_type: %w[Album Song], polymorphic: true
+end
+
+[1] pry(#<TestPolymorphic>)> song = Song.create!
+=> #<Song:0x0000000105beddd0 id: 1, name: nil, created_at: 2022-06-04 14:39:38.837973 UTC, updated_at: 2022-06-04 14:39:38.837973 UTC>
+[2] pry(#<TestPolymorphic>)> album = AlbumBase.create!(name: :folklore)
+=> #<AlbumBase:0x0000000105c36c10 id: 1, name: "folklore", created_at: 2022-06-04 14:39:43.001592 UTC, updated_at: 2022-06-04 14:39:43.001592 UTC>
+[3] pry(#<TestPolymorphic>)> song_award = Award.create!(awardable: song)
+=> #<Award:0x0000000105c77030 id: 1, awardable_type: "Song", awardable_id: "1", created_at: 2022-06-04 14:39:46.714235 UTC, updated_at: 2022-06-04 14:39:46.714235 UTC>
+[4] pry(#<TestPolymorphic>)> album_award = Award.create!(awardable: album)
+=> #<Award:0x0000000105cb4ac0 id: 2, awardable_type: "Album", awardable_id: "1", created_at: 2022-06-04 14:39:49.444071 UTC, updated_at: 2022-06-04 14:39:49.444071 UTC>
+[5] pry(#<TestPolymorphic>)> song_award.song?
+=> true
+[6] pry(#<TestPolymorphic>)> song_award.album?
+=> false
+[7] pry(#<TestPolymorphic>)> album_award.song?
+=> false
+[8] pry(#<TestPolymorphic>)> album_award.album?
+=> true
+[9] pry(#<TestPolymorphic>)> Award.song
+=> [#<Award:0x0000000105dbfca8 id: 1, awardable_type: "Song", awardable_id: "1", created_at: 2022-06-04 14:39:46.714235 UTC, updated_at: 2022-06-04 14:39:46.714235 UTC>]
+[10] pry(#<TestPolymorphic>)> Award.song.to_sql
+=> "SELECT \"awards\".* FROM \"awards\" WHERE \"awards\".\"awardable_type\" = 'Song'"
+```
+
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add taylors_enum
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install taylors_enum
+
+## Usage
+
+Using taylors_enum is simple! Once the gem is installed, just add `taylors_enum <my_column>: ['array', 'of', 'values']` to any model that ultimately inherits from `ActiveRecord::Base`.
+
+The values that you pass will be the values that are stored in the database. taylors_enum will then generate a companion for each value that will be used to define constants, `?` methods to check if an object has the given value in the specified column, `!` methods to update the column to that value, and scopes to query for records with that value. See the top of this README for what this looks like in practice.
+
+taylors_enum also takes a series of options, provided as a hash:
+- `prefix`: defaults to `nil`. If `true` is passed, the name of the column will be prepended to the start of the helper methods, scopes, and constants. If a string is passed, the given string will be prepended to the start of the helper methods, scopes, and constants.
+
+- `suffix`: defaults to `nil`. If `true` is passed, the name of the column will be appended to the end of the helper methods, scopes, and constants. If a string is passed, the given string will be appended to the end of the helper methods, scopes, and constants.
+
+- `constants`: defaults to `true`. If `false` is passed, constants will not be defined. This can be helpful for migrating onto taylors_enum, if you already have constants defined for certain enum values.
+
+- `validations`: defaults to `true`. If `false` is passed, validations, `nil` will be allowed as a value in the specified column.
+
+- `single_table_inheritance`: defaults to `false`. When using taylors_enum to help with columns on [Single Table Inheritance](https://api.rubyonrails.org/classes/ActiveRecord/Inheritance.html) models, pass this value as `true`, otherwise things won't work, and then you'll be sad.
+
+- `polymorphic`: defaults to `false`. When using taylors_enum to help with type columns for [polymorphic associations](https://guides.rubyonrails.org/association_basics.html#polymorphic-associations), pass this value as `true`; this will ensure validations are run correctly, against database values rather than Rails values, and will also not create a `!` method to update the value of the column.
+
+If you want to see the base Rails value that will be used to generate the `value?` and `value!` methods, that `VALUE` constants, and the `value` scopes, you can load
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+You'll also need to have a working database in order to run the tests. First, make sure you have [Postgres](https://www.postgresql.org/) installed. You can easily do this on a Mac with [Homebrew](https://wiki.postgresql.org/wiki/Homebrew).
+
+From there, run `createdb taylors_enum` in the terminal to create a database with the required name. Then, run `psql taylors_enum` to open a terminal to that database, and run `create user postgres;` to create a user with the correct username for the test suite to connect to it. The database connection config is specified in `test/database.yml`
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, 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/isitpj/taylors_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,16 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/taylors_enum/active_record/active_record.rb

@@ -0,0 +1,7 @@
+module TaylorsEnum
+  module ActiveRecord
+    ActiveSupport.on_load :active_record do
+      extend ::TaylorsEnum::ActiveRecord::TaylorsEnum::ClassMethods
+    end
+  end
+end

data/lib/taylors_enum/active_record/taylors_enum.rb

@@ -0,0 +1,157 @@
+module TaylorsEnum
+  module ActiveRecord
+    module TaylorsEnum
+      module ClassMethods
+        DEFAULT_OPTIONS = {
+          prefix: nil, # can be true, false, or a string; if true, will use the column_name as the default value
+          suffix: nil, # can be true, false, or a string; if true, will use the column_name as the default value
+          constants: true, # can be true or false
+          validations: true, # can be true or false; TODO: allow a hash of validations args to be passed
+          single_table_inheritance: false,
+          polymorphic: false,
+          column: nil # this is set by the first argument passed to taylors_enum
+        }.with_indifferent_access.freeze
+
+        def taylors_enum(**enum_args)
+          enum_args, *options = *enum_args
+          enum_column, raw_values = *enum_args
+
+          options = DEFAULT_OPTIONS
+            .merge(**options.to_h)
+            .merge(column: enum_column)
+            .with_indifferent_access
+
+          values = format_values(raw_values, options: options)
+
+          define_list_methods!(values, column: enum_column)
+
+          define_constants!(values) if options[:constants].present?
+
+          # NOTE: when relying on the default rails enum, we validate against the rails-side values, as enum does its own custom validation; however, taylors_enum validates against the database-side values, as it relies on active_record validations
+          values_to_validate = options[:single_table_inheritance] || options[:polymorphic] ? values.values : values.keys
+          enforce_validations!(values: values_to_validate, column: enum_column) if options[:validations].present?
+
+          if options[:single_table_inheritance]
+            manually_define_single_table_inheritance_enum_methods(values, column: enum_column)
+          elsif options[:polymorphic]
+            manually_define_polymorphic_enum_methods(values, column: enum_column)
+          else
+            enum(enum_column => values) unless options[:single_table_inheritance]
+          end
+        end
+
+        def check_rails_value_for(database_value, column: nil, prefix: nil, suffix: nil)
+          format_values(
+            [database_value],
+            options: {
+              column: column,
+              prefix: prefix,
+              suffix: suffix
+            },
+          ).keys.first
+        end
+
+        private
+
+        def manually_define_single_table_inheritance_enum_methods(values, column:)
+          values.each do |rails_value, database_value|
+            define_boolean_method(rails_value, database_value, column)
+            define_update_method(rails_value, database_value, column)
+            define_scope(rails_value, database_value, column)
+          end
+        end
+
+        # NOTE: skip defining the update method for polymorphic, as it makes little sense to update the associated type without also updating the corresponding id
+        def manually_define_polymorphic_enum_methods(values, column:)
+          values.each do |rails_value, database_value|
+            define_boolean_method(rails_value, database_value, column)
+            define_scope(rails_value, database_value, column)
+          end
+        end
+
+        # def active?() status == "active" end
+        def define_boolean_method(rails_value, database_value, column)
+          method_name = "#{rails_value}?"
+          detect_method_conflict(column, method_name, class_method: false)
+          define_method(method_name) { self[column] == database_value }
+        end
+
+        # def active!() update!(status: :active) end
+        def define_update_method(rails_value, database_value, column)
+          method_name = "#{rails_value}!"
+          detect_method_conflict(column, method_name, class_method: false)
+          define_method(method_name) { update!(column => database_value) }
+        end
+
+        # scope :active, -> { where(status: :active) }
+        def define_scope(rails_value, database_value, column)
+          method_name = rails_value
+          detect_method_conflict(column, method_name, class_method: true)
+          scope method_name, -> { where(column => database_value) }
+        end
+
+        def detect_method_conflict(column, method_name, class_method:)
+          send(
+            :detect_enum_conflict!,
+            column,
+            method_name,
+            class_method,
+          )
+        end
+
+        def define_list_methods!(values, column:)
+          define_singleton_method("#{column}_rails_values") do
+            values.keys
+          end
+
+          define_singleton_method("#{column}_database_values") do
+            values.values
+          end
+        end
+
+        def define_constants!(values)
+          values.each do |rails_value, database_value|
+            const_set(rails_value.upcase, database_value)
+          end
+        end
+
+        def enforce_validations!(values:, column:)
+          validates column, presence: true, inclusion: { in: values, message: "%{value} is not a valid #{column}" }
+        end
+
+        def format_values(values, options:)
+          prefix = generate_prefix_name(options[:prefix], column: options[:column])
+          suffix = generate_suffix_name(options[:suffix], column: options[:column])
+
+          values.map do |value|
+            formatted_value = value.to_s.demodulize.underscore
+            [
+              "#{prefix}#{formatted_value}#{suffix}",
+              value
+            ]
+          end.to_h
+        end
+
+        def generate_prefix_name(prefix, column:)
+          enum_prefix = generate_nfix_name(prefix, column: column)
+          enum_prefix.present? ? "#{enum_prefix}_" : ''
+        end
+
+        def generate_suffix_name(suffix, column:)
+          enum_suffix = generate_nfix_name(suffix, column: column)
+          enum_suffix.present? ? "_#{enum_suffix}" : ''
+        end
+
+        def generate_nfix_name(nfix, column:)
+          if nfix == true
+            column
+          elsif nfix
+            nfix
+          else
+            ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/taylors_enum/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TaylorsEnum
+  VERSION = '0.1.0'
+end

data/lib/taylors_enum.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'taylors_enum/version'
+
+module TaylorsEnum
+  class Error < StandardError; end
+  require 'active_support'
+  require 'active_support/core_ext/hash'
+  require 'taylors_enum/active_record/active_record'
+  require 'taylors_enum/active_record/taylors_enum'
+end

data/sig/taylors_enum.rbs

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

data/taylors_enum.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'lib/taylors_enum/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'taylors_enum'
+  spec.version = TaylorsEnum::VERSION
+  spec.authors = ['Cassie Johnstone']
+  spec.email = ['peter.wdj@gmail.com']
+
+  spec.summary = 'Better enums in Rails.'
+  spec.description = 'Helper methods around enumerable values in Rails, including enums, polymorphic associations, and single-table inheritance.'
+  spec.homepage = 'https://github.com/isitpj/taylors_enum'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = 'https://github.com/isitpj/taylors_enum/blob/main/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']
+
+  spec.add_dependency 'activesupport', '>= 4.2'
+  spec.add_development_dependency 'activerecord', '>= 4.2'
+  spec.add_development_dependency 'pg', '~> 1.2.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug', '~> 3.9.0'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: taylors_enum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cassie Johnstone
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.9.0
+description: Helper methods around enumerable values in Rails, including enums, polymorphic
+  associations, and single-table inheritance.
+email:
+- peter.wdj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/taylors_enum.rb
+- lib/taylors_enum/active_record/active_record.rb
+- lib/taylors_enum/active_record/taylors_enum.rb
+- lib/taylors_enum/version.rb
+- sig/taylors_enum.rbs
+- taylors_enum.gemspec
+homepage: https://github.com/isitpj/taylors_enum
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/isitpj/taylors_enum
+  source_code_uri: https://github.com/isitpj/taylors_enum
+  changelog_uri: https://github.com/isitpj/taylors_enum/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Better enums in Rails.
+test_files: []