yinum 0.0.1 → 1.0.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    yinum (0.0.1)
+    yinum (1.0.0)
 
 GEM
   remote: http://rubygems.org/
@@ -20,5 +20,5 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  yinum!
   rspec
+  yinum!

data/README.md

@@ -1,6 +1,6 @@
-# Enum
+# yinum
 
-A straightforward implementation of an enum for Ruby (on Rails).
+A yummy straightforward implementation of an enum for Ruby (on Rails).
 
 The straightforward usage looks like this:
 
@@ -12,11 +12,11 @@ The straightforward usage looks like this:
 
 ## Getting started
 
-    $ gem install enum
+    $ gem install yinum
 
 Or in your Gemfile:
 
-    gem "enum"
+    gem "yinum"
 
 ## Usage
 
@@ -95,7 +95,7 @@ Now the `color` column is always read and written using the enum value feature:
 
 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
+Adding a `:scoped => true` option before the enum values allows automatic generation of scopes and question
 methods on the model as follows:
 
     class Car < ActiveRecord::Base
@@ -106,6 +106,16 @@ methods on the model as follows:
     Car.last.red?
     => true
 
+You can also use another class's enum for your class with enum\_column (including generated methods) like so:
+
+    class Motorcycle < ActiveRecord::Base
+      enum_column :color, Car::COLORS, { :scoped => true }
+    end
+    Motorcycle.black.to_sql
+    => "SELECT `motorcycles`.* FROM `motorcycles` WHERE `motorcycles`.`color` = 2"
+    Motorcycle.black
+    => Car::COLORS.black
+
 Last but not least, automatic translation lookup.
 Given the following `config/locales/en.yml`:
 
@@ -137,7 +147,7 @@ If the translation is missing, it fallbacks to the translation without the class
 
 All enum names (usually CONSTANT\_LIKE) and parent class names are converted to snakecase.
 
-== Limitations
+## Limitations
 
 Since the `===` operator is called on the when value, this syntax cannot be used:
 

data/lib/{enum_value.rb → enum/enum_value.rb}

@@ -1,4 +1,4 @@
-class EnumValue < BasicObject
+class Enum::EnumValue < BasicObject
   attr_reader :enum, :name, :value
 
   def initialize(enum, name, value)

data/lib/{helpers.rb → enum/helpers/enum_columns.rb}

@@ -1,14 +1,6 @@
-module EnumGenerator
-  def enum(name, hash)
-    const_set name, Enum.new(name, self, hash)
-  end
-end
-
-class Object
-  include EnumGenerator
-end
+require 'enum/helpers/enum_generator'
 
-module EnumColumns
+module Enum::Helpers::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).
@@ -16,18 +8,18 @@ module EnumColumns
   # 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)
+    if name_or_enum.is_a?(Enum)
+      e = name_or_enum
+    else
       # 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] }
+    define_method(attr) { v = super(); (v.nil? or not e.values.include?(v)) ? v : e[v] }
     # attribute writer
     define_method("#{attr}=") { |v| v.nil? ? super(v) : super(e[v]) }
     # validation
@@ -44,6 +36,6 @@ end
 
 if defined?(ActiveRecord)
   class ActiveRecord::Base
-    extend EnumColumns
+    extend Enum::Helpers::EnumColumns
   end
 end

data/lib/enum/helpers/enum_generator.rb

@@ -0,0 +1,11 @@
+require 'enum'
+
+module Enum::Helpers::EnumGenerator
+  def enum(name, hash)
+    const_set name, Enum.new(name, self, hash)
+  end
+end
+
+class Object
+  include Enum::Helpers::EnumGenerator
+end

data/lib/enum/helpers.rb

@@ -0,0 +1,5 @@
+module Enum::Helpers
+end
+
+require 'enum/helpers/enum_generator'
+require 'enum/helpers/enum_columns'

data/lib/enum.rb

@@ -0,0 +1,56 @@
+class Enum
+  require 'enum/enum_value'
+  include Enumerable
+
+  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 each(&block)
+    @by_name.each_value(&block)
+  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
+    @by_name.freeze
+    @by_value.freeze
+  end
+  def generate_methods
+    names.each do |name|
+      define_singleton_method(name) { self[name] }
+    end
+  end
+end

