active_attr 0.4.1 → 0.5.0.alpha1

data/lib/active_attr/logger.rb

@@ -19,14 +19,7 @@ module ActiveAttr
     #
     # @since 0.3.0
     def self.logger
-      @logger
-    end
-
-    # Determin if a global default logger is configured
-    #
-    # @since 0.3.0
-    def self.logger?
-      !!logger
+      @logger ||= nil
     end
 
     # Configure the global default logger
@@ -38,6 +31,13 @@ module ActiveAttr
       @logger = new_logger
     end
 
+    # Determine if a global default logger is configured
+    #
+    # @since 0.3.0
+    def self.logger?
+      !!logger
+    end
+
     included do
       class_attribute :logger
       self.logger = Logger.logger

data/lib/active_attr/mass_assignment.rb

@@ -24,7 +24,8 @@ module ActiveAttr
     #   person.first_name #=> "Chris"
     #   person.last_name #=> "Griego"
     #
-    # @param [Hash, #each] attributes Attributes used to populate the model
+    # @param [Hash{#to_s => Object}, #each] attributes Attributes used to
+    #   populate the model
     #
     # @since 0.1.0
     def assign_attributes(new_attributes, options={})

data/lib/active_attr/matchers/have_attribute_matcher.rb

@@ -1,10 +1,11 @@
 module ActiveAttr
   module Matchers
-    # Specify that a model should have an attribute matching the criteria
+    # Specify that a model should have an attribute matching the criteria. See
+    # {HaveAttributeMatcher}
     #
     # @example Person should have a name attribute
     #   describe Person do
-    #     it { should have_attribute(:name) }
+    #     it { should have_attribute(:first_name) }
     #   end
     #
     # @param [Symbol, String, #to_sym] attribute_name
@@ -17,18 +18,35 @@ module ActiveAttr
     end
 
     # Verifies that an ActiveAttr-based model has an attribute matching the
-    # given criteria
+    # given criteria. See {Matchers#have_attribute}
     #
     # @since 0.2.0
     class HaveAttributeMatcher
-      # @return [Symbol]
-      # @private
-      attr_reader :attribute_name
+      attr_reader :attribute_name, :default_value
+      private :attribute_name, :default_value
+
+      # Specify that the attribute should have the given default value
+      #
+      # @example Person's first name should default to John
+      #   describe Person do
+      #     it do
+      #       should have_attribute(:first_name).with_default_value_of("John")
+      #     end
+      #   end
+      #
+      # @param [Object]
+      #
+      # @since 0.5.0
+      def with_default_value_of(default_value)
+        @default_value_set = true
+        @default_value = default_value
+        self
+      end
 
       # @return [String] Description
       # @private
       def description
-        "have attribute named #{attribute_name}"
+        "have attribute named #{attribute_name}#{ " with a default value of #{default_value.inspect}" if @default_value_set}"
       end
 
       # @return [String] Failure message
@@ -42,15 +60,15 @@ module ActiveAttr
       def initialize(attribute_name)
         raise TypeError, "can't convert #{attribute_name.class} into Symbol" unless attribute_name.respond_to? :to_sym
         @attribute_name = attribute_name.to_sym
+        @default_value_set = false
       end
 
       # @private
       def matches?(model_or_model_class)
         @model_class = class_from(model_or_model_class)
+        @attribute_definition = @model_class.attributes[attribute_name]
 
-        @model_class.attributes.any? do |attribute|
-          attribute.name == attribute_name
-        end
+        !!(@attribute_definition && (!@default_value_set || @attribute_definition[:default] == default_value))
       end
 
       # @return [String] Negative failure message

data/lib/active_attr/model.rb

@@ -1,3 +1,4 @@
+require "active_attr/attribute_defaults"
 require "active_attr/basic_model"
 require "active_attr/block_initialization"
 require "active_attr/logger"
@@ -24,6 +25,7 @@ module ActiveAttr
     include BlockInitialization
     include Logger
     include MassAssignmentSecurity
+    include AttributeDefaults
     include QueryAttributes
 
     if defined? ActiveModel::Serializable

data/lib/active_attr/query_attributes.rb

@@ -1,4 +1,5 @@
 require "active_attr/attributes"
+require "active_attr/typecasting/boolean_typecaster"
 require "active_attr/unknown_attribute_error"
 require "active_support/concern"
 require "active_support/core_ext/object/blank"
@@ -52,11 +53,7 @@ module ActiveAttr
     private
 
     def attribute?(name)
-      case value = read_attribute(name)
-      when "false", "FALSE", "f", "F" then false
-      when Numeric, /^\-?[0-9]/ then !value.to_f.zero?
-      else value.present?
-      end
+      Typecasting::BooleanTypecaster.new.call(read_attribute(name))
     end
   end
 end

