enumeration 1.0.0 → 1.1.0

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    enumeration (1.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    json (1.5.1)
+    kelredd-useful (0.4.1)
+      json
+    leftright (0.9.1)
+    shoulda (2.11.3)
+    test-belt (0.2.1)
+      kelredd-useful (~> 0.4.0)
+      leftright (~> 0.9.0)
+      shoulda (~> 2.11)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  enumeration!
+  test-belt (= 0.2.1)

data/README.rdoc

@@ -8,10 +8,58 @@ add enumerated value attributes to your ruby classes
 
     gem install enumeration
 
-== Usage
+== Basic Example and Usage
 
     require 'enumeration'
 
+    class Thing
+      include Enumeration
+
+      # list enumeration
+      enum :word, %w{aye bee see}
+
+      # map enumeration
+      enum :stuff, {
+        :a => "aye",
+        :b => "bee",
+        :c => "see"
+      }
+    end
+
+    # get the enum sets
+    Thing.word_set      # => ['aye', 'bee', 'see']
+    Thing.stuff_set     # => [:a, :b, :c]
+
+    # lookup mapped enum values
+    Thing.stuff(:a)     # => "aye"
+
+
+    t = Thing.new
+
+    # write list enum values
+    t.word              # => nil
+    t.word = "aye"
+    t.word              # => "aye"
+    t.word_key          # => "aye" (a list's 'keys' are it's values, vice-versa)
+    t.word = "dee"
+    t.word              # => nil  (won't write non enum values)
+    t.word_key          # => nil
+
+    # write mapped enum value
+    t.stuff             # => nil
+    t.stuff = :b        #    (write using key)
+    t.stuff             # => "bee"
+    t.stuff_key         # => :b
+    t.stuff = "see"     #    (write using value)
+    t.stuff             # => "see"
+    t.stuff_key         # => :c
+    t.stuff = :d
+    t.stuff             # => nil (won't write non enum keys)
+    t.stuff_key         # => nil
+    t.stuff = "dee"
+    t.stuff             # => nil (won't write non enum values)
+    t.stuff_key         # => nil
+
 == License
 
 Copyright (c) 2011 Kelly D. Redding

data/lib/enumeration.rb

@@ -11,8 +11,9 @@ module Enumeration
       # define an anonymous Module to extend on
       # defining a class level map reader
       class_methods = Module.new do
-        define_method(name) {|k| class_variable_get("@@#{name}")[k]} if c.map?
+        define_method(name.to_s+'_collection') { c.data }
         define_method(name.to_s+'_set') { c.set }
+        define_method(name) {|k| class_variable_get("@@#{name}")[k]} if c.map?
       end
 
       # set a class variable to store the enum map (used by above reader)
@@ -30,8 +31,12 @@ module Enumeration
       end
 
       # instance reader for the enum value
-      define_method(name) do
-        instance_variable_get("@#{name}")
+      define_method(name) { instance_variable_get("@#{name}") }
+
+      # instance reader for the enum key
+      define_method(name.to_s+'_key') do
+        c = self.class.send(:class_variable_get, "@@#{name}")
+        c.key(instance_variable_get("@#{name}"))
       end
     end
   end

data/lib/enumeration/collection.rb

@@ -1,6 +1,8 @@
 module Enumeration
   class Collection
 
+    attr_reader :data
+
     def initialize(map_or_list)
       unless map_or_list.kind_of?(::Hash) || map_or_list.kind_of?(::Array)
         raise ArgumentError, "please specify the enum collection as a Hash or Array"
@@ -8,11 +10,24 @@ module Enumeration
       @data = map_or_list
     end
 
-    def [](value)
-      if self.map? && @data.has_key?(value)
-        @data[value]
-      elsif (self.map? && @data.has_value?(value)) ||
-            (@data.include?(value))
+    # lookup collection value by a key
+    def [](key)
+      if self.map? && @data.has_key?(key)
+        @data[key]
+      elsif (self.map?  && @data.has_value?(key)) ||
+            (self.list? && @data.include?(key))
+        key
+      else
+        nil
+      end
+    end
+
+    # lookup collection key by a value
+    def key(value)
+      if self.map? && @data.has_value?(value)
+        @data.index(value)
+      elsif (self.map?  && @data.has_key?(value)) ||
+            (self.list? && @data.include?(value))
         value
       else
         nil

data/lib/enumeration/version.rb

@@ -1,3 +1,3 @@
 module Enumeration
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/test/collection_test.rb

@@ -5,6 +5,7 @@ class CollectionAPITest < Test::Unit::TestCase
   context "Enumeration collection" do
     subject { Enumeration::Collection.new([]) }
 
+    should_have_reader :data
     should_have_instance_methods :set, :map?, :list?, :[]
 
     should "only be created from Arrays or Hashes" do
@@ -29,14 +30,22 @@ class ListCollectionTest < Test::Unit::TestCase
       assert_equal false, subject.map?
     end
 
+    should "know it's data" do
+      assert_equal ['one', 'two', 'three'], subject.data
+    end
+
     should "know it's set" do
       assert_equal ['one', 'two', 'three'], subject.set
     end
 
-    should "lookup by value" do
+    should "lookup value by key" do
       assert_equal 'two', subject['two']
     end
 
+    should "lookup key by value" do
+      assert_equal 'three', subject.key('three')
+    end
+
   end
 end
 
@@ -49,17 +58,29 @@ class MapCollectionTest < Test::Unit::TestCase
       assert_equal false, subject.list?
     end
 
+    should "know it's data" do
+      assert_equal({:one=>1,:two=>2,:three=>3}, subject.data)
+    end
+
     should "know it's set" do
       [:one, :two, :three].each{|n| assert subject.set.include?(n)}
     end
 
-    should "lookup by key" do
+    should "lookup value by key" do
       assert_equal 2, subject[:two]
     end
 
-    should "lookup by value" do
+    should "lookup value by value" do
       assert_equal 2, subject[2]
     end
 
+    should "lookup key by value" do
+      assert_equal :two, subject.key(2)
+    end
+
+    should "lookup key by key" do
+      assert_equal :two, subject.key(:two)
+    end
+
   end
 end

data/test/list_enum_test.rb

@@ -9,7 +9,7 @@ class ListEnumTest < Test::Unit::TestCase
       Thing.send(:enum, :word, %w{aye bee see})
     end
 
-    should_have_class_method :word_set
+    should_have_class_methods :word_set, :word_collection
     should_have_accessor :word
 
     should "not have a class level lookup method" do
@@ -25,16 +25,23 @@ class ListEnumTest < Test::Unit::TestCase
       assert !words.empty?
       assert_equal 3, words.size
       assert_equal ['aye', 'bee', 'see'], Thing.word_set
+      assert_equal Thing.word_set, Thing.word_collection
     end
 
-    should "write by value and read by value" do
+    should "write a value and read the value" do
       subject.word = "see"
       assert_equal "see", subject.word
     end
 
+    should "write a value and read the key" do
+      subject.word = "see"
+      assert_equal "see", subject.word_key
+    end
+
     should "write nil for values that aren't in the enum" do
       subject.word = "bady-bad"
       assert_equal nil, subject.word
+      assert_equal nil, subject.word_key
     end
 
   end

data/test/map_enum_test.rb

@@ -13,7 +13,7 @@ class MapEnumTest < Test::Unit::TestCase
       })
     end
 
