smart_enum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8033b630c233ee1fb2ffb6edc375cd8923fcaf123b79f0a7cfeb59dfeeb2038f
+  data.tar.gz: a8cbe3f6fab587af7694090fefdd3a0bc572f09b550f05e0feb4c9f976f84e46
+SHA512:
+  metadata.gz: '09c09faf8bf6df24cdb21440a28927da8de576f226c4022b6b8c58698af92395b004a97aa707e321e0923de19caad8401ce7ce04c3be75ee6d602cb7738ea7a3'
+  data.tar.gz: 4f100a58b11ef870bdabe07fbe3053fdb51109ec981f0cfbac68b8bae4dd25060b5a1600c94861a2b06f392cc88dfebd1ed4ecf12c39222e34c682db4f3a2446

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 ShippingEasy
+
+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,39 @@
+# SmartEnum
+
+Create Enum values to replace database lookup tables.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'smart_enum'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install smart_enum
+
+## Usage
+
+TBD
+
+## 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.
+
+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 tags, 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/ShippingEasy/smart_enum.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://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/smart_enum/active_record_compatibility.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require "active_record"
+
+# Methods to make SmartEnum models work in contexts like views where rails
+# expects ActiveRecord instances.
+class SmartEnum
+  module ActiveRecordCompatibility
+    def self.included(base)
+      base.include(ActiveModel::Serialization)
+      base.extend(ActiveModel::Naming)
+      base.extend(ClassMethods)
+      base.extend(QueryMethods)
+    end
+
+    module ClassMethods
+      ID = "id"
+      def primary_key
+        ID
+      end
+
+      def reset_column_information
+        # no-op for legacy migration compatability
+      end
+
+      # Used in AR polymorphic associations.  Returns the base of this class' SmartEnum STI tree.
+      def base_class
+        unless self < ::SmartEnum
+          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from SmartEnum"
+        end
+
+        if superclass == ::SmartEnum
+          self
+        else
+          superclass.base_class
+        end
+      end
+    end
+
+    def to_key
+      [id]
+    end
+
+    def _read_attribute(attribute_name)
+      attributes.fetch(attribute_name.to_sym)
+    end
+
+    def destroyed?
+      false
+    end
+
+    def new_record?
+      false
+    end
+
+    def marked_for_destruction?
+      false
+    end
+
+    def persisted?
+      true
+    end
+
+    # Simulate ActiveRecord Query API
+    module QueryMethods
+      def where(uncast_attrs)
+        attrs = cast_query_attrs(uncast_attrs)
+        all.select do |instance|
+          instance.attributes.slice(*attrs.keys) == attrs
+        end.tap(&:freeze)
+      end
+
+      def find(id, raise_on_missing: true)
+        self[cast_primary_key(id)].tap do |result|
+          if !result && raise_on_missing
+            fail ActiveRecord::RecordNotFound.new("Couldn't find #{self} with 'id'=#{id}")
+          end
+        end
+      end
+
+      def find_by(uncast_attrs)
+        attrs = cast_query_attrs(uncast_attrs)
+        if attrs.size == 1 && attrs.has_key?(:id)
+          return find(attrs[:id], raise_on_missing: false)
+        end
+        all.detect do |instance|
+          instance.attributes.slice(*attrs.keys) == attrs
+        end
+      end
+
+      def find_by!(attrs)
+        find_by(attrs).tap do |result|
+          if !result
+            fail ActiveRecord::RecordNotFound.new("Couldn't find #{self} with #{attrs.inspect}")
+          end
+        end
+      end
+
+      def none
+        []
+      end
+
+      def all
+        values
+      end
+
+      STRING = [String].freeze
+      SYMBOL = [Symbol].freeze
+      BOOLEAN = [TrueClass, FalseClass].freeze
+      INTEGER = [Integer].freeze
+      BIG_DECIMAL = [BigDecimal].freeze
+      # Ensure that the attrs we query by are compatible with the internal
+      # types, casting where possible.  This allows us to e.g.
+      #   find_by(id: '1', key: :blah)
+      # even when types differ like we can in ActiveRecord.
+      def cast_query_attrs(raw_attrs)
+        raw_attrs.symbolize_keys.each_with_object({}) do |(k, v), new_attrs|
+          if v.instance_of?(Array)
+            fail "SmartEnum can't query with array arguments yet.  Got #{raw_attrs.inspect}"
+          end
+          if (attr_def = attribute_set[k])
+            if attr_def.types.any?{|type| v.instance_of?(type) }
+              # No need to cast
+              new_attrs[k] = v
+            elsif (v.nil? && attr_def.types != BOOLEAN)
+              # Querying by nil is a legit case, unless the type is boolean
+              new_attrs[k] = v
+            elsif attr_def.types == STRING
+              new_attrs[k] = String(v)
+            elsif attr_def.types == INTEGER
+              if v.instance_of?(String) && v.empty? # support querying by (id: '')
+                new_attrs[k] = nil
+              else
+                new_attrs[k] = Integer(v)
+              end
+            elsif attr_def.types == BOOLEAN
+              # TODO should we treat "f", 0, etc as false?
+              new_attrs[k] = !!v
+            elsif attr_def.types == BIG_DECIMAL
+              new_attrs[k] = BigDecimal(v)
+            else
+              fail "Passed illegal query arguments for #{k}: #{v} is a #{v.class}, need #{attr_def.types} or a cast rule (got #{raw_attrs.inspect})"
+            end
+          else
+            fail "#{k} is not an attribute of #{self}! (got #{raw_attrs.inspect})"
+          end
+        end
+      end
+
+      # Given an "id-like" parameter (usually the first argument to find),
+      # cast it to the same type used to index the PK lookup hash.
+      def cast_primary_key(id_input)
+        return if id_input == nil
+        id_attribute = attribute_set[:id]
+        fail "no :id attribute defined on #{self}" if !id_attribute
+        types = id_attribute.types
+        # if the type is already compatible, return it.
+        return id_input if types.any? { |t| id_input.instance_of?(t) }
+        case types
+        when INTEGER then Integer(id_input)
+        when STRING  then id_input.to_s
+        when SYMBOL  then id_input.to_s.to_sym
+        else
+          fail "incompatible type: got #{id_input.class}, need #{types.inspect} or something castable to that"
+        end
+      end
+    end
+  end
+
+  # automatically enable when this file is loaded
+  include ActiveRecordCompatibility
+end

