super_awesome_resource_serializer 1.0.5

data/README.rdoc

@@ -0,0 +1,2 @@
+= Super Awesome Resource Serializer
+

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake'
+
+desc 'Default: run unit tests'
+task :default => :test
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+rescue LoadError
+  task :test do
+    raise "You must have rspec 2.0 installed to run the tests"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "super_awesome_resource_serializer"
+    gem.summary = %Q{Quickly create custom serializations for resources}
+    gem.description = %Q{Quickly create custom serializations for resources rather than relying on the generated ones.}
+    gem.authors = ["Brian Durand"]
+    gem.email = ["mdobrota@tribune.com", "ddpr@tribune.com"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile", "License.txt"].to_a
+    gem.has_rdoc = true
+    gem.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
+    gem.extra_rdoc_files = ["README.rdoc"]
+    gem.add_dependency('activesupport')
+    gem.add_development_dependency('rspec', '>= 2.0.0')
+  end
+  Jeweler::RubygemsDotOrgTasks.new
+rescue LoadError
+end

data/lib/super_awesome_resource_serializer.rb

@@ -0,0 +1,349 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/json'
+
+# This class provides the base functionality for serializing Activeobject objects to XML, JSON, or YAML. It is intended to be
+# used with web services where tighter control is desired than is provided by ActiveResource out of the box. For instance, you may have
+# some sensitive fields in your Activeobject that should not be made available through a public web service API unless the user
+# is a trusted user.
+#
+# To create a serializer for you model, you simply need to make a new class named ModelNameSerializer where ModelName is the
+# class name of your model. The serializer class itself then needs to define how each field should be serialized using the serialize
+# method.
+class SuperAwesomeResourceSerializer
+
+  STATIC_CLASSES = [String, Symbol, Fixnum, Float, NilClass, TrueClass, FalseClass, Object].inject({}){|hash, klass| hash[klass] = true; hash}
+
+  class << self
+    # Get the serializer class for a given object.
+    def for_object (object, options = {}, klass = object.class)
+      serializer_class = "#{klass.name}Serializer".constantize
+      return serializer_class.new(object, options)
+    rescue
+      if klass.superclass.nil?
+        raise NameError.new("no known serializers for class #{object.class.name}")
+      else
+        return for_object(object, options, klass.superclass)
+      end
+    end
+
+    # Define how to serialize and deserialize a field. The following options can be passed in to define how to serialize an object.
+    # * :element - The name of the field in the serialized output. This can be used to give a object a prettier name on output.
+    # * :getter - The getter to get the field value.
+    # * :setter - The setter to set the field value.
+    # * :exclude - Indicate that this field should be excluded unless specifically asked for. Values can be :getter, :setter, or true.
+    #
+    # By default, getters and setters will call the field accessor on the serializer (if it is defined) or on the object.
+    # This can be overridden by specifying a different method name to call, or a proc that will be yielded to with the object
+    # (and value for a setter). Finally, getters and setters can be disabled by setting them to false.
+    def serialize (field, options = {})
+      serialized_field_info << SerializedFieldInfo.new(field, options)
+    end
+
+    # Merge the values of two field lists as used in :include, :exclude, and :only options.
+    def merge_field_lists (list_1, list_2)
+      if list_1.blank?
+        if list_2.blank?
+          return nil
+        else
+          return list_2
+        end
+      elsif list_2.blank?
+        return list_1
+      else
+        list_1 = normalize_field_list(list_1)
+        list_2 = normalize_field_list(list_2)
+        merge_hashes(list_1, list_2)
+      end
+    end
+
+   # Turn an :include, :exclude, or :only field list into a hash for consistent access.
+   def normalize_field_list (field_list)
+     case field_list
+     when nil
+       return {}
+     when true
+       return {}
+     when String
+       return {field_list.to_sym => true}
+     when Symbol
+       return {field_list => true}
+     when Array
+       hash = {}
+       field_list.each do |value|
+         if value.is_a?(Hash)
+           hash.merge!(normalize_field_list(value))
+         else
+           hash[value.to_sym] = true
+         end
+       end
+       return hash
+     when Hash
+       hash = {}
+       field_list.each_pair do |key, value|
+         value = normalize_field_list(value) unless value == true
+         hash[key.to_sym] = value
+       end
+       return hash
+     else
+       raise ArgumentError.new("illegal type in field list: #{field_list.class.name}")
+     end
+   end
+
+    # Get a list of serialized field information for preforming an action (either :getter or :setter) on the class.
+    # Option can pass in values for :include, :exclude, and :only to indicate filters on what fields are allowed.
+    # Include can be used to add fields that have been defined but excluded by default, exclude can be used to remove
+    # fields included by default, while only is used to specify the exact list of fields to use.
+    def serializable_fields (action, options = {})
+      if self == SuperAwesomeResourceSerializer
+        return []
+      else
+        exclude_fields = options[:exclude] || {}
+        include_fields = options[:include] || {}
+        only_fields = options[:only] || {}
+
+        all_field_info = superclass.serializable_fields(options) + serialized_field_info
+
+        if only_fields.empty?
+          excluded_field_names = exclude_fields.collect{|k,v| k if v == true}.compact
+          excluded_field_names = (excluded_field_names + all_field_info.select{|field| field.excluded?(action)}.collect{|field| field.name}) - include_fields.keys
+          all_field_info.delete_if{|field| excluded_field_names.include?(field.name)} unless excluded_field_names.empty?
+        else
+          all_field_info.delete_if{|field| not only_fields.include?(field.name)}
+        end
+
+        return all_field_info
+      end
+    end
+
+    # Get the field name with the unique key used to lookup the object
+    def param_key
+      if @param_key
+        @param_key
+      elsif superclass < SuperAwesomeResourceSerializer
+        superclass.param_key
+      else
+        :id
+      end
+    end
+
+    # Set the field name with the unique key used to lookup the object
+    def param_key= (val)
+      @param_key = val
+    end
+
+    protected
+
+    # Merge two hashes recursively
+    def merge_hashes (hash_1, hash_2)
+      hash_1.each_pair do |key, value_1|
+        value_2 = hash_2.delete(key)
+        if value_2.is_a?(Hash)
+          hash_1[key] = merge_hashes(value_1, value_2)
+        end
+      end
+      hash_1.merge(hash_2)
+    end
+
+    def serialized_field_info
+      @serialized_field_info ||= []
+    end
+  end
+
+  attr_reader :object, :include_fields, :exclude_fields, :only_fields, :root_element
+
+  # Create a new serializer. Options can be passed in for :exclude, :include, or :only to determine
+  # which fields will be used.
+  #
+  # To indicate a field should be included or excluded on a serializer returned by a field, prefix it with the field name.
+  # For example, if you have a field :venue and this field returns a VenueSerializer object and you only want the id of the
+  # venue, you can specify :only => "venue.id".
+  def initialize (object, serialize_options = {})
+    @object = object
+    @include_fields = self.class.normalize_field_list(serialize_options[:include])
+    @exclude_fields = self.class.normalize_field_list(serialize_options[:exclude])
+    @only_fields = self.class.normalize_field_list(serialize_options[:only])
+    @root_element = serialize_options[:root_element] ? serialize_options[:root_element].to_s : object.class.name.underscore.gsub("/", "-")
+  end
+
+  # Set the attributes on the underlying object by calling the available setters. All keys in the hash (and in any hashes in the values)
+  # will be converted to symbols.
+  def set_attributes (attributes)
+    return unless attributes
+    attributes = normalize_attribute_keys(attributes)
+    serializable_fields(:setter).each do |field|
+      if attributes.include?(field.name)
+        field.set(self, attributes[field.name])
+      end
+    end
+  end
+
+  # Update the available fields in the object with a serialized representation of the object in XML.
+  def update_with_xml (xml)
+    set_attributes(Hash.from_xml(xml)[root_element])
+  end
+
+  # Update the available fields in the object with a serialized representation of the object in JSON.
+  def update_with_json (json)
+    set_attributes(ActiveSupport::JSON.decode(json))
+  end
+
+  # Update the available fields in the object with a serialized representation of the object in YAML.
+  def update_with_yaml (yaml)
+    set_attributes(YAML.load(yaml))
+  end
+
+  # Serialize the object to a hash.
+  def to_hash
+    hash = HashWithIndifferentAccess.new
+    serializable_fields(:getter).each do |field|
+      if field.getter?
+        hash[field.element] = wrap_object_for_hash(field.get(self), field.name)
+      end
+    end
+    return hash
+  end
+
+  # Serialize the object to XML.
+  def to_xml (xml_options = {})
+    to_hash.to_xml({:root => root_element, :dasherize => false}.reverse_merge(xml_options))
+  end
+
+  # Serialize the object to JSON.
+  def to_json (json_options = nil)
+    to_hash.to_json(json_options)
+  end
+
+  # Serialize the object to YAML.
+  def to_yaml (yaml_options = {})
+    remove_hash_indifferent_access(to_hash).to_yaml(yaml_options)
+  end
+
+  # Get the unique key used for lookups
+  def to_param
+    object.send(self.class.param_key || :id)
+  end
+
+  def == (val)
+    return val.is_a?(self.class) && val.object == object && val.include_fields == include_fields && val.exclude_fields == exclude_fields && val.only_fields == only_fields && val.root_element == root_element
+  end
+
+  private
+
+  # Convert a hash and all contained hashes to use symbols for keys.
+  def normalize_attribute_keys (attributes)
+    attributes = HashWithIndifferentAccess.new(attributes) unless attributes.is_a?(HashWithIndifferentAccess)
+    attributes.each_pair do |key, value|
+      attributes[key] = normalize_attribute_keys(value) if value.is_a?(Hash) and not value.is_a?(HashWithIndifferentAccess)
+    end
+  end
+
+  # Get the list of serializable fields for an action (either :getter or :setter)
+  def serializable_fields (action)
+    return self.class.serializable_fields(action, :include => include_fields, :exclude => exclude_fields, :only => only_fields)
+  end
+
+  # Convert an object to a hash using serializers if they exist.
+  def wrap_object_for_hash (object, field)
+    if STATIC_CLASSES.include?(object.class)
+      return object
+    elsif object.is_a?(Array)
+      return object.collect{|element| wrap_object_for_hash(element, field.to_s.singularize)}
+    elsif object.is_a?(Hash)
+      hash = {}
+      object.each_pair{|key, value| hash[key] = wrap_object_for_hash(value, field)}
+      return hash
+    elsif object.is_a?(SuperAwesomeResourceSerializer)
+      return object.to_hash
+    else
+      serializer_class = "#{object.class.name}Serializer".constantize rescue nil
+      if serializer_class
+        serialize_options = {:include => include_fields[:field], :exclude => exclude_fields[field], :only => only_fields[field]}
+        return serializer_class.new(object, serialize_options).to_hash
+      else
+        return object
+      end
+    end
+  end
+
+  # Change a HashWithIndifferentAccess into a regular hash including all hashes in the values
+  def remove_hash_indifferent_access (value)
+    if value.is_a?(Hash)
+      hash = {}
+      value.each_pair do |key, value|
+        hash[key] = remove_hash_indifferent_access(value)
+      end
+      return hash
+    elsif value.is_a?(Array)
+      return value.collect{|v| remove_hash_indifferent_access(v)}
+    else
+      return value
+    end
+  end
+
+  # Encapulation of information about a serialized field.
+  class SerializedFieldInfo
+    attr_reader :name, :element
+
+    def initialize (name, options)
+      @name = name.to_sym
+      @getter = options[:getter]
+      @setter = options[:setter]
+      @element = (options[:element] || @name).to_sym
+      @exclude = options[:exclude] || []
+    end
+
+    # Get the field value in the specified serializer.
+    def get (serializer)
+      if getter?
+        if @getter.is_a?(Proc)
+          @getter.call(serializer.object) if @getter.is_a?(Proc)
+        else
+          method_name = @getter || name
+          if serializer.respond_to?(method_name)
+            serializer.send(method_name)
+          else
+            serializer.object.send(method_name)
+          end
+        end
+      end
+    end
+
+    # Set the field value in the specified serializer.
+    def set (serializer, value)
+      if setter?
+        if @setter.is_a?(Proc)
+          @setter.call(serializer.object, value) if @setter.is_a?(Proc)
+        else
+          method_name = @setter || "#{name}="
+          if serializer.respond_to?(method_name)
+            serializer.send(method_name, value)
+          else
+            serializer.object.send(method_name, value)
+          end
+        end
+      end
+    end
+
+    # Check if the field has a getter.
+    def getter?
+      return @getter != false
+    end
+
+    # Check if the field has a setter.
+    def setter?
+      return @setter != false
+    end
+
+    # Return true if the field is excluded from the specified action by default.
+    def excluded? (action)
+      if @exclude == true
+        return true
+      elsif @exclude.is_a?(Array)
+        return @exclude.include?(action)
+      else
+        return @exclude == action
+      end
+    end
+  end
+end

data/spec/super_awesome_resource_serializer_spec.rb

@@ -0,0 +1,285 @@
+require 'rubygems'
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
+  # simplecov not installed
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'super_awesome_resource_serializer'))
+
+describe SuperAwesomeResourceSerializer do
+  
+  class SuperAwesomeResourceSerializer
+    class Tester
+      attr_accessor :field_1, :field_2, :field_3, :field_4, :field_5
+      def initialize (values = {})
+        values.each_pair{|key, value| self.send("#{key}=", value)}
+      end
+    end
+    
+    class TesterSubclass < Tester
+    end
+    
+    class TesterSerializer < SuperAwesomeResourceSerializer
+      serialize :field_1
+      serialize :field_2, :exclude => :setter
+      serialize :field_3, :exclude => :getter
+      serialize :field_4, :exclude => true
+      serialize :field_5, :element => :field_five, :exclude => true
+      serialize :field_one, :getter => :field_1, :setter => :field_1=, :exclude => true
+      serialize :virtual_1, :getter => lambda{|object| object.field_1.upcase}, :setter => false, :exclude => true
+      serialize :virtual_2, :getter => false, :setter => lambda{|object, value| object.field_1 = value.upcase}, :exclude => true
+      
+      def field_4
+        object.field_4.upcase if object.field_4
+      end
+      
+      def field_4= (value)
+        value = value.upcase if value
+        object.field_4 = value
+      end
+    end
+    
+    class TesterWithParamKeySerializer < SuperAwesomeResourceSerializer
+      self.param_key = :slug
+    end
+    
+    class Tester2
+      attr_accessor :value
+      def initialize (value)
+        @value = value
+      end
+    end
+  end
+  
+  it "should serialize just the default fields and a HashWithIndifferentAccess" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj)
+    hash = serializer.to_hash
+    hash.should == {"field_1" => "one", "field_2" => "two"}
+    hash[:field_1].should == "one"
+  end
+  
+  it "should be able to add fields to the serialization" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_3 => "three")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :include => :field_3)
+    serializer.to_hash.should == {"field_1" => "one", "field_2" => nil, "field_3" => "three"}
+  end
+  
+  it "should be able to exclude default fields from the serialization" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :exclude => [:field_2])
+    serializer.to_hash.should == {"field_1" => "one"}
+  end
+  
+  it "should be able to define the exact fields to serialize" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two", :field_3 => "three")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => [:field_1, :field_3])
+    serializer.to_hash.should == {"field_1" => "one", "field_3" => "three"}
+  end
+  
+  it "should be able to specify a hash key for serialization with the :element option" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_5 => "five")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_5)
+    serializer.to_hash.should == {"field_five" => "five"}
+  end
+  
+  it "should be able to define a getter with a symbol" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_one)
+    serializer.to_hash.should == {"field_one" => "one"}
+  end
+  
+  it "should call getters on the serializer if they are defined" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_4 => "four")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_4)
+    serializer.to_hash.should == {"field_4" => "FOUR"}
+  end
+  
+  it "should be able to define a getter with a proc" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :virtual_1)
+    serializer.to_hash.should == {"virtual_1" => "ONE"}
+  end
+  
+  it "should not be able to get values without getters" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :virtual_2)
+    serializer.to_hash.should == {}
+  end
+  
+  it "should use an object's serializer on field values if it exists" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two"))
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_1)
+    serializer.to_hash.should == {"field_1" => {"field_1" => "one", "field_2" => "two"}}
+  end
+  
+  it "should not use an object's serializer if it doesn't exist" do
+    value = SuperAwesomeResourceSerializer::Tester2.new("value")
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => value)
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_1)
+    serializer.to_hash.should == {"field_1" => value}
+  end
+  
+  it "should wrap an array's elements with serializers if the exist" do
+    element_1 = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "a", :field_2 => "b")
+    element_2 = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "c", :field_2 => "d")
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => [element_1, element_2])
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_1)
+    serializer.to_hash.should == {"field_1" => [{"field_1" => "a", "field_2" => "b"}, {"field_1" => "c", "field_2" => "d"}]}
+  end
+  
+  it "should wrap a hash's values with serializers if the exist" do
+    element_1 = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "a", :field_2 => "b")
+    element_2 = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "c", :field_2 => "d")
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => {:a => element_1, :b => element_2})
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => :field_1)
+    serializer.to_hash.should == {"field_1" => {"a" => {"field_1" => "a", "field_2" => "b"}, "b" => {"field_1" => "c", "field_2" => "d"}}}
+  end
+  
+  it "should normalize field lists" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :include => [:field_1, :field_2], :exclude => {:field_1 => [:field_1, :field_2], :field_2 => true}, :only => [{:field_1 => "field_1"}, "field_2"])
+    serializer.include_fields.should == {:field_1 => true, :field_2 => true}
+    serializer.exclude_fields.should == {:field_1=>{:field_1=>true, :field_2=>true}, :field_2=>true}
+    serializer.only_fields.should == {:field_1 => {:field_1 => true}, :field_2 => true}
+    SuperAwesomeResourceSerializer.normalize_field_list(:field_1).should == {:field_1 => true}
+  end
+  
+  it "should merge field lists" do
+    SuperAwesomeResourceSerializer.merge_field_lists(nil, "").should == nil
+    SuperAwesomeResourceSerializer.merge_field_lists(:slug, "").should == :slug
+    SuperAwesomeResourceSerializer.merge_field_lists(nil, :slug).should == :slug
+    SuperAwesomeResourceSerializer.merge_field_lists(:slug, "title").should == {:slug => true, :title => true}
+    SuperAwesomeResourceSerializer.merge_field_lists([:slug, {:assoc => :f3}], ["title", {:assoc => [:f1, :f2]}]).should == {:slug => true, :title => true, :assoc => {:f1 => true, :f2 => true, :f3 => true}}
+  end
+  
+  it "should be able to specify filters on object returned by a field that have serializers" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two"), :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :only => [{:field_1 => "field_1"}, "field_2"])
+    serializer.to_hash.should == {"field_1" => {"field_1" => "one"}, "field_2" => "two"}
+  end
+  
+  it "should be able to specify exclude filters on object returned by a field that have serializers and only exclude the subobject fields" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two"), :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :exclude => {:field_1 => "field_1", :field_2 => true})
+    serializer.to_hash.should == {"field_1" => {"field_2" => "two"}}
+  end
+  
+  it "should be able to serialize to xml" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj)
+    Hash.from_xml(serializer.to_xml).should == {"super_awesome_resource_serializer_tester" => {"field_1" => "one", "field_2" => "two"}}
+  end
+  
+  it "should be able to serialize to json" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj)
+    ActiveSupport::JSON.decode(serializer.to_json).should == {"field_1" => "one", "field_2" => "two"}
+  end
+  
+  it "should be able to serialize to yaml" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj)
+    YAML.load(serializer.to_yaml).should == {"field_1" => "one", "field_2" => "two"}
+  end
+  
+  it "should be able to set attribute values" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj)
+    serializer.set_attributes(:field_1 => 1)
+    obj.field_1.should == 1
+    obj.field_2.should == "two"
+  end
+  
+  it "should not be able to set attribute values on fields not included" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :exclude => :field_1, :include => :field_2)
+    serializer.set_attributes(:field_1 => 1, :field_2 => 2)
+    obj.field_1.should == "one"
+    obj.field_2.should == 2
+  end
+  
+  it "should call setters on the serializer if they are defined" do
+    obj = SuperAwesomeResourceSerializer::Tester.new
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :include => :field_4)
+    serializer.set_attributes(:field_4 => "forty")
+    obj.field_4.should == "FORTY"
+  end
+  
+  it "should be able to define setters as procs" do
+    obj = SuperAwesomeResourceSerializer::Tester.new
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :include => :virtual_2)
+    serializer.set_attributes(:virtual_2 => "one")
+    obj.field_1.should == "ONE"
+  end
+  
+  it "should not be able to set values without setters" do
+    obj = SuperAwesomeResourceSerializer::Tester.new
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :include => :virtual_1)
+    serializer.set_attributes(:virtual_1 => "one")
+    obj.field_1.should == nil
+  end
+  
+  it "should be able to use a default root element of the XML document" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj)
+    serializer.root_element.should == "super_awesome_resource_serializer-tester"
+  end
+  
+  it "should be able to use a custom root element of the XML document" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer::TesterSerializer.new(obj, :root_element => "test")
+    serializer.root_element.should == "test"
+  end
+  
+  it "should be able to create a serializer for an object" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer.for_object(obj, :include => :test)
+    serializer.class.should == SuperAwesomeResourceSerializer::TesterSerializer
+    serializer.object.should == obj
+    serializer.include_fields.should == {:test => true}
+  end
+  
+  it "should be able to create a serializer for an object whose superclass has a serializer" do
+    obj = SuperAwesomeResourceSerializer::TesterSubclass.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer.for_object(obj, :include => :test)
+    serializer.class.should == SuperAwesomeResourceSerializer::TesterSerializer
+    serializer.object.should == obj
+    serializer.include_fields.should == {:test => true}
+  end
+  
+  it "should raise an error if an object doesn't have a serializer" do
+    lambda{SuperAwesomeResourceSerializer.for_object(1)}.should raise_error(NameError)
+  end
+  
+  it "should be able to turn a serializer into a param" do
+    obj = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one", :field_2 => "two")
+    serializer = SuperAwesomeResourceSerializer.for_object(obj, :include => :test)
+    obj.should_receive(:id).and_return(5)
+    serializer.to_param.should == 5
+  end
+  
+  it "should be able to customize the param key used" do
+    SuperAwesomeResourceSerializer::TesterSerializer.param_key.should == :id
+    SuperAwesomeResourceSerializer::TesterWithParamKeySerializer.param_key.should == :slug
+  end
+  
+  it "should test equality" do
+    obj_1 = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "one")
+    obj_2 = SuperAwesomeResourceSerializer::Tester.new(:field_1 => "ONE")
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1).should == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1).should_not == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_2)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :include => :field_1).should_not == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :include => :field_1).should == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :include => :field_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :exclude => :field_1).should_not == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :exclude => :field_1).should == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :exclude => :field_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :only => :field_1).should_not == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :only => :field_1).should == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :only => :field_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :root_element => "test").should_not == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1)
+    SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :root_element => "test").should == SuperAwesomeResourceSerializer::TesterSerializer.new(obj_1, :root_element => "test")
+  end
+end