-    should_have_class_methods :stuff, :stuff_set
+    should_have_class_methods :stuff, :stuff_set, :stuff_collection
     should_have_accessor :stuff
 
     should "provide class level access to the enum set" do
@@ -23,23 +23,26 @@ class MapEnumTest < Test::Unit::TestCase
       assert !stuffs.empty?
       assert_equal 3, stuffs.size
       [:a, :b, :c].each{|t| assert Thing.stuff_set.include?(t)}
+      assert_equal({:a=>'aye',:b=>'bee',:c=>'see'}, Thing.stuff_collection)
     end
 
     should "provide class level lookup of the enum" do
       assert_equal "aye", Thing.stuff(:a)
     end
 
-    should "write by key and read by value" do
+    should "write a key and read the value and key" do
       subject.stuff = :b
       assert_equal "bee", subject.stuff
+      assert_equal :b, subject.stuff_key
     end
 
-    should "write by value and read by value" do
+    should "write a value and read the value" do
       subject.stuff = "see"
       assert_equal "see", subject.stuff
+      assert_equal :c, subject.stuff_key
     end
 
-    should "not read by key" do
+    should "not read keys like you would values" do
       subject.stuff = :c
       assert_not_equal :c, subject.stuff
     end
@@ -47,11 +50,13 @@ class MapEnumTest < Test::Unit::TestCase
     should "write nil for keys that aren't in the enum" do
       subject.stuff = :bad
       assert_equal nil, subject.stuff
+      assert_equal nil, subject.stuff_key
     end
 
     should "write nil for values that aren't in the enum" do
       subject.stuff = "bady-bad"
       assert_equal nil, subject.stuff
+      assert_equal nil, subject.stuff_key
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: enumeration
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Kelly D. Redding
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-05 00:00:00 -05:00
+date: 2011-04-06 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,6 +61,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- Gemfile.lock
 - README.rdoc
 - Rakefile
 - enumeration.gemspec