active_attr 0.5.0.alpha2 → 0.5.0

data/lib/active_attr/typecasting/big_decimal_typecaster.rb

@@ -0,0 +1,36 @@
+require "bigdecimal"
+require "bigdecimal/util"
+require "active_support/core_ext/big_decimal/conversions"
+
+module ActiveAttr
+  module Typecasting
+    # Typecasts an Object to a BigDecimal
+    #
+    # @example Usage
+    #   BigDecimalTypecaster.new.call(1).to_s #=> "0.1E1"
+    #
+    # @since 0.5.0
+    class BigDecimalTypecaster
+      # Typecasts an object to a BigDecimal
+      #
+      # Attempt to convert using #to_d, else it creates a BigDecimal using the
+      # String representation of the value.
+      #
+      # @example Typecast a Fixnum
+      #   typecaster.call(1).to_s #=> "0.1E1"
+      #
+      # @param [Object, #to_d, #to_s] value The object to typecast
+      #
+      # @return [BigDecimal, nil] The result of typecasting
+      #
+      # @since 0.5.0
+      def call(value)
+        if value.respond_to? :to_d
+          value.to_d
+        else
+          BigDecimal.new value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/boolean.rb

@@ -1,5 +1,7 @@
 module ActiveAttr
   module Typecasting
+    # Boolean provides a constant to use in typecaster resolution
+    # @since 0.5.0
     class Boolean
     end
   end

data/lib/active_attr/typecasting/boolean_typecaster.rb

@@ -2,13 +2,35 @@ require "active_support/core_ext/object/blank"
 
 module ActiveAttr
   module Typecasting
-    # TODO documentation
+    # Typecasts an Object to true or false
+    #
+    # @example Usage
+    #   BooleanTypecaster.new.call(1) #=> true
+    #
+    # @since 0.5.0
     class BooleanTypecaster
-      # TODO documentation
-      # http://yaml.org/type/bool.html
+      # Values which force a false result for typecasting
+      #
+      # These values are based on the
+      # {YAML language}[http://yaml.org/type/bool.html].
+      #
+      # @since 0.5.0
       FALSE_VALUES = ["n", "N", "no", "No", "NO", "false", "False", "FALSE", "off", "Off", "OFF", "f", "F"]
 
-      # TODO documentation
+      # Typecasts an object to true or false
+      #
+      # Similar to ActiveRecord, when the attribute is a zero value or
+      # is a string that represents false, typecasting returns false.
+      # Otherwise typecasting just checks the presence of a value.
+      #
+      # @example Typecast a Fixnum
+      #   typecaster.call(1) #=> true
+      #
+      # @param [Object] value The object to typecast
+      #
+      # @return [true, false] The result of typecasting
+      #
+      # @since 0.5.0
       def call(value)
         case value
         when *FALSE_VALUES then false

data/lib/active_attr/typecasting/date_time_typecaster.rb

@@ -3,9 +3,26 @@ require "active_support/time"
 
 module ActiveAttr
   module Typecasting
-    # TODO documentation
+    # Typecasts an Object to a DateTime
+    #
+    # @example Usage
+    #   typecaster = DateTimeTypecaster.new
+    #   typecaster.call("2012-01-01") #=> Sun, 01 Jan 2012 00:00:00 +0000
+    #
+    # @since 0.5.0
     class DateTimeTypecaster
-      # TODO documentation
+      # Typecasts an object to a DateTime
+      #
+      # Attempts to convert using #to_datetime.
+      #
+      # @example Typecast a String
+      #   typecaster.call("2012-01-01") #=> Sun, 01 Jan 2012 00:00:00 +0000
+      #
+      # @param [Object, #to_datetime] value The object to typecast
+      #
+      # @return [DateTime, nil] The result of typecasting
+      #
+      # @since 0.5.0
       def call(value)
         value.to_datetime if value.respond_to? :to_datetime
       end

data/lib/active_attr/typecasting/date_typecaster.rb

@@ -3,9 +3,25 @@ require "active_support/time"
 
 module ActiveAttr
   module Typecasting
-    # TODO documentation
+    # Typecasts an Object to a Date
+    #
+    # @example Usage
+    #   DateTypecaster.new.call("2012-01-01") #=> Sun, 01 Jan 2012
+    #
+    # @since 0.5.0
     class DateTypecaster
-      # TODO documentation
+      # Typecasts an object to a Date
+      #
+      # Attempts to convert using #to_date.
+      #
+      # @example Typecast a String
+      #   typecaster.call("2012-01-01") #=> Sun, 01 Jan 2012
+      #
+      # @param [Object, #to_date] value The object to typecast
+      #
+      # @return [Date, nil] The result of typecasting
+      #
+      # @since 0.5.0
       def call(value)
         value.to_date if value.respond_to? :to_date
       end

data/lib/active_attr/typecasting/float_typecaster.rb