data/lib/smart_enum/associations.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Macros for registring associations with other SmartEnum models
+class SmartEnum
+  module Associations
+    def has_many_enums(association_name, class_name: nil, as: nil, foreign_key: nil, through: nil, source: nil)
+      association_name = association_name.to_sym
+      if through
+        return has_many_enums_through(association_name, through, source: source)
+      end
+
+      association = HasAssociation.new(self, association_name, class_name: class_name, as: as, foreign_key: foreign_key)
+      enum_associations[association_name] = association
+
+      define_method(association.generated_method_name) do
+        association.association_class.values.select{|instance|
+          instance.attributes[association.foreign_key] == self.id
+        }
+      end
+    end
+
+    def has_one_enum(association_name, class_name: nil, foreign_key: nil, through: nil, source: nil)
+      if through
+        return has_one_enum_through(association_name, through, source: source)
+      end
+
+      association_name = association_name.to_sym
+      association = HasAssociation.new(self, association_name, class_name: class_name, foreign_key: foreign_key)
+      enum_associations[association_name] = association
+
+      define_method(association_name) do
+        association.association_class.values.detect{|instance|
+          instance.attributes[association.foreign_key] == self.id
+        }
+      end
+    end
+
+    def has_one_enum_through(association_name, through_association, source: nil)
+      association = ThroughAssociation.new(association_name, through_association, source: source)
+      enum_associations[association_name] = association
+
+      define_method(association_name) do
+        public_send(association.through_association).try(association.association_method)
+      end
+    end
+
+    def has_many_enums_through(association_name, through_association, source: nil)
+      association = ThroughAssociation.new(association_name, through_association, source: source)
+      enum_associations[association_name] = association
+
+      define_method(association_name) do
+        public_send(association.through_association).
+          flat_map(&association.association_method).compact.tap(&:freeze)
+      end
+    end
+
+    def belongs_to_enum(association_name, class_name: nil, foreign_key: nil)
+      association_name = association_name.to_sym
+      association = Association.new(self, association_name, class_name: class_name, foreign_key: foreign_key)
+      enum_associations[association_name] = association
+
+      define_method(association_name) do
+        id_to_find = self.public_send(association.foreign_key)
+        association.association_class[id_to_find]
+      end
+
+      fk_writer_name = "#{association.foreign_key}=".to_sym
+
+      generate_writer = instance_methods.include?(fk_writer_name) || (
+        # ActiveRecord may not have generated the FK writer method yet.
+        # We'll assume that it will get a writer if it has a column with the same name.
+        defined?(ActiveRecord::Base) &&
+        self <= ActiveRecord::Base &&
+        self.respond_to?(:column_names) &&
+        self.column_names.include?(association.foreign_key.to_s)
+      )
+
+      if generate_writer
+        define_method("#{association_name}=") do |value|
+          self.public_send(fk_writer_name, value.try(:id))
+        end
+      end
+    end
+
+    def self.__assert_enum(klass)
+      unless klass <= SmartEnum
+        fail "enum associations can only associate to classes which descend from SmartEnum. #{klass} does not."
+      end
+    end
+
+    def enum_associations
+      @enum_associations ||= {}
+    end
+
+    class Association
+      attr_reader :owner_class, :association_name, :class_name_option, :as_option, :foreign_key_option
+
+      def initialize(owner_class, association_name, class_name: nil, as: nil, foreign_key: nil)
+        @owner_class = owner_class
+        @association_name = association_name.to_sym
+        @class_name_option = class_name
+        @as_option = as
+        @foreign_key_option = foreign_key
+      end
+
+      def class_name
+        @class_name ||= (class_name_option || association_name.to_s.classify).to_s
+      end
+
+      def foreign_key
+        @foreign_key ||= (foreign_key_option || association_name.to_s.foreign_key).to_sym
+      end
+
+      def generated_method_name
+        @generated_method_name ||= (as_option || association_name).to_sym
+      end
+
+      def association_class
+        @association_class ||= class_name.constantize.tap{|klass|
+          ::SmartEnum::Associations.__assert_enum(klass)
+        }
+      end
+    end
+
+    class HasAssociation < Association
+      def foreign_key
+        @foreign_key ||=
+          begin
+            return foreign_key_option.to_sym if foreign_key_option
+            if owner_class.name
+              owner_class.name.foreign_key.to_sym
+            else
+              raise "You must specify the foreign_key option when using a 'has_*' association on an anoymous class"
+            end
+          end
+      end
+    end
+
+    class ThroughAssociation
+      attr_reader :association_name, :through_association, :source_option
+
+      def initialize(association_name, through_association, source: nil)
+        @association_name = association_name
+        @through_association = through_association.to_sym
+        @source_option = source
+      end
+
+      def association_method
+        @association_method ||= (source_option || association_name)
+      end
+    end
+  end
+end

