degu 0.0.4

data/lib/degu/renum/enumerated_value_type_factory.rb

@@ -0,0 +1,61 @@
+require 'degu/renum/enumerated_value'
+
+module Degu
+  module Renum
+    module EnumeratedValueTypeFactory
+      class << self
+        def create nest, type_name, values, &block
+          klass = create_class nest, type_name
+          create_values klass, values, &block
+        end
+
+        def create_class nest, type_name
+          klass = Class.new EnumeratedValue
+          nest.const_set(type_name, klass)
+          klass
+        end
+
+        def create_values klass, values, &block
+          setup_for_definition_in_block(klass) if values == :defined_in_block
+          klass.class_eval &block if block_given?
+          if values == :defined_in_block
+            begin
+              klass.block_defined_values.each do |value_name, init_args, instance_block|
+                value = klass.new(value_name)
+                klass.const_set(value_name, value)
+                value.instance_eval &instance_block if instance_block
+                value.init *init_args if value.respond_to? :init
+              end
+            ensure
+              teardown_from_definition_in_block(klass)
+            end
+          else
+            values.each do |name|
+              klass.const_set(name, klass.new(name))
+            end
+          end
+          klass.values.freeze
+        end
+
+        def setup_for_definition_in_block klass
+          klass.class_eval do
+            def self.block_defined_values
+              @block_defined_values ||= []
+            end
+
+            def self.method_missing value_name, *init_args, &instance_block
+              block_defined_values << [value_name, init_args, instance_block]
+            end
+          end
+        end
+
+        def teardown_from_definition_in_block klass
+          class << klass
+            remove_method :block_defined_values
+            remove_method :method_missing
+          end
+        end
+      end
+    end
+  end
+end

data/lib/degu/renum.rb

@@ -0,0 +1,17 @@
+require 'degu/renum/enumerated_value_type_factory'
+
+module Degu
+  # Requiring 'renum' mixes the Renum module into both the main Object and
+  # Module, so it can be called from anywhere that you might reasonably
+  # define an enumeration with an implicit receiver.
+  module Renum
+
+    # Figures out whether the new enumeration will live in Object or the
+    # receiving Module, then delegates to EnumeratedValueTypeFactory#create for
+    # all the real work.
+    def enum(type_name, values = :defined_in_block, &block)
+      nest = self.is_a?(Module) ? self : Object
+      EnumeratedValueTypeFactory.create(nest, type_name, values, &block)
+    end
+  end
+end

data/lib/degu/rude.rb

@@ -0,0 +1,12 @@
+module Degu
+end
+require 'degu/polite'
+class Object
+  include Degu::Renum
+end
+if defined?(ActiveRecord::Base)
+  class ActiveRecord::Base
+    include Degu::HasEnum
+    include Degu::HasSet
+  end
+end

data/lib/degu/version.rb

@@ -0,0 +1,8 @@
+module Degu
+  # Degu version
+  VERSION         = '0.0.4'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end

data/lib/degu.rb

@@ -0,0 +1,3 @@
+module Degu
+end
+require 'degu/rude'

data/spec/renum_spec.rb