@@ -1,8 +1,24 @@
 module ActiveAttr
   module Typecasting
-    # TODO documentation
+    # Typecasts an Object to a Float
+    #
+    # @example Usage
+    #   FloatTypecaster.new.call(1) #=> 1.0
+    #
+    # @since 0.5.0
     class FloatTypecaster
-      # TODO documentation
+      # Typecasts an object to a Float
+      #
+      # Attempts to convert using #to_f.
+      #
+      # @example Typecast a Fixnum
+      #   typecaster.call(1) #=> 1.0
+      #
+      # @param [Object, #to_f] value The object to typecast
+      #
+      # @return [Float, nil] The result of typecasting
+      #
+      # @since 0.5.0
       def call(value)
         value.to_f if value.respond_to? :to_f
       end

data/lib/active_attr/typecasting/integer_typecaster.rb

@@ -1,8 +1,25 @@
 module ActiveAttr
   module Typecasting
-    # TODO documentation
+    # Typecasts an Object to an Integer
+    #
+    # @example Usage
+    #   IntegerTypecaster.new.call("1") #=> 1
+    #
+    # @since 0.5.0
     class IntegerTypecaster
-      # TODO documentation
+      # Typecasts an object to an Integer
+      #
+      # Attempts to convert using #to_i. Handles FloatDomainError if the
+      # object is INFINITY or NAN.
+      #
+      # @example Typecast a String
+      #   typecaster.call("1") #=> 1
+      #
+      # @param [Object, #to_i] value The object to typecast
+      #
+      # @return [Integer, nil] The result of typecasting
+      #
+      # @since 0.5.0
       def call(value)
         value.to_i if value.respond_to? :to_i
       rescue FloatDomainError

data/lib/active_attr/typecasting/object_typecaster.rb

@@ -1,6 +1,22 @@
 module ActiveAttr
   module Typecasting
+    # A "null" typecaster to provide uniformity
+    #
+    # @example Usage
+    #   ObjectTypecaster.new.call("") #=> ""
+    #
+    # @since 0.5.0
     class ObjectTypecaster
+      # Returns the original value unmodified
+      #
+      # @example Typecast an Object
+      #   typecaster.call(1) #=> 1
+      #
+      # @param [Object] value The object to typecast
+      #
+      # @return [Object] Whatever you passed in
+      #
+      # @since 0.5.0
       def call(value)
         value
       end

data/lib/active_attr/typecasting/string_typecaster.rb

@@ -1,8 +1,24 @@
 module ActiveAttr
   module Typecasting
-    # TODO documentation
+    # Typecasts an Object to a String
+    #
+    # @example Usage
+    #   StringTypecaster.new.call(1) #=> "1"
+    #
+    # @since 0.5.0
     class StringTypecaster
-      # TODO documentation
+      # Typecasts an object to a String
+      #
+      # Attempts to convert using #to_s.
+      #
+      # @example Typecast a Fixnum
+      #   typecaster.call(1) #=> "1"
+      #
+      # @param [Object, #to_s] value The object to typecast
+      #
+      # @return [String, nil] The result of typecasting
+      #
+      # @since 0.5.0
       def call(value)
         value.to_s if value.respond_to? :to_s
       end

data/lib/active_attr/version.rb

@@ -1,5 +1,5 @@
 module ActiveAttr
   # Complete version string
   # @since 0.1.0
-  VERSION = "0.5.0.alpha2"
+  VERSION = "0.5.0"
 end

data/spec/functional/active_attr/matchers/have_attribute_matcher_spec.rb