data/lib/smart_enum/attributes.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# A simple replacement for Virtus.
+# - Objects are currently readonly once initialized.
+# - Initialization args either match their type annotation or are nil.
+# - Explicit coercion is supported with the :coercer option.
+# - Booleans have special handling, they get predicate methods and get
+#   automatic nil => false casting.
+# - Child classes automatically inherit parents' attribute set.
+#
+# Example:
+#
+#   class Foo
+#     include SmartEnum::Attributes
+#     attribute :id, Integer
+#     attribute :enabled, Boolean
+#     attribute :created_at, Time, coercer: ->(arg) { Time.parse(arg) }
+#   end
+#
+#   Foo.new(id: 1, created_at: '2016-1-1')
+#   # => #<Foo:0x007f970a090760 @attributes={:id=>1, :created_at=>"2016-01-01T00:00:00.000-06:00", :enabled=>false}}>
+#   Foo.new(id: 1, created_at: 123)
+#   # TypeError: no implicit conversion of 123 into String
+#   Foo.new(id: 1, enabled: true).enabled?
+#   # => true
+#
+class SmartEnum
+  module Attributes
+    Boolean = [TrueClass, FalseClass].freeze
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def attribute_set
+        @attribute_set ||= {}
+      end
+
+      def inherited(child_class)
+        # STI children should start with an attribute set cloned from their parent.
+        # Otherwise theirs will start blank.
+        child_class.instance_variable_set(:@attribute_set, self.attribute_set.dup)
+        # STI children must *share* a reference to the same init_mutex as their
+        # parent so that reads are correctly blocked during async loading.
+        child_class.instance_variable_set(:@_init_mutex, @_init_mutex)
+      end
+
+      def attribute(name, types, coercer: nil, reader_method: nil)
+        name = name.to_sym
+        # ensure `types` is an array.  From activesupport's Array#wrap.
+        types = if types.nil?
+          []
+        elsif types.respond_to?(:to_ary)
+          types.to_ary || [types]
+        else
+          [types]
+        end
+        attribute_set[name] = Attribute.new(name, types, coercer)
+        define_method(reader_method || name) do
+          attributes[name]
+        end
+        if types == Boolean
+          alias_method "#{name}?".to_sym, name
+        end
+      end
+
+      def inspect
+        lock_str = @enum_locked ? "LOCKED" : "UNLOCKED"
+        "#{self}(#{lock_str} #{attribute_set.values.map(&:inspect).join(", ")})"
+      end
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def initialize(opts={})
+      if block_given?
+        fail "Block passed, but it would be ignored"
+      end
+      init_opts = opts.symbolize_keys
+      if self.class.attribute_set.empty?
+        fail "no attributes defined for #{self.class}"
+      end
+      self.class.attribute_set.each do |attr_name, attr_def|
+        if (arg=init_opts.delete(attr_name))
+          if attr_def.types.any?{|type| arg.is_a?(type) }
+            # No coercion necessary
+            attributes[attr_name] = arg
+          elsif attr_def.coercer
+            coerced_arg = attr_def.coercer.call(arg)
+            if attr_def.types.none?{|type| coerced_arg.is_a?(type) }
+              # Coercer didn't give correct type
+              fail "coercer for #{attr_name} failed to coerce #{arg} to one of #{attr_def.types.inspect}.  Got #{coerced_arg}:#{coerced_arg.class} instead"
+            end
+            # Coercer worked
+            attributes[attr_name] = coerced_arg
+          else
+            # Wrong type, no coercer passed
+            fail "Attribute :#{attr_name} passed #{arg}:#{arg.class} in initializer, but needs #{attr_def.types.inspect} and has no coercer"
+          end
+        else
+          if attr_def.types == Boolean
+            # booleans should always be true or false, not nil
+            attributes[attr_name] = false
+          else
+            # Nothing provided for this attr in init opts, set to nil
+            # to make sure we always have a complete attributes hash.
+            attributes[attr_name] = nil
+          end
+        end
+      end
+      if init_opts.any?
+        fail "unrecognized options: #{init_opts.inspect}"
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{attributes.map{|k,v| "#{k}: #{v.inspect}"}.join(", ")}>"
+    end
+
+    def freeze_attributes
+      attributes.values.each(&:freeze)
+      attributes.freeze
+      self
+    end
+
+    class Attribute
+      attr_reader :name, :types, :coercer
+
+      def initialize(name, types, coercer)
+        @name = name
+        @types = types
+        @coercer = coercer
+      end
+
+      def inspect
+        type_str = types.length > 1 ? types.join("|") : types[0]
+        "#{name}: #{type_str}"
+      end
+    end
+  end
+end

