simple_enum 1.6.9 → 2.3.2

data/test/finders_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-class FindersTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db
-  end
-
-  def test_find_all_female_genders
-    girls = Dummy.where(:gender_cd => Dummy.genders[:female]).sort { |a,b| a.name <=> b.name }
-    
-    assert_equal 2, girls.length
-    
-    assert_equal 'Anna', girls.first.name
-    assert_equal :female, girls.first.gender
-    assert_equal true, girls.first.female?
-  end
-  
-  def test_find_all_gamma_words
-    gammas = Dummy.where(:word_cd => Dummy.words(:gamma)).all
-    
-    assert_equal 1, gammas.length
-    assert_equal 'Chris', gammas.first.name
-    assert_equal true, gammas.first.male?
-    assert_equal 'gamma', gammas.first.word_cd
-    assert_equal :gamma, gammas.first.word
-  end
-  
-  def test_find_all_with_attribute_didum_equal_to_foo
-    skip('Not available in Mongoid') if mongoid?
-    
-    foos = Dummy.where('other = ?', Dummy.didums(:foo)).all   
-    
-    assert_equal 1, foos.length
-    assert_equal false, foos.first.foobar?
-  end
-  
-  def test_find_using_insecure_inline_string_conditions
-    skip('Not available in Mongoid') if mongoid?
-    
-    men = Dummy.where("gender_cd = #{Dummy.genders(:male)}").all
-    
-    assert_equal 1, men.length
-    assert_equal true, men.first.male?
-  end  
-end

data/test/locales.yml

@@ -1,25 +0,0 @@
-# english translation
-en:
-  activerecord:
-    errors:
-      models:
-        validated_computer:
-          attributes:
-            operating_system:
-              invalid_enum: y u no os?
-  mongoid:
-    errors:
-      models:
-        validated_computer:
-          attributes:
-            operating_system:
-              invalid_enum: y u no os?
-
-  enums:
-    dummy:
-      genders:
-        female: Girl
-      didums:
-        foo:
-          one: Foo
-          other: Foos

data/test/mongoid_test.rb

@@ -1,66 +0,0 @@
-require 'test_helper'
-
-class MongoidTest < MiniTest::Unit::TestCase
-  def setup
-    @default_options = SimpleEnum.default_options
-    reload_db
-  end
-
-  def teardown
-    SimpleEnum.default_options.clear.update(@default_options)
-  end
-
-  def test_creates_a_field_per_default
-    skip('Only available in mongoid') unless mongoid?
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female]
-    end
-    refute_nil klass.new.fields['gender_cd']
-  end
-
-  def test_passing_custom_field_options
-    skip('Only available in mongoid') unless mongoid?
-    klass = anonymous_dummy do
-      field :verify, :type => Integer
-      as_enum :gender, [:male, :female], :field => { :type => Integer, :default => 1 }
-    end
-
-    gender_field = klass.new.fields['gender_cd']
-    refute_nil gender_field
-    assert_equal 1, gender_field.default
-    assert_equal klass.fields['verify'].class, gender_field.class
-    assert_equal :female, klass.new.gender
-  end
-
-  def test_skip_field_creation_if_field_false
-    skip('Only available in mongoid') unless mongoid?
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female], :field => false
-    end
-
-    assert_nil klass.new.fields['gender_cd']
-  end
-
-  def test_default_field_options
-    skip('Only available in mongoid') unless mongoid?
-    SimpleEnum.default_options[:field] = { :type => String }
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female]
-    end
-
-    refute_nil klass.new.fields['gender_cd']
-    assert_equal String, klass.new.fields['gender_cd'].options[:type]
-  end
-
-  def test_default_field_options_are_merged_recursivly
-    skip('Only available in mongoid') unless mongoid?
-    SimpleEnum.default_options[:field] = { :type => String }
-    klass = anonymous_dummy do
-      as_enum :gender, [:male, :female], :field => { :default => "0" }
-    end
-
-    refute_nil klass.new.fields['gender_cd']
-    assert_equal String, klass.new.fields['gender_cd'].options[:type]
-    assert_equal "0", klass.new.fields['gender_cd'].options[:default]
-  end
-end

data/test/object_backed_test.rb

