restfulie 1.0.0 → 1.0.3

data/tests/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+})();

data/tests/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/tests/public/stylesheets/scaffold.css

@@ -0,0 +1,56 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+div.field, div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  margin-bottom: 0px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}

data/tests/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/tests/spec/controllers/integration/albums_controller_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe AlbumsController do
+  
+  before do
+    response.stub(:content_type) { "application/json" }
+    
+    3.times do |i|
+      album = Album.create!(:title => "Album #{i}", :description => "Description #{i}", :length => i*10)
+      4.times do |j|
+        album.songs.create!(:title => "Song #{j} from Album #{i}", :description => "Description for song #{j} from Album #{i}", :length => j*10 + i)
+      end
+    end
+  end
+
+  render_views
+  
+  describe "get index" do
+    before do
+      request.accept = "application/json"
+      get :index, :format => :Json
+      @feed = Medie::Json::Factory.create(response.body)
+    end
+    
+    it "generation Json feed to get index" do
+      @feed.entries.size.should == Album.count
+    end
+    
+    it "title feed personalize" do
+      @feed.title.should == "Index Album feed spec"
+    end
+    
+    it "members artists transitions included" do
+      transitions = @feed.entries.first.links
+      transitions.find {|t| t.rel == 'artists'}.should be_kind_of(::Medie::Json::Link)
+    end
+  end # describe "get index"
+  
+  describe "get show" do
+    before do
+      response.content_type = "application/json"
+      @album = Album.first
+      pending
+      get :show, :id => @album.id, :format => :Json
+      @entry = Medie::Json::Factory.create(response.body)      
+    end
+  
+    it "generation Json entry" do
+      pending
+      @entry.title.should == @album.title
+    end
+  
+    it "return extension values" do
+      pending
+      @entry.doc.at_xpath("albums:length_in_minutes", "albums" => "http://localhost/albums").content.to_i.should == @album.length
+      @entry.doc.at_xpath("albums:description", "albums" => "http://localhost/albums").content.should == @album.description
+    end
+  end # describe "get show"
+  
+end

data/tests/spec/controllers/integration/cacheable_songs_controller_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe CacheableClientsController do
+  before(:each) do
+    request.accept = "application/json"
+  end
+  
+  context "requesting a single resource" do
+    
+    it "should return 304 Not Modified if client's cache is still valid" do
+      request.env["HTTP_IF_MODIFIED_SINCE"] = Time.utc(2010).httpdate
+      get :single
+      response.status.to_i.should == 304
+    end
+
+    it "refreshes Last-Modified if cache is expired" do
+          request.env["HTTP_IF_MODIFIED_SINCE"] = Time.utc(1999)
+          get :single
+          response.last_modified.should == Time.utc(2010)
+          response.status.to_i.should == 200
+        end
+        
+        it "does not set cache if Last-Modified is already in response" do
+          get :single, :last_modified => true
+          response.last_modified.should == Time.utc(2010, 2)
+        end
+      end
+      
+      context "collection" do
+        it "sets Last-Modified using the most recent updated_at" do
+          get :collection
+          response.last_modified.should == Time.utc(2010)
+          response.status.to_i.should == 200
+        end
+        
+        it "works with empty array" do
+          get :empty
+          response.last_modified.should be_nil
+          response.status.to_i.should == 200
+        end
+  end      
+
+end

data/tests/spec/controllers/integration/controller_base_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require "action_controller"
+
+describe RenderController do
+  
+  before(:each) do
+    @object = Object.new
+    @controller.stub!(:object).and_return(@object)
+  end
+  
+  it "renders show action with application/atom+xml" do
+    get :show, :id => 1
+    @response.content_type.should == "application/atom+xml"
+  end
+  
+  it "renders index action with application/atom+xml" do
+    get :index
+    @response.content_type.should == "application/atom+xml"
+  end
+  
+  it "calls to_atom in show's object if object respond_to :to_atom" do
+    @atom = Object.new
+    @object.should_receive(:to_atom).once.and_return(@atom)
+    @atom.should_receive(:to_xml).once
+    get :show_with_mock, :id => 1
+    @response.content_type.should == "application/atom+xml"
+  end
+
+  it "calls to_xml in show's object if object does not respond_to :to_atom" do
+    @object.should_receive(:to_xml).once
+    get :show_with_mock, :id => 1
+    @response.content_type.should == "application/atom+xml"    
+  end
+  
+end

data/tests/spec/controllers/integration/created_responder_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+class ResponderWithCreated < ::ActionController::Responder
+  include Restfulie::Server::ActionController::Trait::Created
+end
+
+class CreationController < ApplicationController
+  self.responder = ResponderWithCreated
+  respond_to :atom
+
+  def create
+    @resource = Object.new
+    respond_with @resource, :status => :created
+  end
+
+end
+
+describe CreationController do
+  
+  context "creating a resource" do
+    
+    it "should return 201 with location" do
+      request.accept = "application/atom+xml"
+      
+      uri = "http://newlocation.com/uri"
+      
+      controller.stub(:url_for).and_return uri
+
+      post :create
+      response.code.should == "201"
+      response.headers["Location"].should == uri
+    end
+
+  end      
+end

