restful_serializer 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.swp
+.vimrc
+.current
+spec/*.log

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Joshua Partlow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,75 @@
+= Restful Serialization
+
+A gem to help with serializing activerecord instances as Restful resources, including hrefs.
+
+If the model has a name column, it will be used to describe the resource.
+
+This library does not attempt to provide href info for transitions, or deal much with questions of authorization beyond what is specified in the serialization configuration lines.  It assumes that these issues would be resolved in the controller.  It assumes standard naming conventions for routes.
+
+So far only tested with Rails 2.x
+
+== Example 
+
+Models:
+
+  # Columns:
+  #  name
+  #  column1
+  #  column2
+  #  secret
+  class Foo < ActiveRecord::Base
+    has_many :bars
+  end
+
+  # Columns:
+  #  bar1
+  #  bar2
+  #  system
+  class Bar < ActiveRecord::Base
+    has_one :foo
+  end
+
+Example configuration (config/initializers/restful.rb:
+
+  # url prefix for calls to the web service
+  Restful.api_prefix = 'client_api'
+  Restful.model_configuration = {
+    # This configuration provides information which anyone authorized to see a
+    # given object at the most basic level should be able to see.
+  
+    # Note: it is advisable to set :serialization => :only for all models, so that
+    # new attributes do not automatically become available through the api.
+  
+    :foo => {
+      :serialization => {
+        :only => [:id, :column1, :column2],
+      },
+      :associations => {:bars => nil}
+    },
+    :bar => {
+      :serialization => {
+        :only => [:id, :bar1, :bar2],
+        :include => {
+          :foo => { :only => [:column1] }
+        },
+      }
+      :associations => {:foo => nil}
+    }
+  }
+
+Note that the serialization configuration is the same which you would normally pass to ActiveRecord::Serialization (in a model.to_json call, for instance).
+
+Example output:
+
+  foo = Foo.create(:name => 'A foo', :column1 => 1, :column2 => 2, :secret => "very secret")
+  pp foo.restful
+  # =>
+  # {"href"=>"http://test.app/client_api/foos/1",
+  #  "name"=>"A foo",
+  #  "bars_href"=>"http://test.app/client_api/foos/1/bars",
+  #  "foo"=>
+  #   {"id"=>1,
+  #    "name"=>"A foo",
+  #    "column1"=>1,
+  #    "column2"=>2,}}
+

data/Rakefile

@@ -0,0 +1,32 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rubygems'
+require 'rake'
+require 'restful/version'
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = Restful::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "restful #{version}"
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('LICENSE*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/restful.rb

@@ -0,0 +1,120 @@
+# This file is part of restful_serializer.  Copyright 2011 Joshua Partlow.  This is free software, see the LICENSE file for details.
+require 'active_support'
+require 'restful/serializer'
+
+# This library is used to decorate ActiveRecord with methods to assist in generating 
+# Restful content for Web Services.
+#
+# It produces a hash of reference, object and href information for an ActiveRecord instance
+# or association.  Output is highly configurable both through Rails initialization and
+# method calls.
+#
+# = Options
+#
+# The following options may be set in the Restful.model_configuration hash on a per model class
+# basis.
+#
+# * :name => method to call on an instance to produce a human meaningful reference for the instance.
+#   Defaults to :name.
+# * :serialization => options to be passed to ActiveRecord::Serialization::Serializer to configure
+#   serialization of the ActiveRecord instance itself.  See ActiveRecord::Serialization.to_json
+# * :url_for => if the named_route helper method cannot be guessed from normal Rails restful
+#   syntax, it may be overriden here.
+# * :associations => you may include href references to the instance's associations
+# * :shallow => if you are serializing an association, by default member includes and association 
+#   references are stripped.  Set this to false to traverse deeply.
+# * :no_inherited_options => normally a subclass inherits and overrides its base class settings.
+#   Setting this to true prevents this so that only the options specifically set for the class
+#   will be used.  Default false.
+#
+# = Usage
+#
+#   # :first_name => :string
+#   # :last_name => :string
+#   # :age  => :int
+#   # :secrets => :string
+#   class Person < ActiveRecord::Base
+#     has_many :books
+#  
+#     def name
+#       "#{first_name} #{last_name}"
+#     end
+#   end
+#
+#   # :title => :string
+#   # :pages => :int
+#   # :person_id => :int
+#   class Book < ActiveRecord::Base
+#     belongs_to :person
+#   end
+#
+#   ActionController::Routing::Routes.draw do |map|
+#     map.resources :people do |people|
+#       people.resources :books
+#     end 
+#   end
+#
+#   Restful.model_configuration = {
+#     :person => {
+#       :serialization => { :except => :secrets }
+#       :associations => :books,
+#     }
+#     :book => {
+#       :name => :title,
+#       :associations => :person,
+#     }
+#   }
+#
+#   bob = Person.new(:first_name => 'Bob', :last_name => 'Smith', :age => 41, :secrets => 'untold')
+#   bob.restful
+#   # => { 
+#   #   'name' => 'Bob Smith'
+#   #   'person' => { 
+#   #      'id' => 1,
+#   #      'first_name' => 'Bob',
+#   #      'last_name' => 'Bob',
+#   #      'age' : 17,
+#   #   'href' => 'http://www.example.com/web_service/people/1' }
+#   #   'books_href' => 'http://www.example.com/web_service/people/1/books' }
+#   # }
+#
+module Restful
+  # Route prefix for api calls.
+  mattr_accessor :api_prefix
+
+  # Hash for configuration Restful models.
+  mattr_accessor :model_configuration
+  self.model_configuration = {}
+
+  def self.model_configuration=(options)
+    @@model_configuration = options.symbolize_keys
+  end
+
+  def self.model_configuration_for(key)
+    config = case key 
+      when Symbol
+        model_configuration[key]
+      when String
+        model_configuration[key.to_sym]
+      when Class
+        model_configuration[key.name.underscore.to_sym]
+      else
+        model_configuration[key.class.name.underscore.to_sym]
+    end
+    return Marshal.load(Marshal.dump(config)) || {} # deep clone or empty
+  end
+
+  module Extensions
+    def restful(*args)
+      Restful::Serializer.new(self, *args).serialize
+    end
+  end
+
+  module AssociationExtensions
+    def restful(*args)
+      Restful::Serializer.new(self, *args).serialize
+    end
+  end
+end
+ActiveRecord::Base.send(:include, Restful::Extensions)
+ActiveRecord::Associations::AssociationProxy.send(:include, Restful::AssociationExtensions)

data/lib/restful/serializer.rb

@@ -0,0 +1,160 @@
+# This file is part of restful_serializer.  Copyright 2011 Joshua Partlow.  This is free software, see the LICENSE file for details.
+require 'active_record'
+require 'action_controller'
+
+module Restful
+  module UrlForHelpers
+
+    # Used to construct and attempt to call named routes be providing resource strings out
+    # of which an named route method name will be constructed:
+    #
+    # Options:
+    #
+    # * :resources => a symbol, string or array of same describing segments of the helper method name.
+    #   e.g. [:user, :comments] => user_comments (to which _url will be appended...)
+    # * :method => overrides the use of :resources and :prefix
+    # * :args => any arguments to be passed to the named_route when it is called
+    #
+    # = Example
+    #
+    #   get_url_for(:resources => [:user, :comments], :args => 1)
+    #   # => send("#{Restful.api_prefix}_user_comments_url", 1)
+    #   # which if it exists is likely to return something like:
+    #   # "http://example.com/user/1/comments"
+    #
+    def get_url_for(options)
+      url_for = [options[:method], 'url'] if options.include?(:method)
+      url_for ||= [Restful.api_prefix, options[:resources], 'url'].flatten.compact
+      url_for = url_for.join('_').downcase
+      send(url_for, *Array(options[:args])) if respond_to?(url_for) 
+    end
+
+  end
+
+  class Serializer
+    include ActionController::UrlWriter
+    include UrlForHelpers
+    attr_accessor :subject, :base_klass, :klass, :options, :shallow
+  
+    def initialize(subject, *args)
+      self.subject = subject
+
+      self.base_klass = subject.class.base_class.name.underscore if subject.class.respond_to?(:base_class)
+      self.klass = subject.class.name.underscore
+
+      passed_options = (args.pop || {}).symbolize_keys
+      base_options = Restful.model_configuration_for(base_klass) || {}
+      class_options = Restful.model_configuration_for(klass) || {}
+      self.options = (klass == base_klass || class_options[:no_inherited_options]) ? 
+        class_options : 
+        base_options.merge(class_options)
+      self.options.merge!(passed_options)
+
+      self.shallow = options[:shallow]
+    end
+  
+    def serialize
+      case 
+        when subject.respond_to?(:attribute_names) then _serialize_active_record
+        when subject.kind_of?(Array) then _serialize_array
+        else ActiveSupport::JSON.decode(subject.to_json) # just capture the hash of the object structure
+      end
+    end
+
+    def active_record_serialization_options
+      ar_options = (options[:serialization] || {}).clone
+      ar_options.delete(:include) if shallow 
+      return ar_options
+    end
+
+    def name
+      name_method = options[:name] || :name
+      subject.send(name_method) if subject.respond_to?(name_method)
+    end
+
+    def associations
+      unless @associations
+        @associations = case options[:associations]
+          when Array,Hash
+            options[:associations].map do |name,assoc|
+              Association.new(subject, klass, (assoc.nil? ? name : assoc), name)
+            end
+          when nil
+            []
+          else
+            [Association.new(subject, klass, options[:associations])]
+        end
+      end
+      return @associations
+    end
+
+    def href 
+      unless @href
+        @href = get_url_for(:method => options[:url_for], :args => subject.id) if options.include?(:url_for)
+        @href = get_url_for(:resources => klass, :args => subject.id) unless @href
+        @href = get_url_for(:resources => base_klass, :args => subject.id) unless @href || base_klass == klass
+      end
+      return @href
+    end
+
+    private
+
+    def _serialize_active_record
+      restful = {
+        klass => ActiveRecord::Serialization::Serializer.new(subject, active_record_serialization_options).serializable_record,
+      }
+      restful['name'] = name if name
+      restful['href'] = href
+      associations.each do |association|
+        restful["#{association.name}_href"] = association.href 
+      end unless shallow
+
+      return restful
+    end
+
+    def _serialize_array
+      restful = subject.map do |e|
+        array_options = options.clone
+        array_options.merge!(:shallow => true) unless array_options.include?(:shallow)
+        Serializer.new(e, array_options).serialize
+      end 
+      return restful 
+    end
+  end
+
+  # Handle for information about an ActiveRecord association.
+  class Association
+    include ActionController::UrlWriter
+    include UrlForHelpers
+    attr_accessor :name, :association_name, :association, :subject, :subject_klass
+    
+    def initialize(subject, subject_klass, association_name, name = nil)
+      self.subject = subject
+      self.subject_klass = subject_klass
+      self.association_name = association_name
+      self.name = name || association_name
+      self.association = subject.class.reflect_on_association(association_name)
+    end
+
+    def singular?
+      [:belongs_to, :has_one].include?(association.macro)
+    end
+
+    def href
+      if singular?
+        href = get_url_for(:resources => association_name, :args => subject.send(association.name).id)
+      else
+        href = collective_href
+      end
+      return href
+    end
+
+    def collective_href
+      # try url_for nested resources first
+      unless href = get_url_for(:resources => [subject_klass, association_name], :args => subject.id)
+        href = get_url_for(:resources => association_name)
+      end
+      return href 
+    end
+  end
+end

data/lib/restful/version.rb

@@ -0,0 +1,3 @@
+module Restful
+  VERSION = "0.1.0"
+end

data/restful_serializer.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'restful/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{restful_serializer}
+  s.version = Restful::VERSION
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.authors = ["Josh Partlow"]
+  s.email = %q{jpartlow@glatisant.org}
+  s.summary = %q{Helps with serializing activerecord instances as Restful resources.}
+  s.description = %q{This library is used to decorate ActiveRecord with methods to assist in generating Restful content for Web Services.}
+  s.homepage = %q{http://github.com/jpartlow/restful_serializer}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.rdoc_options = ["--main=README.rdoc", "--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files spec/*`.split("\n")
+
+  s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+  s.add_runtime_dependency(%q<activerecord>, [">= 2.1.0", "<3.0.0"])
+  s.add_runtime_dependency(%q<activesupport>, [">= 2.1.0", "<3.0.0"])
+  s.add_runtime_dependency(%q<actionpack>, [">= 2.1.0", "<3.0.0"])
+end

data/spec/database.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+
+gem 'activerecord', '>=2.1.0'
+require 'active_record'
+
+ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
+ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/active_record.log")
+
+def create_schema(&block)
+  connection = ActiveRecord::Base.connection
+  yield connection if block_given?
+end

data/spec/restful_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe Restful do
+
+  it "should have an api_prefix accessor" do
+    Restful.api_prefix.should be_nil
+    Restful.api_prefix = 'foo'
+    Restful.api_prefix.should == 'foo'
+  end
+
+  it "should have a model_configuration accessor" do
+    Restful.model_configuration.should == {}
+  end
+
+  it "should automatically symbolize keys for model_configuration" do
+    Restful.model_configuration = { 'foo' => 'bar' }
+    Restful.model_configuration.should == { :foo => 'bar' }
+  end
+
+  describe "looking up model configurations" do
+
+    class Foo; end
+    class FooBar < Foo; end
+
+    before(:each) do
+      Restful.model_configuration = {
+        :foo => :foo_config,
+        :foo_bar => :foo_bar_config,
+      }
+    end
+
+    it "should return an empty hash if no configuration" do
+      Restful.model_configuration_for(nil).should == {}
+    end
+
+    it "should lookup entries by symbol" do
+      Restful.model_configuration_for(:foo).should == :foo_config
+    end
+
+    it "should lookup entries from a string" do
+      Restful.model_configuration_for('foo').should == :foo_config
+    end
+
+    it "should lookup entries by Class" do
+      Restful.model_configuration_for(Foo).should == :foo_config
+      Restful.model_configuration_for(FooBar).should == :foo_bar_config
+    end
+
+    it "should lookup entries by instance class" do
+      Restful.model_configuration_for(Foo.new).should == :foo_config
+      Restful.model_configuration_for(FooBar.new).should == :foo_bar_config
+    end
+
+    describe "with deep structures" do
+
+      before(:each) do
+        Restful.model_configuration = {
+          :foo => { :setting => {:with => :nested_hash } }
+        }
+      end
+
+      it "should provide deep clones of model_configuration elements" do
+        config = Restful.model_configuration_for(:foo)
+        config[:setting][:with] = "changed"
+        Restful.model_configuration.should == {
+          :foo => { :setting => {:with => :nested_hash } }
+        } 
+      end
+
+    end
+  end
+end

data/spec/serializer_spec.rb

@@ -0,0 +1,322 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+ActionController::Routing::Routes.draw do |map|
+  map.resources :foos
+  map.prefix_foo 'prefix/foos/:id', :controller => 'foos', :action => 'show'
+  map.custom_foo 'custom_foo/:id', :controller => 'foos', :action => 'show'
+  map.resources :bars do |bars|
+    bars.resources :dingos
+  end 
+  map.resources :things
+end
+
+describe Restful::Serializer do
+
+  class Foo < ActiveRecord::Base
+    has_many :bars
+    def fancy_name
+      "fancy: #{name}"
+    end
+
+    def a_method
+      "calculated value"
+    end
+  end
+
+  class Bar < ActiveRecord::Base
+    belongs_to :foo
+    has_one :one
+    has_many :dingos
+  end
+
+  class Dingo < ActiveRecord::Base
+    belongs_to :bar
+  end
+
+  class Thing < ActiveRecord::Base; end
+  class Sub < Thing; end
+
+  def generate_instances
+    @foo = Foo.create!(:name => 'A foo')
+    @bar1 = Bar.create!(:name => 'The bar1', :foo => @foo)
+    @bar2 = Bar.create!(:name => 'The bar2', :foo => @foo)
+    @dingo1 = Dingo.create!(:name => 'The dingo1', :bar => @bar1)
+    @dingo2 = Dingo.create!(:name => 'The dingo2', :bar => @bar1)
+    @dingo3 = Dingo.create!(:name => 'The dingo3', :bar => @bar2)
+    @dingo4 = Dingo.create!(:name => 'The dingo4', :bar => @bar2)
+  end
+
+  before(:all) do
+    create_schema do |conn|
+      conn.create_table(:foos, :force => true) do |t|
+        t.string :name
+      end
+      conn.create_table(:bars, :force => true) do |t|
+        t.string :name
+        t.references :foo
+      end
+      conn.create_table(:dingos, :force => true) do |t|
+        t.string :name
+        t.references :bar
+      end
+      conn.create_table(:things, :force => true) do |t|
+        t.string :name
+        t.string :type 
+        t.string :secret
+      end
+    end 
+  end
+
+  before(:each) do
+    @foo = Foo.new(:name => 'A foo')
+    Restful::Serializer.default_url_options = { :host => 'test.org' }
+  end
+
+  after(:each) do
+    Restful.api_prefix = nil
+    Restful.model_configuration = {}
+  end
+
+  it "should require a subject" do
+    lambda { Restful::Serializer.new }.should raise_error(ArgumentError)
+    Restful::Serializer.new('foo').should be_kind_of(Restful::Serializer)
+  end
+
+  it "should set klass" do
+    rs = Restful::Serializer.new(@foo)
+    rs.klass.should == 'foo'
+  end
+
+  it "should serialize" do
+    @foo.save!
+    rs = Restful::Serializer.new(@foo)
+    rs.serialize.should == {
+      'name' => @foo.name,
+      'foo' => { 
+        'id' => @foo.id,
+        'name' => @foo.name,
+      },
+      'href' => "http://test.org/foos/#{@foo.id}",
+    }
+  end
+
+  describe "with configuration options" do
+
+    before(:each) do
+      Restful.api_prefix = 'prefix'
+      Restful.model_configuration = {
+        :foo => {
+          :name => :fancy_name,
+          :serialization => { :only => [:name], :methods => [:a_method] },
+        }
+      }
+      @foo.save!
+    end
+
+    it "should take options from configuration" do
+      rs = Restful::Serializer.new(@foo)
+      rs.serialize.should == {
+        'name' => @foo.fancy_name,
+        'foo' => { 
+          'name' => @foo.name,
+          :a_method => @foo.a_method,
+        },
+        'href' => "http://test.org/prefix/foos/#{@foo.id}",
+      }
+    end
+  
+    it "should override options during initialization" do
+      rs = Restful::Serializer.new(@foo, 
+        :name => :name, 
+        :serialization => { :only => [:id] }, 
+        :url_for => :custom_foo
+      )
+      rs.serialize.should == {
+        'name' => @foo.name,
+        'foo' => { 
+          'id' => @foo.id,
+        },
+        'href' => "http://test.org/custom_foo/#{@foo.id}",
+      }
+    end
+
+  end
+
+  describe "with associations" do
+
+    before(:each) do
+      Restful.model_configuration = {
+        :foo => {
+          :associations => :bars,
+        },
+        :bar => {
+          :associations => { :special => :foo, :dingos => nil },
+        },
+      }
+      generate_instances
+    end
+
+    it "should include references to associations" do
+      rs = Restful::Serializer.new(@foo)
+      rs.serialize.should == {
+        'name' => @foo.name,
+        'foo' => { 
+          'id' => @foo.id,
+          'name' => @foo.name,
+        },
+        'href' => "http://test.org/foos/#{@foo.id}",
+        'bars_href' => "http://test.org/bars",
+      }
+    end
+
+    it "should handle multiple and nested associations" do
+      rs = Restful::Serializer.new(@bar1)
+      rs.serialize.should == {
+        'name' => @bar1.name,
+        'bar' => { 
+          'id' => @bar1.id,
+          'name' => @bar1.name,
+          'foo_id' => @bar1.foo_id,
+        },
+        'href' => "http://test.org/bars/#{@bar1.id}",
+        'dingos_href' => "http://test.org/bars/#{@bar1.id}/dingos",
+        'special_href' => "http://test.org/foos/#{@bar1.foo_id}",
+      }
+    end
+
+  end
+
+  describe "with subclasses" do
+    
+    before(:each) do
+      Restful.model_configuration = {
+        :thing => {
+          :serialization => { :except => :secret }
+        }
+      }
+      @thing = Thing.create!(:name => 'a thing', :secret => 'a secret')
+      @sub = Sub.create!(:name => 'a sub thing', :secret => 'another secret')
+    end
+
+    it "should pull superclass configuration up into a subclass serialization" do
+      rs = Restful::Serializer.new(@sub)
+      rs.serialize.should == {
+        'name' => @sub.name,
+        'href' => "http://test.org/things/#{@sub.id}",
+        'sub' => {
+          'id' => @sub.id,
+          'name' => @sub.name,
+        }  
+      }
+    end
+  end
+
+  describe "with arrays" do
+    before(:each) do
+      Restful.model_configuration = {
+        :foo => {
+          :associations => :bars,
+        },
+        :bar => {
+          :serialization => { :only => :name, :include => { :dingos => { :only =>  [ :name, :id] } } },
+          :associations => [:foo, :dingos],
+        },
+      }
+      generate_instances
+    end
+
+    it "should serialize arrays" do
+      rs = Restful::Serializer.new(@foo.bars)
+      rs.serialize.should == [
+        {
+          'name' => @bar1.name,
+          'href' => "http://test.org/bars/#{@bar1.id}",
+          'bar'  =>  {
+            'name' => @bar1.name,
+          },
+        },
+        {
+          'name' => @bar2.name,
+          'href' => "http://test.org/bars/#{@bar2.id}",
+          'bar'  =>  {
+            'name' => @bar2.name,
+          },
+        },
+      ] 
+    end
+
+    it "should deeply serialize arrays if told to" do
+      rs = Restful::Serializer.new(@foo.bars, :shallow => false)
+      rs.serialize.should == [
+        {
+          'name' => @bar1.name,
+          'bar'  =>  {
+            'name' => @bar1.name,
+            :dingos => [
+              { 'name' => @dingo1.name, 'id' => @dingo1.id, }, 
+              { 'name' => @dingo2.name, 'id' => @dingo2.id, }, 
+            ],
+          },
+          'href' => "http://test.org/bars/#{@bar1.id}",
+          'dingos_href' => "http://test.org/bars/#{@bar1.id}/dingos",
+          'foo_href' => "http://test.org/foos/#{@bar1.foo_id}",
+        },
+        {
+          'name' => @bar2.name,
+          'bar'  =>  {
+            'name' => @bar2.name,
+            :dingos => [
+              { 'name' => @dingo3.name, 'id' => @dingo3.id, }, 
+              { 'name' => @dingo4.name, 'id' => @dingo4.id, }, 
+            ],
+          },
+          'href' => "http://test.org/bars/#{@bar2.id}",
+          'dingos_href' => "http://test.org/bars/#{@bar2.id}/dingos",
+          'foo_href' => "http://test.org/foos/#{@bar2.foo_id}",
+        },
+      ] 
+    end
+  end
+
+  it "should hook into activerecord" do
+    @foo.save!
+    @foo.should respond_to(:restful)
+    @foo.restful(:serialization => { :only => :name }).should == {
+      'name' => @foo.name,
+      'foo' => { 
+        'name' => @foo.name,
+      },
+      'href' => "http://test.org/foos/#{@foo.id}",
+    }
+  end
+
+  it "Should hook into associations" do
+    generate_instances
+    @foo.bars.restful.should == [
+      {
+        "href" => "http://test.org/bars/#{@bar1.id}",
+        "name" => @bar1.name,
+        "bar" => {
+          "name" => @bar1.name,
+          "foo_id" => @bar1.foo_id,
+          "id" => @bar1.id, 
+        },
+      },
+      {
+        "href" => "http://test.org/bars/#{@bar2.id}",
+        "name" => @bar2.name,
+        "bar" => {
+          "name" => @bar2.name,
+          "foo_id" => @bar2.foo_id,
+          "id" => @bar2.id,
+        },
+      },
+    ]
+  end
+
+  it "should work with AssociationProxy.respond_to" do
+    pending('associations should respond_to :restful (AR 2.1 issue or AR issue in general?)') do
+      @foo.bars.should respond_to(:restful)
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format nested

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'restful'
+require 'spec'
+require 'spec/autorun'
+require 'pp'
+
+require 'database'
+
+#class TestLogger
+#  [:debug, :info, :warn, :error].each do |m|
+#    define_method(m) { |message| puts "#{m.to_s.upcase}: #{message}" }
+#  end
+#end
+
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification 
+name: restful_serializer
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Josh Partlow
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id004
+description: This library is used to decorate ActiveRecord with methods to assist in generating Restful content for Web Services.
+email: jpartlow@glatisant.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/restful.rb
+- lib/restful/serializer.rb
+- lib/restful/version.rb
+- restful_serializer.gemspec
+- spec/database.rb
+- spec/restful_spec.rb
+- spec/serializer_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jpartlow/restful_serializer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main=README.rdoc
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Helps with serializing activerecord instances as Restful resources.
+test_files: 
+- spec/database.rb
+- spec/restful_spec.rb
+- spec/serializer_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb