typesafe_enum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e6e6d0a15330f5ec2dd13061e2da603ec354705
+  data.tar.gz: cfaca6a2bc5a2dd50dd2442abc23a6fe5775e8dd
+SHA512:
+  metadata.gz: 0808cf4b53fc63cd69d330cec45fe2124f73380070e6db5d7c6c03e389f8dbf32d1b9c36ea54147cbe6f2abfcc458b35416371f1242c17d191208e91342033ad
+  data.tar.gz: 604dfd70e95d123a72045757aba249b474c3cb8869282d4eac3d38dd37663a56e5f7724439de1dafc20532b8d2eb79bb813fff60fad22064ac5229dd050df7c7

data/.gitignore

@@ -0,0 +1,42 @@
+# Ruby defaults
+
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# Database
+
+db/*.sqlite3
+
+# Logs
+
+/log/
+
+# IntellJ
+
+*.iml
+*.ipr
+*.iws
+*.ids
+.rakeTasks
+
+# Emacs
+
+*~
+\#*
+.#*
+
+# Mac OS
+
+.DS_Store

data/.rubocop.yml

@@ -0,0 +1,24 @@
+# Disable compact style check for example.rb
+Style/ClassAndModuleChildren:
+  Exclude:
+    - 'example.rb'
+
+# Disable line-length check; it's too easy for the cure to be worse than the disease
+Metrics/LineLength:
+  Enabled: False
+
+# Disable problematic module documentation check (see https://github.com/bbatsov/rubocop/issues/947)
+Style/Documentation:
+  Enabled: false
+
+# Allow one line around class body (Style/EmptyLines will still disallow two or more)
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+# Allow one line around module body (Style/EmptyLines will still disallow two or more)
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+# Allow one line around block body (Style/EmptyLines will still disallow two or more)
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/.travis.yml

@@ -0,0 +1,2 @@
+language: ruby
+

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/CHANGES.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 The Regents of the University of California
+
+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,291 @@
+# typesafe_enum
+
+[![Build Status](https://travis-ci.org/dmolesUC3/typesafe_enum.png?branch=master)](https://travis-ci.org/dmolesUC3/typesafe_enum)
+[![Code Climate](https://codeclimate.com/github/dmolesUC3/typesafe_enum.png)](https://codeclimate.com/github/dmolesUC3/typesafe_enum)
+[![Inline docs](http://inch-ci.org/github/dmolesUC3/typesafe_enum.png)](http://inch-ci.org/github/dmolesUC3/typesafe_enum)
+[![Gem Version](https://img.shields.io/gem/v/typesafe_enum.svg)](https://github.com/dmolesUC3/typesafe_enum/releases)
+
+A Ruby implementation of Joshua Bloch's
+[typesafe enum pattern](http://www.oracle.com/technetwork/java/page1-139488.html#replaceenums),
+with syntax loosely inspired by [Ruby::Enum](https://github.com/dblock/ruby-enum).
+
+## Basic usage
+
+Create a new enum class and a set of instances:
+
+```ruby
+require 'typesafe_enum'
+
+class Suit < TypesafeEnum::Base
+  new :CLUBS
+  new :DIAMONDS
+  new :HEARTS
+  new :SPADES
+end
+```
+
+A constant is declared for each instance, with the key symbol as its
+value:
+
+```ruby
+Suit::CLUBS
+# => #<Suit:0x007fe9b3ba2698 @key=:CLUBS, @value="clubs", @ord=0>
+```
+
+By default, the `value` of an instance is its `key` symbol, lowercased:
+
+```ruby
+Suit::CLUBS.key
+# => :CLUBS
+Suit::CLUBS.value
+# => 'clubs'
+```
+
+But you can also declare an explicit `value`:
+
+```ruby
+class Tarot < TypesafeEnum::Base
+  new :CUPS, 'Cups'
+  new :COINS, 'Coins'
+  new :WANDS, 'Wands'
+  new :SWORDS, 'Swords'
+end
+
+Tarot::CUPS.value
+# => 'Cups'
+```
+
+And `values` need not be strings:
+
+```ruby
+class Scale < TypesafeEnum::Base
+  new :DECA, 10
+  new :HECTO, 100
+  new :KILO, 1_000
+  new :MEGA, 1_000_000
+end
+
+Scale::KILO.value
+# => 1000
+```
+
+## Ordering
+
+Enum instances have an ordinal value corresponding to their declaration
+order:
+
+```ruby
+Suit::SPADES.ord
+# => 3
+```
+
+And enum instances are comparable (within a type) based on that order:
+
+```ruby
+Suit::SPADES.is_a?(Comparable)
+# => true
+Suit::SPADES > Suit::DIAMONDS
+# => true
+Suit::SPADES > Tarot::CUPS
+# ArgumentError: comparison of Suit with Tarot failed
+```
+
+## Convenience methods on enum classes
+
+### `::to_a`
+
+Returns an array of the enum instances in declaration order:
+
+```ruby
+Tarot.to_a
+# => [#<Tarot:0x007fd4db30eca8 @key=:CUPS, @value="Cups", @ord=0>, #<Tarot:0x007fd4db30ebe0 @key=:COINS, @value="Coins", @ord=1>, #<Tarot:0x007fd4db30eaf0 @key=:WANDS, @value="Wands", @ord=2>, #<Tarot:0x007fd4db30e9b0 @key=:SWORDS, @value="Swords", @ord=3>]
+```
+
+### `::size`
+
+Returns the number of enum instances:
+
+```ruby
+Suit.size
+# => 4
+```
+
+### `::each`, `::each_with_index`, and `::map`
+
+Iterate over the set of enum instances:
+
+```ruby
+Suit.each { |s| puts s.value }
+# clubs
+# diamonds
+# hearts
+# spades
+
+Suit.each_with_index { |s, i| puts "#{i}: #{s.key}" }
+# 0: CLUBS
+# 1: DIAMONDS
+# 2: HEARTS
+# 3: SPADES
+
+Suit.map(&:value)
+# => ["clubs", "diamonds", "hearts", "spades"]
+```
+
+### `::find_by_key`, `::find_by_value`, `::find_by_ord`
+
+Look up an enum instance based on its key, value, or ordinal:
+
+```ruby
+Tarot.find_by_key(:CUPS)
+# => #<Tarot:0x007faab19fda40 @key=:CUPS, @value="Cups", @ord=0>
+Tarot.find_by_value('Wands')
+# => #<Tarot:0x007faab19fd8b0 @key=:WANDS, @value="Wands", @ord=2>
+Tarot.find_by_ord(3)
+# => #<Tarot:0x007faab19fd810 @key=:SWORDS, @value="Swords", @ord=3>
+```
+
+## Enum classes with methods
+
+Enum classes can have methods, and other non-enum constants:
+
+```ruby
+class Suit < TypesafeEnum::Base
+  new :CLUBS
+  new :DIAMONDS
+  new :HEARTS
+  new :SPADES
+
+  ALL_PIPS = %w(♣ ♦ ♥ ♠)
+
+  def pip
+    ALL_PIPS[self.ord]
+  end
+end
+
+Suit::ALL_PIPS
+# => ["♣", "♦", "♥", "♠"]
+
+Suit::CLUBS.pip
+# => "♣"
+
+Suit.map(&:pip)
+# => ["♣", "♦", "♥", "♠"]
+```
+
+## Enum instances with methods
+
+Enum instances can declare their own methods via `instance_eval`:
+
+```ruby
+class Operation < TypesafeEnum::Base
+  new(:PLUS, '+').instance_eval do
+    def eval(x, y)
+      x + y
+    end
+  end
+  new(:MINUS, '-').instance_eval do
+    def eval(x, y)
+      x - y
+    end
+  end
+end
+
+Operation::PLUS.eval(11, 17)
+# => 28
+
+Operation::MINUS.eval(28, 11)
+# => 17
+
+Operation.map { |op| op.eval(39, 23) }
+# => [62, 16]
+```
+
+## How is this different from [Ruby::Enum](https://github.com/dblock/ruby-enum)?
+
+[Ruby::Enum](https://github.com/dblock/ruby-enum) is much closer to the classic
+[C enumeration](https://www.gnu.org/software/gnu-c-manual/gnu-c-manual.html#Enumerations)
+as seen in C, [C++](https://msdn.microsoft.com/en-us/library/2dzy4k6e.aspx),
+[C#](https://msdn.microsoft.com/en-us/library/sbbt4032.aspx), and
+[Objective-C](https://developer.apple.com/library/ios/releasenotes/ObjectiveC/ModernizationObjC/AdoptingModernObjective-C/AdoptingModernObjective-C.html#//apple_ref/doc/uid/TP40014150-CH1-SW6).
+In C and most C-like languages, an `enum` is simply a valued set of `int` values
+(though C++ and others require an explicit cast to assign an `enum` value to
+an `int` variable).
+
+Similarly, a `Ruby::Enum` class is simply a valued set of values of any type,
+with convenience methods for iterating over the set. Usually the values are
+strings, but they can be of any type.
+
+```ruby
+# String enum
+class Foo
+  include Ruby::Enum
+
+  new :BAR, 'bar'
+  new :BAZ, 'baz'
+end
+
+Foo::BAR
+#  => "bar"
+Foo::BAR == 'bar'
+# => true
+
+# Integer enum
+class Bar
+  include Ruby::Enum
+
+  new :BAR, 1
+  new :BAZ, 2
+end
+
+Bar::BAR
+#  => "bar"
+Bar::BAR == 1
+# => true
+```
+
+Java introduced the concept of "typesafe enums", first as a
+[design pattern]((http://www.oracle.com/technetwork/java/page1-139488.html#replaceenums))
+and later as a
+[first-class language construct](https://docs.oracle.com/javase/1.5.0/docs/guide/language/enums.html).
+In Java, an `Enum` class news a closed, valued set of _instances of that class,_ rather than
+of a primitive type such as an `int`, and those instances have all the features of other objects,
+such as methods, fields, and type membership. Likewise, a `TypesafeEnum` class news a valued set
+of instances of that class, rather than of a set of some other type.
+
+```ruby
+Suit::CLUBS.is_a?(Suit)
+# => true
+Tarot::CUPS == 'Cups'
+# => false
+```
+
+## How is this different from [java.lang.Enum](http://docs.oracle.com/javase/8/docs/api/java/lang/Enum.html)?
+
+*[TODO: details]*
+
+### Clunkier syntax
+
+### No special `switch`/`case` support
+
+### No serialization support
+
+  - but `#==`, `#hash` etc. are `Marshal`-safe
+
+### No support classes like [`EnumSet`](http://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html) and
+  [`EnumMap`](http://docs.oracle.com/javase/8/docs/api/java/util/EnumMap.html)
+
+### Enum classes are not closed
+
+It's Ruby, so even though `:new` is private to each enum class, you
+can always work around that:
+
+```ruby
+Suit.send(:new, :JOKERS)
+# => #<Suit:0x007fc9e44e4778 @key=:JOKERS, @value="jokers", @ord=4>
+Suit.map(&:key)
+# => [:CLUBS, :DIAMONDS, :HEARTS, :SPADES, :JOKERS]
+Suit.size
+# => 5
+```
+
+### *[Other limitations...]*

data/Rakefile

@@ -0,0 +1,49 @@
+# ------------------------------------------------------------
+# RSpec
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+namespace :spec do
+
+  desc 'Run all unit tests'
+  RSpec::Core::RakeTask.new(:unit) do |task|
+    task.rspec_opts = %w(--color --format documentation --order default)
+    task.pattern = 'unit/**/*_spec.rb'
+  end
+
+  task all: [:unit]
+end
+
+desc 'Run all tests'
+task spec: 'spec:all'
+
+# ------------------------------------------------------------
+# Coverage
+
+desc 'Run all unit tests with coverage'
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task['spec:unit'].execute
+end
+
+# ------------------------------------------------------------
+# RuboCop
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+# ------------------------------------------------------------
+# TODOs
+
+desc 'List TODOs (from spec/todo.rb)'
+RSpec::Core::RakeTask.new(:todo) do |task|
+  task.rspec_opts = %w(--color --format documentation --order default)
+  task.pattern = 'todo.rb'
+end
+
+# ------------------------------------------------------------
+# Defaults
+
+desc 'Run unit tests, check test coverage, run acceptance tests, check code style'
+task default: [:coverage, :rubocop]

