yinum 1.8.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91dd035ae18c028a192338197d8a66f85446f230
-  data.tar.gz: f2f97cb348e34639a03775b4e7106b05f455bf2e
+  metadata.gz: 1e8081295eac8fc84fd85a1d3be91ab25a0c38ea
+  data.tar.gz: b3e09fe7ab057e6d5376c7ff340604e5b1dd96a9
 SHA512:
-  metadata.gz: 8ff43e20151586d1eb18e8b59b4619aebe1038e3813515bd24c4ff3ca374800e3b92d1e5e93dbde62925aaa13a16c81df027dc9895179ba6c74d44480958b424
-  data.tar.gz: b19b884b6c0e0e87b795fcfd16aa3662ca80eef65ab1c1095d7f1df3f00f1de12592e1c89d305fa29407e250cc0ee6af1988578e712f55465722d6abd8741127
+  metadata.gz: dba6fa59647819652cabe411f0af9354abe87b9b522cc4dd03f3ebbfa0837a91e602e6dc195cf91f09cce17d718647037a93e027b3df4da159cfb2450f22d509
+  data.tar.gz: a0e2d4eabcdfdc21557f785db1e0c5b33e9e9f2e0f32f84c2aa59c0cb663993745eaaaa88a14371f808a65be0d3d162932c850120487426a9ea6e6eea5bb5d58

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+**2.0.0**
+* Use `#alias_attr` instead of calling super in `Enum::Helpers::EnumAttribute`.
+* Allow valueless enums (given with `Array` instead of `Hash`), that map to the
+  string of the key.
+
 **1.8.1**
 * Oops, merge 1.7.5 into 1.8.
 

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    yinum (1.8.1)
+    yinum (2.0.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.2.5)
+    nil_or (2.0.0)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
@@ -20,5 +21,6 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  rspec
+  nil_or (~> 2.0)
+  rspec (~> 2.0)
   yinum!

data/README.md

@@ -1,215 +1,288 @@
-# yinum
+# yinum [![Gem Version](https://badge.fury.io/rb/yinum.svg)](http://badge.fury.io/rb/yinum)
 
 A yummy straightforward implementation of an enum for Ruby (on Rails).
 
 The straightforward usage looks like this:
 
-    COLORS = Enum.new(:COLORS, :red => 1, :green => 2, :blue => 3)
-    COLORS.red
-    => COLORS.red
-    COLORS.red == 1 && COLORS.red == :red
-    => true
+```ruby
+COLORS = Enum.new(:COLORS, :red => 1, :green => 2, :blue => 3)
+COLORS.red
+=> COLORS.red
+COLORS.red == 1 && COLORS.red == :red
+=> true
+```
 
-## Getting started
+## Installation
 