data/lib/active_attr/typecasted_attributes.rb

@@ -0,0 +1,77 @@
+require "active_attr/attributes"
+require "active_attr/typecasting"
+require "active_support/concern"
+
+module ActiveAttr
+  # TypecastedAttributes enhances attribute handling with typecasting
+  #
+  # @example Usage
+  #   class Person
+  #     include ActiveAttr::TypecastedAttributes
+  #     attribute :name
+  #     attribute :age, :type => Integer
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = "Ben Poweski"
+  #   person.age  = "29"
+  #
+  #   person.age #=> 29
+  #
+  # @since 0.5.0
+  module TypecastedAttributes
+    extend ActiveSupport::Concern
+    include Attributes
+    include Typecasting
+
+    included do
+      attribute_method_suffix "_before_type_cast"
+    end
+
+    # TODO Documentation
+    def attribute_before_type_cast(name)
+      @attributes[name.to_s]
+    end
+
+    private
+
+    # Reads the attribute and typecasts the result
+    #
+    # @since 0.5.0
+    def attribute(name)
+      typecast_attribute(_attribute_type(name), super)
+    end
+
+    # Calculates an attribute type
+    #
+    # @private
+    # @since 0.5.0
+    def _attribute_type(attribute_name)
+      self.class._attribute_type(attribute_name)
+    end
+
+    module ClassMethods
+      # Returns the class name plus its attribute names and types
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      # @return [String] Human-readable presentation of the attributes
+      #
+      # @since 0.5.0
+      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}"
+      end
+
+      # Calculates an attribute type
+      #
+      # @private
+      # @since 0.5.0
+      def _attribute_type(attribute_name)
+        attributes[attribute_name][:type] || Object
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting.rb

