active_attr 0.1.0 → 0.2.0

data/lib/active_attr/matchers.rb

@@ -0,0 +1,13 @@
+require "active_attr/matchers/have_attribute_matcher"
+
+module ActiveAttr
+  # Matchers that can be used with RSpec and Shoulda to declaritively verify
+  # models based on ActiveAttr modules
+  #
+  # @example Integrate with RSPec
+  #   require "active_attr/rspec"
+  #
+  # @since 0.2.0
+  module Matchers
+  end
+end

data/lib/active_attr/matchers/have_attribute_matcher.rb

@@ -0,0 +1,69 @@
+module ActiveAttr
+  module Matchers
+    # Specify that a model should have an attribute matching the criteria
+    #
+    # @example Person should have a name attribute
+    #   describe Person do
+    #     it { should have_attribute(:name) }
+    #   end
+    #
+    # @param [Symbol, String, #to_sym] attribute_name
+    #
+    # @return [HaveAttributeMatcher]
+    #
+    # @since 0.2.0
+    def have_attribute(attribute_name)
+      HaveAttributeMatcher.new(attribute_name)
+    end
+
+    # Verifies that an ActiveAttr-based model has an attribute matching the
+    # given criteria
+    #
+    # @since 0.2.0
+    class HaveAttributeMatcher
+      # @return [Symbol]
+      # @api private
+      attr_reader :attribute_name
+
+      # @return [String] Description
+      # @api private
+      def description
+        "have attribute named #{attribute_name}"
+      end
+
+      # @return [String] Failure message
+      # @api private
+      def failure_message
+        "Expected #{@model_class} to #{description}"
+      end
+
+      # @param [Symbol, String, #to_sym] attribute_name
+      # @api private
+      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
+      end
+
+      # @api private
+      def matches?(model_or_model_class)
+        @model_class = class_from(model_or_model_class)
+
+        @model_class.attributes.any? do |attribute|
+          attribute.name == attribute_name
+        end
+      end
+
+      # @return [String] Negative failure message
+      # @api private
+      def negative_failure_message
+        "Expected #{@model_class} to not #{description}"
+      end
+
+      private
+
+      def class_from(object)
+        Class === object ? object : object.class
+      end
+    end
+  end
+end

data/lib/active_attr/rspec.rb

@@ -0,0 +1,5 @@
+require "active_attr/matchers"
+
+RSpec.configure do |config|
+  config.include ActiveAttr::Matchers
+end

data/lib/active_attr/strict_mass_assignment.rb

@@ -0,0 +1,44 @@
+require "active_attr/mass_assignment"
+require "active_attr/unknown_attributes_error"
+require "active_support/concern"
+
+module ActiveAttr
+  # StrictMassAssignment allows mass assignment of attributes, but raises an
+  # exception when assigning unknown attributes
+  #
+  # Attempting to assign any unknown or private attribute through any of the
+  # mass assignment methods ({#assign_attributes}, {#attributes=}, and
+  # {#initialize}) will raise an {ActiveAttr::UnknownAttributesError}
+  # exception.
+  #
+  # @example Usage
+  #   class Person
+  #     include ActiveAttr::StrictMassAssignment
+  #   end
+  #
+  # @since 0.2.0
+  module StrictMassAssignment
+    extend ActiveSupport::Concern
+    include MassAssignment
+
+    # Mass update a model's attributes, but raise an error if an attempt is
+    # made to assign an unknown attribute
+    #
+    # @param (see MassAssignment#assign_attributes)
+    #
+    # @raise [ActiveAttr::UnknownAttributesError]
+    #
+    # @since 0.2.0
+    def assign_attributes(new_attributes, options={})
+      unknown_attribute_names = (new_attributes || {}).reject do |name, value|
+        respond_to? "#{name}="
+      end.map { |name, value| name.to_s }.sort
+
+      if unknown_attribute_names.any?
+        raise UnknownAttributesError, "unknown attribute(s): #{unknown_attribute_names.join(", ")}"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/active_attr/unknown_attributes_error.rb

@@ -0,0 +1,18 @@
+require "active_attr/error"
+
+module ActiveAttr
+  # This exception is raised if attempting to mass assign unknown attributes
+  # when using {StrictMassAssignment}
+  #
+  # @example Rescuing an UnknownAttributesError error
+  #   begin
+  #     Person.new(attributes)
+  #   rescue ActiveAttr::UnknownAttributesError
+  #     Person.new
+  #   end
+  #
+  # @since 0.2.0
+  class UnknownAttributesError < NoMethodError
+    include Error
+  end
+end

data/lib/active_attr/version.rb

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

