flexible_enum 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a885917e4b7e8bb397a0dab1d78711395ab49120
+  data.tar.gz: b0baf4ab1c1bd0cfc3c337e5cc585c71043ff96f
+SHA512:
+  metadata.gz: cc8c6c0dc01306ccff5e961de08e66457486b4ef8f3e8ba5a716e356c8ad1b69a5403e51a158f8690e5d3b9a426bfea74c5807791a5dab83dd00d3fca1a7abc3
+  data.tar.gz: da33ab81de96f8813b6cde44c4bafee0ec5b0de44a8f87749c0a2661a2464ca80d626648f6fb9ef31f0af41901d33267b5aafbff7caeea359bc669769e0caf2f

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+gemfiles/*.lock

data/.travis.yml

@@ -0,0 +1,5 @@
+---
+language: ruby
+rvm: 2.1.2
+before_script: bundle exec appraisal install
+script: bundle exec appraisal rspec

data/Appraisals

@@ -0,0 +1,7 @@
+appraise "rails-4.1" do
+  gem "rails", "~> 4.1.10"
+end
+
+appraise "rails-4.2" do
+  gem "rails", "~> 4.2.1"
+end

data/CONTRIBUTING.md

@@ -0,0 +1,17 @@
+# Contributing to FlexibleEnum
+
+By participating in this project, you agree to abide by the MeYou Health [code of conduct].
+
+[code of conduct]: http://engineering.meyouhealth.com/open-source/code-of-conduct
+
+To contribute to FlexibleEnum:
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run the tests (`appraisal rspec`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+Want more detail on these steps? [Learn more about forking git
+repositories](https://guides.github.com/activities/forking/).

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in flexible_enum.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013–2015 MeYou Health
+
+MIT License
+
+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,295 @@
+# FlexibleEnum
+
+Give Ruby enum-like powers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "flexible_enum",     git: 'git@github.com:meyouhealth/flexible_enum.git'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flexible_enum
+
+## Basic Usage
+
+The `flexible_enum` class method is mixed into ActiveRecord::Base. Call it to add enum-like powers to any number of existing attributes on a target class.
+You must provide the name of the attribute and a list of available options. Options consist of a name, value, and optional hash of configuration parameters.
+
+```ruby
+class User < ActiveRecord::Base
+  flexible_enum :status do
+    active    0
+    disabled  1
+    pending   2
+  end
+end
+```
+
+Option values may be any type.
+
+```ruby
+class Product < ActiveRecord::Base
+  flexible_enum :manufacturer do
+    honeywell "HON"
+    sharp "SHCAY"
+  end
+end
+```
+
+## Working with Values
+
+Available options for each attribute are defined as constants on the target class. The classes above would have defined:
+
+```ruby
+User::ACTIVE        # => 0
+User::DISABLED      # => 1
+User::PENDING       # => 2
+Product::HONEYWELL  # => "HON"
+Product::SHARP      # => "SHCAY"
+```
+
+## Setter Methods
+
+FlexibleEnum adds convenience methods for changing the current value of an attribute and immediately saving it to the database. By default, bang methods are added for each option:
+
+```ruby
+u = User.new
+u.active!   # Calls update_attributes(status: 0)
+u.disabled! # Calls update_attributes(status: 1)
+```
+
+The name of the setter method can be changed using option configuration parameters:
+
+```ruby
+class Post < ActiveRecord::Base
+  flexible_enum :visibility do
+    invisible 0, setter: :hide!
+    visible   1, setter: :show!
+  end
+end
+
+p = Post.new
+p.show! # Calls update_attributes(visibility: 1)
+p.hide! # Calls update_attributes(visibility: 0)
+```
+
+### Timestamps
+
+If the target class defines a date and/or time attribute corresponding to the flexible enum option being set it will be updated with the current date/time when using setter methods. For example, Post#show! above will set `visibility = 1`, `visibile_at = Time.now.utc`, and `visible_on = Time.now.utc.to_date` if those columns exist. The existance of columns is checked using ActiveRecord's `attribute_method?` method.
+
+Use the `:timestamp_attribute` option configuration parameter to change the columns used:
+
+```ruby
+flexible_enum :status do
+  unknown  0
+  active   1, timestamp_attribute: :actived
+  disabled 2, timestamp_attribute: :disabled
+end
+```
+
+Calling `active!` will now attempt to set `actived_at` and `actived_on`.
+
+## Predicate Methods
+
+FlexibleEnum adds convenience methods for checking whether an option's value is also the attribute's current value.
+
+```ruby
+p = Post.new
+p.show!
+p.visible?   # => true
+p.invisible? # => false
+```
+
+Inverse predicate methods can be added by setting the :inverse configuration parameter. Inverse predicate methods have the reverse logic:
+
+```ruby
+class Car < ActiveRecord::Base
+  flexible_enum :fuel_type do
+    gasoline 0
+    diesel   1
+    electric 2, inverse: :carbon_emitter
+  end
+end
+
+c = Car.new
+c.gasoline!
+c.carbon_emitter? # => true
+c.diesel!
+c.carbon_emitter? # => true
+c.electric!
+c.carbon_emitter? # => false
+```
+
+## Humanized Values
+
+Humanized versions of attributes are available. This is convenient for displaying the current value on screen (see "Option Reflection" for rendering drop down lists).
+
+```ruby
+c = Car.new(fuel_type: Car::DIESEL)
+c.human_fuel_type = "Diesel"
+Car.human_fuel_type(0) # => "Gasoline"
+Car.fuel_types.collect(&:human_name) # => ["Gasoline", "Diesel", "Electric"]
+```
+
+If the flexible enum value is `nil`, the humanized name will also be `nil`:
+
+```ruby
+c = Car.new(fuel_type: nil)
+c.human_fuel_type # => nil
+```
+
+## Name Method
+
+The name of the attribute value is available. This allows you to grab the stringified version of the name of the value.
+
+```ruby
+c = Car.new(fuel_type: Car::CARBON_EMITTER)
+c.fuel_type_name # => "carbon_emitter"
+```
+
+If the flexible enum value is `nil`, the name will also be `nil`:
+
+```ruby
+c = Car.new(fuel_type: nil)
+c.fuel_type_name # => nil
+```
+
+## Namespaced Attributes
+
+FlexibleEnum attributes may be namespaced. Adding the namespace option to `flexible_enum` results in constants being defined in a new module.
+
+```ruby
+class CashRegister < ActiveRecord::Base
+  flexible_enum :drawer_position, namespace: "DrawerPositions" do
+    opened 0
+    closed 1
+  end
+end
+
+# Constants are defined in a new module
+CashRegister::DrawerPositions::OPENED # => 0
+CashRegister::DrawerPositions::CLOSED # => 1
+
+# Convenience methods are not affected by namespace
+r = CashRegister.new
+r.opened!
+r.closed!
+```
+
+## Scopes
+
+FlexibleEnum adds ActiveRecord scopes for each attribute option:
+
+```ruby
+User.active   # => User.where(status: 0)
+User.disabled # => User.where(status: 1)
+User.pending  # => User.where(status: 2)
+```
+
+When an attribute is namespaced a prefix is added to scope names. The prefix is the singularized namespace name (using Active Support):
+
+```ruby
+CashRegister.drawer_position_opened # => CashRegister.where(drawer_position: 0)
+CashRegister.drawer_position_closed # => CashRegister.where(drawer_position: 1)
+```
+
+## Custom Options
+
+Configuration parameters passed to attribute options are saved even if they are unknown. Getting at custom configuration parameters is a little clumsy at the moment but this can still be useful in some cases:
+
+```ruby
+class EmailEvent < ActiveRecord::Base
+  flexible_enum :event_type do
+    bounce    1, processor_class: RejectedProcessor
+    dropped   2, processor_class: RejectedProcessor
+    opened    3, processor_class: EmailOpenedProcessor
+    delivered 4, processor_class: DeliveryProcessor
+  end
+
+  def process
+    class.event_types[event_type][:processor_class].new(self).process
+  end
+end
+```
+
+## Option Introspection
+
+You may introspect on available options and their configuration parameters:
+
+```ruby
+ary = EmailEvent.event_types
+ary.collect(&:name)       # => ["bounce", "dropped", "opened", "delivered"]
+ary.collect(&:human_name) # => ["Bounce", "Dropped", "Opened", "Delivered"]
+ary.collect(&:value)      # => [1, 2, 3, 4]
+```
+
+This works particularly well with ActionView:
+
+```ruby
+f.collection_select(:event_type, EmailEvent.event_types, :value, :human_name)
+```
+
+## Enum Introspection
+
+You may retrieve a list of all defined `flexible_enum`s on a particular class:
+
+```ruby
+class Car < ActiveRecord::Base
+  flexible_enum :status do
+    new  1
+    used 2
+  end
+
+  flexible_enum :car_type do
+    gas      1
+    hybrid   2
+    electric 3
+  end
+end
+
+Car.flexible_enums # => { status: Car.statuses, car_type: Car.car_types }
+```
+
+## Overriding Methods
+
+You may override any method defined on the target class by FlexibleEnum. In version 0.0.1, `super` behaved as it would without FlexibleEnum being present, you could not call a FlexibleEnum method implementation from an overriding method. As of version 0.0.2, `super` instead references the FlexibleEnum implementation of a method when overriding a FlexibleEnum-defined method.
+
+```ruby
+class Item < ActiveRecord::Base
+  flexible_enum :availability do
+    discontinued 0
+    backorder    1
+    in_stock     2
+  end
+
+  # Version 0.0.1
+  # Calling super would throw NoMethodError so we'd have to reimplement the method.
+  def in_stock!
+    BackInStockNotifier.new(self).queue if backorder?
+    update_attribute!(status: IN_STOCK)
+  end
+
+  # Version 0.0.2
+  # Calling super works and is preferred.
+  def in_stock!
+    BackInStockNotifier.new(self).queue if backorder?
+    super
+  end
+end
+```
+
+## Contributing
+
+Please see [CONTRIBUTING.md].
+
+## About MeYou Health
+
+![http://meyouhealth.com/](https://avatars3.githubusercontent.com/u/249181?v=3&s=200)
+
+FlexibleEnum is maintained by MeYou Health, LLC.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/flexible_enum.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flexible_enum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flexible_enum"
+  spec.version       = FlexibleEnum::VERSION
+
+  contributors       = `git shortlog -sne`.split("\n").collect { |l| l.scan(/\t(.*) <(.*)>/) }.flatten(1)
+  spec.authors       = contributors.collect(&:first)
+  spec.email         = contributors.collect(&:last)
+
+  spec.description   = %q{Helpers for enum-like fields}
+  spec.summary       = %q{Helpers for enum-like fields}
+  spec.homepage      = "https://github.com/meyouhealth/flexible_enum"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 3.0"
+
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "fury"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sqlite3"
+end

data/gemfiles/rails_4.1.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 4.1.10"
+
+gemspec :path => "../"

data/gemfiles/rails_4.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "rails", "~> 4.2.1"
+
+gemspec :path => "../"

data/lib/flexible_enum/abstract_configurator.rb

@@ -0,0 +1,11 @@
+module FlexibleEnum
+  class AbstractConfigurator < Struct.new(:feature_module, :attribute_name, :module_for_elements, :elements)
+    def add_class_method(method_name, &block)
+      feature_module.const_get(:ClassMethods).send(:define_method, method_name, &block)
+    end
+
+    def add_instance_method(method_name, &block)
+      feature_module.send(:define_method, method_name, &block)
+    end
+  end
+end

data/lib/flexible_enum/configuration.rb

@@ -0,0 +1,20 @@
+module FlexibleEnum
+  class Configuration
+    def self.load(&block)
+      new.tap {|i| i.instance_eval(&block) }
+    end
+
+    def initialize
+      @config = {}
+    end
+
+    def elements
+      @config.dup
+    end
+
+    def method_missing(element_name, value, options = {})
+      @config[element_name] = options
+      @config[element_name][:value] = value
+    end
+  end
+end

data/lib/flexible_enum/constant_configurator.rb

@@ -0,0 +1,11 @@
+module FlexibleEnum
+  class ConstantConfigurator < AbstractConfigurator
+    def apply
+      elements.each do |element_name, element_config|
+        constant_name  = element_name.to_s.upcase
+        constant_value = element_config[:value]
+        module_for_elements.const_set(constant_name, constant_value)
+      end
+    end
+  end
+end

data/lib/flexible_enum/mixin.rb

@@ -0,0 +1,47 @@
+require 'active_support/concern'
+require 'active_support/inflector'
+
+module FlexibleEnum
+  module Mixin
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def flexible_enums
+        @flexible_enums ||= {}
+      end
+
+      def flexible_enum(attribute_name, attribute_options = {}, &config)
+        # Methods are defined on the feature module which in turn is mixed in to the target class
+        feature_module = Module.new do |m|
+          extend ActiveSupport::Concern
+          const_set :ClassMethods, Module.new
+          def m.inspect
+            "FlexibleEnum(#{self})"
+          end
+        end
+
+        # The module that will hold references to value constants
+        module_for_elements = attribute_options[:namespace] ? self.const_set(attribute_options[:namespace], Module.new) : feature_module
+
+        # Read configuration
+        elements = Configuration.load(&config).elements
+
+        # Configure the target object for the given attribute
+        configurators = [ConstantConfigurator,
+                         NameConfigurator,
+                         QuestionMethodConfigurator,
+                         SetterMethodConfigurator,
+                         ScopeConfigurator,
+                         PotentialValuesConfigurator]
+        configurators.each do |configurator|
+          configurator.new(feature_module, attribute_name, module_for_elements, elements).apply
+        end
+
+        # Add functionality to target inheritance chain
+        send(:include, feature_module)
+
+        flexible_enums[attribute_name] = public_send("#{attribute_name.to_s.pluralize}_by_sym")
+      end
+    end
+  end
+end

data/lib/flexible_enum/name_configurator.rb

@@ -0,0 +1,44 @@
+module FlexibleEnum
+  class NameConfigurator < AbstractConfigurator
+    def apply
+      configurator = self
+
+      add_instance_method("#{attribute_name}_name") do
+        value = send(configurator.attribute_name)
+        configurator.name_for(value)
+      end
+
+      add_class_method("human_#{attribute_name}") do |value|
+        configurator.human_name_for(value)
+      end
+
+      add_instance_method("human_#{attribute_name}") do
+        value = send(configurator.attribute_name)
+        configurator.human_name_for(value)
+      end
+    end
+
+    def name_for(value)
+      if value
+        element_info(value).first.to_s
+      else
+        nil
+      end
+    end
+
+    def human_name_for(value)
+      if value
+        element_name, element_config = element_info(value)
+        element_config[:human_name] || element_name.to_s.humanize
+      else
+        nil
+      end
+    end
+
+    private
+
+    def element_info(value)
+      elements.select{|e,c| c[:value] == value }.first
+    end
+  end
+end

data/lib/flexible_enum/potential_values_configurator.rb

@@ -0,0 +1,45 @@
+module FlexibleEnum
+  class PotentialValuesConfigurator < AbstractConfigurator
+    def apply
+      configurator = self
+
+      add_class_method(attribute_name.to_s.pluralize) do
+        configurator.elements.map(&configurator.option_builder_for_target(self)).sort_by(&:value)
+      end
+
+      add_class_method("#{attribute_name.to_s.pluralize}_by_sym") do
+        configurator.elements.inject({}) do |all_options, (element_name, element_config)|
+          all_options.merge element_name => configurator.option_builder_for_target(self).call(element_name, element_config)
+        end
+      end
+
+      add_class_method("#{attribute_name}_value_for") do |sym_string_or_const|
+        element_by_symbol = send(:"#{configurator.attribute_name.to_s.pluralize}_by_sym")[:"#{sym_string_or_const.to_s.downcase}"]
+        element_by_value = send(configurator.attribute_name.to_s.pluralize).select { |e| e.value == sym_string_or_const }.first
+        (element_by_symbol || element_by_value).try(:value) or raise("Unknown enumeration element: #{sym_string_or_const}")
+      end
+    end
+
+    def option_builder_for_target(target_instance)
+      proc { |element_name, element_config| Option.new(target_instance, attribute_name, element_name, element_config) }
+    end
+
+    class Option < Struct.new(:target_class, :attribute_name, :element_name, :element_config)
+      def name
+        element_name.to_s
+      end
+
+      def human_name
+        target_class.send("human_#{attribute_name}", value)
+      end
+
+      def value
+        element_config[:value]
+      end
+
+      def [](key)
+        element_config[key]
+      end
+    end
+  end
+end

data/lib/flexible_enum/question_method_configurator.rb

@@ -0,0 +1,21 @@
+module FlexibleEnum
+  class QuestionMethodConfigurator < AbstractConfigurator
+    def apply
+      elements.each do |element_name, element_config|
+        attribute_name = self.attribute_name
+
+        # Define question method
+        add_instance_method("#{element_name}?") do
+          self.send(attribute_name) == element_config[:value]
+        end
+
+        # Define inverse question method (if requested)
+        if element_config[:inverse]
+          add_instance_method("#{element_config[:inverse]}?") do
+            !self.send("#{element_name}?")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flexible_enum/scope_configurator.rb

@@ -0,0 +1,23 @@
+module FlexibleEnum
+  class ScopeConfigurator < AbstractConfigurator
+    def apply
+      configurator = self
+
+      elements.each do |element_name, element_config|
+        add_class_method(scope_name(element_name)) do
+          unscope(:where => configurator.attribute_name).where(configurator.attribute_name => element_config[:value])
+        end
+      end
+    end
+
+    private
+
+    def scope_name(option)
+      if feature_module == module_for_elements
+        option
+      else
+        "#{module_for_elements.to_s.split('::').last.underscore.singularize}_#{option}"
+      end
+    end
+  end
+end

data/lib/flexible_enum/setter_method_configurator.rb

@@ -0,0 +1,20 @@
+module FlexibleEnum
+  class SetterMethodConfigurator < AbstractConfigurator
+    def apply
+      attribute_name = self.attribute_name
+
+      elements.each do |element_name, element_config|
+        bang_method_name = element_config[:setter] || "#{element_name}!"
+        attributes = {attribute_name => element_config[:value]}
+        timestamp_attribute_name = element_config[:timestamp_attribute] || element_name
+
+        add_instance_method(bang_method_name) do
+          time = Time.now.utc
+          attributes["#{timestamp_attribute_name}_on".to_sym] = time.to_date if self.class.attribute_method?("#{timestamp_attribute_name}_on")
+          attributes["#{timestamp_attribute_name}_at".to_sym] = time if self.class.attribute_method?("#{timestamp_attribute_name}_at")
+          update_attributes(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/flexible_enum/version.rb

@@ -0,0 +1,3 @@
+module FlexibleEnum
+  VERSION = "0.2.2"
+end

data/lib/flexible_enum.rb

@@ -0,0 +1,19 @@
+require 'active_support/lazy_load_hooks'
+require 'active_support/core_ext/object'
+
+module FlexibleEnum
+  autoload :Mixin, 'flexible_enum/mixin'
+  autoload :Configuration, 'flexible_enum/configuration'
+  autoload :AbstractConfigurator, 'flexible_enum/abstract_configurator'
+  autoload :ConstantConfigurator, 'flexible_enum/constant_configurator'
+  autoload :NameConfigurator, 'flexible_enum/name_configurator'
+  autoload :QuestionMethodConfigurator, 'flexible_enum/question_method_configurator'
+  autoload :SetterMethodConfigurator, 'flexible_enum/setter_method_configurator'
+  autoload :ScopeConfigurator, 'flexible_enum/scope_configurator'
+  autoload :PotentialValuesConfigurator, 'flexible_enum/potential_values_configurator'
+  autoload :Version, 'flexible_enum/version'
+end
+
+ActiveSupport.on_load :active_record do
+  include FlexibleEnum::Mixin
+end

data/spec/constant_definition_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "constant definition" do
+  it "sets constants for each value choice" do
+    expect(CashRegister::UNKNOWN).to    eq(0)
+    expect(CashRegister::NOT_ACTIVE).to eq(10)
+    expect(CashRegister::ACTIVE).to     eq(20)
+    expect(CashRegister::HONEYWELL).to  eq("HON")
+    expect(CashRegister::SHARP).to      eq("SHCAY")
+  end
+
+  it "sets constants for each namespaced attribute value choice" do
+    expect(CashRegister::DrawerPositions::OPENED).to eq(0)
+    expect(CashRegister::DrawerPositions::CLOSED).to eq(1)
+  end
+end

data/spec/custom_options_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "custom options" do
+  it "records unknown options for client recall" do
+    expect(CashRegister.statuses[1][:my_custom_option]).to eq("Nothing to see here")
+  end
+end

data/spec/enum_introspection_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe "target class exposing flexible_enums" do
+  it "allows consumers to find all defined flexible_enums" do
+    expect(CashRegister.flexible_enums[:status].keys).to eq([:unknown, :not_active, :active, :alarm, :full, :empty])
+    expect(CashRegister.flexible_enums[:drawer_position].keys).to eq([:opened, :closed])
+    expect(CashRegister.flexible_enums[:manufacturer].keys).to eq([:honeywell, :sharp])
+  end
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "inheritance in target class" do
+  it "allows calling super from overwritten methods" do
+    register = CashRegister.new
+    register.honeywell!
+
+    def register.sharp!
+      before = manufacturer
+      super
+      [before, manufacturer]
+    end
+
+    expect(register.sharp!).to eq(["HON", "SHCAY"])
+  end
+end

data/spec/name_values_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe "name values" do
+  it "retrieves the name for the current value" do
+    register = CashRegister.new
+    register.status = CashRegister::UNKNOWN
+    expect(register.status_name).to eq("unknown")
+    register.status = CashRegister::NOT_ACTIVE
+    expect(register.status_name).to eq("not_active")
+    register.status = nil
+    expect(register.status_name).to be_nil
+  end
+
+  it "retrieves the human name of the current value" do
+    register = CashRegister.new
+    register.status = CashRegister::UNKNOWN
+    expect(register.human_status).to eq("Unknown")
+    register.status = CashRegister::NOT_ACTIVE
+    expect(register.human_status).to eq("Not active")
+    register.status = nil
+    expect(register.human_status).to be_nil
+  end
+
+  it "retrieves human names for available options" do
+    expect(CashRegister.human_status(CashRegister::UNKNOWN)).to eq("Unknown")
+    expect(CashRegister.human_status(CashRegister::NOT_ACTIVE)).to eq("Not active")
+  end
+
+  it "retrieves custom human names when provided" do
+    expect(CashRegister.human_status(CashRegister::ALARM)).to eq("Help I'm being robbed!")
+  end
+
+  it "retrieves the human name of the current value of namespaced attributes" do
+    opened_register = CashRegister.new.tap {|r| r.drawer_position = CashRegister::DrawerPositions::OPENED }
+    closed_register = CashRegister.new.tap {|r| r.drawer_position = CashRegister::DrawerPositions::CLOSED }
+    expect(opened_register.human_drawer_position).to eq("Opened")
+    expect(closed_register.human_drawer_position).to eq("Closed")
+  end
+
+  it "retrieves human names for known constants of namespaced attributes" do
+    expect(CashRegister.human_drawer_position(CashRegister::DrawerPositions::OPENED)).to eq("Opened")
+    expect(CashRegister.human_drawer_position(CashRegister::DrawerPositions::CLOSED)).to eq("Closed")
+  end
+end

data/spec/potential_values_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "reflection of attribute options" do
+  it "returns a list of possible elements" do
+    expect(CashRegister.drawer_positions.collect(&:name)).to eq(["opened", "closed"])
+    expect(CashRegister.drawer_positions.collect(&:human_name)).to eq(["Opened", "Closed"])
+    expect(CashRegister.drawer_positions.collect(&:value)).to eq([0, 1])
+  end
+
+  it "finds the element metadata for the option provided by symbol" do
+    opened = CashRegister.drawer_positions_by_sym[:opened]
+    expect(opened.name).to       eq("opened")
+    expect(opened.human_name).to eq("Opened")
+    expect(opened.value).to      eq(0)
+
+    closed = CashRegister.drawer_positions_by_sym[:closed]
+    expect(closed.name).to       eq("closed")
+    expect(closed.human_name).to eq("Closed")
+    expect(closed.value).to      eq(1)
+  end
+
+  it "finds the value corresponding to the option provided by its value" do
+    expect(CashRegister.status_value_for(CashRegister::ACTIVE)).to eq(CashRegister::ACTIVE)
+  end
+
+  it "finds the value corresponding to the option name provided as a string" do
+    expect(CashRegister.status_value_for("active")).to eq(CashRegister::ACTIVE)
+    expect(CashRegister.status_value_for("ACTIVE")).to eq(CashRegister::ACTIVE)
+    expect(CashRegister.manufacturer_value_for("honeywell")).to eq("HON")
+  end
+
+  it "finds the value for a given option name provided as a symbol" do
+    expect(CashRegister.status_value_for(:active)).to eq(CashRegister::ACTIVE)
+    expect(CashRegister.drawer_position_value_for(:opened)).to eq(CashRegister::DrawerPositions::OPENED)
+  end
+
+  it "raises an exception for invalid options" do
+    expect { CashRegister.status_value_for(666) }.to raise_error("Unknown enumeration element: 666")
+    expect { CashRegister.status_value_for("bad_string") }.to raise_error("Unknown enumeration element: bad_string")
+    expect { CashRegister.status_value_for(:bad_symbol) }.to raise_error("Unknown enumeration element: bad_symbol")
+  end
+end

data/spec/predicate_methods_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "default behavior of flexible_enum" do
+  it "adds default predicates that indicate the current value" do
+    register = CashRegister.new
+    register.status = CashRegister::ACTIVE
+    expect(register).to_not be_unknown
+    expect(register).to_not be_not_active
+    expect(register).to be_active
+  end
+
+  it "adds predicates that indicate the negation of the current value" do
+    register = CashRegister.new
+    register.status = CashRegister::UNKNOWN
+    expect(register).to be_unknown
+    expect(register).to_not be_known
+    register.status = CashRegister::NOT_ACTIVE
+    expect(register).to_not be_unknown
+    expect(register).to be_known
+  end
+
+  it "does not set a default value" do
+    default = CashRegister.new
+    expect(default.status).to be_nil
+    expect(default).to_not be_unknown
+    expect(default).to_not be_not_active
+    expect(default).to_not be_active
+  end
+
+  it "adds predicates that indicate the current value when namespaced" do
+    register = CashRegister.new
+    register.drawer_position = CashRegister::DrawerPositions::OPENED
+    expect(register).to be_opened
+    expect(register).to_not be_closed
+    register.drawer_position = CashRegister::DrawerPositions::CLOSED
+    expect(register).to_not be_opened
+    expect(register).to be_closed
+  end
+end

data/spec/scopes_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "scopes" do
+  it "builds scopes for each element" do
+    actives = CashRegister.create!(status: CashRegister::ACTIVE)
+    alarms = CashRegister.create!(status: CashRegister::ALARM)
+
+    expect(CashRegister.active).to contain_exactly(actives)
+    expect(CashRegister.alarm).to contain_exactly(alarms)
+    expect(CashRegister.unknown).to be_empty
+  end
+
+  it "builds scopes with prefixed names for each namespaced element" do
+    opened = CashRegister.new.tap(&:open!)
+    closed = CashRegister.new.tap(&:close!)
+
+    expect(CashRegister.drawer_position_opened).to contain_exactly(opened)
+    expect(CashRegister.drawer_position_closed).to contain_exactly(closed)
+  end
+
+  it "builds scopes that aren't affected by default scopes" do
+    WithDefaultScope.new.tap(&:active!)
+    passive = WithDefaultScope.new.tap(&:passive!)
+
+    expect(WithDefaultScope.passive).to contain_exactly(passive)
+  end
+end

data/spec/setter_methods_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "setter methods" do
+  subject(:register) { CashRegister.new }
+
+  it "adds default bang methods for setting a new value" do
+    expect(register.status).to be_nil
+    register.active!
+    expect(register.status).to eq(20)
+    register.not_active!
+    expect(register.status).to eq(10)
+  end
+
+  it "adds custom bang methods for setting a new value" do
+    expect(register.drawer_position).to be_nil
+    register.open!
+    expect(register.drawer_position).to eq(0)
+    register.close!
+    expect(register.drawer_position).to eq(1)
+  end
+
+  describe "updating database" do
+    let!(:now) { Time.now }
+    let(:updates) { [] }
+
+    before { allow(Time).to receive(:now).and_return(now) }
+
+    it "immediately dispatches a validation-free update" do
+      register.active!
+      register.close!
+
+      expect(register).to be_active
+      expect(register).to be_closed
+    end
+
+    it "updates default timestamp columns with the current date and time" do
+      register.fill!
+      expect(register).to be_full
+      expect(register.full_at).to eq(now)
+    end
+
+    it "updates custom timestamp columns with the current date and time" do
+      register.empty!
+      expect(register).to be_empty
+      expect(register.emptied_at).to eq(now)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+require 'flexible_enum'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+RSpec.configure do |config|
+  config.around(:each) do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end
+
+ActiveRecord::Schema.define do
+  create_table "cash_registers" do |t|
+    t.integer  "status"
+    t.datetime "emptied_at"
+    t.datetime "emptied_on"
+    t.datetime "full_at"
+    t.string   "manufacturer"
+    t.integer  "drawer_position"
+  end
+
+  create_table "with_default_scopes" do |t|
+    t.integer "status"
+  end
+end
+
+class CashRegister < ActiveRecord::Base
+  flexible_enum :status do
+    unknown    0,  inverse: :known
+    not_active 10, my_custom_option: "Nothing to see here"
+    active     20
+    alarm      21, human_name: "Help I'm being robbed!"
+    full       22, setter: :fill!
+    empty      23, timestamp_attribute: :emptied
+  end
+
+  flexible_enum :drawer_position, :namespace => "DrawerPositions" do
+    opened 0, setter: :open!
+    closed 1, setter: :close!
+  end
+
+  flexible_enum :manufacturer do
+    honeywell "HON"
+    sharp "SHCAY"
+  end
+end
+
+class WithDefaultScope < ActiveRecord::Base
+  flexible_enum :status do
+    active  0
+    passive 1
+  end
+
+  default_scope { where(status: ACTIVE) }
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: flexible_enum
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Matt Daubert
+- Alex Robbin
+- Adam Prescott
+- Matthew Daubert
+- Chad Dressler
+- Sean Santry
+- Adam Prescott
+- Sean Santry
+- jon.zeppieri
+- Alex Robbin
+- David C. Goldhirsch
+- David Larrabee
+- Guillermo Guerini
+- Matthew Daubert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: fury
+  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: rake
+  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: rspec
+  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: sqlite3
+  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: Helpers for enum-like fields
+email:
+- matt.daubert@meyouhealth.com
+- alex.robbin@meyouhealth.com
+- adam@aprescott.com
+- mdaubert@gmail.com
+- chad@dresslerfamily.com
+- sean.santry@meyouhealth.com
+- adam.prescott@meyouhealth.com
+- sean@seansantry.com
+- jon.zeppieri@meyouhealth.com
+- alex@robbinsweb.biz
+- dgoldhirsch@yahoo.com
+- david.larrabee@meyouhealth.com
+- guillermo@gguerini.com
+- mdaubert+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Appraisals
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- flexible_enum.gemspec
+- gemfiles/rails_4.1.gemfile
+- gemfiles/rails_4.2.gemfile
+- lib/flexible_enum.rb
+- lib/flexible_enum/abstract_configurator.rb
+- lib/flexible_enum/configuration.rb
+- lib/flexible_enum/constant_configurator.rb
+- lib/flexible_enum/mixin.rb
+- lib/flexible_enum/name_configurator.rb
+- lib/flexible_enum/potential_values_configurator.rb
+- lib/flexible_enum/question_method_configurator.rb
+- lib/flexible_enum/scope_configurator.rb
+- lib/flexible_enum/setter_method_configurator.rb
+- lib/flexible_enum/version.rb
+- spec/constant_definition_spec.rb
+- spec/custom_options_spec.rb
+- spec/enum_introspection_spec.rb
+- spec/inheritance_spec.rb
+- spec/name_values_spec.rb
+- spec/potential_values_spec.rb
+- spec/predicate_methods_spec.rb
+- spec/scopes_spec.rb
+- spec/setter_methods_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/meyouhealth/flexible_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.0.14
+signing_key: 
+specification_version: 4
+summary: Helpers for enum-like fields
+test_files:
+- spec/constant_definition_spec.rb
+- spec/custom_options_spec.rb
+- spec/enum_introspection_spec.rb
+- spec/inheritance_spec.rb
+- spec/name_values_spec.rb
+- spec/potential_values_spec.rb
+- spec/predicate_methods_spec.rb
+- spec/scopes_spec.rb
+- spec/setter_methods_spec.rb
+- spec/spec_helper.rb