@@ -1,61 +0,0 @@
-require 'test_helper'
-
-class ObjectBackedTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db :genders => true    
-  end
-
-  def test_how_working_with_object_backed_columns_work
-    # simple object -> not db backed instance
-    simple_obj = Class.new do
-      attr_accessor :name
-      def initialize(name)
-        @name = name
-      end  
-    end
-        
-    # create new class by using simple_obj
-    with_object = anonymous_dummy do
-      as_enum :gender, { simple_obj.new('Male') => 0, simple_obj.new('Female') => 1 }      
-    end
-        
-    d = with_object.where(:name => 'Anna').first
-    
-    assert_same simple_obj, d.gender.class
-    assert_equal 'Female', d.gender.name
-    assert_same true, d.female?
-    assert_same false, d.male?
-    assert_same 0, with_object.male    
-  end
-  
-  def test_db_backed_objects
-    # using method described in 'Advanced Rails Recipes - Recipe 61: Look Up Constant Data Efficiently'
-    # "cache" as defined in ARR#61
-    genders = Gender.all
-    # works without mapping... .map { |g| [g, g.id] }
-    
-    # use cached array of values
-    with_db_obj = anonymous_dummy do
-      as_enum :gender, genders
-    end
-    
-    d = with_db_obj.where(:name => 'Bella').first
-    
-    assert_respond_to with_db_obj, :female
-    assert_respond_to with_db_obj, :male
-    assert_equal 0, with_db_obj.male
-  end
-  
-  def test_that_accesing_keys_and_values_of_each_enumeration_value_works_as_expected
-
-    with_db_obj = anonymous_dummy do
-      as_enum :gender, Gender.all.to_a
-    end
-    
-    assert_same 0, with_db_obj.male
-    assert_equal @male.id, with_db_obj.male(true).id
-    
-    assert_same :male, Dummy.male(true)
-    assert_same 0, Dummy.male
-  end
-end

data/test/orm/active_record.rb

@@ -1,114 +0,0 @@
-require 'active_record/version'
-
-def orm_version
-  ActiveRecord::VERSION::STRING
-end
-
-def ar32?
-  ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR >= 2
-end
-
-def setup_db
-  # create database connection (in memory db!)
-  ActiveRecord::Base.establish_connection({
-    :adapter => RUBY_PLATFORM =~ /java/ ? 'jdbcsqlite3' : 'sqlite3',
-    :database => ':memory:'})
-    
-  # Fix visitor, for JRuby
-  if RUBY_PLATFORM =~ /java/ && ar32?
-    ActiveRecord::ConnectionAdapters::SQLiteAdapter.send(:define_method, :visitor) do
-      @visitor ||= Arel::Visitors::SQLite.new(self)
-    end
-  end
-end
-
-# Reload database
-def reload_db(options = {})
-  ActiveRecord::Base.connection.create_table :dummies, :force => true do |t|
-    t.column :name, :string
-    t.column :gender_cd, :integer
-    t.column :word_cd, :string, :limit => 5
-    t.column :role_cd, :string
-    t.column :other, :integer
-    t.column :numeric_cd, :string
-    t.column :nilish_cd, :string
-  end
-
-  # Create ref-data table and fill with records
-  ActiveRecord::Base.connection.create_table :genders, :force => true do |t|
-    t.column :name, :string
-  end
-  
-  # Validations
-  ActiveRecord::Base.connection.create_table :computers, :force => true do |t|
-    t.column :name, :string
-    t.column :operating_system_cd, :integer
-    t.column :manufacturer_cd, :integer
-  end  
-  
-  fill_db(options)
-end
-
-# Models
-def anonymous_dummy(&block)
-  Class.new(ActiveRecord::Base) do
-    ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-    instance_eval &block 
-  end
-end
-
-def extend_computer(current_i18n_name = "Computer", &block)
-  Class.new(Computer) do
-    ar32? ? self.table_name = 'computers' : set_table_name('computers')
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def extend_dummy(current_i18n_name = "Dummy", &block)
-  Class.new(Dummy) do
-    ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def named_dummy(class_name, &block)
-  begin
-    return class_name.constantize
-  rescue NameError
-    klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
-    klass.module_eval do
-      ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-      instance_eval &block
-    end
-    klass
-  end
-end
-
-class Dummy < ActiveRecord::Base
-  as_enum :gender, [:male, :female]
-  as_enum :word, { :alpha => 'alpha', :beta => 'beta', :gamma => 'gamma'}
-  as_enum :didum, [ :foo, :bar, :foobar ], :column => 'other'
-  as_enum :role, [:admin, :member, :anon], :strings => true
-  as_enum :numeric, [:"100", :"3.14"], :strings => true
-  as_enum :nilish, [:nil], :strings => true
-end
-
-class Gender < ActiveRecord::Base
-end
-
-class Computer < ActiveRecord::Base
-  as_enum :manufacturer, [:dell, :compaq, :apple]
-  as_enum :operating_system, [:windows, :osx, :linux, :bsd]
-end
-
-# Used to test STI stuff
-class SpecificDummy < Dummy
-  ar32? ? self.table_name = 'dummies' : set_table_name('dummies')
-end
-

data/test/orm/common.rb

@@ -1,23 +0,0 @@
-class MockName < String
-  def name; to_s end
-  
-  def self.mock!(name)
-    ActiveModel::Name.new(MockName.new(name))
-  end
-end
-
-def fill_db(options={})
-  options = { :fill => true, :genders => false }.merge(options)
-
-  if options[:fill]
-    # fill db with some rows
-    Dummy.create({ :name => 'Anna',  :gender_cd => 1, :word_cd => 'alpha', :other => 0})
-    Dummy.create({ :name => 'Bella', :gender_cd => 1, :word_cd => 'beta', :other => 1})
-    Dummy.create({ :name => 'Chris', :gender_cd => 0, :word_cd => 'gamma', :other => 2})
-  end
-
-  if options[:genders]
-    @male   = Gender.create!({ :name => 'male' })
-    @female = Gender.create!({ :name => 'female' })
-  end
-end