data/lib/yinum.rb

@@ -1,52 +1,2 @@
-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'
+require 'enum'
+require 'enum/helpers'

data/spec/enum/enum_value_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Enum::EnumValue do
+  subject { @enum }
+
+  context "no parent" do
+    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+    # can't use subject @enum.red as it turns into a Fixnum
+
+    specify { @enum.red.inspect.should == "MY_COLORS.red" }
+    specify { @enum.red.t.should == "I18n not available: enums.my_colors.red" }
+  end # context "no parent"
+
+  context "with parent" do
+    before { @enum = Enum.new(:MY_COLORS, Object, :red => 1, :blue => 2) }
+    # can't use subject @enum.red as it turns into a Fixnum
+
+    specify { @enum.red.inspect.should == "Object::MY_COLORS.red" }
+    specify { @enum.red.t.should == "I18n not available: enums.object.my_colors.red" }
+  end # context "with parent"
+
+  context "comparison" do
+    before { @enum = Enum.new(:MY_COLORS, :red => 1, :blue => 2) }
+
+    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 "comparison"
+
+  context "invalid" do
+    specify { expect { @enum[:green] }.to raise_error(StandardError) }
+    specify { expect { @enum[3] }.to raise_error(StandardError) }
+  end # context "invalid"
+end # describe EnumValue

data/spec/enum/helpers/enum_columns_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+class UsesEnumColumns < Hash # to allow setting 'attributes'
+  extend Enum::Helpers::EnumColumns
+
+  class << self
+    # enum definition
+    def define_enum(attr, name_or_enum, options={}, hash=nil)
+      @enum_name = name_or_enum.is_a?(Enum) ? name_or_enum.name : name_or_enum
+      reset_mocks
+      enum_column attr, name_or_enum, options, hash
+    end
+    def undefine_enum
+      remove_const :COLORS
+    end
+    def reset_mocks
+      @inclusion_validations = []
+      @scopes = []
+    end
+
+    # mocking validates_inclusion_of
+    attr_reader :inclusion_validations
+    def validates_inclusion_of(*attributes)
+      @inclusion_validations << attributes
+    end
+    # mocking scopes
+    def where(*attributes)
+      { :where => attributes }
+    end
+    attr_reader :scopes
+    def scope(*attributes)
+      @scopes << attributes
+    end
+
+  end
+
+  # mocking setters
+  def method_missing(method, *args, &block)
+    if method.to_s.end_with?('=') and args.length == 1
+      self[method.to_s.chop.to_sym] = args.first
+    elsif method =~ /^[a-z_]*$/ and args.length == 0
+      self[method]
+    else
+      super
+    end
+  end
+end
+
+class UsesAnoterEnumColumns < UsesEnumColumns
+end
+
+def enum_generator_specs
+  describe Enum::Helpers::EnumGenerator do
+    subject { UsesEnumColumns::COLORS }
+
+    its(:name) { should == :COLORS }
+    its(:klass) { should == UsesEnumColumns }
+    its(:by_name) { should == { :red => 1, :blue => 2 } }
+  end # describe Enum::Helpers::EnumGenerator
+end
+
+def enum_columns_attribute_specs
+  context "attributes" do
+    before do
+      @record = UsesEnumColumns.new
+      @record[:color] = :unknown
+    end
+    subject { @record }
+
+    context "setter" do
+      specify "nil" do
+        @record.color = nil
+        @record[:color].should be_nil
+      end
+
+      specify "name" do
+        @record.color = :red
+        @record[:color].should be_enum_value and @record[:color].should be_red
+      end
+
+      specify "value" do
+        @record.color = 2
+        @record[:color].should be_enum_value and @record[:color].should be_blue
+      end
+
+      specify "invalid" do
+        expect { @record.color = 3 }.to raise_error(StandardError)
+      end
+    end # context "setter"
+
+    context "getter" do
+      specify "nil" do
+        @record[:color] = nil
+        @record.color.should be_nil
+      end
+
+      specify "value" do
+        @record[:color] = 2
+        @record.color.should be_enum_value and @record.color.should be_blue
+      end
+
+      specify "invalid" do
+        @record[:color] = 3
+        @record.color.should_not respond_to(:enum_value?) and @record.color.should == 3
+      end
+    end # context "getter"
+  end # context "attribute"
+
+  context "validations" do
+    its(:inclusion_validations) { should have(1).item }
+    its(:inclusion_validations) { should include([:color, :in => [1, 2], :allow_nil => true]) }
+  end # context "validations"
+end
+
+describe Enum::Helpers::EnumColumns do
+  after { UsesEnumColumns.undefine_enum }
+  subject { UsesEnumColumns }
+
+  context "not scoped" do
+    before { UsesEnumColumns.define_enum(:color, :COLORS, :red => 1, :blue => 2) }
+
+    enum_generator_specs
+    enum_columns_attribute_specs
+  end # context "not scoped"
+
+  context "scoped" do
+    before { UsesEnumColumns.define_enum(:color, :COLORS, { :scoped => true }, :red => 1, :blue => 2) }
+
+    enum_generator_specs
+    enum_columns_attribute_specs
+
+    context "scopes" do
+      its(:scopes) { should have(2).items }
+      its(:scopes) { should include([:red, :where => [:color => 1]]) }
+      its(:scopes) { should include([:blue, :where => [:color => 2]]) }
+    end # context "scopes"
+
+    context "questions" do
+      before do
+        @record = UsesEnumColumns.new
+        @record.color = :red
+      end
+      subject { @record }
+
+      it { should be_red }
+      it { should_not be_blue }
+    end # context "questions"
+  end # context "scoped"
+
+  context "use another enum" do
+    before do
+      UsesEnumColumns.define_enum(:color, :COLORS, { :scoped => true }, :red => 1, :blue => 2)
+      UsesAnoterEnumColumns.define_enum(:color, UsesEnumColumns::COLORS)
+    end
+
+    enum_generator_specs
+    enum_columns_attribute_specs
+  end
+end # describe Enum::Helpers::EnumColumns