data/spec/active_attr/attribute_definition_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "active_attr/attribute_definition"
+
+module ActiveAttr
+  describe AttributeDefinition do
+    subject { described_class.new(:amount) }
+
+    describe "#==" do
+      it "returns true when the attribute name is equal" do
+        described_class.new(:amount).should == described_class.new(:amount)
+      end
+
+      it "returns false when another object is compared" do
+        described_class.new(:amount).should_not == Struct.new(:name).new(:amount)
+      end
+    end
+
+    describe "#initialize" do
+      it "raises an ArgumentError when no arguments" do
+        expect { described_class.new }.to raise_error ArgumentError
+      end
+
+      it "assigns the first argument to name" do
+        described_class.new(:amount).name.should == :amount
+      end
+
+      it "converts a String attribute name to a Symbol" do
+        described_class.new('amount').name.should == :amount
+      end
+
+      it "raises a TypeError when the attribute name does not respond to #to_sym" do
+        expect { described_class.new(Object.new) }.to raise_error(TypeError, "can't convert Object into Symbol")
+      end
+    end
+
+    describe "#name" do
+      it { should respond_to(:name) }
+    end
+
+    describe "#to_s" do
+      it "renders the name" do
+        subject.to_s.should == subject.name.to_s
+      end
+    end
+  end
+end

