iron-enum 1.0.0

data/.rspec

@@ -0,0 +1 @@
+--require <%= File.join(File.expand_path(File.dirname(__FILE__)), 'spec', 'spec_helper.rb') %>

data/History.txt

@@ -0,0 +1,7 @@
+== 1.0.0 / 2013-03-23
+
+* Initial revision
+* Support declaring enums using #enum
+* Support enum attributes using #enum_attr
+* ActiveRecord support for automatic scope creation and pretty inspects
+* Add to GitHub

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Irongaze Consulting LLC
+
+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.rdoc

@@ -0,0 +1,93 @@
+= GEM: iron-enum
+
+Written by Rob Morris @ Irongaze Consulting LLC (http://irongaze.com)
+
+== DESCRIPTION
+
+Add support for rich enum values (enumerated constants) to Ruby/Rails.
+
+== SYNOPSIS
+
+Managing constants - status flags, system states, etc - is frustrating when working
+with Ruby and Rails.  The canonical solution is to use class constants.  But doing so
+leaves a lot to be desired.  This gem provides a much more Ruby-like way of dealing
+with magic constants, that provides symbol/key-based lookup, automatic conversion between
+keys and values, user-friendly naming, Rails integration, attribute support, and more.
+
+To use:
+
+    # Require the gem's classes (not needed if using Bundler)
+    require 'iron/enum'  
+
+    # Declare an enum module.  In this case, let's say we're working on a
+    # shopping cart system that tracks orders.  Orders have a status - perfect
+    # place for an enumeration!
+    module OrderStatus
+      enum :created,   1
+      enum :cancelled, 2, 'No Sale'
+      enum :purchased, 3
+      enum :shipped,   4
+      enum :returned,  5
+    end
+
+    # Once you have your enum set up, there are a host of things you can do
+    # To start with, enums set up normal Ruby class constants
+    >> puts OrderStatus::PURCHASED
+    => 3
+    
+    # But you can also refer to them with symbolic keys
+    >> puts OrderStatus.value(:purchased)
+    => 3
+    
+    # You can convert between values, keys and text
+    >> OrderStatus.value(:shipped)
+    => 4
+    >> OrderStatus.name(:shipped)
+    => 'Shipped'
+    >> OrderStatus.key(4)
+    => :shipped
+    
+    # Validate values against the set of good values
+    >> OrderStatus.valid?(10)
+    => false
+    
+    # Get an array of all valid values
+    >> OrderStatus.values
+    => [1, 2, 3, 4, 5]
+    # Get a selection of values by key
+    >> OrderStatus.values(:created, :cancelled, :returned)
+    => [1, 2, 5]
+    
+    # This is all handy, but where enums really shine is as declared attributes
+    class Order < ActiveRecord::Base
+      enum_attr :status => OrderStatus
+    end
+    
+    # Now you can set a value using a key
+    >> @order = Order.new
+    >> @order.status = :shipped
+    => 4
+    # Test for a given value with a clear syntax
+    >> @order.status_returned?
+    => false
+    # Set a value
+    >> @order.status_returned!
+    => 5
+    
+    # You even get free scoping
+    >> Order.with_status(:shipped)
+    => [...all orders with status == 4...]
+    
+== REQUIREMENTS
+
+None, though you'll need rspec, sqlite3 and active_record gems to test and build the gem
+
+== INSTALL
+
+To install, simply run:
+
+    sudo gem install iron-enum
+    
+RVM users can skip the sudo:
+  
+    gem install iron-enum

data/Version.txt

@@ -0,0 +1 @@
+1.0.0

data/lib/iron/enum/attr_support.rb

@@ -0,0 +1,141 @@
+module Enum
+
+  # Provides helper methods to integrate enumerated constants (Enum) into your model layer.  Given an enum
+  # defined like so:
+  #
+  #   module UserType
+  #     enum :guest,  0
+  #     enum :member, 1
+  #     enum :admin,  2
+  #   end 
+  #
+  # To add an enumerated value to a Rails model, simply add a column of type :integer to your model, then
+  # declare it like so:
+  #
+  #   class User < ActiveRecord::Base
+  #     enum_attr :user_type => UserType
+  #   end
+  #
+  # When using non-model classes, it's the same syntax:
+  #
+  #   class User
+  #     enum_attr :user_type => UserType
+  #   end
+  #
+  # This will tell your class/model that the user_type attribute contains values from the UserType enum, and
+  # will add:
+  #
+  #   @user.user_type => integer value or nil
+  #   @user.user_type_admin? => true if object's user_type value == UserType::ADMIN
+  #   @user.user_type_admin! => set the object's user_type to be UserType::ADMIN (does not save model!)
+  #   @user.user_type_as_key => returns the key form of the current field value, eg :member
+  #   @user.user_type_as_name => returns text name of the current field's value, eg 'Guest'
+  #
+  # In addition, you can set enum attributes via key, eg:
+  #
+  #   @user.user_type = :admin
+  #
+  # and the key will be converted to a value on the fly.
+  #
+  # ActiveRecord models get a few extras.  To start, each enum attribute will add a smart scope:
+  #
+  #   User.with_user_type(UserType::MEMBER) => scope returning a relation selecting User instances where user_type's value == UserType::MEMBER
+  #
+  # In addition, enum attributes will show up in #inspect output as e.g. UserType::GUEST instead of 0.
+  module AttrSupport
+
+    # Call with enum_attr :field => Enum
+    def enum_attr(name_to_enum_map)
+      # Save off the attr map
+      @enum_attrs ||= {}
+      @enum_attrs.merge!(name_to_enum_map)
+
+      # Run each newly added enum attribute
+      name_to_enum_map.each_pair do |attr_name, enum|
+        # Convert Enum to "Enum"
+        enum_klass = enum.to_s
+
+        # Set up general use sugar - allows calling:
+        #   attr_as_key to get back eg :production or :online instead of 1 or 5
+        #   attr_as_name to get back eg "Production" or "Online"
+        class_eval <<-eos, __FILE__, __LINE__ + 1
+          def #{attr_name}_as_key
+            #{enum_klass}.key(self.#{attr_name})
+          end
+
+          def #{attr_name}_as_name
+            #{enum_klass}.name(self.#{attr_name})
+          end
+        eos
+
+        # Get all the possible values for this enum in :key format (ie as symbols)
+        enum.keys.each do |key|
+          # Get the value for this key (ie in integer format)
+          val = enum.value(key)
+
+          # Build sugar for testing and setting the attribute's enumerated value
+          class_eval <<-eos, __FILE__, __LINE__ + 1
+            def #{attr_name}_#{key}?
+              self.#{attr_name} == #{val}
+            end
+
+            def #{attr_name}_#{key}!
+              self.#{attr_name} = #{val}
+            end
+          eos
+        end
+
+        if defined?(ActiveRecord) && self < ActiveRecord::Base
+
+          # Define a finder scope
+          scope "with_#{attr_name}", lambda {|*vals|
+            vals.flatten!
+            if vals.empty?
+              where("?", false)
+            elsif vals.count == 1
+              where(attr_name => enum.value(vals.first))
+            else
+              where(attr_name => enum.values(vals))
+            end
+          }
+
+          # Override default setter to allow setting an enum attribute via key
+          class_eval <<-eos, __FILE__, __LINE__ + 1
+            def #{attr_name}=(val)
+              write_attribute(:#{attr_name}, #{enum_klass}.value(val))
+            end
+          eos
+
+        else 
+
+          # Create getter/setter to allow setting an enum attribute via key
+          class_eval <<-eos, __FILE__, __LINE__ + 1
+            def #{attr_name}
+              @#{attr_name}
+            end
+
+            def #{attr_name}=(val)
+              @#{attr_name} = #{enum_klass}.value(val)
+            end
+          eos
+
+        end
+
+      end
+    end
+
+    # True if the given symbol maps to an enum-backed attribute
+    def enum_attr?(name)
+      return false unless @enum_attrs
+      @enum_attrs.key?(name)
+    end
+
+    # Gets the enum class for a given attribute, or nil for none
+    def enum_for_attr(name)
+      return nil unless @enum_attrs
+      @enum_attrs[name]
+    end
+
+  end
+  
+end

data/lib/iron/enum/core.rb

@@ -0,0 +1,101 @@
+module Enum
+  module Core
+    
+    # List of enum data used for all other enum methods
+    def enum_list
+      @enum_list ||= []
+      @enum_list
+    end
+
+    # Value for a given key or value
+    def value(key)
+      return nil if key.nil?
+      row_for(key)[VALUE_IDX]
+    end
+
+    # Convert array of keys to an array of values
+    def values(*included)
+      rows_for(*included).collect {|row| row[VALUE_IDX]}
+    end
+
+    # True if a valid value (not key!), false if not
+    def valid_value?(val)
+      return values.include?(val)
+    end
+
+    # Key for a given key or value
+    def key(key)
+      return nil if key.nil?
+      row_for(key)[KEY_IDX]
+    end
+
+    # Convert an array of values into an array of keys
+    def keys(*included)
+      rows_for(*included).collect {|row| row[KEY_IDX]}
+    end
+
+    # Name for a given key/value
+    def name(key = :_no_value_)
+      return nil if key.nil?
+      return super() if key == :_no_value_
+      row_for(key)[NAME_IDX]
+    end
+
+    # Convert arrays of keys/values into an array of names
+    def names(*included)
+      rows_for(*included).collect {|row| row[NAME_IDX]}
+    end
+
+    # Used for select tag options, optionally pass set of keys/ids to include, eg if there are only
+    # a subset that would be valid for selection in a given context.
+    def options(*included)
+      included.flatten!
+      if included.empty?
+        # All options
+        enum_list.collect {|row| option_for(row.first)}
+      else
+        # Only the specified ones
+        included.collect {|key| option_for(key)}.compact
+      end
+    end
+
+    # Array in order required by select fields
+    def option_for(key)
+      opt = [name(key), value(key)]
+    end
+
+    # Override inspect on the enum module to give a pretty listing
+    def inspect
+      values.collect do |v|
+        "#{self.to_s}::#{key(v).to_s.upcase} => #{v}"
+      end.join("\n")
+    end
+
+    private
+
+    def to_key(id)
+      return id if id.is_a?(Symbol)
+      row = enum_list.find {|row| row[VALUE_IDX] == id}
+      row.nil? ? nil : row[KEY_IDX]
+    end
+
+    def row_for(in_key)
+      key = to_key(in_key)
+      row = enum_list.find {|r| r[KEY_IDX] == key}
+      raise "No information on key [#{in_key.inspect}] in enum #{self}" unless row
+      row
+    end
+
+    def rows_for(*included)
+      included.flatten!
+      if included.empty?
+        # All enums
+        enum_list
+      else
+        # Only the specified ones
+        included.collect {|key| row_for(key)}.compact
+      end
+    end
+    
+  end
+end

data/lib/iron/enum/model_support.rb

@@ -0,0 +1,30 @@
+module Enum
+
+  # Provides ActiveRecord-specific functionality for enum attributes
+  module ModelSupport
+
+    # Provide pretty output of enumerated values in console, overrides
+    # Rails' internal method for doing the same for AR models generally.
+    def attribute_for_inspect(name)
+      # Convert to symbol and get our current value
+      name = name.to_sym
+      val = self.send(name)
+
+      # Check to see if we're non-nil and that this attribute is an enumeration attribute
+      if val && self.class.enum_attr?(name)
+        # Get the enum for this attribute
+        enum = self.class.enum_for_attr(name)
+        # Get the key version of the value
+        key = enum.key(val)
+        # Generate our pretty version in Enum::VALUE_KEY format
+        "#{enum.to_s}::#{key.to_s.upcase}"
+
+      else
+        # Not an enum attr or nil - fall back on standard implementation
+        super
+      end
+    end
+
+  end
+
+end

data/lib/iron/enum.rb

@@ -0,0 +1,77 @@
+# Provides enumerated value support for use as magic constants (status flags, types, etc...)
+#
+# Sample usage:
+#
+# Enum.enable_support(:all)
+# module Fruit
+#   enum :apple, 1
+#   enum :pear,  2
+# end
+#
+# Yields:
+#
+# Fruit::APPLE => 1
+# Fruit.name(1) => 'Apple'
+# Fruit.keys => [:apple, :pear]
+# etc...
+#
+module Enum
+
+  # Indexes into our definition list
+  KEY_IDX = 0
+  VALUE_IDX = 1
+  NAME_IDX = 2
+
+  # Legacy method of enum creation.  Call with a set of arrays, one for each desired enum.  Arrays should
+  # contain the parameters supported by #enum, e.g. [:key, <value>, "<optional name>"]
+  def define_enum(*items)
+    items.each do |item|
+      enum(*item)
+    end
+  end
+
+  # Add an enumerated constant to the given module/class.  The key should be a symbol, the value a fixed integer
+  # that the symbol represents.  The name is an optional user-friendly name for the enum, which will efault to
+  # a capitalized version of the key.
+  #
+  # Sample usage:
+  #
+  #   module HTTPCode
+  #     enum :success, 200
+  #     enum :missing, 404
+  #     enum :error,   500, 'Server Error'
+  #   end
+  def enum(key, value, name = nil)
+    # Make sure we have our enum stuff in here
+    self.extend(Enum::Core) unless respond_to?(:enum_list)
+
+    # Validate input
+    raise "Invalid enum key: #{key.inspect}" unless key.is_a?(Symbol)
+    raise "Invalid enum value: #{value.inspect}" unless value.is_a?(Fixnum)
+    raise "Invalid enum name: #{name.inspect}" unless name.nil? || name.is_a?(String)
+    
+    # Set our constant
+    const_set(key.to_s.upcase, value)
+    
+    # Ensure we have a valid name
+    name ||= key.to_s.split('_').collect(&:capitalize).join(' ')
+    
+    # Save to our list
+    enum_list << [key, value, name]
+  end
+
+end
+
+# Require additional files
+require_relative './enum/core'
+require_relative './enum/attr_support'
+require_relative './enum/model_support'
+
+# Bind to Module to enable #define_enum, #enum_attr and friends
+Module.send(:include, Enum)
+Module.send(:include, Enum::AttrSupport)
+
+# Add our ActiveRecord extensions if we're in Rails
+if defined?(ActiveRecord) 
+  ActiveRecord::Base.send(:include, Enum::ModelSupport)
+end

data/spec/enum/attr_spec.rb

@@ -0,0 +1,32 @@
+describe Enum do
+  describe 'using attributes' do
+    
+    module AttrTest
+      enum :first, 1
+      enum :second, 2
+    end
+    
+    class AttrClass
+      enum_attr :pos => AttrTest
+    end
+    
+    before do
+      @obj = AttrClass.new
+    end
+    
+    it 'should support declaring enum attributes' do
+      Module.should respond_to(:enum_attr)
+    end
+    
+    it 'should allow getting an attribute in key form' do
+      @obj.pos = AttrTest::SECOND
+      @obj.pos_as_key.should == :second
+    end
+    
+    it 'should allow getting an attribute in name form' do
+      @obj.pos = 1
+      @obj.pos_as_name.should == 'First'
+    end
+    
+  end
+end

data/spec/enum/enum_spec.rb

@@ -0,0 +1,29 @@
+describe Enum do
+
+  # Sample for use below, using old declaration syntax
+  class EnumTest
+    define_enum(
+      [:alpha, 5],
+      [:beta, 10, 'A label'],
+      [:gamma, 2]
+    )
+  end
+  
+  it 'should provide #define_enum and #enum on Module' do
+    Module.should respond_to(:define_enum)
+    Module.should respond_to(:enum)
+  end
+  
+  it 'should add enums to the enum list on calling #enum' do
+    count = EnumTest.enum_list.count
+    EnumTest.enum(:epsilon, 22)
+    EnumTest.enum_list.count.should == count + 1
+    EnumTest.value(:epsilon).should == 22
+  end
+  
+  it 'should test the validity of values' do
+    EnumTest.valid_value?(10).should be_true
+    EnumTest.valid_value?(555).should be_false
+  end
+
+end

data/spec/enum/key_spec.rb

@@ -0,0 +1,23 @@
+describe Enum do
+  describe 'with keys' do
+
+    module KeyTest
+      enum :key1, 10
+      enum :key2, 20
+      enum :key3, 5000
+    end
+    
+    it 'should set enum keys as constants' do
+      KeyTest::KEY1.should == 10
+    end
+    
+    it 'should convert values to keys' do
+      KeyTest.key(20).should == :key2
+    end
+    
+    it 'should return a list of all keys' do
+      KeyTest.keys.should == [:key1, :key2, :key3]
+    end
+
+  end
+end

data/spec/enum/model_spec.rb

@@ -0,0 +1,79 @@
+describe Enum do
+  describe 'model attributes' do
+    
+    module AREnum
+      enum :one, 1
+      enum :two, 2
+      enum :thirty_three, 33
+    end
+    
+    module AnotherEnum
+      enum :yo, 10
+      enum :bob, 20
+    end
+    
+    class ARTest < ActiveRecord::Base
+      enum_attr :enum_field => AREnum, :another_enum => AnotherEnum
+    end
+    
+    before do
+      @test = ARTest.new
+    end
+    
+    it 'should allow setting values by key' do
+      @test.enum_field = :two
+      @test.enum_field.should == 2
+    end
+    
+    it 'should allow testing for a given value via method call' do
+      @test.enum_field = AREnum::ONE
+      @test.enum_field_one?.should be_true
+    end
+    
+    it 'should allow setting a field to a value via method call' do
+      @test.enum_field_two!
+      @test.enum_field.should == 2
+    end
+    
+    it 'should show enum values in inspect as full definition' do
+      @test.enum_field = :two
+      @test.inspect.should match(/AREnum::TWO/)
+    end
+    
+    it 'should define a with_<enum field> scope' do
+      ARTest.should respond_to(:with_enum_field)
+    end
+    
+    it 'should find models with the provided scope' do
+      ARTest.delete_all
+      ARTest.create!(:enum_field => :two)
+      ARTest.create!(:enum_field => :two)
+      ARTest.with_enum_field(2).count.should == 2
+    end
+    
+    it 'should support multiple values in the automatic scope' do
+      ARTest.delete_all
+      ARTest.create!(:enum_field => :two)
+      ARTest.create!(:enum_field => 33)
+      ARTest.with_enum_field(2, :thirty_three).count.should == 2
+      ARTest.with_enum_field([2, :thirty_three]).count.should == 2
+    end
+    
+    it 'should return no models for empty scope' do
+      ARTest.delete_all
+      ARTest.create!(:enum_field => nil)
+      ARTest.create!(:enum_field => 2)
+      ARTest.with_enum_field([]).count.should == 0
+    end
+    
+    it 'should return models with null values for nil scope' do
+      ARTest.delete_all
+      ARTest.with_enum_field(nil).count.should == 0
+      ARTest.create!(:enum_field => nil)
+      ARTest.create!(:enum_field => 2)
+      ARTest.create!(:enum_field => 2)
+      ARTest.with_enum_field(nil).count.should == 1
+    end
+    
+  end
+end

data/spec/enum/name_spec.rb

@@ -0,0 +1,32 @@
+describe Enum do
+  describe 'using names' do
+    
+    # Sample for use below
+    module NameTest
+      enum :a_long_key, 1
+      enum :custom_name, 2, 'Wahoo'
+      enum :singleton, 3
+    end
+
+    it 'should return a name from a value' do
+      NameTest.name(3).should == 'Singleton'
+    end
+    
+    it 'should return all names in order' do
+      NameTest.names.should == ['A Long Key', 'Wahoo', 'Singleton']
+    end
+    
+    it 'should return a set of names from a set of keys or values' do 
+      NameTest.names(2, 1, :singleton).should == ['Wahoo', 'A Long Key', 'Singleton']
+    end
+    
+    it 'should return nil for the name of nil' do
+      NameTest.name(nil).should be_nil
+    end
+    
+    it 'should keep normal Module#name behavior' do
+      NameTest.name.should == 'NameTest'
+    end
+    
+  end
+end

data/spec/enum/option_spec.rb

@@ -0,0 +1,20 @@
+describe Enum do
+  describe 'using options' do
+    
+    # Sample for use below
+    module OptionTest
+      enum :alpha, 5
+      enum :beta,  10
+      enum :gamma, 20, 'Monkeys'
+    end
+
+    it 'should return name + values as options array' do
+      OptionTest.options.should == [['Alpha', 5], ['Beta', 10], ['Monkeys', 20]]
+    end
+    
+    it 'should enable getting options array subset' do
+      OptionTest.options(:gamma, :beta).should == [['Monkeys', 20], ['Beta', 10]]
+    end
+    
+  end
+end

data/spec/enum/value_spec.rb

@@ -0,0 +1,32 @@
+describe Enum do
+  describe 'using values' do
+
+    # Sample for use below
+    module ValueTest
+      enum :alpha, 5
+      enum :beta, 10, 'a label'
+      enum :gamma, 2
+    end
+
+    it 'should return a value as that value' do
+      ValueTest.value(5).should == 5
+    end
+  
+    it 'should convert keys to values' do
+      ValueTest.value(:beta).should == 10
+    end
+  
+    it 'should return nil for the value of nil' do
+      EnumTest.value(nil).should be_nil
+    end
+    
+    it 'should return all values' do
+      ValueTest.values.should == [5, 10, 2]
+    end
+    
+    it 'should return select values' do
+      ValueTest.values(:alpha, :gamma).should == [5, 2]
+    end
+  
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# Set up activerecord & in-memory SQLite DB
+require 'active_record'
+require 'sqlite3'
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+# Run a migration to create our test table
+ActiveRecord::Migration.create_table :ar_tests do |t|
+  t.integer 'enum_field'
+  t.integer 'another_enum'
+end
+
+# Require our library
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'iron', 'enum'))
+
+# Config RSpec options
+RSpec.configure do |config|
+  config.add_formatter 'documentation'
+  config.color = true
+  config.backtrace_clean_patterns = [/rspec/]
+end
+

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: iron-enum
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Rob Morris
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: active_record
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Adds enumerated constant value support to Ruby and Rails projects
+email:
+- rob@irongaze.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/iron/enum/attr_support.rb
+- lib/iron/enum/core.rb
+- lib/iron/enum/model_support.rb
+- lib/iron/enum.rb
+- spec/enum/attr_spec.rb
+- spec/enum/enum_spec.rb
+- spec/enum/key_spec.rb
+- spec/enum/model_spec.rb
+- spec/enum/name_spec.rb
+- spec/enum/option_spec.rb
+- spec/enum/value_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- History.txt
+- Version.txt
+- README.rdoc
+- .rspec
+homepage: http://irongaze.com
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Enum support for Ruby and Rails
+test_files: []