data/lib/smart_enum/monetize_interop.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Simple emulation of the monetize macro.
+class SmartEnum
+  INTEGER = [Integer].freeze
+  module MonetizeInterop
+    require 'money'
+
+    CENTS_SUFFIX = /_cents\z/
+    # Note: this ignores the currency column since we only ever monetize things
+    # as USD.  If that changes this should start reading the currency column.
+    def monetize(cents_field_name, as: nil, **opts)
+      if opts.any?
+        fail "unsupported options: #{opts.keys.join(',')}"
+      end
+
+      attr_def = attribute_set[cents_field_name.to_sym]
+      if !attr_def
+        fail "no attribute called #{cents_field_name}, (Do you need to add '_cents'?)"
+      end
+
+      if attr_def.types != INTEGER
+        fail "attribute #{cents_field_name.inspect} can't monetize, only Integer is allowed"
+      end
+
+      money_attribute = as || cents_field_name.to_s.sub(CENTS_SUFFIX, '')
+
+      define_method(money_attribute) do
+        if MonetizeInterop.memoize_method_value
+          @money_cache ||= {}
+          @money_cache[money_attribute] ||= Money.new(public_send(cents_field_name))
+        else
+          Money.new(public_send(cents_field_name))
+        end
+      end
+    end
+
+    @memoize_method_value = true
+
+    def self.memoize_method_value
+      @memoize_method_value
+    end
+
+    def self.disable_memoization!
+      @memoize_method_value = false
+    end
+  end
+end