data/test/orm/mongoid.rb

@@ -1,114 +0,0 @@
-require 'mongoid/version'
-require 'simple_enum/mongoid'
-
-def orm_version
-  Mongoid::VERSION
-end
-
-def setup_db
-  # create database connection
-  Mongoid.configure do |config|
-    config.master = Mongo::Connection.new('localhost').db("simple-enum-test-suite")
-    config.use_utc = true
-    config.include_root_in_json = true
-  end
-end
-
-
-# Reload database
-def reload_db(options = {})
-
-  # clear collections except system
-  Mongoid.master.collections.select do |collection|
-    collection.name !~ /system/
-  end.each(&:drop)
-
-  fill_db(options)
-end
-
-# models
-def anonymous_dummy(&block)
-  Class.new do
-    include Mongoid::Document
-    include SimpleEnum::Mongoid
-    self.collection_name = 'dummies'
-    instance_eval &block
-  end
-end
-
-def extend_computer(current_i18n_name = "Computer", &block)
-  Class.new(Computer) do
-    self.collection_name = 'computers'
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def extend_dummy(current_i18n_name = "Dummy", &block)
-  Class.new(Dummy) do
-    self.collection_name = 'dummies'
-    instance_eval &block
-    instance_eval <<-RUBY
-      def self.model_name; MockName.mock!(#{current_i18n_name.inspect}) end
-    RUBY
-  end
-end
-
-def named_dummy(class_name, &block)
-  begin
-    return class_name.constantize
-  rescue NameError
-    klass = Object.const_set(class_name, Class.new)
-    klass.module_eval do
-      include Mongoid::Document
-      include SimpleEnum::Mongoid
-
-      self.collection_name = 'dummies'
-      instance_eval &block
-    end
-
-    klass
-  end
-
-end
-
-class Dummy
-  include Mongoid::Document
-  include SimpleEnum::Mongoid
-
-  as_enum :gender, [:male, :female]
-  as_enum :word, { :alpha => 'alpha', :beta => 'beta', :gamma => 'gamma'}
-  as_enum :didum, [ :foo, :bar, :foobar ], :column => 'other'
-  as_enum :role, [:admin, :member, :anon], :strings => true
-  as_enum :numeric, [:"100", :"3.14"], :strings => true
-  as_enum :nilish, [:nil], :strings => true
-
-  before_save :check_typed
-
-  def check_typed
-    attributes['_type'] = nil unless (self.hereditary? || self.polymorphic?)
-  end
-
-end
-
-class Gender
-  include Mongoid::Document
-  include SimpleEnum::Mongoid
-
-  field :name, :type => String
-end
-
-class Computer
-  include Mongoid::Document
-  include SimpleEnum::Mongoid
-
-  field :name, :type => String
-
-  as_enum :manufacturer, [:dell, :compaq, :apple]
-  as_enum :operating_system, [:windows, :osx, :linux, :bsd]
-end
-
-# Used to test STI stuff
-class SpecificDummy < Dummy; end

data/test/poro_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class POROTest < MiniTest::Unit::TestCase
-  class MyPORO
-    include SimpleEnum
-
-    attr_accessor :gender_cd
-    as_enum :gender, [:male, :female]
-  end
-
-  def test_reading_and_writing
-    poro = POROTest::MyPORO.new
-    poro.gender_cd = 1
-    assert_equal :female, poro.gender
-
-    poro.male!
-    assert_equal 0, poro.gender_cd
-    assert_equal :male, poro.gender
-  end
-end

data/test/prefixes_test.rb

@@ -1,36 +0,0 @@
-require 'test_helper'
-
-class PrefixesTest < MiniTest::Unit::TestCase
-  def setup
-    reload_db
-  end
-
-  def test_that_gender_is_prefixed_in_getters_and_setters
-    with_prefix = anonymous_dummy do
-      as_enum :gender, [:male, :female], :prefix => true
-    end
-    
-    d = with_prefix.new :gender => :male
-    assert_respond_to d, :gender_male?
-    assert_respond_to d, :gender_male!
-    assert_respond_to d, :gender_female?
-    assert_respond_to d, :gender_female!
-    
-    # just ensure that it DOES NOT RESPOND TO good old male!
-    assert !d.respond_to?(:male!)
-  end
-  
-  def test_that_custom_prefix_is_applied_to_getters_and_setters
-    with_string_prefix = anonymous_dummy do
-      as_enum :gender, [:male, :female], :prefix => 'didum'
-    end
-    
-    d = with_string_prefix.new :gender => :female
-    assert_respond_to d, :didum_female?
-    assert_respond_to d, :didum_female!    
-    
-    # just check wheter the results are still correct :)
-    assert d.didum_female?
-    assert !d.didum_male?
-  end
-end