-    $ gem install yinum
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yinum'
+```
+
+And then execute:
 
-Or in your Gemfile:
+    $ bundle
 
-    gem "yinum"
+Or install it yourself as:
+
+    $ gem install yinum
 
 ## Usage
 
 Creating an enum:
 
-    FRUITS = Enum.new(:FRUITS, :apple => 1, :orange => 2)
-    => FRUITS(:apple => 1, :orange => 2)
+```ruby
+FRUITS = Enum.new(:FRUITS, :apple => 1, :orange => 2)
+=> FRUITS(:apple => 1, :orange => 2)
+```
 
 Creating an enum with a parent class:
 
-    class Car
-      COLORS = Enum.new(:COLORS, Car, :red => 1, :black => 2)
-    end
-    => Car::COLORS(:red => 1, :black => 2)
+```ruby
+class Car
+  COLORS = Enum.new(:COLORS, Car, :red => 1, :black => 2)
+end
+=> Car::COLORS(:red => 1, :black => 2)
+```
 
 Another way, with the helper method:
 
-    class Car
-      enum :COLORS, 1 => :red, 2 => :black
-    end
-    => Car::COLORS(:red => 1, :black => 2)
+```ruby
+class Car
+  enum :COLORS, 1 => :red, 2 => :black
+end
+=> Car::COLORS(:red => 1, :black => 2)
+```
 
 (Can go either KEY => VALUE or VALUE => KEY as long as the key is a Symbol or the value is a Numeric).
 
 Getting enum values:
 
-    FRUITS.apple
-    => FRUITS.apple
-    FRUITS[:apple]
-    => FRUITS.apple
-    FRUITS[1]
-    => FRUITS.apple
-    FRUITS['orange']
-    => FRUITS.orange
-    FRUITS['2']
-    => FRUITS.orange
-    FRUITS['orange', '1']
-    => [FRUITS.orange, FRUITS.apple]
+```ruby
+FRUITS.apple
+=> FRUITS.apple
+FRUITS[:apple]
+=> FRUITS.apple
+FRUITS[1]
+=> FRUITS.apple
+FRUITS['orange']
+=> FRUITS.orange
+FRUITS['2']
+=> FRUITS.orange
+FRUITS['orange', '1']
+=> [FRUITS.orange, FRUITS.apple]
+```
 
 Comparing enum values:
 
-    fruit = FRUITS.orange
-    => FRUITS.orange
-    fruit == 2
-    => true
-    fruit == :orange
-    => true
-    fruit.apple?
-    => false
+```ruby
+fruit = FRUITS.orange
+=> FRUITS.orange
+fruit == 2
+=> true
+fruit == :orange
+=> true
+fruit.apple?
+=> false
+```
 
 The enum value is actually a delegate to the value with a special inspect and comparison:
 
-    fruit = FRUITS.orange
-    => FRUITS.orange
-    fruit.to_i
-    => 2
-    fruit + 1
-    => 3
-    fruit > FRUITS.apple
-    => true
+```ruby
+fruit = FRUITS.orange
+=> FRUITS.orange
+fruit.to_i
+=> 2
+fruit + 1
+=> 3
+fruit > FRUITS.apple
+=> true
+```
 
 Generating enum attribute methods for your class:
 
-    class Car
-      attr_accessor :color
-      attr_enum :color, :COLORS, :red => 1, :black => 2
-    end
-    car = Car.new
-    car.color = :red
-    car.color
-    => Car::COLORS.red
-    car.color = "2"
-    car.color
-    => Car::COLORS.black
-    car.color.black?
-    => false
+```ruby
+class Car
+  attr_accessor :color
+  attr_enum :color, :COLORS, :red => 1, :black => 2
+end
+car = Car.new
+car.color = :red
+car.color
+=> Car::COLORS.red
+car.color = "2"
+car.color
+=> Car::COLORS.black
+car.color_without_enum
+=> "2"
+car.color.black?
+=> false
+```
 
 If this is a defining attribute for the class, add `:qualifier => true` to generate question methods like so:
 
-    class Car
-      attr_accessor :color
-      attr_enum :color, :COLORS, { :qualifier => true }, :red => 1, :black => 2
-    end
-    car = Car.new
-    car.color = :red
-    car.red?
-    => true
+```ruby
+class Car
+  attr_accessor :color
+  attr_enum :color, :COLORS, { :qualifier => true }, :red => 1, :black => 2
+end
+car = Car.new
+car.color = :red
+car.red?
+=> true
+```
 
 How the enum gets along with Rails, assuming the following model:
 
-    # == Schema Info
-    #
-    # Table name: cars
-    #
-    #  id                  :integer(11)    not null, primary key
-    #  color               :integer(11)
-    #
+```ruby
+# == Schema Info
+#
+# Table name: cars
+#
+#  id                  :integer(11)    not null, primary key
+#  color               :integer(11)
+#
 
