enumeration 1.3.1 → 1.3.2

data/.gitignore

@@ -1,4 +1,19 @@
-pkg/*
-.bundle
 *.gem
-*.log
+*.log
+*.rbc
+.rbx/
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -1,5 +1,6 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gemspec
 
-gem 'rake', '~>0.9.2'
+gem 'rake', "~> 10.4.0"
+gem 'pry', "~> 0.9.0"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2011-Present Kelly Redding and Collin Redding
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# Enumeration
+
+Add enumerated value attributes to your ruby classes.
+
+## Usage
+
+```ruby
+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
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'enumeration'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install enumeration
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -1,7 +1 @@
-require 'assert/rake_tasks'
-include Assert::RakeTasks
-
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-task :default => :build
+require "bundler/gem_tasks"

data/enumeration.gemspec

@@ -1,22 +1,23 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "enumeration/version"
 
-Gem::Specification.new do |s|
-  s.name        = "enumeration"
-  s.version     = Enumeration::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Kelly D. Redding"]
-  s.email       = ["kelly@kelredd.com"]
-  s.homepage    = "http://github.com/kelredd/enumeration"
-  s.summary     = %q{add enumerated value attributes to your ruby classes}
-  s.description = %q{add enumerated value attributes to your ruby classes}
+Gem::Specification.new do |gem|
+  gem.name        = "enumeration"
+  gem.version     = Enumeration::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.description = %q{Add enumerated value attributes to your ruby classes.}
+  gem.summary     = %q{Add enumerated value attributes to your ruby classes.}
+  gem.homepage    = "http://github.com/redding/enumeration"
+  gem.license     = 'MIT'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert", ["~> 2.13"])
 
-  s.add_development_dependency("bundler", ["~> 1.0"])
-  s.add_development_dependency("assert", ["~> 0.7"])
 end

data/lib/enumeration.rb

@@ -1,4 +1,4 @@
-module Enumeration; end
+require 'enumeration/version'
 require 'enumeration/collection'
 
 module Enumeration

data/lib/enumeration/assert_macros.rb

@@ -1,55 +1,58 @@
-module Enumeration; end
-module Enumeration::AssertMacros
+module Enumeration
 
-  # a set of Assert macros to help write enum definition and
-  # regression tests in Assert (https://github.com/teaminsight/assert)
+  module AssertMacros
 
-  def self.included(receiver)
-    receiver.class_eval do
-      extend MacroMethods
-    end
-  end
+    # a set of Assert macros to help write enum definition and
+    # regression tests in Assert (https://github.com/teaminsight/assert)
 
-  module MacroMethods
-
-    def have_enum(name, *args)
-      values = [*args].flatten
-      type = nil
-      if values.first.kind_of?(::Hash)
-        values = values.first
-        type = 'map'
-      elsif !values.empty?
-        type = 'list'
+    def self.included(receiver)
+      receiver.class_eval do
+        extend MacroMethods
       end
+    end
 
-      called_from = caller.first
-      macro_name =  "have the"
-      macro_name += " #{type}" if type
-      macro_name += " enum '#{name}'"
-      macro_name += " with #{values.inspect} values" if !values.empty?
+    module MacroMethods
 
-      Assert::Macro.new(macro_name) do
-        should have_accessor name, [called_from]
+      def have_enum(name, *args)
+        values = [*args].flatten
+        type = nil
+        if values.first.kind_of?(::Hash)
+          values = values.first
+          type = 'map'
+        elsif !values.empty?
+          type = 'list'
+        end
 
-        should have_class_method "#{name}_collection", [called_from]
+        called_from = caller.first
+        macro_name =  "have the"
+        macro_name += " #{type}" if type
+        macro_name += " enum '#{name}'"
+        macro_name += " with #{values.inspect} values" if !values.empty?
 
-        if type == 'map'
-          should have_class_method name, [called_from]
-        end
+        Assert::Macro.new(macro_name) do
+          should have_accessor name, [called_from]
 
-        if !values.empty?
-          should "know its '#{name}' enum values", called_from do
-            assert_equal values, subject.class.send("#{name}_collection")
-          end
+          should have_class_method "#{name}_collection", [called_from]
 
           if type == 'map'
-            should "map the '#{name}' enum values at the class level", called_from do
-              values.each {|k,v| assert_equal v, subject.class.send(name, k)}
+            should have_class_method name, [called_from]
+          end
+
+          if !values.empty?
+            should "know its '#{name}' enum values", called_from do
+              assert_equal values, subject.class.send("#{name}_collection")
+            end
+
+            if type == 'map'
+              should "map the '#{name}' enum values at the class level", called_from do
+                values.each {|k,v| assert_equal v, subject.class.send(name, k)}
+              end
             end
           end
-        end
 
+        end
       end
+
     end
 
   end

data/lib/enumeration/collection.rb

@@ -1,49 +1,52 @@
-module Enumeration; end
-class Enumeration::Collection
+module Enumeration
 
-  attr_reader :data
+  class Collection
 
-  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"
+    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"
+      end
+      @data = map_or_list
     end
-    @data = map_or_list
-  end
 
-  # 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
+    # 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
-  end
 
-  # lookup collection key by a value
-  def key(value)
-    if self.map? && @data.has_value?(value)
-      @data.invert[value]
-    elsif (self.map?  && @data.has_key?(value)) ||
-          (self.list? && @data.include?(value))
-      value
-    else
-      nil
+    # lookup collection key by a value
+    def key(value)
+      if self.map? && @data.has_value?(value)
+        @data.invert[value]
+      elsif (self.map?  && @data.has_key?(value)) ||
+            (self.list? && @data.include?(value))
+        value
+      else
+        nil
+      end
     end
-  end
 
-  def list?
-    @data.kind_of?(::Array)
-  end
+    def list?
+      @data.kind_of?(::Array)
+    end
 
-  def map?
-    @data.kind_of?(::Hash)
-  end
+    def map?
+      @data.kind_of?(::Hash)
+    end
+
+    def set
+      self.map? ? @data.keys : @data
+    end
 
-  def set
-    self.map? ? @data.keys : @data
   end
 
 end

data/lib/enumeration/version.rb

@@ -1,3 +1,3 @@
 module Enumeration
-  VERSION = "1.3.1"
+  VERSION = "1.3.2"
 end

data/test/helper.rb

@@ -1,7 +1,10 @@
-# this file is automatically required in when you require 'assert'
-# put test helpers here
+# this file is automatically required when you run `assert`
+# put any test helpers here
 
-# add root dir to the load path
+# add the root dir to the load path
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
-require 'test/thing'
+# require pry for debugging (`binding.pry`)
+require 'pry'
+
+require 'test/support/factory'

data/test/support/factory.rb

@@ -0,0 +1,6 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+end

data/test/{assert_macros_test.rb → unit/assert_macros_tests.rb}

@@ -1,25 +1,27 @@
 require 'assert'
-
-require 'enumeration'
 require 'enumeration/assert_macros'
 
 module Enumeration::AssertMacros
 
-  class BaseTests < Assert::Context
-    desc "Enumeration::AssertMacros"
+  class UnitTests < Assert::Context
     include Enumeration::AssertMacros
 
-    before do
-      Thing.send :include, Enumeration
-      Thing.send(:enum, :list, %w{aye bee see})
-      Thing.send(:enum, :map, {
-        :a => "aye",
-        :b => "bee",
-        :c => "see"
-      })
-      @a_thing = Thing.new
+    desc "Enumeration::AssertMacros"
+    setup do
+      @enum_class = Class.new do
+        include Enumeration
+
+        enum :list, %w{aye bee see}
+
+        enum :map, {
+          :a => "aye",
+          :b => "bee",
+          :c => "see"
+        }
+      end
+      @enum = @enum_class.new
     end
-    subject { @a_thing }
+    subject{ @enum }
 
     should have_enum :list
     should have_enum :list, ['aye', 'bee', 'see']

data/test/unit/collection_tests.rb

@@ -0,0 +1,100 @@
+require "assert"
+require "enumeration/collection"
+
+class Enumeration::Collection
+
+  class UnitTests < Assert::Context
+    desc "Enumeration::Collection"
+    setup do
+      @collection = Enumeration::Collection.new([])
+    end
+    subject{ @collection }
+
+    should have_readers :data
+    should have_imeths :[], :key, :list?, :map?, :set
+
+    should "only be created from Arrays or Hashes" do
+      assert_raises ArgumentError do
+        Enumeration::Collection.new(Factory.string)
+      end
+      assert_nothing_raised do
+        Enumeration::Collection.new([])
+        Enumeration::Collection.new({})
+      end
+    end
+
+  end
+
+  class ListCollectionTests < UnitTests
+    desc "for a list"
+    setup do
+      @list = ['one', 'two', 'three']
+      @collection = Enumeration::Collection.new(@list)
+    end
+
+    should "be a list" do
+      assert_true  subject.list?
+      assert_false subject.map?
+    end
+
+    should "know its data" do
+      assert_equal @list, subject.data
+    end
+
+    should "know its set" do
+      assert_equal @list, subject.set
+    end
+
+    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
+
+  class MapCollectionTests < UnitTests
+    desc "for a map"
+    setup do
+      @map = {
+        :one   => 1,
+        :two   => 2,
+        :three => 3
+      }
+      @collection = Enumeration::Collection.new(@map)
+    end
+
+    should "be a map" do
+      assert_true  subject.map?
+      assert_false subject.list?
+    end
+
+    should "know its data" do
+      assert_equal(@map, subject.data)
+    end
+
+    should "know it's set" do
+      @map.keys.each{ |k| assert subject.set.include?(k) }
+    end
+
+    should "lookup value by key" do
+      assert_equal 2, subject[:two]
+    end
+
+    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/unit/enumeration_tests.rb

@@ -0,0 +1,117 @@
+require "assert"
+require 'enumeration'
+
+module Enumeration
+
+  class UnitTests < Assert::Context
+    desc "Enumeration"
+    setup do
+      @enum_class = Class.new{ include Enumeration }
+      @enum = @enum_class.new
+    end
+    subject{ @enum }
+
+    should have_class_method :enum
+
+  end
+
+  class ListEnumTests < UnitTests
+    desc "for a list"
+    setup do
+      @enum_class.send(:enum, :word, %w{aye bee see})
+    end
+
+    should have_cmeths :word_set, :word_collection
+    should have_accessor :word
+
+    should "not have a class level lookup method" do
+      assert_raises NoMethodError do
+        @enum_class.word
+      end
+    end
+
+    should "provide class level access to the enum list" do
+      words = @enum_class.word_set
+      assert_kind_of ::Array, words
+      assert_equal 3, words.size
+      assert_equal ['aye', 'bee', 'see'], words
+      assert_equal words, @enum_class.word_collection
+    end
+
+    should "write a value and read the value" do
+      subject.word = "see"
+      assert_equal "see", subject.word
+      assert_equal "see", subject.word_key
+    end
+
+    should "write nil for values that aren't in the enum" do
+      subject.word = Factory.string
+      assert_equal nil, subject.word
+      assert_equal nil, subject.word_key
+    end
+
+  end
+
+  class MapEnumTests < UnitTests
+    desc "for a map"
+    setup do
+      @enum_class.send(:enum, :stuff, {
+        :a => "aye",
+        :b => "bee",
+        :c => "see"
+      })
+    end
+
+    should have_cmeths :stuff, :stuff_set, :stuff_collection
+    should have_accessor :stuff
+
+    should "provide class level lookup of the enum" do
+      assert_equal "aye", @enum_class.stuff(:a)
+    end
+
+    should "provide class level access to the enum set" do
+      stuffs = @enum_class.stuff_set
+      assert_kind_of ::Array, stuffs
+      assert_equal 3, stuffs.size
+      [:a, :b, :c].each{ |s| assert @enum_class.stuff_set.include?(s) }
+
+      exp = {
+        :a => 'aye',
+        :b => 'bee',
+        :c => 'see'
+      }
+      assert_equal exp, @enum_class.stuff_collection
+    end
+
+    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 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 keys like you would values" do
+      subject.stuff = :c
+      assert_not_equal :c, subject.stuff
+    end
+
+    should "write nil for keys that aren't in the enum" do
+      subject.stuff = Factory.string.to_sym
+      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 = Factory.string
+      assert_equal nil, subject.stuff
+      assert_equal nil, subject.stuff_key
+    end
+
+  end
+
+end

metadata

@@ -1,55 +1,42 @@
 --- !ruby/object:Gem::Specification 
 name: enumeration
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 1
   - 3
-  - 1
-  version: 1.3.1
+  - 2
+  version: 1.3.2
 platform: ruby
 authors: 
-- Kelly D. Redding
+- Kelly Redding
+- Collin Redding
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2012-01-10 00:00:00 Z
+date: 2015-02-28 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  type: :development
-  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 25
         segments: 
-        - 1
-        - 0
-        version: "1.0"
-  version_requirements: *id001
-  name: bundler
-- !ruby/object:Gem::Dependency 
+        - 2
+        - 13
+        version: "2.13"
   type: :development
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 0
-        - 7
-        version: "0.7"
-  version_requirements: *id002
   name: assert
-description: add enumerated value attributes to your ruby classes
+  version_requirements: *id001
+  prerelease: false
+description: Add enumerated value attributes to your ruby classes.
 email: 
-- kelly@kelredd.com
+- kelly@kellyredding.com
+- collin.redding@me.com
 executables: []
 
 extensions: []
@@ -59,25 +46,22 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
-- Gemfile.lock
-- README.rdoc
+- LICENSE.txt
+- README.md
 - Rakefile
 - enumeration.gemspec
 - lib/enumeration.rb
 - lib/enumeration/assert_macros.rb
 - lib/enumeration/collection.rb
 - lib/enumeration/version.rb
-- test/api_test.rb
-- test/assert_macros_test.rb
-- test/collection_test.rb
 - test/helper.rb
-- test/irb.rb
-- test/list_enum_test.rb
-- test/map_enum_test.rb
-- test/thing.rb
-homepage: http://github.com/kelredd/enumeration
-licenses: []
-
+- test/support/factory.rb
+- test/unit/assert_macros_tests.rb
+- test/unit/collection_tests.rb
+- test/unit/enumeration_tests.rb
+homepage: http://github.com/redding/enumeration
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: []
 
@@ -104,16 +88,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.29
 signing_key: 
 specification_version: 3
-summary: add enumerated value attributes to your ruby classes
+summary: Add enumerated value attributes to your ruby classes.
 test_files: 
-- test/api_test.rb
-- test/assert_macros_test.rb
-- test/collection_test.rb
 - test/helper.rb
-- test/irb.rb
-- test/list_enum_test.rb
-- test/map_enum_test.rb
-- test/thing.rb
+- test/support/factory.rb
+- test/unit/assert_macros_tests.rb
+- test/unit/collection_tests.rb
+- test/unit/enumeration_tests.rb

data/Gemfile.lock

@@ -1,25 +0,0 @@
-PATH
-  remote: .
-  specs:
-    enumeration (1.3.1)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    ansi (1.4.1)
-    assert (0.7.3)
-      assert-view (~> 0.5)
-    assert-view (0.5.0)
-      ansi (~> 1.3)
-      undies (~> 2.0)
-    rake (0.9.2)
-    undies (2.0.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  assert (~> 0.7)
-  bundler (~> 1.0)
-  enumeration!
-  rake (~> 0.9.2)

data/README.rdoc

@@ -1,86 +0,0 @@
-= Enumeration
-
-== Description
-
-add enumerated value attributes to your ruby classes
-
-== Installation
-
-    gem install enumeration
-
-== 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
-
-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/test/api_test.rb

@@ -1,15 +0,0 @@
-require "assert"
-
-require 'enumeration'
-
-class APITest < Assert::Context
-  desc "Enumeration mixin"
-
-  subject { Thing.new }
-  before do
-    Thing.send :include, Enumeration
-  end
-
-  should have_class_method :enum
-
-end

data/test/collection_test.rb

@@ -1,84 +0,0 @@
-require "assert"
-
-require "enumeration/collection"
-
-class CollectionAPITest < Assert::Context
-  desc "Enumeration collection"
-  subject { Enumeration::Collection.new([]) }
-
-  should have_reader :data
-  should have_instance_methods :set, :map?, :list?, :[]
-
-  should "only be created from Arrays or Hashes" do
-    assert_raises ArgumentError do
-      Enumeration::Collection.new('stuff')
-    end
-    assert_nothing_raised do
-      Enumeration::Collection.new([])
-      Enumeration::Collection.new({})
-    end
-  end
-
-end
-
-class ListCollectionTest < Assert::Context
-  desc "List collection"
-  subject { Enumeration::Collection.new(['one', 'two', 'three']) }
-
-  should "be a list" do
-    assert_equal true, subject.list?
-    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 value by key" do
-    assert_equal 'two', subject['two']
-  end
-
-  should "lookup key by value" do
-    assert_equal 'three', subject.key('three')
-  end
-
-end
-
-class MapCollectionTest < Assert::Context
-  desc "Map collection"
-  subject { Enumeration::Collection.new({ :one => 1, :two => 2, :three => 3}) }
-
-  should "be a map" do
-    assert_equal true, subject.map?
-    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 value by key" do
-    assert_equal 2, subject[:two]
-  end
-
-  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

data/test/irb.rb

@@ -1,10 +0,0 @@
-require 'assert/setup'
-
-# this file is required in when the 'irb' rake test is run.
-# b/c 'assert' is required above, the test helper will be
-# required in.
-
-# put any IRB setup code here
-
-require 'enumeration'
-

data/test/list_enum_test.rb

@@ -1,51 +0,0 @@
-require "assert"
-
-require 'enumeration'
-
-class ListEnumTest < Assert::Context
-  desc "instance"
-
-  subject { @a_thing }
-  before do
-    Thing.send :include, Enumeration
-    Thing.send(:enum, :word, %w{aye bee see})
-    @a_thing = Thing.new
-  end
-
-  should have_class_methods :word_set, :word_collection
-  should have_accessor :word
-
-  should "not have a class level lookup method" do
-    assert_raises NoMethodError do
-      Thing.word
-    end
-  end
-
-  should "provide class level access to the enum set" do
-    words = Thing.word_set
-    assert words
-    assert_kind_of ::Array, words
-    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 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

@@ -1,65 +0,0 @@
-require "assert"
-
-require 'enumeration'
-
-class MapEnumTest < Assert::Context
-  desc "instance"
-
-  subject { @a_thing }
-  before do
-    Thing.send :include, Enumeration
-    Thing.send(:enum, :stuff, {
-      :a => "aye",
-      :b => "bee",
-      :c => "see"
-    })
-    @a_thing = Thing.new
-  end
-
-  should have_class_methods :stuff, :stuff_set, :stuff_collection
-  should have_accessor :stuff
-
-  should "provide class level access to the enum set" do
-    stuffs = Thing.stuff_set
-    assert stuffs
-    assert_kind_of ::Array, stuffs
-    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 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 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 keys like you would values" do
-    subject.stuff = :c
-    assert_not_equal :c, subject.stuff
-  end
-
-  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

data/test/thing.rb

@@ -1,3 +0,0 @@
-class Thing
-  attr_accessor :one, :two, :three
-end