data/lib/typesafe_enum/base.rb

@@ -0,0 +1,133 @@
+# A Ruby implementation of Joshua Bloch's
+# [typesafe enum pattern](http://www.oracle.com/technetwork/java/page1-139488.html#replaceenums)
+module TypesafeEnum
+  # Base class for typesafe enum classes.
+  class Base
+    include Comparable
+
+    class << self
+
+      # Returns an array of the enum instances in declaration order
+      def to_a
+        as_array.dup
+      end
+
+      # Returns the number of enum instances
+      def size
+        as_array ? as_array.length : 0
+      end
+
+      # Iterates over the set of enum instances
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      # Iterates over the set of enum instances
+      def each_with_index(&block)
+        to_a.each_with_index(&block)
+      end
+
+      # Iterates over the set of enum instances
+      def map(&block)
+        to_a.map(&block)
+      end
+
+      # Looks up an enum instance based on its key
+      def find_by_key(key)
+        by_key[key]
+      end
+
+      # Looks up an enum instance based on its value
+      def find_by_value(value)
+        by_value[value]
+      end
+
+      # Looks up an enum instance based on its ordinal
+      def find_by_ord(ord)
+        return nil if ord < 0 || ord > size
+        as_array[ord]
+      end
+
+      private
+
+      attr_accessor :by_key
+      attr_accessor :by_value
+      attr_accessor :as_array
+
+      def undefine_class
+        enclosing_module = Module.nesting.last
+        class_value = name.split('::').last || ''
+        enclosing_module.send(:remove_const, class_value)
+      end
+
+      def register(instance)
+        ensure_registries
+        key, value = valid_key_and_value(instance)
+
+        by_key[key] = instance
+        by_value[value] = instance
+        as_array << instance
+        const_set(key.to_s, instance)
+      end
+
+      def ensure_registries
+        self.by_key ||= {}
+        self.by_value ||= {}
+        self.as_array ||= []
+      end
+
+      def valid_key_and_value(instance)
+        key = instance.key
+        value = instance.value
+
+        begin
+          fail NameError, "#{name}::#{key} already exists" if find_by_key(key)
+          fail NameError, "A #{name} instance with value '#{value}' already exists" if find_by_value(value)
+        rescue NameError => e
+          undefine_class
+          raise e
+        end
+
+        [key, value]
+      end
+
+    end
+
+    # The symbol key for the enum instance
+    attr_reader :key
+    # The value encapsulated by the enum instance
+    attr_reader :value
+    # The ordinal of the enum instance, in declaration order
+    attr_reader :ord
+
+    # Compares two instances of the same enum class based on their declaration order
+    def <=>(other)
+      ord <=> other.ord if self.class == other.class
+    end
+
+    # Generates a Fixnum hash value for this enum instance
+    def hash
+      @hash ||= begin
+        result = 17
+        result = 31 * result + self.class.hash
+        result = 31 * result + ord
+        result.is_a?(Fixnum) ? result : result.hash
+      end
+    end
+
+    private
+
+    def initialize(key, value = nil)
+      fail TypeError, "#{key} is not a symbol" unless key.is_a?(Symbol)
+      @key = key
+      @value = value || key.to_s.downcase
+      @ord = self.class.size
+      self.class.class_exec(self) do |instance|
+        register(instance)
+      end
+    end
+
+    private_class_method :new
+
+  end
+end