-    class Car < ActiveRecord::Base
-      enum_column :color, :COLORS, :red => 1, :black => 2
-    end
+class Car < ActiveRecord::Base
+  enum_column :color, :COLORS, :red => 1, :black => 2
+end
+```
 
 Now the `color` column is always read and written using the enum value feature:
 
-    Car.create! :color => :red
-    => #<Car id: 1, color: 1>
-    Car.last.color.red?
-    => true
+```ruby
+Car.create! :color => :red
+=> #<Car id: 1, color: 1>
+Car.last.color.red?
+=> true
+```
 
 This also creates a `validates_inclusion_of` with `allow_nil => true` to prevent having bad values.
 
 Adding a `:scoped => true` option before the enum values allows automatic generation of scopes and question
 methods on the model as follows:
 
-    class Car < ActiveRecord::Base
-      enum_column :color, :COLORS, { :scoped => true }, :red => 1, :black => 2
-    end
-    Car.red.to_sql
-    => "SELECT `cars`.* FROM `cars` WHERE `cars`.`color` = 1"
-    Car.last.red?
-    => true
+```ruby
+class Car < ActiveRecord::Base
+  enum_column :color, :COLORS, { :scoped => true }, :red => 1, :black => 2
+end
+Car.red.to_sql
+=> "SELECT `cars`.* FROM `cars` WHERE `cars`.`color` = 1"
+Car.last.red?
+=> true
+```
 
 You can also use another class's enum for your class with enum\_column and attr\_enum (including generated methods) like so:
 
-    class Motorcycle < ActiveRecord::Base
-      enum_column :color, Car::COLORS, { :scoped => true }
-    end
-    Motorcycle.black.to_sql
-    => "SELECT `motorcycles`.* FROM `motorcycles` WHERE `motorcycles`.`color` = 2"
-    Motorcycle.black
-    => Car::COLORS.black
+```ruby
+class Motorcycle < ActiveRecord::Base
+  enum_column :color, Car::COLORS, { :scoped => true }
+end
+Motorcycle.black.to_sql
+=> "SELECT `motorcycles`.* FROM `motorcycles` WHERE `motorcycles`.`color` = 2"
+Motorcycle.black
+=> Car::COLORS.black
+```
 
 Last but not least, automatic translation lookup.
 Given the following `config/locales/en.yml`:
 
-    en:
-      enums:
-        fruits:
-          apple: Green Apple
-          orange: Orange Color
-        colors:
-          red: Shiny Red
-          black: Blackest Black
-        car:
-          colors:
-            black: Actually, white
+```yaml
+en:
+  enums:
+    fruits:
+      apple: Green Apple
+      orange: Orange Color
+    colors:
+      red: Shiny Red
+      black: Blackest Black
+    car:
+      colors:
+        black: Actually, white
+```
 
 The following will occur:
 
-    FRUITS.apple.t
-    => "Green Apple"
-    FRUITS[2].t
-    => "Orange Color"
-    Car::COLORS.red.t
-    => "Shiny Red"
-    Car::COLORS.black.t
-    => "Actually, white"
-    Car::COLORS.options # nice for options_for_select
-    => { "Shiny Red" => :red, "Actually, white" => :black }
+```ruby
+FRUITS.apple.t
+=> "Green Apple"
+FRUITS[2].t
+=> "Orange Color"
+Car::COLORS.red.t
+=> "Shiny Red"
+Car::COLORS.black.t
+=> "Actually, white"
+Car::COLORS.options # nice for options_for_select
+=> { "Shiny Red" => :red, "Actually, white" => :black }
+```
 
 When the enum is given a parent, the class's name is used in the translation.
 If the translation is missing, it fallbacks to the translation without the class's name.
 
 All enum names (usually CONSTANT\_LIKE) and parent class names are converted to snakecase.
 
+### Valueless Enums
+
+You can also define an enum without giving values, by giving an `Array` instead
+of a `Hash`.
+
+```ruby
+FRUITS = Enum.new(:FRUITS, [:apple, :orange])
+FRUITES.apple.value
+=> "apple"
+```
+
+This will give you validations on attributes and columns, without forcing you
+to keep track of an incremental value for the keys.
+
+Keep in mind that with columns it means that you'll need a string column type
+instead of an integer.
+
 ## Limitations
 
 Since the `===` operator is called on the when value, this syntax cannot be used:
 
-    case fruit
-      when :apple then "This will never happen!"
-    end
+```ruby
+case fruit
+  when :apple then "This will never happen!"
+end
+```
 
 The following should be used instead:
 
-    case fruit
-      when FRUITS.apple then "This is better..."
-    end
+```ruby
+case fruit
+  when FRUITS.apple then "This is better..."
+end
+```
 
 This is because I had trouble overriding the `===` operator of the Symbol class.
 
 Another limitation is the following:
 
-    Car.where(:color => :red) # bad
-    Car.where(:color => Car::COLORS.red) # good
+```ruby
+Car.where(:color => :red) # bad
+Car.where(:color => Car::COLORS.red) # good
+```
 
 You may use the EnumValue object for anything, but don't get smart using the key.
 If the EnumValue doesn't work in a spot, use #name (in `options_for_select`) or #value (in `update_all`).
 
 ## Also
 
-EnumValue also works well with [nil_or](https://github.com/toplex/nil_or):
+EnumValue also works well with [nil_or](https://github.com/odedniv/nil_or):
+
+```ruby
+fruit = FRUITS.apple
+fruit.nil_or.t
+=> "Green Apple"
+```
+
+## Contributing
 
-    fruit = FRUITS.apple
-    fruit.nil_or.t
-    => "Green Apple"
+1. Fork it ( https://github.com/odedniv/enum/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/enum.rb

@@ -5,7 +5,7 @@ class Enum
   attr_reader :klass, :name, :by_name, :by_value
 
   def initialize(name, klass=nil, hash={})
-    klass, hash = nil, klass if klass.is_a?(Hash)
+    klass, hash = nil, klass unless klass.is_a?(Class)
     @name, @klass = name, klass
     map_hash(hash)
     generate_methods
@@ -48,12 +48,13 @@ class Enum
 
   private
   def map_hash(hash)
+    hash = Hash[hash.map { |n| [n, n.to_s] }] if hash.is_a?(Array)
     @by_name = {}
     @by_value = {}
     @by_name_s = {}
     @by_value_s = {}
     hash.each do |n, v|
-      n, v = v, n if v.is_a?(Symbol) or n.is_a?(Numeric)
+      n, v = v, n if v.is_a?(Symbol) and not n.is_a?(Symbol)
       raise "duplicate enum name #{n} for #{to_s}" if @by_name.has_key?(n)
       raise "duplicate enum value #{v} for #{to_s}.#{n}" if @by_value.has_key?(v)
       raise "value can't be nil for #{to_s}.#{n}" if v.nil?

data/lib/enum/enum_value.rb

@@ -104,6 +104,6 @@ class Enum::EnumValue < BasicObject
     require 'nil_or'
   rescue ::LoadError
   else
-    include ::NilOr
+    include ::NilOr::Methods
   end
 end

data/lib/enum/helpers/enum_attribute.rb

@@ -19,19 +19,31 @@ module Enum::Helpers::EnumAttribute
       e = const_get(name_or_enum)
     end
     # attribute reader
-    define_method(attr) do
-      v = super()
-      (ev = e.get(v)).nil? ? Enum::EnumValue.new(e, v) : ev
+    reader, reader_without_enum = attr, :"#{attr}_without_enum"
+    begin
+      alias_method reader_without_enum, reader
+    rescue NameError # reader does not exist
+    else
+      define_method(reader) do
+        v = send(reader_without_enum)
+        (ev = e.get(v)).nil? ? Enum::EnumValue.new(e, v) : ev
+      end
     end
     # attribute writer
-    define_method("#{attr}=") do |v|
-      case
-      when v.enum_value?
-        super(v.value)
-      when v.nil?, v == "" # might be received from forms
-        super(v)
-      else
-        super(e[v].value)
+    writer, writer_without_enum = :"#{attr}=", :"#{attr}_without_enum="
+    begin
+      alias_method writer_without_enum, writer
+    rescue NameError # writer does not exist
+    else
+      define_method(writer) do |v|
+        case
+        when v.enum_value?
+          send(writer_without_enum, v.value)
+        when v.nil?, v == "" # might be received from forms
+          send(writer_without_enum, v)
+        else
+          send(writer_without_enum, e[v].value)
+        end
       end
     end
 

data/lib/enum/version.rb

@@ -1,3 +1,3 @@
 class Enum
-  VERSION = '1.8.1'
+  VERSION = '2.0.0'
 end

data/spec/lib/enum/enum_value_spec.rb

@@ -7,26 +7,24 @@ class I18n
 end
 
 describe Enum::EnumValue do
-  subject { @enum }
-
   context "no parent" do
-    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
-    # can't use subject @enum.red as it turns into a Fixnum
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+    # can't use EnumValue in subject for some reason
 
-    specify { @enum.red.inspect.should == "MY_COLORS.red" }
-    specify { @enum.red.t.should == "enums.my_colors.red" }
-  end # context "no parent"
+    specify { enum.red.inspect.should == "MY_COLORS.red" }
+    specify { enum.red.t.should == "enums.my_colors.red" }
+  end
 
   context "with parent" do
-    before { @enum = Enum.new(:MY_COLORS, Object, :red => 1, :blue => 2) }
-    # can't use subject @enum.red as it turns into a Fixnum
+    subject(:enum) { Enum.new(:MY_COLORS, Object, :red => 1, :blue => 2) }
+    # can't use EnumValue in subject for some reason
 
-    specify { @enum.red.inspect.should == "Object::MY_COLORS.red" }
-    specify { @enum.red.t.should == "enums.object.my_colors.red" }
-  end # context "with parent"
+    specify { enum.red.inspect.should == "Object::MY_COLORS.red" }
+    specify { enum.red.t.should == "enums.object.my_colors.red" }
+  end
 
   context "comparison" do
-    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
 
     its(:red) { should == 1 }
     its(:blue) { should_not == 1 }
@@ -38,12 +36,21 @@ describe Enum::EnumValue do
     its(:blue) { should_not === :red }
     its(:red) { should be_red }
     its(:blue) { should_not be_red }
-    specify { @enum.red.object_id.should == @enum[:red].object_id }
-    specify { @enum.red.object_id.should == @enum[1].object_id }
-  end # context "comparison"
+    specify { enum.red.object_id.should == enum[:red].object_id }
+    specify { enum.red.object_id.should == enum[1].object_id }
+  end
 
   context "invalid" do
-    specify { expect { @enum[:green] }.to raise_error(StandardError) }
-    specify { expect { @enum[3] }.to raise_error(StandardError) }
-  end # context "invalid"
-end # describe EnumValue
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+
+    specify { expect { enum[:green] }.to raise_error(StandardError) }
+    specify { expect { enum[3] }.to raise_error(StandardError) }
+  end
+
+  describe "#nil_or" do
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+    # can't use EnumValue in subject for some reason
+
+    specify { enum.red.nil_or.should be_enum_value }
+  end
+end

data/spec/lib/enum/helpers/common_specs.rb

@@ -0,0 +1,68 @@
+class EnumUserBase
+  attr_accessor :color
+
+  class << self
+    def create_class(name = self.name)
+      klass_name = :"Anonymous#{name}"
+      send(:remove_const, klass_name) if const_defined?(klass_name)
+      const_set(klass_name, Class.new(self)) # gives a name
+    end
+  end
+end
+
+shared_examples_for Enum::Helpers::EnumGenerator do
+  subject { klass::COLORS }
+
+  its(:name) { should == :COLORS }
+  its(:klass) { should == klass }
+  its(:by_name) { should == { :red => 1, :blue => 2 } }
+end
+
+shared_examples_for Enum::Helpers::EnumAttribute do
+  subject(:record) { klass.new }
+  before { record.instance_eval { @color = :unknown } }
+
+  describe "setter" do
+    context "nil" do
+      before { record.color = nil }
+      specify { record.instance_eval { @color }.should be_nil }
+      specify { record.instance_eval { @color }.should_not be_enum_value }
+    end
+
+    context "name" do
+      before { record.color = :red }
+      specify { record.instance_eval { @color }.should == 1 }
+      specify { record.instance_eval { @color }.should_not be_enum_value }
+    end
+
+    context "value" do
+      before { record.color = 2 }
+      specify { record.instance_eval { @color }.should == 2 }
+      specify { record.instance_eval { @color }.should_not be_enum_value }
+    end
+
+    specify "invalid" do
+      expect { @record.color = 3 }.to raise_error(StandardError)
+    end
+  end
+
+  describe "getter" do
+    context "nil" do
+      before { record.instance_eval { @color = nil } }
+      specify { record.color.should be_nil }
+      specify { record.color.should be_enum_value }
+    end
+
+    context "value" do
+      before { record.instance_eval { @color = 2 } }
+      specify { record.color.should be_blue }
+      specify { record.color.should be_enum_value }
+    end
+
+    context "invalid" do
+      before { record.instance_eval { @color = 3 } }
+      specify { record.color.should == 3 }
+      specify { record.color.should be_enum_value }
+    end
+  end
+end

data/spec/lib/enum/helpers/enum_attribute_spec.rb

@@ -1,152 +1,43 @@
 require 'spec_helper'
+require 'lib/enum/helpers/common_specs'
 
-class UsesEnumAttribute < Hash # to allow setting 'attributes'
+class EnumAttributeUser < EnumUserBase
   extend Enum::Helpers::EnumAttribute
-
-  class << self
-    # enum definition
-    def define_enum(attr, name_or_enum, options = {}, hash = nil)
-      @enum_name = name_or_enum.is_a?(Enum) ? name_or_enum.name : name_or_enum
-      attr_enum attr, name_or_enum, options, hash
-    end
-    def undefine_enum
-      remove_const :COLORS
-    end
-  end
-
-  # mocking setters
-  def method_missing(method, *args, &block)
-    if method.to_s.end_with?('=') and args.length == 1
-      self[method.to_s.chop.to_sym] = args.first
-    elsif method =~ /^[a-z_]*$/ and args.length == 0
-      self[method]
-    else
-      super
-    end
-  end
-end
-
-class UsesAnoterEnumAttribute < UsesEnumAttribute
-end
-
-def enum_generator_specs
-  describe Enum::Helpers::EnumGenerator do
-    subject { UsesEnumAttribute::COLORS }
-
-    its(:name) { should == :COLORS }
-    its(:klass) { should == UsesEnumAttribute }
-    its(:by_name) { should == { :red => 1, :blue => 2 } }
-  end # describe Enum::Helpers::EnumGenerator
-end
-
-def enum_attribute_specs
-  context "attributes" do
-    before do
-      @record = UsesEnumAttribute.new
-      @record[:color] = :unknown
-    end
-    subject { @record }
-
-    context "setter" do
-      specify "nil" do
-        @record.color = nil
-        @record[:color].should be_nil
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "empty string" do
-        @record.color = ""
-        @record[:color].should == ""
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "symbol name" do
-        @record.color = :red
-        @record[:color].should == 1
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "string name" do
-        @record.color = 'red'
-        @record[:color].should == 1
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "value" do
-        @record.color = 2
-        @record[:color].should == 2
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "invalid" do
-        expect { @record.color = 3 }.to raise_error(StandardError)
-      end
-    end # context "setter"
-
-    context "getter" do
-      specify "nil" do
-        @record[:color] = nil
-        @record.color.should be_nil
-        @record.color.should be_enum_value
-      end
-
-      specify "value" do
-        @record[:color] = 2
-        @record.color.should be_blue
-        @record.color.should be_enum_value
-      end
-
-      specify "invalid" do
-        @record[:color] = 3
-        @record.color.should == 3
-        @record.color.should be_enum_value
-      end
-
-      specify "invalid empty string" do
-        @record[:color] = ""
-        @record.color.should == ""
-        @record.color.should be_enum_value
-      end
-    end # context "getter"
-  end # context "attribute"
 end
 
 describe Enum::Helpers::EnumAttribute do
-  after { UsesEnumAttribute.undefine_enum }
-  subject { UsesEnumAttribute }
+  subject(:klass) { EnumAttributeUser.create_class }
 
   context "not qualifier" do
-    before { UsesEnumAttribute.define_enum(:color, :COLORS, :red => 1, :blue => 2) }
+    before { klass.attr_enum(:color, :COLORS, :red => 1, :blue => 2) }
 
-    enum_generator_specs
-    enum_attribute_specs
-  end # context "not qualifier"
+    it_behaves_like Enum::Helpers::EnumGenerator
+    it_behaves_like Enum::Helpers::EnumAttribute
+  end
 
   context "qualifier" do
-    before { UsesEnumAttribute.define_enum(:color, :COLORS, { :qualifier => true }, :red => 1, :blue => 2) }
+    before { klass.attr_enum(:color, :COLORS, { :qualifier => true }, :red => 1, :blue => 2) }
 
-    enum_generator_specs
-    enum_attribute_specs
+    it_behaves_like Enum::Helpers::EnumGenerator
+    it_behaves_like Enum::Helpers::EnumAttribute
 
     context "questions" do
-      before do
-        @record = UsesEnumAttribute.new
-        @record.color = :red
-      end
-      subject { @record }
+      subject(:record) { klass.new }
+      before { record.color = :red }
 
       it { should be_red }
       it { should_not be_blue }
-    end # context "questions"
-  end # context "qualifier"
+    end
+  end
 
   context "use another enum" do
     before do
-      UsesEnumAttribute.define_enum(:color, :COLORS, { :qualifier => true }, :red => 1, :blue => 2)
-      UsesAnoterEnumAttribute.define_enum(:color, UsesEnumAttribute::COLORS)
+      klass.attr_enum(:color, :COLORS, { :qualifier => true }, :red => 1, :blue => 2)
+      another_klass = EnumAttributeUser.create_class(:AnotherEnumAttributeUser)
+      another_klass.attr_enum(:color, klass::COLORS)
     end
 
-    enum_generator_specs
-    enum_attribute_specs
+    it_behaves_like Enum::Helpers::EnumGenerator
+    it_behaves_like Enum::Helpers::EnumAttribute
   end
-end # describe Enum::Helpers::EnumAttribute
+end

data/spec/lib/enum/helpers/enum_column_spec.rb

@@ -1,27 +1,13 @@
 require 'spec_helper'
+require 'lib/enum/helpers/common_specs'
 
-class UsesEnumColumn < Hash # to allow setting 'attributes'
+class EnumColumnUser < EnumUserBase
   extend Enum::Helpers::EnumColumn
-
   class << self
-    # enum definition
-    def define_enum(attr, name_or_enum, options={}, hash=nil)
-      @enum_name = name_or_enum.is_a?(Enum) ? name_or_enum.name : name_or_enum
-      reset_mocks
-      enum_column attr, name_or_enum, options, hash
-    end
-    def undefine_enum
-      remove_const :COLORS
-    end
-    def reset_mocks
-      @inclusion_validations = []
-      @scopes = []
-    end
-
     # mocking validates_inclusion_of
     attr_reader :inclusion_validations
     def validates_inclusion_of(*attributes)
-      @inclusion_validations << attributes
+      (@inclusion_validations ||= []) << attributes
     end
     # mocking scopes
     def where(*attributes)
@@ -29,137 +15,59 @@ class UsesEnumColumn < Hash # to allow setting 'attributes'
     end
     attr_reader :scopes
     def scope(name, value)
-      @scopes << [name, value.call]
-    end
-
-  end
-
-  # mocking setters
-  def method_missing(method, *args, &block)
-    if method.to_s.end_with?('=') and args.length == 1
-      self[method.to_s.chop.to_sym] = args.first
-    elsif method =~ /^[a-z_]*$/ and args.length == 0
-      self[method]
-    else
-      super
+      (@scopes ||= []) << [name, value.call]
     end
   end
 end
 
-class UsesAnoterEnumColumn < UsesEnumColumn
-end
-
-def enum_generator_specs
-  describe Enum::Helpers::EnumGenerator do
-    subject { UsesEnumColumn::COLORS }
-
-    its(:name) { should == :COLORS }
-    its(:klass) { should == UsesEnumColumn }
-    its(:by_name) { should == { :red => 1, :blue => 2 } }
-  end # describe Enum::Helpers::EnumGenerator
-end
-
-def enum_columns_attribute_specs
-  context "attributes" do
-    before do
-      @record = UsesEnumColumn.new
-      @record[:color] = :unknown
-    end
-    subject { @record }
-
-    context "setter" do
-      specify "nil" do
-        @record.color = nil
-        @record[:color].should be_nil
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "name" do
-        @record.color = :red
-        @record[:color].should == 1
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "value" do
-        @record.color = 2
-        @record[:color].should == 2
-        @record[:color].should_not be_enum_value
-      end
-
-      specify "invalid" do
-        expect { @record.color = 3 }.to raise_error(StandardError)
-      end
-    end # context "setter"
-
-    context "getter" do
-      specify "nil" do
-        @record[:color] = nil
-        @record.color.should be_nil
-        @record.color.should be_enum_value
-      end
-
-      specify "value" do
-        @record[:color] = 2
-        @record.color.should be_blue
-        @record.color.should be_enum_value
-      end
-
-      specify "invalid" do
-        @record[:color] = 3
-        @record.color.should == 3
-        @record.color.should be_enum_value
-      end
-    end # context "getter"
-  end # context "attribute"
-
-  context "validations" do
+describe Enum::Helpers::EnumColumn do
+  shared_examples_for "validations" do
     its(:inclusion_validations) { should have(1).item }
     its(:inclusion_validations) { should include([:color, :in => [1, 2], :allow_nil => true]) }
-  end # context "validations"
-end
+  end
 
-describe Enum::Helpers::EnumColumn do
-  after { UsesEnumColumn.undefine_enum }
-  subject { UsesEnumColumn }
+  subject(:klass) { EnumColumnUser.create_class }
 
   context "not scoped" do
-    before { UsesEnumColumn.define_enum(:color, :COLORS, :red => 1, :blue => 2) }
+    before { klass.enum_column(:color, :COLORS, :red => 1, :blue => 2) }
 
-    enum_generator_specs
-    enum_columns_attribute_specs
-  end # context "not scoped"
+    it_behaves_like Enum::Helpers::EnumGenerator
+    it_behaves_like "validations"
+  end
 
   context "scoped" do
-    before { UsesEnumColumn.define_enum(:color, :COLORS, { :scoped => true }, :red => 1, :blue => 2) }
+    before { klass.enum_column(:color, :COLORS, { :scoped => true }, :red => 1, :blue => 2) }
 
-    enum_generator_specs
-    enum_columns_attribute_specs
+    it_behaves_like Enum::Helpers::EnumGenerator
+    it_behaves_like Enum::Helpers::EnumAttribute
+    it_behaves_like "validations"
 
-    context "scopes" do
+    describe "scopes" do
       its(:scopes) { should have(2).items }
       its(:scopes) { should include([:red, :where => [:color => 1]]) }
       its(:scopes) { should include([:blue, :where => [:color => 2]]) }
-    end # context "scopes"
+    end
 
-    context "questions" do
-      before do
-        @record = UsesEnumColumn.new
-        @record.color = :red
-      end
-      subject { @record }
+    describe "questions" do
+      subject(:record) { klass.new }
+      before { record.color = :red }
 
       it { should be_red }
       it { should_not be_blue }
-    end # context "questions"
-  end # context "scoped"
+    end
+  end
 
   context "use another enum" do
+    subject(:klass) { EnumColumnUser.create_class }
+
     before do
-      UsesEnumColumn.define_enum(:color, :COLORS, { :scoped => true }, :red => 1, :blue => 2)
-      UsesAnoterEnumColumn.define_enum(:color, UsesEnumColumn::COLORS)
+      klass.enum_column(:color, :COLORS, { :scoped => true }, :red => 1, :blue => 2)
+      another_klass = EnumColumnUser.create_class(:AnotherEnumColumnUser)
+      another_klass.enum_column(:color, klass::COLORS)
     end
 
-    enum_generator_specs
-    enum_columns_attribute_specs
+    it_behaves_like Enum::Helpers::EnumGenerator
+    it_behaves_like Enum::Helpers::EnumAttribute
+    it_behaves_like "validations"
   end
-end # describe Enum::Helpers::EnumColumn
+end

data/spec/lib/enum/helpers/enum_generator_spec.rb

@@ -1,13 +1,11 @@
 require 'spec_helper'
 
-class UsesEnumGenerator
-  enum :COLORS, :red => 1, :blue => 2
-end
-
 describe Enum::Helpers::EnumGenerator do
-  subject { UsesEnumGenerator::COLORS }
+  let(:klass) { EnumUserBase.create_class }
+  before { klass.enum(:COLORS, :red => 1, :blue => 2) }
+  subject { klass::COLORS }
 
   its(:name) { should == :COLORS }
-  its(:klass) { should == UsesEnumGenerator }
+  its(:klass) { should == klass }
   its(:by_name) { should == { :red => 1, :blue => 2 } }
-end # describe Enum::Helpers::EnumGenerator
+end

data/spec/lib/enum_spec.rb

@@ -1,39 +1,47 @@
 require 'spec_helper'
 
 describe Enum do
-  context "accessors" do
-    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+  describe "accessors" do
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
 
-    specify { @enum.red.should == 1 }
-    specify { @enum[:red].should == 1 }
-    specify { expect { @enum[:black] }.to raise_error(StandardError) }
-    specify { @enum[:red, :blue].should == [1, 2] }
-  end # context "accessors
+    its(:red) { should == 1 }
+    specify { enum[:red].should == 1 }
+    specify { expect { enum[:black] }.to raise_error(StandardError) }
+    specify { enum[:red, :blue].should == [1, 2] }
+  end
 
   context "keys on left and right" do
-    before { @enum = Enum.new(:MY_COLORS, :red => 1, 2 => :blue) }
-    subject { @enum }
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, 2 => :blue) }
 
     its(:names) { should have(2).items }
     its(:names) { should include(:red, :blue) }
     its(:values) { should have(2).items }
     its(:values) { should include(1, 2) }
     its(:to_a) { should have(2).items }
-  end # context "keys on left and right"
+  end
 
   context "no parent" do
-    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
-    subject { @enum }
+    subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
 
     its(:to_s)    { should == "MY_COLORS" }
     its(:inspect) { should == "MY_COLORS(:red => 1, :blue => 2)" }
-  end # context "no parent"
+  end
 
   context "with parent" do
-    before { @enum = Enum.new(:MY_COLORS, Object, :red => 1, :blue => 2) }
-    subject { @enum }
+    subject(:enum) { Enum.new(:MY_COLORS, Object, :red => 1, :blue => 2) }
 
     its(:to_s)    { should == "Object::MY_COLORS" }
     its(:inspect) { should == "Object::MY_COLORS(:red => 1, :blue => 2)" }
-  end # context "with parent"
-end # describe Enum
+  end
+
+  context "valueless" do
+    subject(:enum) { Enum.new(:MY_COLORS, [:red, :blue]) }
+
+    its(:to_s)    { should == "MY_COLORS" }
+    its(:inspect) { should == 'MY_COLORS(:red => "red", :blue => "blue")' }
+    its(:red)     { should == "red" }
+    specify { enum[:red].should == "red" }
+    specify { expect { enum[:black] }.to raise_error(StandardError) }
+    specify { enum[:red, :blue].should == ["red", "blue"] }
+  end
+end

data/yinum.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = Enum::VERSION
   s.authors     = ["Oded Niv"]
   s.email       = ["oded.niv@gmail.com"]
-  s.homepage    = "https://github.com/toplex/enum"
+  s.homepage    = "https://github.com/odedniv/enum"
   s.summary     = %q{Enum implementation}
   s.description = %q{Yummy implementation of enum that gives integer values with a special wrapping.}
   s.license     = 'UNLICENSE'
@@ -19,5 +19,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '~> 2.0'
+  s.add_development_dependency 'nil_or', '~> 2.0'
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: yinum
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Oded Niv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-04 00:00:00.000000000 Z
+date: 2014-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: nil_or
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Yummy implementation of enum that gives integer values with a special
   wrapping.
 email:
@@ -32,7 +46,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -48,13 +62,14 @@ files:
 - lib/enum/version.rb
 - lib/yinum.rb
 - spec/lib/enum/enum_value_spec.rb
+- spec/lib/enum/helpers/common_specs.rb
 - spec/lib/enum/helpers/enum_attribute_spec.rb
 - spec/lib/enum/helpers/enum_column_spec.rb
 - spec/lib/enum/helpers/enum_generator_spec.rb
 - spec/lib/enum_spec.rb
 - spec/spec_helper.rb
 - yinum.gemspec
-homepage: https://github.com/toplex/enum
+homepage: https://github.com/odedniv/enum
 licenses:
 - UNLICENSE
 metadata: {}
@@ -64,18 +79,25 @@ 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: yinum
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Enum implementation
-test_files: []
+test_files:
+- spec/lib/enum/enum_value_spec.rb
+- spec/lib/enum/helpers/common_specs.rb
+- spec/lib/enum/helpers/enum_attribute_spec.rb
+- spec/lib/enum/helpers/enum_column_spec.rb
+- spec/lib/enum/helpers/enum_generator_spec.rb
+- spec/lib/enum_spec.rb
+- spec/spec_helper.rb