enumattr 0.0.1 → 0.0.2

data/README.md

@@ -21,111 +21,121 @@ Or install it yourself as:
 
 ### defining
 
-* `include Enumattr::Base` and declare `enum_attr_for some_attribute do ... end`
-* `enum :symbol, value` in block
+1. `include Enumattr::Base` and declare `enumattr attribute_name do ... end`
+2. `enum :symbol, value` in `do ... end`
 
+example:
 
-<pre>
-class User
-  include Enumattr::Base
+    class User
+      include Enumattr::Base
 
-  attr_accessor :status
+      attr_accessor :status
 
-  enum_attr_for :status do
-    enum :active,  1
-    enum :suspend, 2
-    enum :deleted, 3
-  end
+      enumattr :status do
+        enum :active,   1
+        enum :inactive, 2
+        enum :deleted,  3
+      end
 
-  def initialize(status)
-    @status = status
-  end
-end
-</pre>
+      def initialize(status)
+        @status = status
+      end
+    end
 
 ### defined methods
 
 #### class methods
 
-* `SomeClass.#{some_attribute}_enums` return enum set
-* `SomeClass.#{some_attribute}_keys` return key set
-* `SomeClass.#{some_attribute}_values` return value set
+* `#{attribute_name}_enums` return enum set
+* `#{attribute_name}_keys` return  key set
+* `#{attribute_name}_values` return value set
 
-<pre>
-User.status_enums
-#=&gt; #&lt;Set: {#&lt;Enumattr::Enum:0x8a8d13c @key=:active, @value=1&gt;, #&lt;Enumattr::Enum:0x8a8d100 @key=:suspend, @value=2&gt;, #&lt;Enumattr::Enum:0x8a8d0ec @key=:deleted, @value=3&gt;}&gt;
+example:
 
-User.status_keys
-#=&gt; #&lt;Set: {:active, :suspend, :deleted}&gt;
+    User.status_enums
+    #=> #<Set: {#<Enumattr::Enums::Enum:0x8a8d13c @key=:active, @value=1>, #<Enumattr::Enums::Enum:0x8a8d100 @key=:inactive, @value=2>, #<Enumattr::Enums::Enum:0x8a8d0ec @key=:deleted, @value=3>}>
 
-User.status_values
-#=&gt; #&lt;Set: {1, 2, 3}&gt;
-</pre>
+    User.status_keys
+    #=> #<Set: {:active, :inactive, :deleted}>
 
-* `SomeClass.#{some_attribute}_enum_by_key(:symbol)` return an enum
-* `SomeClass.#{some_attribute}_value_by_key(:symbol)` return a value
+    User.status_values
+    #=> #<Set: {1, 2, 3}>
 
-<pre>
-User.status_enum_by_key :active
-#=&gt; #&lt;Enumattr::Enum:0x8a8d13c @key=:active, @value=1&gt;
+* `#{attribute_name}_enum(key)` return an enum
+* `#{attribute_name}_value(key)` return a value
 
-User.status_enum_by_key :suspend
-#=&gt; #&lt;Enumattr::Enum:0x8a8d100 @key=:suspend, @value=2&gt;
+example:
 
-User.status_enum_by_key :dummy
-#=&gt; nil
-
-User.status_value_by_key :active
-#=&gt; 1
-
-User.status_value_by_key :suspend
-#=&gt; 2
-
-User.status_value_by_key :dummy
-#=&gt; nil
-</pre>
+    User.status_enum :active
+    #=> #<Enumattr::Enums::Enum:0x8a8d13c @key=:active, @value=1>
+    
+    User.status_enum :inactive
+    #=> #<Enumattr::Enums::Enum:0x8a8d100 @key=:inactive, @value=2>
+    
+    User.status_enum :dummy
+    #=> nil
+    
+    User.status_value :active
+    #=> 1
+    
+    User.status_value :inactive
+    #=> 2
+    
+    User.status_value :dummy
+    #=> nil
 
 #### instance methods
 