data/lib/smart_enum/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class SmartEnum
+  VERSION = "0.1.0"
+end

data/lib/smart_enum/yaml_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'yaml'
+# Methods for registering values from YAML files
+class SmartEnum
+  module YamlStore
+    def register_values_from_file!
+      unless SmartEnum::YamlStore.data_root
+        raise "Must set SmartEnum::YamlStore.data_root before using `register_values_from_file!`"
+      end
+      unless self.name
+        raise "Cannot infer data file for anonymous class"
+      end
+
+      filename = "#{self.name.tableize}.yml"
+      file_path = File.join(SmartEnum::YamlStore.data_root, filename)
+      values = YAML.load_file(file_path)
+      register_values(values, self, detect_sti_types: true)
+    end
+
+    def self.data_root
+      @data_root
+    end
+
+    def self.data_root=(val)
+      @data_root = val
+    end
+  end
+
+  # automatically enable YAML store when this file is loaded
+  extend YamlStore
+end

data/lib/smart_enum.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "smart_enum/version"
+require "smart_enum/associations"
+require "smart_enum/attributes"
+
+# A class used to build in-memory graphs of "lookup" objects that are
+# long-lived and can associate among themselves or ActiveRecord instances.
+#
+# Example:
+#
+#   class Foo < SmartEnum
+#     attribute :id, Integer
+#     has_many :accounts, :class_name => "Customer"
+#   end
+#
+#   class Bar < SmartEnum
+#     attribute :foo_id, Integer
+#     belongs_to :foo
+#   end
+#
+#   Foo.register_values([{id: 1},{id: 2}])
+#   Bar.register_values([{id:9, foo_id: 1},{id: 10, foo_id: 2}])
+#   Bar.find(1)
+#   # ActiveRecord::RecordNotFound: Couldn't find Bar with 'id'=1
+#   bar = Bar.find(9)
+#   # => #<Bar:0x007fcb6440a1f0 @attributes={:foo_id=>1, :id=>9}>
+#   bar.foo
+#   # => #<Foo:0x007fcb643633c8 @attributes={:id=>1}>
+#   bar.foo.accounts
+#   #  Customer Load (1.3ms)  SELECT "customers".* FROM "customers" WHERE "customers"."foo_id" = 1
+#   # => [#<Customer id: 13, foo_id: 1>, ...]
+#
+class SmartEnum
+  include SmartEnum::Attributes
+
+  def self.[](id)
+    ensure_ready_for_reads!
+    _enum_storage[id]
+  end
+
+  def self.values
+    ensure_ready_for_reads!
+    _enum_storage.values
+  end
+
+  def self.enum_locked?
+    @enum_locked
+  end
+
+  class << self
+    attr_accessor :abstract_class
+
+    protected def _enum_storage
+      @_enum_storage ||= {}
+    end
+
+    protected def ensure_ready_for_reads!
+      return true if enum_locked?
+      # This method must be called on a base class if in an STI heirarachy,
+      # because that is the only place deferred hashes are stored.
+      if superclass != SmartEnum
+        return superclass.ensure_ready_for_reads!
+      end
+      if @_deferred_values_present
+        # if we have deferred hashes, instantiate them and lock the enum
+        process_deferred_attr_hashes
+        lock_enum!
+      else
+        # No instance registration has been attempted, need to call
+        # register_values or register_value and lock_enum! first.
+        raise "Cannot use unlocked enum"
+      end
+    end
+
+    private def _constantize_cache
+      @_constantize_cache ||= {}
+    end
+
+    private def _descends_from_cache
+      @_descends_from_cache ||= {}
+    end
+
+    # The descendants of a class.  From activesupport's Class#descendants
+    private def class_descendants(klass)
+      descendants = []
+      ObjectSpace.each_object(klass.singleton_class) do |k|
+        next if k.singleton_class?
+        descendants.unshift k unless k == self
+      end
+      descendants
+    end
+
+    private def _deferred_attr_hashes
+      @_deferred_attr_hashes ||= []
+    end
+
+    private def process_deferred_attr_hashes
+      _deferred_attr_hashes.each do |args|
+        register_value(**args)
+      end
+    end
+  end
+
+  extend Associations
+
+  def self.lock_enum!
+    return if @enum_locked
+    @enum_locked = true
+    @_constantize_cache = nil
+    @_descends_from_cache = nil
+
+    _enum_storage.freeze
+    class_descendants(self).each do |klass|
+      klass.lock_enum!
+    end
+  end
+
+  def self.register_values(values, enum_type=self, detect_sti_types: false)
+    values.each do |raw_attrs|
+      _deferred_attr_hashes << raw_attrs.symbolize_keys.merge(enum_type: enum_type, detect_sti_types: detect_sti_types)
+    end
+    @_deferred_values_present = true
+  end
+
+  # TODO: allow a SmartEnum to define its own type discriminator attr?
+  DEFAULT_TYPE_ATTR_STR = "type"
+  DEFAULT_TYPE_ATTR_SYM = :type
+
+  def self.register_value(enum_type: self, detect_sti_types: false, **attrs)
+    fail EnumLocked.new(enum_type) if enum_locked?
+    type_attr_val = attrs[DEFAULT_TYPE_ATTR_STR] || attrs[DEFAULT_TYPE_ATTR_SYM]
+    klass = if type_attr_val && detect_sti_types
+              _constantize_cache[type_attr_val] ||= type_attr_val.constantize
+            else
+              enum_type
+            end
+    unless (_descends_from_cache[klass] ||= (klass <= self))
+      raise "Specified class #{klass} must derive from #{self}"
+    end
+    if klass.abstract_class
+      raise "#{klass} is marked as abstract and may not be registered"
+    end
+
+    instance = klass.new(attrs)
+    id = instance.id
+    raise "Must provide id" unless id
+    raise "Already registered id #{id}!" if _enum_storage.has_key?(id)
+    instance.freeze_attributes
+    _enum_storage[id] = instance
+    if klass != self
+      klass._enum_storage[id] = instance
+    end
+  end
+
+  class EnumLocked < StandardError
+    def initialize(klass)
+      super("#{klass} has been locked and can not be written to")
+    end
+  end
+end