data/lib/typesafe_enum/module_info.rb

@@ -0,0 +1,10 @@
+module TypesafeEnum
+  # The name of this gem
+  NAME = 'typesafe_enum'
+
+  # The version of this gem
+  VERSION = '0.1.0'
+
+  # The copyright notice for this gem
+  COPYRIGHT = 'Copyright (c) 2015 The Regents of the University of California'
+end

data/lib/typesafe_enum.rb

@@ -0,0 +1,3 @@
+module TypesafeEnum
+  Dir.glob(File.expand_path('../typesafe_enum/*.rb', __FILE__)).sort.each(&method(:require))
+end

data/spec/.rubocop.yml

@@ -0,0 +1,7 @@
+inherit_from: ../.rubocop.yml
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+# ------------------------------------------------------------
+# SimpleCov setup
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  require 'simplecov-console'
+
+  SimpleCov.minimum_coverage 100
+  SimpleCov.start do
+    add_filter '/spec/'
+    SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::Console,
+    ]
+  end
+end
+
+# ------------------------------------------------------------
+# Rspec configuration
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+  config.mock_with :rspec
+end
+
+# ------------------------------------------------------------
+# TypesafeEnum
+
+require 'typesafe_enum'

data/spec/unit/typesafe_enum/base_spec.rb

