classy_enum 2.3.0 → 3.0.0

data/lib/classy_enum/instance_methods.rb

@@ -1,122 +0,0 @@
-module ClassyEnum
-  module InstanceMethods
-    # Returns an integer representing the order that this element was defined in.
-    # Also used internally for sorting.
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  @priority = PriorityMedium.new
-    #  @priority.index # => 2
-    def index
-      self.class.instance_variable_get('@index')
-    end
-
-    alias :to_i :index
-
-    # Returns the name or string corresponding to element
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  @priority = PriorityLow.new
-    #  @priority.to_s # => 'low'
-    def to_s
-      self.class.instance_variable_get('@option').to_s
-    end
-
-    # Returns a Symbol corresponding to a string representation of element,
-    # creating the symbol if it did not previously exist
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  @priority = PriorityLow.new
-    #  @priority.to_sym # => :low
-    def to_sym
-      to_s.to_sym
-    end
-
-    # Returns string representing enum in Rails titleize format
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high, :really_high
-    #  end
-    #
-    #  @priority = Priority.build(:really_high)
-    #  @priority.name # => "Really High"
-    def name
-      ActiveSupport::Deprecation.warn('name is deprecated, and will be removed in ClassyEnum 3.0. Replace calls with to_s.titleize.', caller)
-      to_s.titleize
-    end
-
-    # Sort an array of elements based on the order they are defined
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Priority < ClassyEnum::Base
-    #    enum_classes :low, :medium, :high
-    #  end
-    #
-    #  @low = Priority.build(:low)
-    #  @medium = Priority.build(:medium)
-    #  @high = Priority.build(:high)
-    #  priorities = [@low, @high, @medium]
-    #  priorities.sort # => [@low, @medium, @high]
-    #  priorities.max # => @high
-    #  priorities.min # => @low
-    def <=> other
-      index <=> other.index
-    end
-
-    # Overrides as_json to remove owner reference recursion issues
-    def as_json(options=nil)
-      return to_s unless serialize_as_json
-      json = super(options)
-      json.delete('owner')
-      json.delete('serialize_as_json')
-      json
-    end
-
-  protected
-
-    # Determine if the enum attribute is a particular member.
-    #
-    # ==== Example
-    #  # Create an Enum with some elements
-    #  class Breed < ClassyEnum::Base
-    #    enum_classes :golden_retriever, :snoop
-    #  end
-    #
-    #  # Create an ActiveRecord class using the Breed enum
-    #  class Dog < ActiveRecord::Base
-    #    classy_enum_attr :breed
-    #  end
-    #
-    #  @dog = Dog.new(:breed => :snoop)
-    #  @dog.breed.snoop? # => true
-    #  @dog.breed.golden_retriever? # => false
-    def attribute?(attribute)
-      to_s == attribute
-    end
-
-  private
-
-    # Used by attribute methods
-    def attributes
-      []
-    end
-
-  end
-end

data/spec/active_record_spec.rb

@@ -1,70 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-class Color < ClassyEnum::Base
-  enum_classes :white, :black
-end
-
-class ColorWhite < Color; end;
-
-class ColorBlack < Color; end;
-
-class ActiveDog < ActiveRecord::Base
-  classy_enum_attr :breed, :suffix => 'type'
-  classy_enum_attr :color
-
-  validates :name,
-    :presence => true,
-    :uniqueness => { :scope => [:breed] }
-
-  validates_uniqueness_of :name, :scope => :color
-
-  scope :goldens, where(:breed => 'golden_retriever')
-
-end
-
-describe ActiveDog do
-
-  context 'valid instance' do
-    subject { ActiveDog.new(:name => 'sirius', :breed => :golden_retriever, :color => :black) }
-
-    it { should have(:no).errors_on(:breed) }
-    its(:breed_type) { should be_a_golden_retriever }
-    its(:breed) { should == 'golden_retriever' }
-  end
-
-  context 'uniqueness on name' do
-    subject { ActiveDog.new(:name => 'Kitteh', :breed => :golden_retriever, :color => :black) }
-    it { should be_valid }
-
-    context 'with existing kitteh' do
-      before do
-        ActiveDog.create!(:name => 'Kitteh', :breed => :husky, :color => :black)
-      end
-
-      it { should have(1).error_on(:name) }
-    end
-  end
-
-  context 'invalid instance' do
-    subject { ActiveDog.new(:name => 'sirius', :breed => :golden_retrievers, :color => :white) }
-
-    it { should have(1).error_on(:breed) }
-  end
-
-  context 'scopes' do
-    let!(:golden) { ActiveDog.create!(:name => 'Sebastian', :breed => :golden_retriever, :color => :white) }
-    let!(:husky) { ActiveDog.create!(:name => 'Sirius', :breed => :husky, :color => :black) }
-
-    after { ActiveDog.destroy_all }
-
-    it 'should know all dogs' do
-      ActiveDog.all.should include(golden, husky)
-    end
-
-    it 'should have a working scope' do
-      ActiveDog.goldens.should include(golden)
-      ActiveDog.goldens.should_not include(husky)
-    end
-  end
-
-end