@@ -0,0 +1,364 @@
+require "spec_helper"
+require "active_attr/attributes"
+require "active_attr/attribute_defaults"
+require "active_attr/matchers/have_attribute_matcher"
+require "active_attr/typecasted_attributes"
+
+module ActiveAttr
+  module Matchers
+    describe HaveAttributeMatcher do
+      let :model_class do
+        Class.new do
+          include Attributes
+          include AttributeDefaults
+          include TypecastedAttributes
+
+          def self.name
+            "Person"
+          end
+        end
+      end
+
+      shared_examples "a matcher matching a class without ActiveAttr::Attributes" do
+        let :model_class do
+          Class.new do
+            def self.name
+              "Person"
+            end
+          end
+        end
+
+        describe "#matches?" do
+          it { subject.matches?(model_class).should be_false }
+        end
+
+        describe "#failure_message" do
+          before { subject.matches?(model_class) }
+
+          it { subject.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::Attributes} }
+        end
+      end
+
+      shared_examples "a matcher matching a class without ActiveAttr::AttributeDefaults" do
+        let :model_class do
+          Class.new do
+            include Attributes
+
+            def self.name
+              "Person"
+            end
+          end
+        end
+
+        describe "#matches?" do
+          it { subject.matches?(model_class).should be_false }
+        end
+
+        describe "#failure_message" do
+          before { subject.matches?(model_class) }
+
+          it { subject.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::AttributeDefaults} }
+        end
+      end
+
+      shared_examples "a matcher matching a class without ActiveAttr::TypecastedAttributes" do
+        let :model_class do
+          Class.new do
+            include Attributes
+
+            def self.name
+              "Person"
+            end
+          end
+        end
+
+        describe "#matches?" do
+          it { subject.matches?(model_class).should be_false }
+        end
+
+        describe "#failure_message" do
+          before { subject.matches?(model_class) }
+
+          it { subject.failure_message.should == %{expected #{model_class.name} to include ActiveAttr::TypecastedAttributes} }
+        end
+      end
+
+      context "a matcher with just an attribute name" do
+        subject { described_class.new(:first_name) }
+
+        it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
+
+        context "a class with the attribute" do
+          before { model_class.attribute :first_name }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name} }
+          end
+        end
+
+        context "a class without the attribute" do
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name} }
+          end
+        end
+      end
+
+      context "a matcher with a default value" do
+        subject { described_class.new(:first_name).with_default_value_of("John") }
+
+        it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
+        it_should_behave_like "a matcher matching a class without ActiveAttr::AttributeDefaults"
+
+        context "a class with the attribute but no default" do
+          before { model_class.attribute :first_name }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name with a default value of "John"} }
+          end
+        end
+
+        context "a class with the attribute and a different default" do
+          before { model_class.attribute :first_name, :default => "Doe" }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name with a default value of "John"} }
+          end
+        end
+
+        context "a class with the attribute and the right default" do
+          before { model_class.attribute :first_name, :default => "John" }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name with a default value of "John"} }
+          end
+        end
+      end
+
+      context "a matcher with a default value of false" do
+        subject { described_class.new(:admin).with_default_value_of(false) }
+
+        it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
+        it_should_behave_like "a matcher matching a class without ActiveAttr::AttributeDefaults"
+
+        context "a class with the attribute but no default" do
+          before { model_class.attribute :admin }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named admin with a default value of false} }
+          end
+        end
+
+        context "a class with the attribute and a default of nil" do
+          before { model_class.attribute :admin, :default => nil }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named admin with a default value of false} }
+          end
+        end
+
+        context "a class with the attribute and the right default" do
+          before { model_class.attribute :admin, :default => false }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named admin with a default value of false} }
+          end
+        end
+      end
+
+      context "a matcher with a default value of nil" do
+        subject { described_class.new(:first_name).with_default_value_of(nil) }
+
+        it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
+        it_should_behave_like "a matcher matching a class without ActiveAttr::AttributeDefaults"
+
+        context "a class with the attribute but no default" do
+          before { model_class.attribute :first_name }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name with a default value of nil} }
+          end
+        end
+
+        context "a class with the attribute and a default of false" do
+          before { model_class.attribute :first_name, :default => false }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name with a default value of nil} }
+          end
+        end
+
+        context "a class with the attribute and the right default" do
+          before { model_class.attribute :first_name, :default => nil }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name with a default value of nil} }
+          end
+        end
+      end
+
+      context "a matcher with a type" do
+        subject { described_class.new(:first_name).of_type(String) }
+
+        it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
+        it_should_behave_like "a matcher matching a class without ActiveAttr::TypecastedAttributes"
+
+        context "a class with the attribute but no type" do
+          before { model_class.attribute :first_name }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name of type String} }
+          end
+        end
+
+        context "a class with the attribute and a different type" do
+          before { model_class.attribute :first_name, :type => Symbol }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name of type String} }
+          end
+        end
+
+        context "a class with the attribute and the right type" do
+          before { model_class.attribute :first_name, :type => String }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name of type String} }
+          end
+        end
+      end
+
+      context "a matcher with a type of Object" do
+        subject { described_class.new(:first_name).of_type(Object) }
+
+        it_should_behave_like "a matcher matching a class without ActiveAttr::Attributes"
+        it_should_behave_like "a matcher matching a class without ActiveAttr::TypecastedAttributes"
+
+        context "a class with the attribute but no type" do
+          before { model_class.attribute :first_name }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name of type Object} }
+          end
+        end
+
+        context "a class with the attribute and a different type" do
+          before { model_class.attribute :first_name, :type => String }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_false }
+          end
+
+          describe "#failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.failure_message.should == %{expected Person to have attribute named first_name of type Object} }
+          end
+        end
+
+        context "a class with the attribute and the right type" do
+          before { model_class.attribute :first_name, :type => Object }
+
+          describe "#matches?" do
+            it { subject.matches?(model_class).should be_true }
+          end
+
+          describe "#negative_failure_message" do
+            before { subject.matches?(model_class) }
+
+            it { subject.negative_failure_message.should == %{expected Person to not have attribute named first_name of type Object} }
+          end
+        end
+      end
+    end
+  end
+end