@@ -0,0 +1,370 @@
+# coding: UTF-8
+require 'spec_helper'
+
+class Suit < TypesafeEnum::Base
+  new :CLUBS
+  new :DIAMONDS
+  new :HEARTS
+  new :SPADES
+end
+
+class Tarot < TypesafeEnum::Base
+  new :CUPS, 'Cups'
+  new :COINS, 'Coins'
+  new :WANDS, 'Wands'
+  new :SWORDS, 'Swords'
+end
+
+module TypesafeEnum
+  describe Base do
+
+    describe ':: new' do
+      it ' news a constant enum value' do
+        enum = Suit::CLUBS
+        expect(enum).to be_a(Suit)
+      end
+
+      it 'insists symbols be symbols' do
+        expect do
+          class Cheat < Base
+            new 'spades', 'spades'
+          end
+        end.to raise_error(TypeError)
+      end
+
+      it 'insists symbols be uppercase' do
+        expect do
+          class Cheat < Base
+            new :spades, 'spades'
+          end
+        end.to raise_error(NameError)
+      end
+
+      it 'disallows duplicate symbols' do
+        expect do
+          class Cheat < Base
+            new :SPADES, 'spades'
+            new :SPADES, 'more spades'
+          end
+        end.to raise_error(NameError)
+
+        expect { Cheat.class }.to raise_error(NameError)
+      end
+
+      it 'disallows duplicate values' do
+        expect do
+          class Cheat < Base
+            new :SPADES, 'spades'
+            new :ALSO_SPADES, 'spades'
+          end
+        end.to raise_error(NameError)
+
+        expect { Cheat.class }.to raise_error(NameError)
+      end
+
+      it 'defaults the value to a lower-cased version of the symbol' do
+        expect(Suit::CLUBS.value).to eq('clubs')
+        expect(Suit::DIAMONDS.value).to eq('diamonds')
+        expect(Suit::HEARTS.value).to eq('hearts')
+        expect(Suit::SPADES.value).to eq('spades')
+      end
+
+      it 'is private' do
+        expect { Tarot.new(:PENTACLES) }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe '::to_a' do
+      it 'returns the values as an array' do
+        expect(Suit.to_a).to eq([Suit::CLUBS, Suit::DIAMONDS, Suit::HEARTS, Suit::SPADES])
+      end
+      it 'returns a copy' do
+        array = Suit.to_a
+        array.clear
+        expect(array.empty?).to eq(true)
+        expect(Suit.to_a).to eq([Suit::CLUBS, Suit::DIAMONDS, Suit::HEARTS, Suit::SPADES])
+      end
+    end
+
+    describe '::size' do
+      it 'returns the number of enum instnaces' do
+        expect(Suit.size).to eq(4)
+      end
+    end
+
+    describe '::each' do
+      it 'iterates the enum values' do
+        expected = [Suit::CLUBS, Suit::DIAMONDS, Suit::HEARTS, Suit::SPADES]
+        index = 0
+        Suit.each do |s|
+          expect(s).to be(expected[index])
+          index += 1
+        end
+      end
+    end
+
+    describe '::each_with_index' do
+      it 'iterates the enum values with indices' do
+        expected = [Suit::CLUBS, Suit::DIAMONDS, Suit::HEARTS, Suit::SPADES]
+        Suit.each_with_index do |s, index|
+          expect(s).to be(expected[index])
+        end
+      end
+    end
+
+    describe '::map' do
+      it 'maps enum values' do
+        all_keys = Suit.map(&:key)
+        expect(all_keys).to eq([:CLUBS, :DIAMONDS, :HEARTS, :SPADES])
+      end
+    end
+
+    describe '#<=>' do
+      it 'orders enum instances' do
+        Suit.each_with_index do |s1, i1|
+          Suit.each_with_index do |s2, i2|
+            expect(s1 <=> s2).to eq(i1 <=> i2)
+          end
+        end
+      end
+    end
+
+    describe '#==' do
+      it 'returns true for identical instances, false otherwise' do
+        Suit.each do |s1|
+          Suit.each do |s2|
+            identical = s1.equal?(s2)
+            expect(s1 == s2).to eq(identical)
+          end
+        end
+      end
+
+      it 'reports instances as unequal to nil and other objects' do
+        a_nil_value = nil
+        Suit.each do |s|
+          expect(s.nil?).to eq(false)
+          expect(s == a_nil_value).to eq(false)
+          Tarot.each do |t|
+            expect(s == t).to eq(false)
+            expect(t == s).to eq(false)
+          end
+        end
+      end
+
+      it 'survives marshalling' do
+        Suit.each do |s1|
+          dump = Marshal.dump(s1)
+          s2 = Marshal.load(dump)
+          expect(s1 == s2).to eq(true)
+          expect(s2 == s1).to eq(true)
+        end
+      end
+    end
+
+    describe '#!=' do
+      it 'returns false for identical instances, true otherwise' do
+        Suit.each do |s1|
+          Suit.each do |s2|
+            different = !s1.equal?(s2)
+            expect(s1 != s2).to eq(different)
+          end
+        end
+      end
+
+      it 'reports instances as unequal to nil and other objects' do
+        a_nil_value = nil
+        Suit.each do |s|
+          expect(s != a_nil_value).to eq(true)
+          Tarot.each do |t|
+            expect(s != t).to eq(true)
+            expect(t != s).to eq(true)
+          end
+        end
+      end
+    end
+
+    describe '#hash' do
+      it 'gives consistent values' do
+        Suit.each do |s1|
+          Suit.each do |s2|
+            expect(s1.hash == s2.hash).to eq(s1 == s2)
+          end
+        end
+      end
+
+      it 'returns different values for different types' do
+        class Suit2 < Base
+          new :CLUBS, 'Clubs'
+          new :DIAMONDS, 'Diamonds'
+          new :HEARTS, 'Hearts'
+          new :SPADES, 'Spades'
+        end
+
+        Suit.each do |s1|
+          s2 = Suit2.find_by_key(s1.key)
+          expect(s1.hash == s2.hash).to eq(false)
+        end
+      end
+
+      it 'survives marshalling' do
+        Suit.each do |s1|
+          dump = Marshal.dump(s1)
+          s2 = Marshal.load(dump)
+          expect(s2.hash).to eq(s1.hash)
+        end
+      end
+
+      it 'always returns a Fixnum' do
+        Suit.each do |s1|
+          expect(s1.hash).to be_a(Fixnum)
+        end
+      end
+    end
+
+    describe '#eql?' do
+      it 'is consistent with #hash' do
+        Suit.each do |s1|
+          Suit.each do |s2|
+            expect(s1.eql?(s2)).to eq(s1.hash == s2.hash)
+          end
+        end
+      end
+    end
+
+    describe '#value' do
+      it 'returns the string value of the enum instance' do
+        expected = %w(clubs diamonds hearts spades)
+        Suit.each_with_index do |s, index|
+          expect(s.value).to eq(expected[index])
+        end
+      end
+    end
+
+    describe '#key' do
+      it 'returns the symbol key of the enum instance' do
+        expected = [:CLUBS, :DIAMONDS, :HEARTS, :SPADES]
+        Suit.each_with_index do |s, index|
+          expect(s.key).to eq(expected[index])
+        end
+      end
+    end
+
+    describe '#ord' do
+      it 'returns the ord value of the enum instance' do
+        Suit.each_with_index do |s, index|
+          expect(s.ord).to eq(index)
+        end
+      end
+    end
+
+    describe '::find_by_key' do
+      it 'maps symbol keys to enum instances' do
+        keys = [:CLUBS, :DIAMONDS, :HEARTS, :SPADES]
+        expected = Suit.to_a
+        keys.each_with_index do |k, index|
+          expect(Suit.find_by_key(k)).to be(expected[index])
+        end
+      end
+
+      it 'returns nil for invalid keys' do
+        expect(Suit.find_by_key(:WANDS)).to be_nil
+      end
+    end
+
+    describe '::find_by_value' do
+      it 'maps values to enum instances' do
+        values = %w(clubs diamonds hearts spades)
+        expected = Suit.to_a
+        values.each_with_index do |n, index|
+          expect(Suit.find_by_value(n)).to be(expected[index])
+        end
+      end
+
+      it 'returns nil for invalid values' do
+        expect(Suit.find_by_value('wands')).to be_nil
+      end
+
+      it 'supports enums with symbol values' do
+        class RGBColors < Base
+          new :RED, :red
+          new :GREEN, :green
+          new :BLUE, :blue
+        end
+
+        RGBColors.each do |c|
+          expect(RGBColors.find_by_value(c.value)).to be(c)
+        end
+      end
+
+      it 'supports enums with integer values' do
+        class Scale < Base
+          new :DECA, 10
+          new :HECTO, 100
+          new :KILO, 1_000
+          new :MEGA, 1_000_000
+        end
+
+        Scale.each do |s|
+          expect(Scale.find_by_value(s.value)).to be(s)
+        end
+      end
+    end
+
+    describe '::find_by_ord' do
+
+      it 'maps ordinal indices to enum instances' do
+        Suit.each do |s|
+          expect(Suit.find_by_ord(s.ord)).to be(s)
+        end
+      end
+
+      it 'returns nil for negative indices' do
+        expect(Suit.find_by_ord(-1)).to be_nil
+      end
+
+      it 'returns nil for out-of-range indices' do
+        expect(Suit.find_by_ord(Suit.size)).to be_nil
+      end
+
+      it 'returns nil for invalid indices' do
+        expect(Suit.find_by_ord(100)).to be_nil
+      end
+    end
+
+    it 'supports case statements' do
+      def pip(suit)
+        case suit
+        when Suit::CLUBS
+          '♣'
+        when Suit::DIAMONDS
+          '♦'
+        when Suit::HEARTS
+          '♥'
+        when Suit::SPADES
+          '♠'
+        else
+          fail "unknown suit: #{self}"
+        end
+      end
+
+      expect(Suit.map { |s| pip(s) }).to eq(%w(♣ ♦ ♥ ♠))
+    end
+
+    it 'supports "inner class" methods via instance_eval' do
+      class Operation < Base
+        new(:PLUS, '+').instance_eval do
+          def eval(x, y)
+            x + y
+          end
+        end
+        new(:MINUS, '-').instance_eval do
+          def eval(x, y)
+            x - y
+          end
+        end
+      end
+
+      expect(Operation.map { |op| op.eval(39, 23) }).to eq([39 + 23, 39 - 23])
+    end
+  end
+end