@@ -0,0 +1,60 @@
+require "active_attr/typecasting/boolean"
+require "active_attr/typecasting/boolean_typecaster"
+require "active_attr/typecasting/date_time_typecaster"
+require "active_attr/typecasting/date_typecaster"
+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"
+
+module ActiveAttr
+  # Typecasting provides methods to typecast a value to a different type
+  #
+  # @since 0.5.0
+  module Typecasting
+    extend ActiveSupport::Concern
+
+    # @private
+    TYPECASTERS = {
+      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 [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
+      return value if value.nil?
+      typecast_value(type, value)
+    end
+
+    # Typecasts a value according to a predefined set of mapping rules defined
+    #   in TYPECASTING_METHODS
+    #
+    # @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
+    #
+    # @since 0.5.0
+    def typecast_value(type, value)
+      if typecaster = TYPECASTERS[type]
+        typecaster.new.call(value)
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/boolean.rb

@@ -0,0 +1,6 @@
+module ActiveAttr
+  module Typecasting
+    class Boolean
+    end
+  end
+end

data/lib/active_attr/typecasting/boolean_typecaster.rb

@@ -0,0 +1,21 @@
+require "active_support/core_ext/object/blank"
+
+module ActiveAttr
+  module Typecasting
+    # TODO documentation
+    class BooleanTypecaster
+      # TODO documentation
+      # http://yaml.org/type/bool.html
+      FALSE_VALUES = ["n", "N", "no", "No", "NO", "false", "False", "FALSE", "off", "Off", "OFF", "f", "F"]
+
+      # TODO documentation
+      def call(value)
+        case value
+        when *FALSE_VALUES then false
+        when Numeric, /^\-?[0-9]/ then !value.to_f.zero?
+        else value.present?
+        end
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/date_time_typecaster.rb

@@ -0,0 +1,14 @@
+require "active_support/core_ext/string/conversions"
+require "active_support/time"
+
+module ActiveAttr
+  module Typecasting
+    # TODO documentation
+    class DateTimeTypecaster
+      # TODO documentation
+      def call(value)
+        value.to_datetime if value.respond_to? :to_datetime
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/date_typecaster.rb

@@ -0,0 +1,14 @@
+require "active_support/core_ext/string/conversions"
+require "active_support/time"
+
+module ActiveAttr
+  module Typecasting
+    # TODO documentation
+    class DateTypecaster
+      # TODO documentation
+      def call(value)
+        value.to_date if value.respond_to? :to_date
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/float_typecaster.rb

@@ -0,0 +1,11 @@
+module ActiveAttr
+  module Typecasting
+    # TODO documentation
+    class FloatTypecaster
+      # TODO documentation
+      def call(value)
+        value.to_f if value.respond_to? :to_f
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/integer_typecaster.rb

@@ -0,0 +1,12 @@
+module ActiveAttr
+  module Typecasting
+    # TODO documentation
+    class IntegerTypecaster
+      # TODO documentation
+      def call(value)
+        value.to_i if value.respond_to? :to_i
+      rescue FloatDomainError
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/object_typecaster.rb

@@ -0,0 +1,9 @@
+module ActiveAttr
+  module Typecasting
+    class ObjectTypecaster
+      def call(value)
+        value
+      end
+    end
+  end
+end

data/lib/active_attr/typecasting/string_typecaster.rb

@@ -0,0 +1,11 @@
+module ActiveAttr
+  module Typecasting
+    # TODO documentation
+    class StringTypecaster
+      # TODO documentation
+      def call(value)
+        value.to_s if value.respond_to? :to_s
+      end
+    end
+  end
+end

data/lib/active_attr/version.rb

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

data/spec/functional/active_attr/attribute_defaults_spec.rb

@@ -0,0 +1,136 @@
+require "spec_helper"
+require "active_attr/attribute_defaults"
+require "active_attr/mass_assignment"
+require "active_attr/typecasted_attributes"
+require "active_model"
+
+module ActiveAttr
+  describe AttributeDefaults do
+    subject { model_class.new }
+
+    let :model_class do
+      Class.new do
+        include ActiveAttr::AttributeDefaults
+      end
+    end
+
+    context "an attribute with a default string" do
+      before { model_class.attribute :first_name, :default => "John" }
+
+      it "the attribute getter returns the string by default" do
+        subject.first_name.should == "John"
+      end
+
+      it "#attributes includes the default attributes" do
+        subject.attributes["first_name"].should == "John"
+      end
+
+      it "#read_attribute returns the string by default" do
+        subject.read_attribute("first_name").should == "John"
+      end
+
+      it "assigning nil sets nil as the attribute value" do
+        subject.first_name = nil
+        subject.first_name.should be_nil
+      end
+
+      it "mutating the default value does not mutate the attribute definition" do
+        model_class.new.first_name.upcase!
+        model_class.new.first_name.should == "John"
+      end
+    end
+
+    context "an attribute with a default of false" do
+      before { model_class.attribute :admin, :default => false }
+
+      it "the attribute getter returns false by default" do
+        subject.admin.should == false
+      end
+    end
+
+    context "an attribute with a default of true" do
+      before { model_class.attribute :remember_me, :default => true }
+
+      it "the attribute getter returns true by default" do
+        subject.remember_me.should == true
+      end
+    end
+
+    context "an attribute with a dynamic Time.now default" do
+      before { model_class.attribute :created_at, :default => lambda { Time.now } }
+
+      it "the attribute getter returns a Time instance" do
+        subject.created_at.should be_a_kind_of Time
+      end
+
+      it "the attribute default is only evaulated once per instance" do
+        subject.created_at.should == subject.created_at
+      end
+
+      it "the attribute default is different per instance" do
+        model_class.new.created_at.should_not == model_class.new.created_at
+      end
+    end
+
+    context "an attribute with a default based on the instance" do
+      before { model_class.attribute :id, :default => lambda { object_id } }
+
+      it "the attribute getter returns the default based on the instance" do
+        subject.id.should == subject.object_id
+      end
+    end
+
+    context "combined with MassAssignment" do
+      let :model_class do
+        Class.new do
+          include ActiveAttr::MassAssignment
+          include ActiveAttr::AttributeDefaults
+
+          attribute :start_date
+          attribute :end_date, :default => lambda { start_date }
+          attribute :age_limit, :default => 21
+        end
+      end
+
+      it "applies the default attributes" do
+        model_class.new.age_limit.should == 21
+      end
+
+      it "mass assignment at initialization overrides the defaults" do
+        model_class.new(:age_limit => 18).age_limit.should == 18
+      end
+
+      it "mass assignment at initialization can override the default with a nil value" do
+        model_class.new(:age_limit => nil).age_limit.should be_nil
+      end
+
+      it "dynamic defaults have access to other attribute methods" do
+        model_class.new.end_date.should be_nil
+      end
+
+      it "dynamic defaults have access to attributes mass assigned at initialization" do
+        model_class.new(:start_date => Date.today).end_date.should == Date.today
+      end
+    end
+
+    context "combined with TypecastedAttributes" do
+      let :model_class do
+        Class.new do
+          include ActiveAttr::TypecastedAttributes
+          include ActiveAttr::AttributeDefaults
+
+          attribute :age, :type => Integer, :default => "21"
+          attribute :start_date, :type => String, :default => lambda { Date.today }
+        end
+      end
+
+      it "typecasts a default value literal" do
+        model_class.new.age.should == 21
+      end
+
+      it "typecasts a dynamic default" do
+        model_class.new.start_date.should == Date.today.to_s
+      end
+    end
+  end
+end