data/tests/spec/controllers/integration/params_parser_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require "action_controller"
+
+class TestController < ::ActionController::Base
+  include Restfulie::Server::ActionController::Base
+  def create
+    render :text => (params.keys - ['controller', 'action']).sort.join(", ")
+  end
+end
+
+class NormalController < ::ActionController::Base
+  def build
+    render :text => (params.keys - ['controller', 'action']).sort.join(", ") 
+  end
+end
+
+class CSVRepresentation
+  cattr_reader :media_type_name
+  @@media_type_name = 'text/csv'
+
+  cattr_reader :headers
+  @@headers = { 
+    :get  => { 'Accept'       => media_type_name },
+    :post => { 'Content-Type' => media_type_name }
+  }
+
+  def self.to_hash(string)
+    { :data => string }.with_indifferent_access
+  end
+end
+
+# This test uses ActionController::IntegrationTest because we needed a specific implementation of the post test method, which accepts a payload passed as string, and not only a hash.
+class ParamsParserTest < ActionController::IntegrationTest
+
+  def setup
+    ActionController::Base.session_store = nil
+  end
+
+  def teardown
+    ActionController::Base.session_store = ActionController::Session::CookieStore
+  end
+
+  def test_simple_getting
+    with_test_route_set do
+      get '/create', :sort => true
+
+      assert_equal 'sort', @controller.response.body
+      assert @controller.params.has_key?(:sort)
+      assert_equal "true", @controller.params["sort"]
+    end
+  end
+
+ def test_offer_proper_params_hash_when_doing_post_with_xml 
+    with_test_route_set do
+      post '/create', 
+        '<feed xmlns="http://www.w3.org/2005/Atom"><title>Top Ten Songs feed</title><id>http://local/songs_top_ten</id></feed>',
+        :content_type => 'application/xml'
+
+      assert_equal 'feed', @controller.response.body
+      assert @controller.params.has_key?(:feed)
+      assert_equal 'Top Ten Songs feed', @controller.params["feed"]['title']
+    end
+  end
+
+ def test_offer_proper_params_hash_when_doing_post_with_atom 
+    with_test_route_set do
+      post '/create', 
+        '<feed xmlns="http://www.w3.org/2005/Atom"><title>Top Ten Songs feed</title><id>http://local/songs_top_ten</id><updated>2010-12-13T18:30:02Z</updated></feed>',
+        :content_type => 'application/atom+xml'
+
+      assert_equal 'feed', @controller.response.body
+      assert @controller.params.has_key?(:feed)
+      assert_equal 'Top Ten Songs feed', @controller.params["feed"]['title']
+    end
+  end
+
+  def test_raise_bad_request_when_doing_post_with_invalid_atom 
+    with_test_route_set do
+      begin
+        $stderr = StringIO.new
+        log_io = StringIO.new
+        ::ActionController::Base.logger = Logger.new(log_io)
+
+        post '/create', 
+          '<feed xmlns="http://www.w3.org/2005/Atom">Top Ten Songs feed</title><id>http://local/songs_top_ten</id></feed>',
+          :content_type => 'application/atom+xml'
+
+        assert_response :bad_request
+        assert_match /400 Bad Request/, log_io.string 
+        $stderr.rewind 
+      ensure
+        $stderr = STDERR
+      end
+    end
+  end
+
+  def test_unsupported_media_type_when_doing_post_with_csv
+    with_test_route_set do
+      log_io = StringIO.new
+      ::ActionController::Base.logger = Logger.new(log_io)
+
+      post '/create', 'name,age\njohndoe,42', 
+        :content_type => 'text/csv'
+
+      assert_response :unsupported_media_type
+      assert_match /415 Unsupported Media Type/, log_io.string 
+    end
+  end
+
+  def test_posting_with_csv_after_registering_it_as_supported_type
+    Restfulie::Server::ActionController::ParamsParser.register('text/csv',CSVRepresentation)
+    with_test_route_set do
+      post '/create', 'name,age\njohndoe,42', 
+        :content_type => 'text/csv'
+
+      assert_equal 'data', @controller.response.body
+      assert @controller.params.has_key?(:data)
+      assert_equal 'name,age\njohndoe,42', @controller.params["data"]
+    end
+    Restfulie::Server::ActionController::ParamsParser.unregister('text/csv')
+  end
+
+  def test_normal_controller_should_behave_just_as_any_rails_controller 
+    with_test_route_set do
+      post '/build', 
+        'foo=1',
+        :content_type => 'application/x-www-form-urlencoded'
+
+      assert_equal 'foo', @controller.response.body
+      assert @controller.params.has_key?(:foo)
+      assert_equal "1", @controller.params["foo"]
+    end
+  end
+
+  private
+    def with_test_route_set
+      with_routing do |set|
+        set.draw do |map|
+          map.with_options :controller => "test" do |c|
+            c.connect "/create", :action => "create"
+          end
+          map.with_options :controller => "normal" do |c|
+            c.connect "/build", :action => "build"
+          end
+        end
+        yield
+      end
+    end
+  
+end