data/smart_enum.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'smart_enum/version'
+
+
+Gem::Specification.new do |spec|
+  spec.name          = "smart_enum"
+  spec.version       = SmartEnum::VERSION
+  spec.authors       = ["Carl Brasic", "Joshua Flanagan"]
+  spec.email         = ["cbrasic@gmail.com", "joshuaflanagan@gmail.com"]
+
+  spec.summary       = %q{Enums to replace database lookup tables}
+  spec.description   = %q{Enums to replace database lookup tables}
+  spec.homepage      = "https://github.com/ShippingEasy/smart_enum"
+  spec.license       = "MIT"
+
+  spec.files         = Dir["lib/**/*", "Rakefile", "README.md", "LICENSE.txt", "smart_enum.gemspec"]
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+
+  # needed to run test suite for optional features, but consumers don't need it
+  spec.add_development_dependency "activerecord"
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: smart_enum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Carl Brasic
+- Joshua Flanagan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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'
+description: Enums to replace database lookup tables
+email:
+- cbrasic@gmail.com
+- joshuaflanagan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/smart_enum.rb
+- lib/smart_enum/active_record_compatibility.rb
+- lib/smart_enum/associations.rb
+- lib/smart_enum/attributes.rb
+- lib/smart_enum/monetize_interop.rb
+- lib/smart_enum/version.rb
+- lib/smart_enum/yaml_store.rb
+- smart_enum.gemspec
+homepage: https://github.com/ShippingEasy/smart_enum
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.4
+signing_key: 
+specification_version: 4
+summary: Enums to replace database lookup tables
+test_files: []