make_resourceful 1.0

data/lib/resourceful/serialize.rb

@@ -0,0 +1,185 @@
+require 'resourceful/builder'
+
+module Resourceful
+  # This module contains mixin modules
+  # used to implement the object serialization
+  # used for the Builder#publish method.
+  # They can also be used to get serialized representations of objects
+  # in other contexts.
+  #
+  # Serialization makes use of duck typing.
+  # Each class that can be serialized
+  # (just Array and ActiveRecord::Base by default)
+  # implements the +serialize+ and +to_serializable+ methods.
+  # These methods are implemented differently by the different classes,
+  # but the semantics of the implementations are consistent,
+  # so they can be used consistently.
+  #
+  # +to_serializable+ returns an object that can be directly serialized
+  # with a call to +to_xml+, +to_yaml+, or +to_json+.
+  # This object is either a hash or an array,
+  # and all the elements are either values, like strings and integers,
+  # or other serializable objects.
+  # This is useful for getting a model into a simple data structure format.
+  # The +attributes+ argument uses the same semantics
+  # as the <tt>:attributes</tt> option for Builder#publish.
+  # For example:
+  #
+  #   c = Cake.new(:flavor => 'chocolate', :text => 'Happy birthday, Chris!')
+  #   c.recipient = User.new(:name => 'Chris', :password => 'not very secure')
+  #   c.to_serializable [
+  #       :flavor, :text,
+  #       :recipient => :name
+  #     ]
+  #
+  # This would return the Ruby hash
+  #
+  #   { :flavor => 'chocolate', :text => 'Happy birthday, Chris!',
+  #     :user => {:name => 'Chris'} }
+  #
+  # +serialize+ takes a format (<tt>:xml</tt>, <tt>:yaml</tt>, or <tt>:json</tt> - see New Formats below)
+  # and a hash of options.
+  # The only option currently recognized is <tt>:attributes</tt>,
+  # which has the same semantics
+  # as the <tt>:attributes</tt> option for Builder#publish.
+  # +serialize+ returns a string containing the target
+  # serialized in the given format.
+  # For example:
+  #
+  #   c = CandyBag.new(:title => 'jellybag')
+  #   c.candies << Candy.new(:type => 'jellybean', :flavor => 'root beer')
+  #   c.candies << Candy.new(:type => 'jellybean', :flavor => 'pear')
+  #   c.candies << Candy.new(:type => 'licorice',  :flavor => 'anisey')
+  #   c.serialize :xml, :attributes => [:title, {:candies => [:type, :flavor]}]
+  #
+  # This would return a Ruby string containing
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <candy-bag>
+  #     <title>jellybag</title>
+  #     <candies>
+  #       <candy>
+  #         <type>jellybean</type>
+  #         <flavor>root beer</flavor>
+  #       </candy>
+  #       <candy>
+  #         <type>jellybean</type>
+  #         <flavor>pear</flavor>
+  #       </candy>
+  #       <candy>
+  #         <type>licorice</type>
+  #         <flavor>anisey</flavor>
+  #       </candy>
+  #     </candies>
+  #   </candy-bag>
+  # 
+  module Serialize
+
+    # Takes an attributes option in the form passed to Builder#publish
+    # and returns a hash (or nil, if attributes is nil)
+    # containing the same data,
+    # but in a more consistent format.
+    # All keys are converted to symbols,
+    # and all lists are converted to hashes.
+    # For example:
+    #
+    #   Resourceful::Serialize.normalize_attributes([:foo, :bar, {"baz" => ["boom"]}])
+    #     #=> {"baz"=>["boom"], :foo=>nil, :bar=>nil}
+    # 
+    def self.normalize_attributes(attributes) # :nodoc:
+      return nil if attributes.nil?
+      return {attributes.to_sym => nil} if String === attributes
+      return {attributes => nil} if !attributes.respond_to?(:inject)
+
+      attributes.inject({}) do |hash, attr|
+        if Array === attr
+          hash[attr[0]] = attr[1]
+          hash
+        else
+          hash.merge normalize_attributes(attr)
+        end
+      end
+    end
+
+    # This module contains the definitions of +serialize+ and +to_serializable+
+    # that are included in ActiveRecord::Base.
+    module Model
+      # :call-seq:
+      #   serialize format, options = {}, :attributes => [ ... ]
+      #
+      # See the module documentation for Serialize for details.
+      def serialize(format, options)
+        raise "Must specify :attributes option" unless options[:attributes]
+        hash = self.to_serializable(options[:attributes])
+        root = self.class.to_s.underscore
+        if format == :xml
+          hash.send("to_#{format}", :root => root)
+        else
+          {root => hash}.send("to_#{format}")
+        end
+      end
+
+      # See the module documentation for Serialize for details.
+      def to_serializable(attributes)
+        raise "Must specify attributes for #{self.inspect}.to_serializable" if attributes.nil?
+
+        Serialize.normalize_attributes(attributes).inject({}) do |hash, (key, value)|
+          hash[key.to_s] = attr_hash_value(self.send(key), value)
+          hash
+        end
+      end
+
+      private
+
+      # Given an attribute value
+      # and a normalized (see above) attribute hash,
+      # returns the serializable form of that attribute.
+      def attr_hash_value(attr, sub_attributes)
+        if attr.respond_to?(:to_serializable)
+          attr.to_serializable(sub_attributes)
+        else
+          attr
+        end
+      end
+    end
+
+    # This module contains the definitions of +serialize+ and +to_serializable+
+    # that are included in ActiveRecord::Base.
+    module Array
+      # :call-seq:
+      #   serialize format, options = {}, :attributes => [ ... ]
+      #
+      # See the module documentation for Serialize for details.      
+      def serialize(format, options)
+        raise "Not all elements respond to to_serializable" unless all? { |e| e.respond_to? :to_serializable }
+        raise "Must specify :attributes option" unless options[:attributes]
+
+        serialized = map { |e| e.to_serializable(options[:attributes]) }
+        root = first.class.to_s.pluralize.underscore
+
+        if format == :xml
+          serialized.send("to_#{format}", :root => root)
+        else
+          {root => serialized}.send("to_#{format}")
+        end
+      end
+
+      # See the module documentation for Serialize for details.
+      def to_serializable(attributes)
+        if first.respond_to?(:to_serializable)
+          attributes = Serialize.normalize_attributes(attributes)
+          map { |e| e.to_serializable(attributes) }
+        else
+          self
+        end
+      end
+    end
+  end
+end
+
+if defined? ActiveModel
+  class ActiveModel::Base; include Resourceful::Serialize::Model; end
+else
+  class ActiveRecord::Base; include Resourceful::Serialize::Model; end
+end
+class Array; include Resourceful::Serialize::Array; end