@@ -0,0 +1,281 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+enum :Status, [ :NOT_STARTED, :IN_PROGRESS, :COMPLETE ]
+
+enum :Fuzzy, [ :FooBar, :BarFoo ]
+
+describe "basic enum" do
+
+  it "creates a class for the value type" do
+    Status.should be_an_instance_of(Class)
+  end
+
+  it "makes each value an instance of the value type" do
+    Status::NOT_STARTED.should be_an_instance_of(Status)
+  end
+
+  it "exposes array of values" do
+    Status.values.should == [Status::NOT_STARTED, Status::IN_PROGRESS, Status::COMPLETE]
+    Status.all.should == [Status::NOT_STARTED, Status::IN_PROGRESS, Status::COMPLETE]
+  end
+
+  it "groks first and last to retreive value" do
+    Status.first.should == Status::NOT_STARTED
+    Status.last.should == Status::COMPLETE
+  end
+
+  it "enumerates over values" do
+    Status.map {|s| s.name}.should == %w[NOT_STARTED IN_PROGRESS COMPLETE]
+  end
+
+  it "indexes values" do
+    Status[2].should == Status::COMPLETE
+    Color[0].should == Color::RED
+    Status['2'].should == Status::COMPLETE
+    Color['0'].should == Color::RED
+  end
+
+  it "provides index lookup on values" do
+    Status::IN_PROGRESS.index.should == 1
+    Color::GREEN.index.should == 1
+  end
+
+  it "provides an id on values" do
+    Status::IN_PROGRESS.id.should == 1
+    Color::GREEN.id.should == 1
+  end
+
+
+  it "provides name lookup on values" do
+    Status.with_name('IN_PROGRESS').should == Status::IN_PROGRESS
+    Color.with_name('GREEN').should == Color::GREEN
+    Color.with_name('IN_PROGRESS').should be_nil
+  end
+
+  it "provides fuzzy name lookup on values" do
+    Fuzzy[0].should == Fuzzy::FooBar
+    Fuzzy[1].should == Fuzzy::BarFoo
+    Fuzzy[:FooBar].should == Fuzzy::FooBar
+    Fuzzy[:BarFoo].should == Fuzzy::BarFoo
+    Fuzzy['FooBar'].should == Fuzzy::FooBar
+    Fuzzy['BarFoo'].should == Fuzzy::BarFoo
+    Fuzzy[:foo_bar].should == Fuzzy::FooBar
+    Fuzzy[:bar_foo].should == Fuzzy::BarFoo
+    Fuzzy['foo_bar'].should == Fuzzy::FooBar
+    Fuzzy['bar_foo'].should == Fuzzy::BarFoo
+    Fuzzy[Fuzzy::FooBar].should == Fuzzy::FooBar
+    Fuzzy[Fuzzy::BarFoo].should == Fuzzy::BarFoo
+  end
+
+  it "provides a reasonable to_s for values" do
+    Status::NOT_STARTED.to_s.should == "Status::NOT_STARTED"
+  end
+
+  it "makes values comparable" do
+    Color::RED.should < Color::GREEN
+  end
+end
+
+module MyNamespace
+  enum :FooValue, %w( Bar Baz Bat )
+end
+
+describe "nested enum" do
+  it "is namespaced in the containing module or class" do
+    MyNamespace::FooValue::Bar.class.should == MyNamespace::FooValue
+  end
+end
+
+enum :Color, [ :RED, :GREEN, :BLUE ] do
+  def abbr
+    name[0..0]
+  end
+end
+
+describe "enum with a block" do
+  it "can define additional instance methods" do
+    Color::RED.abbr.should == "R"
+  end
+end
+
+enum :Size do
+  Small("Really really tiny")
+  Medium("Sort of in the middle")
+  Large("Quite big")
+  Unknown()
+
+  attr_reader :description
+
+  def init description = nil
+    @description = description || "NO DESCRIPTION GIVEN"
+  end
+end
+
+enum :HairColor do
+  BLONDE()
+  BRUNETTE()
+  RED()
+end
+
+describe "enum with no values array and values declared in the block" do
+  it "provides another way to declare values where an init method can take extra params" do
+    Size::Small.description.should == "Really really tiny"
+  end
+
+  it "works the same as the basic form with respect to ordering" do
+    Size.values.should == [Size::Small, Size::Medium, Size::Large, Size::Unknown]
+  end
+
+  it "responds as expected to arbitrary method calls, in spite of using method_missing for value definition" do
+    lambda { Size.ExtraLarge() }.should raise_error(NoMethodError)
+  end
+
+  it "supports there being no extra data and no init() method defined, if you don't need them" do
+    HairColor::BLONDE.name.should == "BLONDE"
+  end
+
+  it "calls the init method even if no arguments are provided" do
+    Size::Unknown.description.should == "NO DESCRIPTION GIVEN"
+  end
+end
+
+enum :Rating do
+  NotRated()
+
+  ThumbsDown do
+    def description
+      "real real bad"
+    end
+  end
+
+  ThumbsUp do
+    def description
+      "so so good"
+    end
+
+    def thumbs_up_only_method
+      "this method is only defined on ThumbsUp"
+    end
+  end
+
+  def description
+    raise NotImplementedError
+  end
+end
+
+describe "an enum with instance-specific method definitions" do
+  it "allows each instance to have its own behavior" do
+    Rating::ThumbsDown.description.should == "real real bad"
+    Rating::ThumbsUp.description.should == "so so good"
+  end
+
+  it "uses the implementation given at the top level if no alternate definition is given for an instance" do
+    lambda { Rating::NotRated.description }.should raise_error(NotImplementedError)
+  end
+
+  it "allows definition of a method on just one instance" do
+    Rating::ThumbsUp.thumbs_up_only_method.should == "this method is only defined on ThumbsUp"
+    lambda { Rating::NotRated.thumbs_up_only_method }.should raise_error(NoMethodError)
+  end
+end
+
+describe "<=> comparison issue that at one time was causing segfaults on MRI" do
+  it "doesn't cause the ruby process to bomb!" do
+    Color::RED.should < Color::GREEN
+    Color::RED.should_not > Color::GREEN
+    Color::RED.should < Color::BLUE
+  end
+end
+
+modify_frozen_error =
+  begin
+    [].freeze << true
+  rescue => e
+    e.class
+  end
+
+describe "prevention of subtle and annoying bugs" do
+  it "prevents you modifying the values array" do
+    lambda { Color.values << 'some crazy value' }.should raise_error(modify_frozen_error, /can't modify frozen/)
+  end
+
+  it "prevents you modifying the name hash" do
+    lambda { Color.values_by_name['MAGENTA'] = 'some crazy value' }.should raise_error(modify_frozen_error, /can't modify frozen/)
+  end
+
+  it "prevents you modifying the name of a value" do
+    lambda { Color::RED.name << 'dish-Brown' }.should raise_error(modify_frozen_error, /can't modify frozen/)
+  end
+end
+
+enum :Foo1 do
+  field :foo
+  field :bar, :default => 'my bar'
+  field :baz do |obj|
+    obj.__id__
+  end
+
+  Baz(
+    :foo => 'my foo'
+  )
+end
+
+enum :Foo2 do
+  field :foo
+  field :bar, :default => 'my bar'
+  field :baz do |obj|
+    obj.__id__
+  end
+
+
+  Baz(
+    :foo => 'my foo'
+  )
+
+  def init(opts = {})
+    super
+  end
+end
+
+describe "use field method to specify methods and defaults" do
+  it "should define methods with defaults for fields" do
+    Foo1::Baz.foo.should == "my foo"
+    Foo2::Baz.foo.should == "my foo"
+    Foo1::Baz.bar.should == "my bar"
+    Foo2::Baz.bar.should == "my bar"
+    Foo1::Baz.baz.should == Foo1::Baz.__id__
+    Foo2::Baz.baz.should == Foo2::Baz.__id__
+  end
+end
+
+describe "serialize and deserialize via Marshal" do
+  it "should define methods with defaults for fields" do
+    Marshal.load(Marshal.dump(Status::NOT_STARTED)).should == Status::NOT_STARTED
+  end
+end
+
+if defined?(::JSON)
+  describe "serialize and deserialize via JSON" do
+    it "should define methods with defaults for fields" do
+      JSON(JSON(Status::NOT_STARTED)).should == Status::NOT_STARTED
+    end
+
+    it "should not serialize fields by default" do
+      foo1_json = JSON(Foo1::Baz)
+      foo1_hash = JSON.parse(foo1_json, :create_additions => false)
+      foo1_hash.keys.sort.should == %w[name json_class].sort
+    end
+
+    it "should serialize all fields if desired" do
+      foo1_json = Foo1::Baz.to_json(:fields => true)
+      foo1_hash = JSON.parse(foo1_json, :create_additions => false)
+      foo1_hash.keys.sort.should == %w[name json_class bar baz foo].sort
+    end
+
+    it "should serialize requested fields" do
+      foo1_json = Foo1::Baz.to_json(:fields => [ :bar, 'baz' ])
+      foo1_hash = JSON.parse(foo1_json, :create_additions => false)
+      foo1_hash.keys.sort.should == %w[name json_class bar baz].sort
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+require 'degu'

data/test/has_enum_test.rb

@@ -0,0 +1,184 @@
+require 'test_helper'
+
+class HasEnumTest < Test::Unit::TestCase
+
+  def setup
+    setup_db
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def test_should_have_enum
+    assert ClassWithEnum.respond_to?(:has_enum)
+    product_enum = ClassWithEnum.new(:product => Product::Silver)
+    assert_equal Product::Silver, product_enum.product
+  end
+
+  def test_should_have_enum_column_value_set_to_enum_name
+    product_enum = ClassWithEnum.new
+    product_enum.product = Product::Gold
+    assert_equal Product::Gold.name, product_enum.product_type
+  end
+
+  def test_should_be_nullable
+    product_enum = ClassWithEnum.new
+    product_enum.product = Product::Silver
+    product_enum.reset_enum_changed
+    assert_equal false, product_enum.product_has_changed?
+    product_enum.product = nil
+    assert_nil product_enum.product
+    assert_equal true, product_enum.product_has_changed?
+  end
+
+  def test_should_be_nil_if_spaces_string
+    product_enum = ClassWithEnum.new
+    product_enum.product = Product::Silver
+    product_enum.reset_enum_changed
+    assert_equal false, product_enum.product_has_changed?
+    product_enum.product = "    "
+    assert_nil product_enum.product
+    assert_equal true, product_enum.product_has_changed?
+  end
+
+  def test_should_be_setable_by_string
+    product_enum = ClassWithEnum.new
+    product_enum.product = Product::Silver
+    product_enum.reset_enum_changed
+    assert_equal false, product_enum.product_has_changed?
+    product_enum.product = 'Gold'
+    assert_equal Product::Gold, product_enum.product
+    assert_equal true, product_enum.product_has_changed?
+  end
+
+  def test_should_be_setable_by_symbol
+    product_enum = ClassWithEnum.new
+    product_enum.product = Product::Silver
+    product_enum.reset_enum_changed
+    assert_equal false, product_enum.product_has_changed?
+    product_enum.product = :gold
+    assert_equal Product::Gold, product_enum.product
+    assert_equal true, product_enum.product_has_changed?
+  end
+
+  def test_should_be_setable_by_number
+    product_enum = ClassWithEnum.new
+    product_enum.product = Product::Silver
+    product_enum.reset_enum_changed
+    assert_equal false, product_enum.product_has_changed?
+    product_enum.product = 1
+    assert_equal Product::Gold, product_enum.product
+    assert_equal true, product_enum.product_has_changed?
+  end
+
+  def test_should_accept_only_defined_enums
+    product_enum = ClassWithEnum.new
+
+    assert_raise(ArgumentError) { product_enum.product = Fakes::NOT_DEFINIED }
+    assert_raise(ArgumentError) { product_enum.product = "Product::Titanium" }
+    assert_raise(ArgumentError) { product_enum.product = Product }
+    assert_raise(ArgumentError) { product_enum.product = :symbol }
+  end
+
+  def test_should_not_set_enum_in_setter_if_new_enum_is_equal_to_current_enum
+    product_enum = ClassWithEnum.new(:product => Product::Silver)
+    assert product_enum.product=Product::Gold
+  end
+
+  def test_should_have_custom_column_name
+    enum_with_custom_column_name = ClassWithCustomNameEnum.new
+    enum_with_custom_column_name.product = Product::Gold
+    assert_equal Product::Gold, enum_with_custom_column_name.product
+  end
+
+  def test_should_mark_enum_as_changed_if_enum_column_was_set_directly
+    product_enum = ClassWithEnum.new
+    assert !product_enum.product_has_changed?
+    product_enum.product_type = "Gold"
+    assert product_enum.product_has_changed?
+  end
+
+  def test_should_only_change_enum_column_if_other_value_is_set
+    product_enum = ClassWithEnum.new
+    product_enum.product_type = "Gold"
+    product_enum.instance_variable_set("@enum_changed", false)
+    product_enum.product_type = "Gold"
+    assert !product_enum.product_has_changed?
+  end
+
+  def test_should_have_custom_column_value_set_to_enum_name
+    enum_with_custom_column_name = ClassWithCustomNameEnum.new
+    enum_with_custom_column_name.product = Product::Gold
+    assert_equal Product::Gold.name, enum_with_custom_column_name.product_enum
+  end
+
+  def test_should_raise_class_not_found_exception_if_enum_class_not_found
+    assert_raise(NameError) { ClassWithoutEnum.has_enum :foo }
+  end
+
+  def test_should_raise_argument_error_if_enum_is_no_renum_enum
+    assert_raise(ArgumentError) { ClassWithoutEnum.has_enum :array }
+  end
+
+  def test_should_know_if_enum_has_changed
+    product_enum = ClassWithEnum.new(:product => Product::Silver)
+    assert product_enum.product_has_changed?
+    product_enum.save
+    product_enum.reload
+    product_enum.product = Product::Gold
+    assert product_enum.product_has_changed?
+  end
+
+  def test_should_not_fail_if_no_enum_was_set_yet
+    enum_mixin = ClassWithEnum.new
+    assert_nothing_raised(TypeError) { enum_mixin.product }
+  end
+
+  def test_should_not_change_if_same_enum_was_assigned
+    enum_mixin = ClassWithEnum.new(:product => Product::Silver)
+    enum_mixin.save
+    enum_mixin.reload
+    enum_mixin.product = Product::Silver
+    assert !enum_mixin.product_has_changed?
+  end
+
+  def test_should_have_reset_changed_state_after_save
+    enum_mixin = ClassWithEnum.new(:product => Product::Silver)
+    enum_mixin.save
+    enum_mixin.reload
+    assert !enum_mixin.product_has_changed?
+  end
+
+  def test_should_not_be_able_to_set_invalid_enum
+    enum_mixin = ClassWithEnum.new
+    assert_raise(NameError) { enum_mixin.product = Product::Platin }
+  end
+
+  def test_should_not_be_able_to_set_invalid_enum_2
+    enum_mixin = ClassWithEnum.new
+    enum_mixin[:product_type] = "Platin"
+    enum_mixin.valid?
+    assert enum_mixin.errors[:product_type]
+  end
+
+  def test_should_not_return_validation_error_if_enum_is_nil
+    enum_mixin = ClassWithEnum.new
+    enum_mixin.valid?
+    assert_equal [], enum_mixin.errors[:product_type]
+  end
+
+  def test_should_return_nil_if_enum_is_of_wrong_type
+    enum_mixin = ClassWithEnum.new
+    enum_mixin[:product_type] = "Platin"
+    assert_nil enum_mixin.product
+  end
+
+  def test_should_execute_all_callbacks
+    enum_mixin = ClassWithEnum.new
+    enum_mixin.product = Product::Gold
+    assert enum_mixin.save
+    assert enum_mixin.callback1_executed
+  end
+
+end