enumb 0.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in Renum.gemspec
+
+gem 'rspec'
+gem 'simplecov'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Manther
+
+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,177 @@
+# Renum
+
+Authors: Jason Young
+
+Renum helps developers create an enum class in Ruby that closely resembles commonly found enum behavior in most popular languages.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'Renum'
+
+Install as Ruby Gem:
+
+    gem install renums
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install Renum
+
+## Usage
+
+Simply extend the Enum module and define a class with as many enumerators as desired.
+
+Example:
+```ruby
+class TestEnumByte
+   extend Renum
+   enumerator :Nones => 0x0000
+   enumerator :Somes => 0x0001
+   enumerator :Anys => 0x0002
+   enumerator :Each => 0x0004
+end
+```
+
+Further examples can be seen in spec test:
+
+```ruby
+require 'Renum'
+describe 'Renum' do
+  context 'Given a class extends Renum' do
+    it 'if not passed a hash expect exception' do
+      class TestEnumNoHash
+        extend Renum
+
+        def init_enumerators
+          enumerator 'None'
+        end
+      end
+      expect { puts TestEnumNoHash.whatever }.to raise_error(Exception)
+    end
+    it 'if class has enumerator undefined expect exception' do
+      class TestEnumUndefined
+        extend Renum
+        enumerator 'None' => '123'
+      end
+      expect { puts TestEnumUndefined.whatever }.to raise_error(Exception)
+    end
+    it 'if class has multiple nodes defined for enumerator hash expect exception' do
+      expect {
+        class TestEnumMultiple
+          extend Renum
+          enumerator :None => '123', :Stuff => 456
+        end
+        TestEnumMultiple.None
+      }.to raise_error(Exception)
+    end
+    it 'if class does not have referenced enumerator defined expect exception' do
+      class TestEnumMissing
+        extend Renum
+        #nothing here
+      end
+      expect { puts TestEnumMissing.whatever }.to raise_error(Exception)
+    end
+    it 'if enum class enumerator keys are strings, values should evaluate correctly' do
+      class TestEnumStringKeys
+        extend Renum
+        enumerator 'None' => '123'
+        enumerator 'Some' => '456'
+      end
+      expect(TestEnumStringKeys.None).to eq('123')
+    end
+    it 'if enum class enumerator keys are symbols, values should evaluate correctly' do
+      class TestEnumSyms
+        extend Renum
+        enumerator :Nones => '123'
+        enumerator :Somes => '456'
+      end
+      expect(TestEnumSyms.Nones).to eq('123')
+    end
+    it 'if enum class has byte valued enumerators, bitwise comparisons should evaluate correctly' do
+      class TestEnumByte
+        extend Renum
+        enumerator :Nones => 0x0000
+        enumerator :Somes => 0x0001
+        enumerator :Anys => 0x0002
+        enumerator :Each => 0x0004
+      end
+
+      testItem = TestEnumByte.Nones
+      testItem = testItem | TestEnumByte.Anys
+      expect(((testItem & TestEnumByte.Each) == TestEnumByte.Each)).to eq(false)
+      expect(((testItem & TestEnumByte.Anys) == TestEnumByte.Anys)).to eq(true)
+      expect(((testItem & TestEnumByte.Anys) != 0)).to eq(true)
+      expect(((testItem & TestEnumByte.Somes) != 0)).to eq(false)
+    end
+    it 'if enum values are ints values should evaluate correctly' do
+      class TestEnumInts
+        extend Renum
+        enumerator :Nones => 1
+        enumerator :Somes => 2
+        enumerator :Anys => 3
+        enumerator :Each => 4
+      end
+      expect(TestEnumInts.Nones).to eq(1)
+      expect(TestEnumInts.Somes).to eq(2)
+      expect(TestEnumInts.Anys).to eq(3)
+      expect(TestEnumInts.Each).to eq(4)
+    end
+    it 'if enum values are bools values should evaluate correctly' do
+      class Tristate
+        extend Renum
+        enumerator :True => true
+        enumerator :False => false
+        enumerator :Undef => 'Undefined'
+      end
+      expect(Tristate.True).to eq(true)
+      expect(Tristate.False).to eq(false)
+      expect(Tristate.Undef).to eq('Undefined')
+    end
+    it 'if to_descriptor called, should evaluate correctly' do
+      class TestEnumDescriptor
+        extend Renum
+        enumerator :Nones => '123'
+        enumerator :Somes => '456'
+      end
+      expect(TestEnumDescriptor.to_descriptor('123')).to eq('Nones')
+    end
+    it 'if to_value called, should evaluate correctly' do
+      class TestEnumToValue
+        extend Renum
+        enumerator :Nones => '123'
+        enumerator :Somes => '456'
+      end
+      expect(TestEnumToValue.to_value(:Nones)).to eq('123')
+    end
+    it 'if iterate over enum correct values yielded' do
+      class TestEnumToIterate
+        extend Renum
+        enumerator :Nones => 0x0000
+        enumerator :Somes => 0x0001
+        enumerator :Anys => 0x0002
+        enumerator :Each => 0x0004
+      end
+
+      TestEnumToIterate.each do |x|
+        expect((((TestEnumToIterate.Nones |
+            TestEnumToIterate.Somes |
+            TestEnumToIterate.Anys |
+            TestEnumToIterate.Each) & x) == x)).to eq(true)
+      end
+    end
+  end
+end
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/Renum.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'Renum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "enumb"
+  spec.version       = Renum::VERSION
+  spec.authors       = ["Manther"]
+  spec.email         = ["jason.manther.young@gmail.com"]
+  spec.description   = %q{Renum helps developers create an enum like object in Ruby that closely resembles commonly found enum behavior of popular statically typed languages.}
+  spec.summary       = %q{Enum module}
+  spec.homepage      = "http://jasonwyoung.blogspot.com/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/Renum/version.rb

@@ -0,0 +1,3 @@
+module Renum
+  VERSION = "0.0.1"
+end

data/lib/Renum.rb

@@ -0,0 +1,59 @@
+#
+# ***********************************************************************
+#  Copyright (c) 2014, Jason Young and Contributors. All Rights Reserved.
+# ***********************************************************************
+#
+
+require "Renum/version"
+
+module Renum
+  Enumerator
+  def enumerator(hash)
+    raise 'Parameter must be hash' unless hash.is_a?(Hash)
+    raise 'Multiple key/value pairs passed. Only single pair accepted.' unless hash.length == 1
+    key, val = hash.first
+    raise 'Enumerator key needs to be convertible to string' unless key.respond_to?(:to_s)
+    create_class_method(key.to_s) {
+      self.class_variable_get(String('@@__enum__' + key.to_s).to_sym)
+    }
+    self.class_variable_set(String('@@__enum__' + key.to_s).to_sym, val)
+  end
+
+  def to_descriptor(value)
+    self.methods.each do |x|
+      if ((self.send(x) rescue nil) == value)
+        return x.to_s
+      end
+    end
+  end
+
+  def parse(descriptor)
+    raise Exception('Descriptor needs to be convertible to string') unless descriptor.respond_to?(:to_s)
+    self.class_variables.each do |x|
+      if x.to_s.downcase == '@@__enum__' + descriptor.to_s.downcase
+        return self.class_variable_get(x)
+      end
+    end
+  end
+
+  def each
+    self.class_variables.each do |e|
+      if (e.to_s.include? '__enum__')
+        yield(self.class_variable_get(e))
+      end
+    end
+  end
+
+  private
+  def create_class_method(name, &block)
+    self.class.send(:define_method, name, &block)
+  end
+
+  #decided not to limit in these ways, but;
+  #if you want your enum sealed implement something similar
+  #def inherited subclass
+  #  raise "class #{subclass} cannot be derived from sealed class #{self}"
+  #end
+  #you may also want to add self.freeze if you are heading down this restrictive path.
+
+end

data/spec/unit/Renum_spec.rb

@@ -0,0 +1,133 @@
+#
+# ***********************************************************************
+#  Copyright (c) 2014, Jason Young and Contributors. All Rights Reserved.
+# ***********************************************************************
+#
+
+require 'Renum'
+describe 'Renum' do
+  context 'Given a class extends Renum' do
+    it 'if not passed a hash expect exception' do
+      class TestEnumNoHash
+        extend Renum
+
+        def init_enumerators
+          enumerator 'None'
+        end
+      end
+      expect { puts TestEnumNoHash.whatever }.to raise_error(Exception)
+    end
+    it 'if class has enumerator undefined expect exception' do
+      class TestEnumUndefined
+        extend Renum
+        enumerator 'None' => '123'
+      end
+      expect { puts TestEnumUndefined.whatever }.to raise_error(Exception)
+    end
+    it 'if class has multiple nodes defined for enumerator hash expect exception' do
+      expect {
+        class TestEnumMultiple
+          extend Renum
+          enumerator :None => '123', :Stuff => 456
+        end
+        TestEnumMultiple.None
+      }.to raise_error(Exception)
+    end
+    it 'if class does not have referenced enumerator defined expect exception' do
+      class TestEnumMissing
+        extend Renum
+        #nothing here
+      end
+      expect { puts TestEnumMissing.whatever }.to raise_error(Exception)
+    end
+    it 'if enum class enumerator keys are strings, values should evaluate correctly' do
+      class TestEnumStringKeys
+        extend Renum
+        enumerator 'None' => '123'
+        enumerator 'Some' => '456'
+      end
+      expect(TestEnumStringKeys.None).to eq('123')
+    end
+    it 'if enum class enumerator keys are symbols, values should evaluate correctly' do
+      class TestEnumSyms
+        extend Renum
+        enumerator :Nones => '123'
+        enumerator :Somes => '456'
+      end
+      expect(TestEnumSyms.Nones).to eq('123')
+    end
+    it 'if enum class has byte valued enumerators, bitwise comparisons should evaluate correctly' do
+      class TestEnumByte
+        extend Renum
+        enumerator :Nones => 0x0000
+        enumerator :Somes => 0x0001
+        enumerator :Anys => 0x0002
+        enumerator :Each => 0x0004
+      end
+
+      testItem = TestEnumByte.Nones
+      testItem = testItem | TestEnumByte.Anys
+      expect(((testItem & TestEnumByte.Each) == TestEnumByte.Each)).to eq(false)
+      expect(((testItem & TestEnumByte.Anys) == TestEnumByte.Anys)).to eq(true)
+      expect(((testItem & TestEnumByte.Anys) != 0)).to eq(true)
+      expect(((testItem & TestEnumByte.Somes) != 0)).to eq(false)
+    end
+    it 'if enum values are ints values should evaluate correctly' do
+      class TestEnumInts
+        extend Renum
+        enumerator :Nones => 1
+        enumerator :Somes => 2
+        enumerator :Anys => 3
+        enumerator :Each => 4
+      end
+
+      expect(TestEnumInts.Nones).to eq(1)
+      expect(TestEnumInts.Somes).to eq(2)
+      expect(TestEnumInts.Anys).to eq(3)
+      expect(TestEnumInts.Each).to eq(4)
+    end
+    it 'if enum values are bools values should evaluate correctly' do
+      class Tristate
+        extend Renum
+        enumerator :True => true
+        enumerator :False => false
+        enumerator :Undef => 'Undefined'
+      end
+      expect(Tristate.True).to eq(true)
+      expect(Tristate.False).to eq(false)
+      expect(Tristate.Undef).to eq('Undefined')
+    end
+    it 'if to_descriptor called, should evaluate correctly' do
+      class TestEnumDescriptor
+        extend Renum
+        enumerator :Nones => '123'
+        enumerator :Somes => '456'
+      end
+      expect(TestEnumDescriptor.to_descriptor('123')).to eq('Nones')
+    end
+    it 'if to_value called, should evaluate correctly' do
+      class TestEnumToValue
+        extend Renum
+        enumerator :Nones => '123'
+        enumerator :Somes => '456'
+      end
+      expect(TestEnumToValue.parse(:Nones)).to eq('123')
+    end
+    it 'if iterate over enum correct values yielded' do
+      class TestEnumToIterate
+        extend Renum
+        enumerator :Nones => 0x0000
+        enumerator :Somes => 0x0001
+        enumerator :Anys => 0x0002
+        enumerator :Each => 0x0004
+      end
+
+      TestEnumToIterate.each do |x|
+        expect((((TestEnumToIterate.Nones |
+            TestEnumToIterate.Somes |
+            TestEnumToIterate.Anys |
+            TestEnumToIterate.Each) & x) == x)).to eq(true)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: enumb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Manther
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-01-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: Renum helps developers create an enum like object in Ruby that closely resembles commonly found enum behavior of popular statically typed languages.
+email:
+- jason.manther.young@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/.name"
+- ".idea/.rakeTasks"
+- ".idea/Renum.iml"
+- ".idea/dictionaries/jasony.xml"
+- ".idea/encodings.xml"
+- ".idea/misc.xml"
+- ".idea/modules.xml"
+- ".idea/scopes/scope_settings.xml"
+- ".idea/vcs.xml"
+- ".idea/workspace.xml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- Renum.gemspec
+- lib/Renum.rb
+- lib/Renum/version.rb
+- spec/unit/Renum_spec.rb
+homepage: http://jasonwyoung.blogspot.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+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:
+rubygems_version: 2.2.1
+signing_key:
+specification_version: 4
+summary: Enum module
+test_files:
+- spec/unit/Renum_spec.rb