data/spec/classy_enum_attributes_spec.rb

@@ -1,97 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "A Dog" do
-
-  context "with valid breed options" do
-    subject { Dog.new(:breed => :golden_retriever) }
-
-    it { should be_valid }
-    its(:breed) { should be_a(BreedGoldenRetriever) }
-    its(:breed_options) { should eql({:enum => :breed, :allow_blank => false}) }
-  end
-
-  it "should not be valid with a nil breed" do
-    Dog.new(:breed => nil).should_not be_valid
-  end
-
-  it "should not be valid with a blank breed" do
-    Dog.new(:breed => "").should_not be_valid
-  end
-
-  context "with invalid breed options" do
-    let(:dog) { Dog.new(:breed => :fake_breed) }
-    subject { dog }
-    it { should_not be_valid }
-
-    it 'should have an error message containing the right options' do
-      dog.valid?
-      dog.errors[:breed].should include("must be one of #{Breed.all.map(&:to_sym).join(', ')}")
-    end
-  end
-
-end
-
-describe "A ClassyEnum that allows blanks" do
-
-  context "with valid breed options" do
-    subject { AllowBlankBreedDog.new(:breed => :golden_retriever) }
-
-    it { should be_valid }
-    its(:breed_options) { should eql({:enum => :breed, :allow_blank => true}) }
-  end
-
-  it "should be valid with a nil breed" do
-    AllowBlankBreedDog.new(:breed => nil).should be_valid
-  end
-
-  it "should be valid with a blank breed" do
-    AllowBlankBreedDog.new(:breed => "").should be_valid
-  end
-
-  context "with invalid breed options" do
-    let(:dog) { AllowBlankBreedDog.new(:breed => :fake_breed) }
-    subject { dog }
-    it { should_not be_valid }
-
-    it 'should have an error message containing the right options' do
-      dog.valid?
-      dog.errors[:breed].should include("must be one of #{Breed.all.map(&:to_sym).join(', ')}")
-    end
-  end
-
-end
-
-describe "A ClassyEnum that allows nils" do
-
-  context "with valid breed options" do
-    subject { AllowNilBreedDog.new(:breed => :golden_retriever) }
-
-    it { should be_valid }
-    its(:breed_options) { should eql({:enum => :breed, :allow_blank => false}) }
-  end
-
-  it "should be valid with a nil breed" do
-    AllowNilBreedDog.new(:breed => nil).should be_valid
-  end
-
-  it "should not be valid with a blank breed" do
-    AllowNilBreedDog.new(:breed => "").should_not be_valid
-  end
-
-  context "with invalid breed options" do
-    let(:dog) { AllowNilBreedDog.new(:breed => :fake_breed) }
-    subject { dog }
-    it { should_not be_valid }
-
-    it 'should have an error message containing the right options' do
-      dog.valid?
-      dog.errors[:breed].should include("must be one of #{Breed.all.map(&:to_sym).join(', ')}")
-    end
-  end
-
-end
-
-describe "A ClassyEnum that has a different field name than the enum" do
-  subject { OtherDog.new(:other_breed => :snoop) }
-  its(:other_breed) { should be_a(BreedSnoop) }
-end

data/spec/classy_enum_owner_reference_spec.rb

@@ -1,53 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-class CatBreed < ClassyEnum::Base
-  enum_classes :abyssian, :bengal, :birman, :persian
-  owner :cat
-
-  def breed_color
-    "#{cat.color} #{name}"
-  end
-end
-
-class CatBreedAbyssian < CatBreed
-end
-
-class CatBreedBengal < CatBreed
-end
-
-class CatBreedBirman < CatBreed
-end
-
-class CatBreedPersian < CatBreed
-end
-
-class Cat < ActiveRecord::Base
-  classy_enum_attr :breed, :enum => :cat_breed
-  attr_accessor :color
-  delegate :breed_color, :to => :breed
-end
-
-class OtherCat < ActiveRecord::Base
-  classy_enum_attr :breed, :enum => :cat_breed, :serialize_as_json => true
-  attr_accessor :color
-  delegate :breed_color, :to => :breed
-end
-
-describe Cat do
-  let(:abyssian) { Cat.new(:breed => :abyssian, :color => 'black') }
-  let(:persian) { OtherCat.new(:breed => :persian, :color => 'white') }
-
-  it 'should delegate breed color to breed with an ownership reference' do
-    abyssian.breed_color { should eql('black Abyssian') }
-    persian.breed_color { should eql('white Persian') }
-  end
-
-  it 'should correctly serialize without the owner reference' do
-    JSON.parse(abyssian.to_json)['cat']['breed'].should == 'abyssian'
-  end
-
-  it 'should convert the enum to a string when serializing' do
-    JSON.parse(persian.to_json)['other_cat']['breed'].should be_a(Hash)
-  end
-
-end

data/spec/classy_enum_spec.rb

@@ -1,105 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-class TestEnum < ClassyEnum::Base
-  enum_classes :one, :two, :three
-
-  def self.test_class_method?
-    false
-  end
-
-  def test_instance_method?
-    false
-  end
-end
-
-class TestEnumOne < TestEnum
-end
-
-class TestEnumTwo < TestEnum
-  def self.test_class_method?
-    true
-  end
-
-  def test_instance_method?
-    true
-  end
-end
-
-class TestEnumThree < TestEnum
-end
-
-describe "A ClassyEnum Descendent" do
-
-  it "should return an array of enums" do
-    TestEnum.all.map(&:class).should == [TestEnumOne, TestEnumTwo, TestEnumThree]
-  end
-
-  it "should return an array of enums for a select tag" do
-    TestEnum.select_options.should == TestEnum.enum_options.map {|o| [TestEnum.build(o).name, TestEnum.build(o).to_s] }
-  end
-
-  it "should return a type error when adding an invalid option" do
-    TestEnum.build(:invalid_option).class.should == TypeError
-  end
-
-  it "should find an enum by symbol" do
-    TestEnum.find(:one).class.should == TestEnumOne
-  end
-
-  it "should find an enum by string" do
-    TestEnum.find("one").class.should == TestEnumOne
-  end
-
-  it "should create an instance with a string" do
-    TestEnum.build("one").should be_a(TestEnumOne)
-  end
-end
-
-describe "A collection of ClassyEnums" do
-  let(:one) { TestEnum.build(:one) }
-  let(:two) { TestEnum.build(:two) }
-  let(:three) { TestEnum.build(:three) }
-
-  subject { [one, three, two] }
-  its(:sort) { should eql([one, two, three]) }
-  its(:max) { should eql(three) }
-end
-
-describe "A ClassyEnum element" do
-  it "should instantiate a member" do
-    TestEnumOne.new.should be_a(TestEnumOne)
-  end
-
-  it "should inherit the default class methods" do
-    TestEnumOne.test_class_method?.should be_false
-  end
-
-  it "should compare different elements based on their index" do
-    TestEnumOne.new.should == TestEnumOne.new
-  end
-end
-
-describe "A ClassyEnum instance" do
-  subject { TestEnum.build(:one) }
-
-  it { should be_a(TestEnum) }
-  its(:class) { should eql(TestEnumOne) }
-  its(:one?) { should be_true }
-  its(:two?) { should be_false }
-  its(:index) { should eql(1) }
-  its(:to_i) { should eql(1) }
-  its(:to_s) { should eql('one') }
-  its(:to_sym) { should be(:one) }
-  its(:name) { should eql('One') }
-  its(:test_instance_method?) { should be_false }
-end
-
-describe "A ClassyEnum that overrides values" do
-  subject { TestEnum.build(:two) }
-
-  its(:test_instance_method?) { should be_true }
-
-  it "should override the default class methods" do
-    TestEnumTwo.test_class_method?.should be_true
-  end
-end