data/spec/active_attr/attributes_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+require "active_attr/attributes"
+
+module ActiveAttr
+  describe Attributes do
+    let(:model_class) do
+      Class.new do
+        include Attributes
+        attribute :name
+      end
+    end
+
+    subject do
+      Class.new do
+        include Attributes
+        attribute :name
+        attribute :amount
+
+        def self.name
+          "Foo"
+        end
+      end
+    end
+
+    describe ".attribute" do
+      let(:instance) { subject.new }
+
+      it "creates an attribute with no options" do
+        subject.attributes.should include(AttributeDefinition.new(:name))
+      end
+
+      it "defined an attribute reader that calls #read_attribute" do
+        instance.should_receive(:read_attribute).with(:name)
+        instance.name
+      end
+
+      it "defines an attribute writer method that calls #write_attribute" do
+        instance.should_receive(:write_attribute).with(:name, "Ben")
+        instance.name = "Ben"
+      end
+    end
+
+    describe ".attributes" do
+      it { should respond_to(:attributes) }
+
+      context "when no attributes exist" do
+        subject do
+          Class.new { include Attributes }.attributes
+        end
+
+        it "returns an empty Array" do
+          should == []
+        end
+      end
+    end
+
+    describe ".inspect" do
+      it "renders the class name" do
+        subject.inspect.should match "Foo"
+      end
+
+      it "renders the attribute name and type" do
+        subject.inspect.should match subject.attributes.map { |a| a.name }.join(", ")
+      end
+    end
+
+    describe "#==" do
+      let(:model_class) do
+        Class.new do
+          include Attributes
+          attribute :name
+
+          def initialize(name)
+            write_attribute(:name, name)
+          end
+        end
+      end
+
+      subject { model_class.new("Ben") }
+
+      it "returns true when all attributes are equal" do
+        should == model_class.new("Ben")
+      end
+
+      it "returns false when compared to another type" do
+        should_not == Struct.new(:attributes).new("name" => "Ben")
+      end
+    end
+
+    describe "#attributes" do
+      context "when no attributes are defined" do
+        subject { Class.new { include Attributes } }
+
+        it "returns an empty Hash" do
+          subject.new.attributes.should == {}
+        end
+      end
+    end
+
+    describe "#inspect" do
+      let(:instance) { subject.new.tap { |obj| obj.name = "Ben" }  }
+
+      it "includes the class name and all attribute values" do
+        instance.inspect.should == %q{#<Foo name: "Ben", amount: nil>}
+      end
+    end
+
+    describe "#read_attribute" do
+      let(:name) { "Bob" }
+      subject { model_class.new.tap { |s| s.write_attribute(:name, name) } }
+
+      it "returns the attribute using a Symbol" do
+        subject.read_attribute(:name).should == name
+      end
+
+      it "returns the attribute using a String" do
+        subject.read_attribute('name').should == name
+      end
+    end
+
+    describe "#write_attribute" do
+      subject { model_class.new }
+
+      it "raises ArgumentError with one argument" do
+        expect { subject.write_attribute(:name) }.to raise_error(ArgumentError)
+      end
+
+      it "raises ArgumentError with no arguments" do
+        expect { subject.write_attribute }.to raise_error(ArgumentError)
+      end
+
+      it "assigns sets an attribute using a Symbol and value" do
+        expect { subject.write_attribute(:name, "Ben") }.to change(subject, :attributes).from({}).to("name" => "Ben")
+      end
+
+      it "assigns sets an attribute using a String and value" do
+        expect { subject.write_attribute('name', "Ben") }.to change(subject, :attributes).from({}).to("name" => "Ben")
+      end
+    end
+  end
+end

data/spec/active_attr/basic_model_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "active_attr/basic_model"
+
+module ActiveAttr
+  describe BasicModel do
+    let(:model_class) do
+      Class.new do
+        include BasicModel
+
+        def self.name
+          "Foo"
+        end
+      end
+    end
+
+    subject { model_class.new }
+    it_should_behave_like "ActiveModel"
+  end
+end

data/spec/active_attr/error_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+require "active_attr/error"
+
+module ActiveAttr
+  describe Error do
+    it { should be_a_kind_of Module }
+  end
+end

data/spec/active_attr/mass_assignment_spec.rb

@@ -2,45 +2,15 @@ require "spec_helper"
 require "active_attr/mass_assignment"
 
 module ActiveAttr
-  describe MassAssignment do
+  describe MassAssignment, :mass_assignment do
     subject do
-      Class.new do
+      model_class.class_eval do
         include MassAssignment
-
-        attr_accessor :first_name, :last_name, :middle_name
-        private :middle_name=
-
-        def name=(name)
-          self.last_name, self.first_name = name.split(nil, 2).reverse
-        end
       end
     end
 
-    let(:person) { subject.new }
-    let(:first_name) { "Chris" }
-    let(:last_name) { "Griego" }
-
-    def should_assign_names_to(person)
-      person.first_name.should == first_name
-      person.last_name.should == last_name
-    end
-
-    shared_examples_for "a mass assigning method" do
-      it "does not raise when assigning nil attributes" do
-        expect { mass_assign_attributes nil }.not_to raise_error
-      end
-
-      it "assigns all valid attributes when passed as a hash with string keys" do
-        should_assign_names_to mass_assign_attributes('first_name' => first_name, 'last_name' => last_name)
-      end
-
-      it "assigns all valid attributes when passed as a hash with symbol keys" do
-        should_assign_names_to mass_assign_attributes(:first_name => first_name, :last_name => last_name)
-      end
-
-      it "uses any available writer methods" do
-        should_assign_names_to mass_assign_attributes(:name => "#{first_name} #{last_name}")
-      end
+    shared_examples "lenient mass assignment method", :lenient_mass_assignment_method => true do
+      include_examples "mass assignment method"
 
       it "ignores attributes which do not have a writer" do
         person = mass_assign_attributes(:middle_initial => "J")
@@ -54,66 +24,8 @@ module ActiveAttr
       end
     end
 
-    describe "#initialize" do
-      it "raises ArgumentError when called with three arguments" do
-        expect { subject.new({}, {}, nil) }.to raise_error ArgumentError
-      end
-
-      it "does not raise when called with two arguments" do
-        expect { subject.new({}, {}) }.not_to raise_error
-      end
-
-      it "does not raise when called with a single argument" do
-        expect { subject.new({}) }.not_to raise_error
-      end
-
-      it "does not raise when called with no arguments" do
-        expect { subject.new }.not_to raise_error
-      end
-
-      def mass_assign_attributes(attributes)
-        subject.new(attributes)
-      end
-
-      it_should_behave_like "a mass assigning method"
-    end
-
-    describe "#attributes=" do
-      it "raises ArgumentError when called with two arguments" do
-        expect { person.send(:attributes=, {}, {}) }.to raise_error ArgumentError
-      end
-
-      def mass_assign_attributes(attributes)
-        person.attributes = attributes
-        person
-      end
-
-      it_should_behave_like "a mass assigning method"
-    end
-
-    describe "#assign_attributes" do
-      it "raises ArgumentError when called with three arguments" do
-        expect { subject.new.assign_attributes({}, {}, nil) }.to raise_error ArgumentError
-      end
-
-      it "does not raise when called with two arguments" do
-        expect { subject.new.assign_attributes({}, {}) }.not_to raise_error
-      end
-
-      it "does not raise when called with a single argument" do
-        expect { subject.new.assign_attributes({}) }.not_to raise_error
-      end
-
-      it "raises ArgumentError when called with no arguments" do
-        expect { subject.new.assign_attributes }.to raise_error ArgumentError
-      end
-
-      def mass_assign_attributes(attributes)
-        person.assign_attributes attributes
-        person
-      end
-
-      it_should_behave_like "a mass assigning method"
-    end
+    describe "#assign_attributes", :assign_attributes, :lenient_mass_assignment_method
+    describe "#attributes=", :attributes=, :lenient_mass_assignment_method
+    describe "#initialize", :initialize, :lenient_mass_assignment_method
   end
 end