-* alias `#{some_attribute}_value` `some_attribute`
-* `#{some_attribute}_key` return symbol
-* `#{some_attribute}_enum` return enum
-
-<pre>
-user = User.new(1)
-#=&gt; #&lt;User:0x8e17dac @status=1&gt;
-
-user.status
-#=&gt; 1
-
-user.status_value # alias
-#=&gt; 1
-
-user.status_key
-#=&gt; :active
-
-user.status_enum
-#=&gt; #&lt;Enumattr::Enum:0x8de2e68 @key=:active, @value=1&gt;
-</pre>
-
-
-* define query method
-* `#{some_attribute}_#{some_symbol}?` return bool
-
-<pre>
-user.status_active?
-#=&gt; true
-
-user.status_suspend?
-#=&gt; false
-
-user.status_deleted?
-#=&gt; false
-
-user.status_dummy?
-NoMethodError: undefined method `status_dummy?' for #&lt;User:0x8e17dac @status=1&gt;
-</pre>
-
+* getters
+  * alias `#{attribute_name}_value` `attribute_name`
+  * `#{attribute_name}_key` return symbol
+  * `#{attribute_name}_enum` return enum
+* setter (if writable)
+  * `#{attribute_name}_key=(key)`
+  
+
+getters example:
+
+    user = User.new(1)
+    #=> #<User:0x8e17dac @status=1>
+    
+    user.status
+    #=> 1
+    
+    user.status_value # alias
+    #=> 1
+    
+    user.status_key
+    #=> :active
+    
+    user.status_enum
+    #=> #<Enumattr::Enums::Enum:0x8de2e68 @key=:active, @value=1>
+
+setter example:
+
+    user.status_key = :inactive
+    #=> :inactive
+
+    user.status
+    #=> 2
+
+
+* Query Method
+* `#{attribute_name}_#{key}?` return true or false
+
+example:
+
+    user.status_active?
+    #=> false
+    
+    user.status_inactive?
+    #=> true
+    
+    user.status_deleted?
+    #=> false
+    
+    user.status_dummy?
+    NoMethodError: undefined method `status_dummy?' for #<User:0x8e17dac @status=1>
 
 ## Contributing
 

data/enumattr.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["aisuiiaisuii@gmail.com"]
   gem.description   = %q{simple enum}
   gem.summary       = %q{manage constants by enum like object}
-  gem.homepage      = ""
+  gem.homepage      = "https://github.com/aisuii/enumattr"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/examples/admin_user.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+class AdminUser
+  include Enumattr::Base
+
+  attr_accessor :role
+
+  enumattr :authority, :on => :role do
+    enum :super,    1
+    enum :approver, 2
+    enum :editor,   3
+  end
+
+  def initialize(role)
+    @role = role
+  end
+end

data/examples/entry.rb

@@ -0,0 +1,13 @@
+# -*- encoding: utf-8 -*-
+
+class Entry
+  include Enumattr::Base
+
+  attr_accessor :show_flag
+
+  enumattr :show_flag, :enums => {:opened => true, :closed => false}
+
+  def initialize(show_flag)
+    @show_flag = show_flag
+  end
+end

data/examples/user.rb

@@ -5,10 +5,10 @@ class User
 
   attr_accessor :status
 
-  enum_attr_for :status do
-    enum :active,  1
-    enum :suspend, 2
-    enum :deleted, 3
+  enumattr :status do
+    enum :active,   1
+    enum :inactive, 2
+    enum :deleted,  3
   end
 
   def initialize(status)

data/lib/enumattr/base.rb

@@ -8,71 +8,89 @@ module Enumattr
 
     module ClassMethods
       private
-      def enum_attr_for(enum_attr_name, &block)
-        enum_attrs[enum_attr_name] = Enums.new(&block)
-        define_class_methods enum_attr_name
-        define_instance_methods enum_attr_name
-        define_instance_query_methods enum_attr_name
+      def enumattr(enumattr_name, options = {}, &block)
+        if options[:enums]
+          closure = Proc.new do
+            options[:enums].each{|key, value| enum key, value }
+          end
+          enumattrs[enumattr_name] = Enums.new(self, &closure)
+        else
+          enumattrs[enumattr_name] = Enums.new(self, &block)
+        end
+
+        enumattr_bases[enumattr_name] = options[:on] || enumattr_name
+
+        define_enumattr_class_methods enumattr_name
+        define_enumattr_instance_methods enumattr_name
       end
 
-      def enum_attrs
-        @enum_attrs ||= {}
+      def enumattrs
+        @enumattrs ||= {}
       end
 
-      def define_class_methods(enum_attr_name)
-        enums = enum_attrs[enum_attr_name]
-        method_prefix = "#{enum_attr_name}_"
+      def enumattr_bases
+        @enumattr_bases ||= {}
+      end
 
-        mod = Module.new do
+      def define_enumattr_class_methods(enumattr_name)
+        method_prefix = "#{enumattr_name}_"
+
+        enumattr_class_methods = Module.new do
           define_method("#{method_prefix}enums") do
-            enums.enums
+            enumattrs[enumattr_name].enums
           end
 
           define_method("#{method_prefix}keys") do
-            enums.keys
+            enumattrs[enumattr_name].keys
           end
 
           define_method("#{method_prefix}values") do
-            enums.values
+            enumattrs[enumattr_name].values
           end
 
-          define_method("#{method_prefix}enum_by_key") do |key|
-            enums.enum_by_key(key)
+          define_method("#{method_prefix}enum") do |key|
+            enumattrs[enumattr_name].enum_by_key(key)
           end
 
-          define_method("#{method_prefix}value_by_key") do |key|
-            enum = enums.enum_by_key(key)
+          define_method("#{method_prefix}value") do |key|
+            enum = enumattrs[enumattr_name].enum_by_key(key)
             enum && enum.value
           end
         end
 
-        extend mod
+        extend enumattr_class_methods
       end
 
-      def define_instance_methods(enum_attr_name)
-        enums = enum_attrs[enum_attr_name]
-        method_prefix = "#{enum_attr_name}_"
+      def define_enumattr_instance_methods(enumattr_name)
+        enums = enumattrs[enumattr_name]
+        method_prefix = "#{enumattr_name}_"
+        enumattr_base = enumattr_bases[enumattr_name]
 
         define_method("#{method_prefix}enum") do
-          value = __send__ enum_attr_name
+          value = send enumattr_base
           enums.enum_by_value(value)
         end
 
         define_method("#{method_prefix}key") do
-          enum = __send__ "#{method_prefix}enum"
-          enum.key
+          enum = send "#{method_prefix}enum"
+          enum && enum.key
         end
 
-        alias_method :"#{method_prefix}value", enum_attr_name
-      end
+        define_method(:"#{method_prefix}value") do
+          send enumattr_base
+        end
 
-      def define_instance_query_methods(enum_attr_name)
-        enums = enum_attrs[enum_attr_name]
-        method_prefix = "#{enum_attr_name}_"
+        # setter by key
+        define_method("#{method_prefix}key=") do |new_key|
+          new_enum = enums.enum_by_key(new_key)
+          new_value = new_enum && new_enum.value
+          send "#{enumattr_base}=", new_value
+        end
 
+        # Query methods
         enums.enums.each do |enum|
           define_method("#{method_prefix}#{enum.key}?") do
-            value = __send__ enum_attr_name
+            value = send enumattr_base
             value == enum.value
           end
         end

data/lib/enumattr/enums.rb

@@ -3,10 +3,12 @@ require 'set'
 
 module Enumattr
   class Enums
-    def initialize(&block)
+    attr_reader :base
+
+    def initialize(base, &block)
+      @base = base
       @set = Set.new
       instance_eval(&block)
-      freeze
     end
 
     def enums
@@ -31,7 +33,29 @@ module Enumattr
 
     private
     def enum(key, value)
-      @set.add Enum.new(key, value)
+      @set.add Enum.new(key, value, self)
+    end
+
+    class Enum
+      attr_reader :key, :value
+
+      def initialize(key, value, container)
+        @key = key.to_sym
+        @value = value
+        @container = container
+      end
+
+      def enums
+        @container.enums
+      end
+
+      def hash
+        @key.hash
+      end
+
+      def eql?(other)
+        @key == other.key
+      end
     end
   end
 end

data/lib/enumattr/version.rb

@@ -1,3 +1,3 @@
 module Enumattr
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/enumattr.rb

@@ -4,5 +4,4 @@ require "enumattr/version"
 module Enumattr
   autoload :Base,  'enumattr/base'
   autoload :Enums, 'enumattr/enums'
-  autoload :Enum,  'enumattr/enum'
 end

data/spec/enumattr/enums_spec.rb

@@ -2,21 +2,28 @@
 require 'spec_helper'
 
 describe Enumattr::Enums do
+  let(:base) { Object }
+
   let(:enums) do
-    Enumattr::Enums.new do
+    Enumattr::Enums.new(base) do
       enum :key1, 1
       enum :key2, 2
       enum :key3, 3
     end
   end
 
+  describe "#base" do
+    subject { enums.base }
+    it { should == Object }
+  end
+
   describe "#enums" do
     subject { enums.enums }
     it { should be_a Set }
     it { should have(3).items }
-    it "should have Enumattr::Enum instances" do
+    it "should have Enumattr::Enums::Enum instances" do
       should satisfy { |enums|
-        enums.all?{|item| item.is_a? Enumattr::Enum }
+        enums.all?{|item| item.is_a? Enumattr::Enums::Enum }
       }
     end
   end
@@ -45,7 +52,7 @@ describe Enumattr::Enums do
 
   describe "find methods" do
     shared_examples "#enum_by_foo(foo) each items" do
-      it { should be_a Enumattr::Enum }
+      it { should be_a Enumattr::Enums::Enum }
       its(:key)   { should == expects[:key] }
       its(:value) { should == expects[:value] }
     end
@@ -81,4 +88,11 @@ describe Enumattr::Enums do
       end
     end
   end
+
+  describe Enumattr::Enums::Enum do
+    subject { enums.enum_by_key(:key1) }
+    its(:key) { should == :key1 }
+    its(:value) { should == 1 }
+    its(:enums) { should == enums.enums }
+  end
 end

data/spec/enumattr/included_spec.rb

@@ -1,22 +1,24 @@
 # -*- encoding: utf-8 -*-
 require 'spec_helper'
 require 'user'
+require 'admin_user'
+require 'entry'
 
-describe User do
+describe User, 'declare with block' do
   describe "class methods" do
-    describe '.status_enums as #{enum_attr_name}_enums' do
+    describe '.status_enums as #{enumattr_name}_enums' do
       subject { described_class.status_enums }
 
       it { should be_a Set }
       it { should have(3).items }
       it "should have Enum instances" do
         should satisfy { |enums|
-          enums.all?{|item| item.is_a? Enumattr::Enum }
+          enums.all?{|item| item.is_a? Enumattr::Enums::Enum }
         }
       end
     end
 
-    describe '.status_keys as #{enum_attr_name}_keys' do
+    describe '.status_keys as #{enumattr_name}_keys' do
       subject { described_class.status_keys }
 
       it { should be_a Set }
@@ -28,7 +30,7 @@ describe User do
       end
     end
 
-    describe '.status_values as #{enum_attr_name}_values' do
+    describe '.status_values as #{enumattr_name}_values' do
       subject { described_class.status_values }
 
       it { should be_a Set }
@@ -40,23 +42,23 @@ describe User do
       end
     end
 
-    describe '.status_enum_by_key as #{enum_attr_name}_enum_by_key' do
-      subject { described_class.status_enum_by_key(:active) }
+    describe '.status_enum(key) as #{enumattr_name}_enum(key)' do
+      subject { described_class.status_enum(:active) }
 
-      it { should be_a Enumattr::Enum }
+      it { should be_a Enumattr::Enums::Enum }
       its(:key) { should == :active }
       its(:value) { should == 1 }
     end
 
-    describe '.status_value_by_key as #{enum_attr_name}_value_by_key' do
+    describe '.status_value(key) as #{enumattr_name}_value(key)' do
       context "present key" do
-        subject { described_class.status_value_by_key(:active) }
+        subject { described_class.status_value(:active) }
 
         it { should == 1 }
       end
 
       context "not present key" do
-        subject { described_class.status_value_by_key(:not_present_key) }
+        subject { described_class.status_value(:not_present_key) }
 
         it { should be_nil }
       end
@@ -65,7 +67,7 @@ describe User do
 
 
   describe "instance methods" do
-    let(:user) { User.new(1) }
+    let(:user) { described_class.new(1) }
 
     describe "#status" do
       subject { user.status }
@@ -73,44 +75,312 @@ describe User do
       it { should == 1 }
     end
 
-    describe '#status_enum as #{enum_attr_name}_enum' do
+    describe '#status_enum as #{enumattr_name}_enum' do
       subject { user.status_enum }
 
-      it { should be_a Enumattr::Enum }
+      it { should be_a Enumattr::Enums::Enum }
       its(:key)   { should == :active }
       its(:value) { should == 1 }
     end
 
-    describe '#status_key as #{enum_attr_name}_key' do
+    describe '#status_key as #{enumattr_name}_key' do
       subject { user.status_key }
 
       it { should be_a Symbol }
       it { should == :active }
     end
 
-    describe '#status_value as #{enum_attr_name}_value' do
+    describe '#status_key=(key) as #{enumattr_name}_key=(key)' do
+      before do
+        user.status_key = :inactive
+      end
+
+      subject { user }
+
+      its(:status)     { should == 2 }
+      its(:status_key) { should == :inactive }
+    end
+
+    describe '#status_value as #{enumattr_name}_value' do
       subject { user.status_value }
 
       it { should be_a Numeric }
       it { should == 1 }
     end
 
-    describe '#status_active? as #{enum_attr_name}_#{status_key}?' do
+    describe '#status_active? as #{enumattr_name}_#{status_key}?' do
       subject { user.status_active? }
 
       it { should be_true }
     end
 
-    describe '#status_suspend? as #{enum_attr_name}_#{other_status_key}?' do
-      subject { user.status_suspend? }
+    describe '#status_inactive? as #{enumattr_name}_#{other_status_key}?' do
+      subject { user.status_inactive? }
 
       it { should be_false }
     end
 
-    describe '#status_deleted? as #{enum_attr_name}_#{other_status_key}?' do
+    describe '#status_deleted? as #{enumattr_name}_#{other_status_key}?' do
       subject { user.status_deleted? }
 
       it { should be_false }
     end
+
+    context "out of range value" do
+      subject { user }
+      before { user.status = 4 }
+      its(:status_enum)      { should be_nil }
+      its(:status_key)       { should be_nil }
+      its(:status_value)     { should == 4 }
+      its(:status_active?)   { should be_false }
+      its(:status_inactive?) { should be_false }
+      its(:status_deleted?)  { should be_false }
+    end
+  end
+end
+
+
+describe AdminUser,"with :on option" do
+  describe 'class methods' do
+    describe '.authority_enums as #{enumattr_name}_enums' do
+      subject { described_class.authority_enums }
+
+      it { should be_a Set }
+      it { should have(3).items }
+      it "should have Enum instances" do
+        should satisfy { |enums|
+          enums.all?{|item| item.is_a? Enumattr::Enums::Enum }
+        }
+      end
+    end
+
+    describe '.authority_keys as #{enumattr_name}_keys' do
+      subject { described_class.authority_keys }
+
+      it { should be_a Set }
+      it { should have(3).items }
+      it "should have Symbol instances" do
+        should satisfy { |keys|
+          keys.all?{|item| item.is_a? Symbol }
+        }
+      end
+    end
+
+    describe '.authority_values as #{enumattr_name}_values' do
+      subject { described_class.authority_values }
+
+      it { should be_a Set }
+      it { should have(3).items }
+      it "should have Numeric instances" do
+        should satisfy { |values|
+          values.all?{|item| item.is_a? Numeric }
+        }
+      end
+    end
+
+    describe '.authority_enum(key) as #{enumattr_name}_enum(key)' do
+      subject { described_class.authority_enum(:super) }
+
+      it { should be_a Enumattr::Enums::Enum }
+      its(:key) { should == :super }
+      its(:value) { should == 1 }
+    end
+
+    describe '.authority_value(key) as #{enumattr_name}_value(key)' do
+      context "present key" do
+        subject { described_class.authority_value(:super) }
+
+        it { should == 1 }
+      end
+
+      context "not present key" do
+        subject { described_class.authority_value(:not_present_key) }
+
+        it { should be_nil }
+      end
+    end
+  end
+
+
+  describe "instance methods" do
+    let(:user) { described_class.new(1) }
+
+    describe "#role" do
+      subject { user.role }
+
+      it { should == 1 }
+    end
+
+    describe '#authority_enum as #{enumattr_name}_enum' do
+      subject { user.authority_enum }
+
+      it { should be_a Enumattr::Enums::Enum }
+      its(:key)   { should == :super }
+      its(:value) { should == 1 }
+    end
+
+    describe '#authority_key as #{enumattr_name}_key' do
+      subject { user.authority_key }
+
+      it { should be_a Symbol }
+      it { should == :super }
+    end
+
+    describe '#authority_key=(key) as #{enumattr_name}_key=(key)' do
+      before do
+        user.authority_key = :approver
+      end
+
+      subject { user }
+
+      its(:role) { should == 2 }
+      its(:authority_value) { should == 2 }
+      its(:authority_key) { should == :approver }
+    end
+
+    describe '#authority_value as #{enumattr_name}_value' do
+      subject { user.authority_value }
+
+      it { should be_a Numeric }
+      it { should == 1 }
+    end
+
+    describe '#authority_super? as #{enumattr_name}_#{authority_key}?' do
+      subject { user.authority_super? }
+
+      it { should be_true }
+    end
+
+    describe '#authority_approver? as #{enumattr_name}_#{other_authority_key}?' do
+      subject { user.authority_approver? }
+
+      it { should be_false }
+    end
+
+    describe '#authority_editor? as #{enumattr_name}_#{other_authority_key}?' do
+      subject { user.authority_editor? }
+
+      it { should be_false }
+    end
+  end
+end
+
+
+describe Entry,"with :enums option" do
+  describe 'class methods' do
+    describe '.show_flag_enums as #{enumattr_name}_enums' do
+      subject { described_class.show_flag_enums }
+
+      it { should be_a Set }
+      it { should have(2).items }
+      it "should have Enum instances" do
+        should satisfy { |enums|
+          enums.all?{|item| item.is_a? Enumattr::Enums::Enum }
+        }
+      end
+    end
+
+    describe '.show_flag_keys as #{enumattr_name}_keys' do
+      subject { described_class.show_flag_keys }
+
+      it { should be_a Set }
+      it { should have(2).items }
+      it "should have Symbol instances" do
+        should satisfy { |keys|
+          keys.all?{|item| item.is_a? Symbol }
+        }
+      end
+    end
+
+    describe '.show_flag_values as #{enumattr_name}_values' do
+      subject { described_class.show_flag_values }
+
+      it { should be_a Set }
+      it { should have(2).items }
+      it "should have TrueClass or FalseClass instances" do
+        should satisfy { |values|
+          values.all?{|item| item.is_a? TrueClass or item.is_a? FalseClass }
+        }
+      end
+    end
+
+    describe '.show_flag_enum(key) as #{enumattr_name}_enum(key)' do
+      subject { described_class.show_flag_enum(:opened) }
+
+      it { should be_a Enumattr::Enums::Enum }
+      its(:key) { should == :opened }
+      its(:value) { should == true }
+    end
+
+    describe '.show_flag_value(key) as #{enumattr_name}_value(key)' do
+      context "present key" do
+        subject { described_class.show_flag_value(:opened) }
+
+        it { should == true }
+      end
+
+      context "not present key" do
+        subject { described_class.show_flag_value(:not_present_key) }
+
+        it { should be_nil }
+      end
+    end
+  end
+
+
+  describe "instance methods" do
+    let(:entry) { described_class.new(true) }
+
+    describe "#show_flag" do
+      subject { entry.show_flag }
+
+      it { should == true }
+    end
+
+    describe '#show_flag_enum as #{enumattr_name}_enum' do
+      subject { entry.show_flag_enum }
+
+      it { should be_a Enumattr::Enums::Enum }
+      its(:key)   { should == :opened }
+      its(:value) { should == true }
+    end
+
+    describe '#show_flag_key as #{enumattr_name}_key' do
+      subject { entry.show_flag_key }
+
+      it { should be_a Symbol }
+      it { should == :opened }
+    end
+
+    describe '#show_flag_key=(key) as #{enumattr_name}_key=(key)' do
+      before do
+        entry.show_flag_key = :closed
+      end
+
+      subject { entry }
+
+      its(:show_flag) { should == false }
+      its(:show_flag_value) { should == false }
+      its(:show_flag_key) { should == :closed }
+    end
+
+    describe '#show_flag_value as #{enumattr_name}_value' do
+      subject { entry.show_flag_value }
+
+      it { should be_a TrueClass }
+      it { should == true }
+    end
+
+    describe '#show_flag_opened? as #{enumattr_name}_#{show_flag_key}?' do
+      subject { entry.show_flag_opened? }
+
+      it { should be_true }
+    end
+
+    describe '#show_flag_closed? as #{enumattr_name}_#{other_show_flag_key}?' do
+      subject { entry.show_flag_closed? }
+
+      it { should be_false }
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: enumattr
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-27 00:00:00.000000000 Z
+date: 2012-04-29 00:00:00.000000000 Z
 dependencies: []
 description: simple enum
 email:
@@ -25,17 +25,17 @@ files:
 - README.md
 - Rakefile
 - enumattr.gemspec
+- examples/admin_user.rb
+- examples/entry.rb
 - examples/user.rb
 - lib/enumattr.rb
 - lib/enumattr/base.rb
-- lib/enumattr/enum.rb
 - lib/enumattr/enums.rb
 - lib/enumattr/version.rb
-- spec/enumattr/enum_spec.rb
 - spec/enumattr/enums_spec.rb
 - spec/enumattr/included_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/aisuii/enumattr
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -55,12 +55,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: manage constants by enum like object
 test_files:
-- spec/enumattr/enum_spec.rb
 - spec/enumattr/enums_spec.rb
 - spec/enumattr/included_spec.rb
 - spec/spec_helper.rb

data/lib/enumattr/enum.rb

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module Enumattr
-  class Enum
-    attr_reader :key, :value
-
-    def initialize(key, value)
-      @key = key.to_sym
-      @value = value
-    end
-
-    def hash
-      @key.hash
-    end
-
-    def eql?(other)
-      @key == other.key
-    end
-  end
-end

data/spec/enumattr/enum_spec.rb

@@ -1,38 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'spec_helper'
-
-describe Enumattr::Enum do
-  let(:one_enum)      { Enumattr::Enum.new(:my_key, 1) }
-  let(:same_key_enum) { Enumattr::Enum.new(:my_key, 2) }
-  let(:another_enum)  { Enumattr::Enum.new(:another, 3) }
-
-  describe "getters" do
-    subject { one_enum }
-    its(:key)  { should == :my_key }
-    its(:value) { should == 1 }
-  end
-
-  describe "in hash key" do
-    context "when hash has same key enum as hash key" do
-      subject do
-        hash = {}
-        hash[one_enum]       = 1
-        hash[same_key_enum]  = 2 # only value overrided
-        hash[another_enum]   = 3
-        hash
-      end
-
-      its(:keys) { should     include one_enum      }
-      its(:keys) { should_not include same_key_enum }
-      its(:keys) { should     include another_enum  }
-
-      its(:values) { should_not include 1 }
-      its(:values) { should     include 2 }
-      its(:values) { should     include 3 }
-
-      it "should have 2 items" do
-        subject.should have(2).items
-      end
-    end
-  end
-end