data/spec/accessors_spec.rb

@@ -0,0 +1,474 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Resourceful::Default::Accessors, "#current_objects" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @objects = stub_list 5, 'object'
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+  end
+
+  it "should look up all objects in the current model" do
+    @model.expects(:find).with(:all).returns(@objects)
+    @controller.current_objects.should == @objects
+  end
+
+  it "should cache the result, so subsequent calls won't run multiple queries" do
+    @model.expects(:find).once.returns(@objects)
+    @controller.current_objects
+    @controller.current_objects
+  end
+
+  it "shouldn't run a query if @current_objects is set" do
+    @controller.instance_variable_set('@current_objects', @objects)
+    @model.expects(:find).never
+    @controller.current_objects.should == @objects
+  end
+end
+
+describe Resourceful::Default::Accessors, "#load_objects" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @objects = stub_list 5, 'object'
+    @controller.stubs(:current_objects).returns(@objects)
+    @controller.stubs(:instance_variable_name).returns("posts")
+  end
+
+  it "should set the current instance variable to the object collection" do
+    @controller.load_objects
+    @controller.instance_variable_get('@posts').should == @objects
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_object on a plural controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:plural?).returns(true)
+    @controller.stubs(:params).returns(:id => "12")
+
+    @object = stub
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+  end
+
+  it "should look up the object specified by the :id parameter in the current model" do
+    @model.expects(:find).with('12').returns(@object)
+    @controller.current_object.should == @object
+  end
+
+  it "should cache the result, so subsequent calls won't run multiple queries" do
+    @model.expects(:find).once.returns(@object)
+    @controller.current_object
+    @controller.current_object
+  end
+
+  it "shouldn't run a query if @current_object is set" do
+    @controller.instance_variable_set('@current_object', @object)
+    @model.expects(:find).never
+    @controller.current_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_object on a singular controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:plural?).returns(false)
+    @controller.stubs(:controller_name).returns("posts")
+
+    @parent = stub('parent')
+    @controller.stubs(:parent_object).returns(@parent)
+    @controller.stubs(:parent?).returns(true)
+
+    @object = stub
+  end
+
+  it "should return the instance object from parent object" do
+    @parent.expects(:post).returns(@object)
+    @controller.current_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#load_object" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @object = stub
+    @controller.stubs(:current_object).returns(@object)
+    @controller.stubs(:instance_variable_name).returns("posts")
+  end
+
+  it "should set the current singular instance variable to the current object" do
+    @controller.load_object
+    @controller.instance_variable_get('@post').should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#build_object with a #build-able model" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @params = {:name => "Bob", :password => "hideously insecure"}
+    @controller.stubs(:object_parameters).returns(@params)
+
+    @object = stub
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+
+    @model.stubs(:build).returns(@object)
+  end
+
+  it "should return a new object built with current_model from the object parameters" do
+    @model.expects(:build).with(@params).returns(@object)
+    @controller.build_object.should == @object
+  end
+
+  it "should make current_object return the newly built object" do
+    @controller.build_object
+    @controller.current_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#build_object with a non-#build-able model" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @params = {:name => "Bob", :password => "hideously insecure"}
+    @controller.stubs(:object_parameters).returns(@params)
+
+    @controller.stubs(:singular?).returns(false)
+    @controller.stubs(:parent?).returns(false)
+
+    @object = stub
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+
+    @model.stubs(:new).returns(@object)
+  end
+
+  it "should return a new instance of the current_model built with the object parameters" do
+    @model.expects(:new).with(@params).returns(@object)
+    @controller.build_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_model_name" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:controller_name).returns("funky_posts")
+  end
+
+  it "should return the controller's name, singularized and camel-cased" do
+    @controller.current_model_name.should == "FunkyPost"
+  end
+end
+
+describe Resourceful::Default::Accessors, "#namespaces" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @kontroller.stubs(:name).returns("FunkyStuff::Admin::Posts")
+  end
+
+  it "should return an array of underscored symbols representing the namespaces of the controller class" do
+    @controller.namespaces.should == [:funky_stuff, :admin]
+  end
+
+  it "should cache the result, so subsequent calls won't run multiple computations" do
+    @kontroller.expects(:name).once.returns("Posts")
+    @controller.namespaces
+    @controller.namespaces
+  end
+end
+
+describe Resourceful::Default::Accessors, "#instance_variable_name" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:controller_name).returns("posts")
+  end
+  
+  it "should return controller_name" do
+    @controller.instance_variable_name == "posts"
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_model for a singular controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    stub_const :Post
+    @controller.stubs(:singular?).returns(true)
+    @controller.stubs(:current_model_name).returns("Post")
+
+    @parent = stub('parent')
+    @controller.stubs(:parent_object).returns(@parent)
+    @controller.stubs(:parent?).returns(true)
+  end
+  
+  it "should return the constant named by current_model_name" do
+    @controller.current_model.should == Post
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_model for a plural controller with no parent" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    stub_const :Post
+    @controller.stubs(:singular?).returns(false)
+    @controller.stubs(:current_model_name).returns("Post")
+    @controller.stubs(:parent?).returns(false)
+  end
+  
+  it "should return the constant named by current_model_name" do
+    @controller.current_model.should == Post
+  end
+end
+
+describe Resourceful::Default::Accessors, "#object_parameters" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @params = {"crazy_user" => {:name => "Hampton", :location => "Canada"}}
+    @controller.stubs(:params).returns(@params)
+    @controller.stubs(:current_model_name).returns("CrazyUser")
+  end
+
+  it "should return the element of the params hash with the name of the model" do
+    @controller.object_parameters.should == @params["crazy_user"]
+  end
+end
+
+describe Resourceful::Default::Accessors, " with two parent classes set on the controller class and one parent parameter supplied" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @parents = %w{post comment}
+    @models = @parents.map(&:camelize).map(&method(:stub_const))
+    @kontroller.parents = @parents
+    @controller.stubs(:singular?).returns(false)
+    @controller.stubs(:instance_variable_name).returns('lines')
+
+    @params = HashWithIndifferentAccess.new :post_id => 12
+    @controller.stubs(:params).returns(@params)
+
+    @post = stub('Post')
+    Post.stubs(:find).returns(@post)
+
+    @model = stub
+  end
+
+  it "should return true for #parent?" do
+    @controller.parent?.should be_true
+  end
+
+  it "should return the string names of all the parents for #parent_names" do
+    @controller.parent_names.should == @parents
+  end
+
+  it "should return the string name of the current parent for #parent_name" do
+    @controller.parent_name.should == 'post'
+  end
+
+  it "should return the model class for #parent_model" do
+    @controller.parent_model.should == Post
+  end
+
+  it "should return the parent object for #parent_object" do
+    Post.expects(:find).with(12).returns(@post)
+    @controller.parent_object.should == @post
+  end
+
+  it "should cache the value of #parent_object so multiple calls won't cause multiple queries" do
+    Post.expects(:find).returns(@post).once
+    @controller.parent_object
+    @controller.parent_object
+  end
+
+  it "should bind the parent object its proper instance variable" do
+    @controller.load_parent_object
+    @controller.instance_variable_get('@post').should == @post
+  end
+
+  it "should return the parent-scoped model for #current_model" do
+    @post.stubs(:lines).returns(@model)
+    @controller.current_model.should == @model
+  end
+
+  it "should return true for #ensure_parent_exists" do
+    @controller.expects(:render).never
+    @controller.ensure_parent_exists.should be_true
+  end
+end
+
+describe Resourceful::Default::Accessors, " with two parent classes set on the controller class but no parent parameter supplied" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @parents = %w{post comment}
+    @models = @parents.map(&:camelize).map(&method(:stub_const))
+    @kontroller.parents = @parents
+    @controller.stubs(:params).returns({})
+    @controller.stubs(:controller_name).returns('line')
+    stub_const('Line')
+  end
+
+  it "should return false for #parent?" do
+    @controller.parent?.should be_false
+  end
+
+  it "should return nil for #parent_name" do
+    @controller.parent_name.should be_nil
+  end
+
+  it "should return the unscoped model for #current_model" do
+    @controller.current_model.should == Line
+  end
+
+  it "should return false and render a 422 error for #ensure_parent_exists" do
+    @controller.expects(:render).with(has_entry(:status, 422))
+    @controller.ensure_parent_exists.should be_false
+  end
+end
+
+describe Resourceful::Default::Accessors, " with no parents" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:parents).returns([])
+    @controller.stubs(:current_model_name).returns('Line')
+    @controller.stubs(:params).returns({})
+    stub_const 'Line'
+  end
+
+  it "should return false for #parent?" do
+    @controller.parent?.should be_false
+  end
+
+  it "should return nil for #parent_name" do
+    @controller.parent_name.should be_nil
+  end
+
+  it "should return the unscoped model for #current_model" do
+    @controller.current_model.should == Line
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a singular controller with a parent" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:singular?).returns(true)
+    
+    @model = stub_model('Thing')    
+    @model.send(:attr_accessor, :person_id)
+    @controller.stubs(:current_model).returns(@model)
+
+    @person = stub_model('Person')
+    @person.stubs(:id).returns 42
+    @controller.stubs(:parent_object).returns(@person)
+    @controller.stubs(:parent_name).returns('person')
+    @controller.stubs(:parent?).returns(true)
+
+    @controller.stubs(:object_parameters).returns :thinginess => 12, :bacon => true
+  end
+
+  it "should set assign the parent's id to a newly built object" do
+    thing = @controller.build_object
+    thing.thinginess.should == 12
+    thing.person_id.should == @person.id
+  end
+end
+
+describe Resourceful::Default::Accessors, "#save_succeeded!" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.save_succeeded!
+  end
+
+  it "should make #save_succeeded? return true" do
+    @controller.save_succeeded?.should be_true
+  end
+end
+
+describe Resourceful::Default::Accessors, "#save_failed!" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.save_failed!
+  end
+
+  it "should make #save_succeeded? return false" do
+    @controller.save_succeeded?.should be_false
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a plural action" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:params).returns :action => "index"
+  end
+
+  it "should know it's a plural action" do
+    @controller.should be_a_plural_action
+  end
+
+  it "should know it's not a singular action" do
+    @controller.should_not be_a_singular_action
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a singular action" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:params).returns :action => "show"
+  end
+
+  it "should know it's not a plural action" do
+    @controller.should_not be_a_plural_action
+  end
+
+  it "should know it's a singular action" do
+    @controller.should be_a_singular_action
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a singular controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:instance_variable_name).returns "post"
+  end
+
+  it "should know it's not plural" do
+    @controller.should_not be_plural
+  end
+
+  it "should know it's singular" do
+    @controller.should be_singular
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a plural controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:instance_variable_name).returns "posts"
+  end
+
+  it "should know it's plural" do
+    @controller.should be_plural
+  end
+
+  it "should know it's not singular" do
+    @controller.should_not be_singular
+  end
+end