data/typesafe_enum.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'uri'
+require 'typesafe_enum/module_info'
+
+Gem::Specification.new do |spec|
+  spec.name          = TypesafeEnum::NAME
+  spec.version       = TypesafeEnum::VERSION
+  spec.authors       = ['David Moles']
+  spec.email         = ['david.moles@ucop.edu']
+  spec.summary       = 'Typesafe enum pattern for Ruby'
+  spec.description   = 'A gem that implements the typesafe enum pattern in Ruby'
+  spec.license       = 'MIT'
+
+  origin_uri = URI(`git config --get remote.origin.url`.chomp)
+  spec.homepage = URI::HTTP.build(host: origin_uri.host, path: origin_uri.path.chomp('.git')).to_s
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.4'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'simplecov', '~> 0.9.2'
+  spec.add_development_dependency 'simplecov-console', '~> 0.2.0'
+  spec.add_development_dependency 'rubocop', '~> 0.32.1'
+  spec.add_development_dependency 'yard', '~> 0.8'
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: typesafe_enum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Moles
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.32.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.32.1
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: A gem that implements the typesafe enum pattern in Ruby
+email:
+- david.moles@ucop.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- ".yardopts"
+- CHANGES.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/typesafe_enum.rb
+- lib/typesafe_enum/base.rb
+- lib/typesafe_enum/module_info.rb
+- spec/.rubocop.yml
+- spec/spec_helper.rb
+- spec/unit/typesafe_enum/base_spec.rb
+- typesafe_enum.gemspec
+homepage: http://github.com/dmolesUC3/typesafe_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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Typesafe enum pattern for Ruby
+test_files:
+- spec/.rubocop.yml
+- spec/spec_helper.rb
+- spec/unit/typesafe_enum/base_spec.rb
+has_rdoc: