active_attr 0.5.1 → 0.6.0

data/lib/active_attr/typecasted_attributes.rb

@@ -55,7 +55,7 @@ module ActiveAttr
     #
     # @since 0.5.0
     def attribute(name)
-      typecast_attribute(_attribute_type(name), super)
+      typecast_attribute(_attribute_typecaster(name), super)
     end
 
     # Calculates an attribute type
@@ -66,6 +66,15 @@ module ActiveAttr
       self.class._attribute_type(attribute_name)
     end
 
+    # Resolve an attribute typecaster
+    #
+    # @private
+    # @since 0.6.0
+    def _attribute_typecaster(attribute_name)
+      type = _attribute_type(attribute_name)
+      self.class.attributes[attribute_name][:typecaster] || typecaster_for(type) or raise UnknownTypecasterError, "Unable to cast to type #{type}"
+    end
+
     module ClassMethods
       # Returns the class name plus its attribute names and types
       #
@@ -78,7 +87,7 @@ module ActiveAttr
       def inspect
         inspected_attributes = attribute_names.sort.map { |name| "#{name}: #{_attribute_type(name)}" }
         attributes_list = "(#{inspected_attributes.join(", ")})" unless inspected_attributes.empty?
-        "#{self.name}#{attributes_list}"
+        "#{name}#{attributes_list}"
       end
 
       # Calculates an attribute type

data/lib/active_attr/typecasting.rb

@@ -7,7 +7,7 @@ require "active_attr/typecasting/float_typecaster"
 require "active_attr/typecasting/integer_typecaster"
 require "active_attr/typecasting/object_typecaster"
 require "active_attr/typecasting/string_typecaster"
-require "active_support/concern"
+require "active_attr/typecasting/unknown_typecaster_error"
 
 module ActiveAttr
   # Typecasting provides methods to typecast a value to a different type
@@ -24,49 +24,41 @@ module ActiveAttr
   #
   # @since 0.5.0
   module Typecasting
-    extend ActiveSupport::Concern
-
-    # @private
-    TYPECASTERS = {
-      BigDecimal => BigDecimalTypecaster,
-      Boolean    => BooleanTypecaster,
-      Date       => DateTypecaster,
-      DateTime   => DateTimeTypecaster,
-      Float      => FloatTypecaster,
-      Integer    => IntegerTypecaster,
-      Object     => ObjectTypecaster,
-      String     => StringTypecaster,
-    }
-
     # Typecasts a value using a Class
     #
-    # @param [Class] type The type to cast to
+    # @param [#call] typecaster The typecaster to use for typecasting
     # @param [Object] value The value to be typecasted
     #
     # @return [Object, nil] The typecasted value or nil if it cannot be
     #   typecasted
     #
     # @since 0.5.0
-    def typecast_attribute(type, value)
-      raise ArgumentError, "a Class must be given" unless type
+    def typecast_attribute(typecaster, value)
+      raise ArgumentError, "a typecaster must be given" unless typecaster.respond_to?(:call)
       return value if value.nil?
-      typecast_value(type, value)
+      typecaster.call(value)
     end
 
-    # Typecasts a value according to a predefined set of mapping rules defined
-    #   in TYPECASTING_METHODS
+    # Resolve a Class to a typecaster
     #
     # @param [Class] type The type to cast to
-    # @param [Object] value The value to be typecasted
     #
-    # @return [Object, nil] The result of a method call defined in
-    #   TYPECASTING_METHODS, nil if no method is found
+    # @return [#call, nil] The typecaster to use
     #
-    # @since 0.5.0
-    def typecast_value(type, value)
-      if typecaster = TYPECASTERS[type]
-        typecaster.new.call(value)
-      end
+    # @since 0.6.0
+    def typecaster_for(type)
+      typecaster = {
+        BigDecimal => BigDecimalTypecaster,
+        Boolean    => BooleanTypecaster,
+        Date       => DateTypecaster,
+        DateTime   => DateTimeTypecaster,
+        Float      => FloatTypecaster,
+        Integer    => IntegerTypecaster,
+        Object     => ObjectTypecaster,
+        String     => StringTypecaster,
+      }[type]
+
+      typecaster.new if typecaster
     end
   end
 end

data/lib/active_attr/typecasting/unknown_typecaster_error.rb

@@ -0,0 +1,13 @@
+require "active_attr/error"
+
+module ActiveAttr
+  module Typecasting
+    # This exception is raised if attempting to cast to an unknown type when
+    # using {Typecasting}
+    #
+    # @since 0.6.0
+    class UnknownTypecasterError < TypeError
+      include Error
+    end
+  end
+end

data/lib/active_attr/version.rb

@@ -1,5 +1,5 @@
 module ActiveAttr
   # Complete version string
   # @since 0.1.0
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/spec/functional/active_attr/attribute_defaults_spec.rb

@@ -58,6 +58,14 @@ module ActiveAttr
       end
     end
 
+    context "an attribute with a default empty Array" do
+      before { model_class.attribute :roles, :default => [] }
+
+      it "the attribute getter returns an empty array by default" do
+        subject.roles.should == []
+      end
+    end
+
     context "an attribute with a dynamic Time.now default" do
       before { model_class.attribute :created_at, :default => lambda { Time.now } }
 
@@ -70,7 +78,7 @@ module ActiveAttr
       end
 
       it "the attribute default is different per instance" do
-        model_class.new.created_at.should_not == model_class.new.created_at
+        model_class.new.created_at.should_not equal model_class.new.created_at
       end
     end
 

data/spec/functional/active_attr/attributes_spec.rb

@@ -113,6 +113,7 @@ module ActiveAttr
             include ActiveModel::Serializers::Xml
           end
 
+          self.include_root_in_json = true
           attribute :first_name
           attribute :last_name
 
@@ -160,9 +161,11 @@ module ActiveAttr
       before do
         Object.const_set("Person", model_class)
 
-        Factory.define :person, :class => :person do |model|
-          model.first_name "Chris"
-          model.last_name "Griego"
+        FactoryGirl.define do
+          factory :person, :class => :person do
+            first_name "Chris"
+            last_name "Griego"
+          end
         end
       end
 
@@ -190,41 +193,86 @@ module ActiveAttr
     end
 
     context "defining dangerous attributes" do
-      shared_examples "defining a dangerous attribute" do
-        it "defining an attribute that conflicts with #{described_class} raises DangerousAttributeError" do
-          expect { model_class.attribute(:write_attribute) }.to raise_error DangerousAttributeError, %{an attribute method named "write_attribute" would conflict with an existing method}
+      shared_examples "a dangerous attribute" do
+        it ".dangerous_attribute? is true" do
+          model_class.dangerous_attribute?(attribute_name).should be_true
+        end
+
+        it ".attribute raises DangerousAttributeError" do
+          expect { model_class.attribute(attribute_name) }.to raise_error DangerousAttributeError, %{an attribute method named "#{attribute_name}" would conflict with an existing method}
+        end
+
+        it ".attribute! does not raise" do
+          expect { model_class.attribute!(attribute_name) }.not_to raise_error
+        end
+      end
+
+      shared_examples "a whitelisted attribute" do
+        it ".dangerous_attribute? is false" do
+          model_class.dangerous_attribute?(attribute_name).should be_false
+        end
+
+        it ".attribute does not raise" do
+          expect { model_class.attribute(attribute_name) }.not_to raise_error
+        end
+
+        it ".attribute! does not raise" do
+          expect { model_class.attribute!(attribute_name) }.not_to raise_error
+        end
+
+        it "can be set and get" do
+          model_class.attribute attribute_name
+          model = model_class.new
+          value = mock
+          model.send "#{attribute_name}=", value
+          model.send(attribute_name).should equal value
+        end
+      end
+
+      shared_examples "defining dangerous attributes" do
+        context "an attribute that conflicts with #{described_class}" do
+          let(:attribute_name) { :write_attribute }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining an attribute that conflicts with ActiveModel::AttributeMethods raises DangerousAttributeError" do
-          expect { model_class.attribute(:inspect) }.to raise_error DangerousAttributeError, %{an attribute method named "inspect" would conflict with an existing method}
+        context "an attribute that conflicts with ActiveModel::AttributeMethods" do
+          let(:attribute_name) { :inspect }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining an :id attribute does not raise" do
-          expect { model_class.attribute(:id) }.not_to raise_error
+        context "an attribute that conflicts with Kernel" do
+          let(:attribute_name) { :puts }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining a :type attribute does not raise" do
-          expect { model_class.attribute(:type) }.not_to raise_error
+        context "an attribute that conflicts with Object" do
+          let(:attribute_name) { :class }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining an attribute that conflicts with Kernel raises DangerousAttributeError" do
-          expect { model_class.attribute(:puts) }.to raise_error DangerousAttributeError
+        context "an attribute that conflicts with BasicObject" do
+          let(:attribute_name) { :instance_eval }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining an attribute that conflicts with Object raises DangerousAttributeError" do
-          expect { model_class.attribute(:class) }.to raise_error DangerousAttributeError
+        context "an attribute that conflicts with a properly implemented method_missing callback" do
+          let(:attribute_name) { :my_proper_missing_method }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining an attribute that conflicts with BasicObject raises DangerousAttributeError" do
-          expect { model_class.attribute(:instance_eval) }.to raise_error DangerousAttributeError
+        context "an attribute that conflicts with a less properly implemented method_missing callback" do
+          let(:attribute_name) { :my_less_proper_missing_method }
+          include_examples "a dangerous attribute"
         end
 
-        it "defining an attribute that conflicts with a properly implemented method_missing callback raises DangerousAttributeError" do
-          expect { model_class.attribute(:my_proper_missing_method) }.to raise_error DangerousAttributeError
+        context "an :id attribute" do
+          let(:attribute_name) { :id }
+          include_examples "a whitelisted attribute"
         end
 
-        it "defining an attribute that conflicts with a less properly implemented method_missing callback raises DangerousAttributeError" do
-          expect { model_class.attribute(:my_less_proper_missing_method) }.to raise_error DangerousAttributeError
+        context "a :type attribute" do
+          let(:attribute_name) { :type }
+          include_examples "a whitelisted attribute"
         end
       end
 
@@ -250,12 +298,12 @@ module ActiveAttr
 
       context "on a model class" do
         let(:model_class) { dangerous_model_class }
-        include_examples "defining a dangerous attribute"
+        include_examples "defining dangerous attributes"
       end
 
       context "on a child class" do
         let(:model_class) { Class.new(dangerous_model_class) }
-        include_examples "defining a dangerous attribute"
+        include_examples "defining dangerous attributes"
       end
     end
   end

data/spec/functional/active_attr/typecasted_attributes_spec.rb

@@ -10,6 +10,7 @@ module ActiveAttr
         include TypecastedAttributes
 
         attribute :typeless
+        attribute :age,         :type => Age, :typecaster => lambda { |value| Age.new(value) }
         attribute :object,      :type => Object
         attribute :big_decimal, :type => BigDecimal
         attribute :boolean,     :type => Typecasting::Boolean
@@ -18,6 +19,12 @@ module ActiveAttr
         attribute :float,       :type => Float
         attribute :integer,     :type => Integer
         attribute :string,      :type => String
+
+        attribute :unknown, :type => Class.new {
+          def self.to_s
+            "Unknown"
+          end
+        }
       end
     end
 
@@ -27,6 +34,16 @@ module ActiveAttr
         subject.typeless.should be_nil
       end
 
+      it "an attribute with no known typecaster raises" do
+        subject.unknown = nil
+        expect { subject.unknown }.to raise_error Typecasting::UnknownTypecasterError, "Unable to cast to type Unknown"
+      end
+
+      it "an attribute with an inline typecaster returns nil" do
+        subject.age = nil
+        subject.age.should be_nil
+      end
+
       it "an Object attribute returns nil" do
         subject.object = nil
         subject.object.should be_nil
@@ -121,6 +138,11 @@ module ActiveAttr
         subject.string = "1.0"
         subject.string.should eql "1.0"
       end
+
+      it "an attribute using an inline typecaster returns the result of the inline typecaster" do
+        subject.age = 2
+        subject.age.should == Age.new(2)
+      end
     end
   end
 end

data/spec/support/age.rb

@@ -0,0 +1,17 @@
+class Age
+  def ==(other)
+    other.kind_of?(self.class) && other.to_i == to_i
+  end
+
+  def initialize(years)
+    @years = years.to_i
+  end
+
+  def inspect
+    "#{@years} years old"
+  end
+
+  def to_i
+    @years
+  end
+end

data/spec/unit/active_attr/attribute_definition_spec.rb

@@ -61,6 +61,30 @@ module ActiveAttr
       end
     end
 
+    describe "#inspect" do
+      it "generates attribute definition code for an attribute without options" do
+        described_class.new(:first_name).inspect.should == %{attribute :first_name}
+      end
+
+      it "generates attribute definition code for an attribute with a single option" do
+        described_class.new(:first_name, :type => String).inspect.should == %{attribute :first_name, :type => String}
+      end
+
+      it "generates attribute definition code for an attribute with a single option, inspecting the option value" do
+        described_class.new(:first_name, :default => "John").inspect.should == %{attribute :first_name, :default => "John"}
+      end
+
+      it "generates attribute definition code for an attribute with multiple options sorted alphabetically" do
+        expected = %{attribute :first_name, :default => "John", :type => String}
+        described_class.new(:first_name, :default => "John", :type => String).inspect.should eq expected
+        described_class.new(:first_name, :type => String, :default => "John").inspect.should == expected
+      end
+
+      it "generate attribute definition code for an attribute with a string option key" do
+        described_class.new(:first_name, "foo" => "bar").inspect.should == %{attribute :first_name, "foo" => "bar"}
+      end
+    end
+
     describe "#name" do
       it { should respond_to(:name) }
     end

data/spec/unit/active_attr/attributes_spec.rb

@@ -41,61 +41,97 @@ module ActiveAttr
     end
 
     let :attributeless do
-      Class.new do
-        include Attributes
+      Class.new.tap do |attributeless|
+        attributeless.class_eval do
+          include Attributes
 
-        def self.name
-          "Foo"
+          def self.name
+            "Foo"
+          end
         end
       end
     end
 
     describe ".attribute" do
-      it "creates an attribute with no options" do
-        model_class.attributes.values.should include(AttributeDefinition.new(:first_name))
-      end
+      context "a dangerous attribute" do
+        before { model_class.stub(:dangerous_attribute?).and_return(true) }
 
-      it "returns the attribute definition" do
-        Class.new(model_class).attribute(:address).should == AttributeDefinition.new(:address)
+        it { expect { model_class.attribute(:address) }.to raise_error DangerousAttributeError }
       end
 
-      it "defines an attribute reader that calls #attribute" do
-        subject.should_receive(:attribute).with("first_name")
-        subject.first_name
-      end
+      context "a harmless attribute" do
+        it "creates an attribute with no options" do
+          model_class.attributes.values.should include(AttributeDefinition.new(:first_name))
+        end
 
-      it "defines an attribute reader that can be called via super" do
-        subject.should_receive(:attribute).with("amount")
-        subject.amount
-      end
+        it "returns the attribute definition" do
+          model_class.attribute(:address).should == AttributeDefinition.new(:address)
+        end
 
-      it "defines an attribute writer that calls #attribute=" do
-        subject.should_receive(:attribute=).with("first_name", "Ben")
-        subject.first_name = "Ben"
+        it "defines an attribute reader that calls #attribute" do
+          subject.should_receive(:attribute).with("first_name")
+          subject.first_name
+        end
+
+        it "defines an attribute reader that can be called via super" do
+          subject.should_receive(:attribute).with("amount")
+          subject.amount
+        end
+
+        it "defines an attribute writer that calls #attribute=" do
+          subject.should_receive(:attribute=).with("first_name", "Ben")
+          subject.first_name = "Ben"
+        end
+
+        it "defines an attribute writer that can be called via super" do
+          subject.should_receive(:attribute=).with("amount", 1)
+          subject.amount = 1
+        end
+
+        it "defining an attribute twice does not give the class two attribute definitions" do
+          Class.new do
+            include Attributes
+            attribute :name
+            attribute :name
+          end.should have(1).attributes
+        end
+
+        it "redefining an attribute replaces the attribute definition" do
+          klass = Class.new do
+            include Attributes
+            attribute :name, :type => Symbol
+            attribute :name, :type => String
+          end
+
+          klass.should have(1).attributes
+          klass.attributes[:name].should == AttributeDefinition.new(:name, :type => String)
+        end
       end
+    end
 
-      it "defines an attribute writer that can be called via super" do
-        subject.should_receive(:attribute=).with("amount", 1)
-        subject.amount = 1
+    describe ".attribute!" do
+      it "can create an attribute with no options" do
+        attributeless.attribute! :first_name
+        attributeless.attributes.values.should include AttributeDefinition.new(:first_name)
       end
 
-      it "defining an attribute twice does not give the class two attribute definitions" do
-        Class.new do
-          include Attributes
-          attribute :name
-          attribute :name
-        end.should have(1).attributes
+      it "returns the attribute definition" do
+        attributeless.attribute!(:address).should == AttributeDefinition.new(:address)
       end
 
-      it "redefining an attribute replaces the attribute definition" do
-        klass = Class.new do
-          include Attributes
-          attribute :name, :type => Symbol
-          attribute :name, :type => String
-        end
+      it "defines an attribute reader that calls #attribute" do
+        attributeless.attribute! :first_name
+        instance = attributeless.new
+        result = mock
+        instance.should_receive(:attribute).with("first_name").and_return(result)
+        instance.first_name.should equal result
+      end
 
-        klass.should have(1).attributes
-        klass.attributes[:name].should == AttributeDefinition.new(:name, :type => String)
+      it "defines an attribute writer that calls #attribute=" do
+        attributeless.attribute! :first_name
+        instance = attributeless.new
+        instance.should_receive(:attribute=).with("first_name", "Ben")
+        instance.first_name = "Ben"
       end
     end