data/spec/enum/helpers/enum_generator_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class UsesEnumGenerator
+  enum :COLORS, :red => 1, :blue => 2
+end
+
+describe Enum::Helpers::EnumGenerator do
+  subject { UsesEnumGenerator::COLORS }
+
+  its(:name) { should == :COLORS }
+  its(:klass) { should == UsesEnumGenerator }
+  its(:by_name) { should == { :red => 1, :blue => 2 } }
+end # describe Enum::Helpers::EnumGenerator

data/spec/enum_spec.rb

@@ -0,0 +1,30 @@
+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) }
+    its(:to_a) { should have(2).items }
+  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)" }
+  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)" }
+  end # context "with parent"
+end # describe Enum

data/yinum.gemspec

@@ -3,12 +3,12 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "yinum"
-  s.version     = "0.0.1"
+  s.version     = "1.0.0"
   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.description = %q{Yummy implementation of enum that gives integer values with a special wrapping.}
 
   s.rubyforge_project = "yinum"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yinum
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ 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
+description: Yummy implementation of enum that gives integer values with a special
   wrapping.
 email:
 - oded.niv@gmail.com
@@ -24,11 +24,17 @@ files:
 - Gemfile.lock
 - README.md
 - Rakefile
-- lib/enum_value.rb
-- lib/helpers.rb
+- lib/enum.rb
+- lib/enum/enum_value.rb
+- lib/enum/helpers.rb
+- lib/enum/helpers/enum_columns.rb
+- lib/enum/helpers/enum_generator.rb
 - lib/yinum.rb
+- spec/enum/enum_value_spec.rb
+- spec/enum/helpers/enum_columns_spec.rb
+- spec/enum/helpers/enum_generator_spec.rb
+- spec/enum_spec.rb
 - spec/spec_helper.rb
-- spec/yinum_spec.rb
 - yinum.gemspec
 homepage: https://github.com/toplex/enum
 licenses: []
@@ -55,5 +61,8 @@ signing_key:
 specification_version: 3
 summary: Enum implementation
 test_files:
+- spec/enum/enum_value_spec.rb
+- spec/enum/helpers/enum_columns_spec.rb
+- spec/enum/helpers/enum_generator_spec.rb
+- spec/enum_spec.rb
 - spec/spec_helper.rb
-- spec/yinum_spec.rb

data/spec/yinum_spec.rb

@@ -1,57 +0,0 @@
-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