yinum 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+*.sassc
+.sass-cache
+capybara-*.html
+.rspec
+/.bundle
+/vendor/bundle
+/log/*
+/tmp/*
+/db/*.sqlite3
+/public/system/*
+/coverage/
+/spec/tmp/*
+**.orig
+rerun.txt
+pickle-email-*.html

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in commod.gemspec
+gemspec
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    yinum (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.1)
+    rspec-expectations (2.12.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  yinum!
+  rspec

data/README.md

@@ -0,0 +1,155 @@
+# Enum
+
+A 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
+
+## Getting started
+
+    $ gem install enum
+
+Or in your Gemfile:
+
+    gem "enum"
+
+## Usage
+
+Creating an enum:
+
+    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)
+
+Another way, with the helper method:
+
+    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
+
+Comparing enum values:
+
+    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
+
+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)
+    #
+
+    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
+
+This also creates a `validates\_inclusion\_of` with `allow\_nil => true` to prevent having bad values.
+
+Adding another `: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
+
+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
+
+The following will occur:
+
+    FRUITS.apple.t
+    => "Green Apple"
+    FRUITS[2].t
+    => "Orange Color"
+    Car::COLORS.red
+    => "Shiny Red"
+    Car::COLORS.black
+    => "Actually, white"
+
+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.
+
+== Limitations
+
+Since the `===` operator is called on the when value, this syntax cannot be used:
+
+    case fruit
+      when :red then "This will never happen!"
+    end
+
+The following should be used instead:
+
+    case fruit
+      when FRUITS.red then "This is better..."
+    end
+
+This is because I had trouble overriding the `===` operator of the Symbol class.
+

data/Rakefile

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

data/lib/enum_value.rb

@@ -0,0 +1,72 @@
+class EnumValue < BasicObject
+  attr_reader :enum, :name, :value
+
+  def initialize(enum, name, value)
+    @enum, @name, @value = enum, name, value
+  end
+
+  def enum_value?
+    true
+  end
+
+  def inspect
+    "#{@enum.to_s}.#{@name}"
+  end
+
+  def ==(other)
+    @name == other or @value == other
+  end
+
+  def ===(other)
+    @name === other or @value === other
+  end
+
+  def t(options={})
+    scope_without_klass = "enums.#{const_to_translation(@enum.name)}"
+    if @enum.klass
+      scope_with_klass = "enums.#{const_to_translation(@enum.klass.name)}.#{const_to_translation(@enum.name)}"
+      return "I18n not available: #{scope_with_klass}.#{@name}" unless defined?(::I18n)
+
+      ::I18n.t(@name,
+               # prefer scope with klass
+               options.reverse_merge(:scope => scope_with_klass,
+                                     :default => ::I18n.t(@name,
+                                                          # but if not, use without
+                                                          options.reverse_merge(:scope => scope_without_klass,
+                                                                                # but! if not, return scope with klass error
+                                                                                :default => ::I18n.t(@name,
+                                                                                                     options.reverse_merge(:scope => scope_with_klass))))))
+    else
+      return "I18n not available: #{scope_without_klass}.#{@name}" unless defined?(::I18n)
+
+      ::I18n.t(@name, options.reverse_merge(:scope => scope_without_klass))
+    end
+  end
+
+  def methods
+    super + @value.methods
+  end
+
+  def method_missing(method, *args, &block)
+    match = method.to_s.match(/^(.+)\?$/)
+    enum_name = match[1].to_sym if match
+    if @enum.names.include?(enum_name)
+      @name.==(enum_name, *args, &block)
+    elsif @value.respond_to?(method)
+      @value.send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  private
+  def const_to_translation(name)
+    # From Rails' ActiveSupport String#underscore
+    name.to_s.
+      gsub(/::/, '.').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+end

data/lib/helpers.rb

@@ -0,0 +1,49 @@
+module EnumGenerator
+  def enum(name, hash)
+    const_set name, Enum.new(name, self, hash)
+  end
+end
+
+class Object
+  include EnumGenerator
+end
+
+module EnumColumns
+  # Bind a column to an enum by:
+  #   Generating attribute reader and writer to convert to EnumValue.
+  #   Creating a validation for the attribute so it must have valid enum values (allowing nil).
+  #   If :scoped => true, generates scopes and questioning methods for every name in the enum.
+  # If given a enum name (a symbol) and hash, also creates the enum.
+  def enum_column(attr, name_or_enum, options={}, hash=nil)
+    # generating or getting the enum
+    if name_or_enum.is_a?(Symbol)
+      # the first hash is either options or the hash if the options are missing
+      hash, options = options, {} if hash.nil?
+      # generating the enum if the hash is not empty
+      enum name_or_enum, hash if hash.any?
+
+      e = const_get(name_or_enum)
+    else
+      e = name_or_enum
+    end
+    # attribute reader
+    define_method(attr) { v = super(); (v.nil? or e.values.exclude?(v)) ? v : e[v] }
+    # attribute writer
+    define_method("#{attr}=") { |v| v.nil? ? super(v) : super(e[v]) }
+    # validation
+    validates_inclusion_of attr, :in => e.values, :allow_nil => true
+    if options[:scoped]
+      # generating scopes and questioning methods
+      e.by_name.each do |n, ev|
+        scope n, where(attr => ev)
+        define_method("#{n}?") { self[attr] == ev }
+      end
+    end
+  end
+end
+
+if defined?(ActiveRecord)
+  class ActiveRecord::Base
+    extend EnumColumns
+  end
+end

data/lib/yinum.rb

@@ -0,0 +1,52 @@
+require 'enum_value'
+
+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)
+    @name, @klass = name, klass
+    map_hash(hash)
+    generate_methods
+  end
+
+  def to_s
+    @klass ? "#{@klass.name}::#{@name}" : @name.to_s
+  end
+  def inspect
+    "#{to_s}(#{@by_name.map { |n,ev| "#{n.inspect} => #{ev.value.inspect}"}.join(", ")})"
+  end
+
+  def names
+    @by_name.keys
+  end
+  def values
+    @by_value.keys
+  end
+
+  def [](name_or_value)
+    ev = @by_name[name_or_value] || @by_value[name_or_value]
+    raise "#{inspect} does not know #{name_or_value.inspect}" if ev.nil?
+    ev
+  end
+
+  private
+  def map_hash(hash)
+    @by_name = {}
+    @by_value = {}
+    hash.each do |n, v|
+      n, v = v, n if v.is_a?(Symbol) or n.is_a?(Numeric)
+      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?
+      @by_name[n] = @by_value[v] = EnumValue.new(self, n, v)
+    end
+  end
+  def generate_methods
+    names.each do |name|
+      define_singleton_method(name) { self[name] }
+    end
+  end
+end
+
+require 'helpers'

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'yinum'
+
+RSpec.configure do |config|
+end

data/spec/yinum_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Enum do
+  context "keys on left and right" do
+    before { @enum = Enum.new(:MY_COLORS, :red => 1, 2 => :blue) }
+    subject { @enum }
+
+    its(:names) { should have(2).items }
+    its(:names) { should include(:red, :blue) }
+    its(:values) { should have(2).items }
+    its(:values) { should include(1, 2) }
+  end # context "keys on left and right"
+  
+  context "no parent" do
+    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+    subject { @enum  }
+
+    its(:to_s)    { should == "MY_COLORS" }
+    its(:inspect) { should == "MY_COLORS(:red => 1, :blue => 2)" }
+
+    context "enum value" do
+      specify { @enum.red.inspect.should == "MY_COLORS.red" }
+      specify { @enum.red.t.should == "I18n not available: enums.my_colors.red" }
+    end # context "enum value"
+  end # context "no parent"
+
+  context "with parent" do
+    before { @enum = Enum.new(:MY_COLORS, Object, :red => 1, :blue => 2) }
+    subject { @enum }
+
+    its(:to_s)    { should == "Object::MY_COLORS" }
+    its(:inspect) { should == "Object::MY_COLORS(:red => 1, :blue => 2)" }
+
+    context "enum value" do
+      specify { @enum.red.inspect.should == "Object::MY_COLORS.red" }
+      specify { @enum.red.t.should == "I18n not available: enums.object.my_colors.red" }
+    end # context "enum value"
+  end # context "with parent"
+
+  context "enum value" do
+    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+    subject { @enum }
+
+    its(:red) { should == 1 }
+    its(:blue) { should_not == 1 }
+    its(:red) { should == :red }
+    its(:blue) { should_not == :red }
+    its(:red) { should === 1 }
+    its(:blue) { should_not === 1 }
+    its(:red) { should === :red }
+    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 "enum value"
+end # describe Enum

data/yinum.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "yinum"
+  s.version     = "0.0.1"
+  s.authors     = ["Oded Niv"]
+  s.email       = ["oded.niv@gmail.com"]
+  s.homepage    = "https://github.com/toplex/enum"
+  s.summary     = %q{Enum implementation}
+  s.description = %q{Awesome enum implementation that gives integer values with a special wrapping.}
+
+  s.rubyforge_project = "yinum"
+
+  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"]
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: yinum
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Oded Niv
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-06 00:00:00.000000000 Z
+dependencies: []
+description: Awesome enum implementation that gives integer values with a special
+  wrapping.
+email:
+- oded.niv@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/enum_value.rb
+- lib/helpers.rb
+- lib/yinum.rb
+- spec/spec_helper.rb
+- spec/yinum_spec.rb
+- yinum.gemspec
+homepage: https://github.com/toplex/enum
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: yinum
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Enum implementation
+test_files:
+- spec/spec_helper.rb
+- spec/yinum_spec.rb