restfulie 1.0.0 → 1.0.3

data/full-examples/rest_from_scratch/part_3/test/fixtures/items.yml

@@ -0,0 +1,9 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+
+one:
+  name: MyString
+  price: 9.99
+
+two:
+  name: MyString
+  price: 9.99

data/full-examples/rest_from_scratch/part_3/test/functional/items_controller_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class ItemsControllerTest < ActionController::TestCase
+  setup do
+    @item = items(:one)
+  end
+
+  test "should get index" do
+    get :index
+    assert_response :success
+    assert_not_nil assigns(:items)
+  end
+
+  test "should get new" do
+    get :new
+    assert_response :success
+  end
+
+  test "should create item" do
+    assert_difference('Item.count') do
+      post :create, :item => @item.attributes
+    end
+
+    assert_redirected_to item_path(assigns(:item))
+  end
+
+  test "should show item" do
+    get :show, :id => @item.to_param
+    assert_response :success
+  end
+
+  test "should get edit" do
+    get :edit, :id => @item.to_param
+    assert_response :success
+  end
+
+  test "should update item" do
+    put :update, :id => @item.to_param, :item => @item.attributes
+    assert_redirected_to item_path(assigns(:item))
+  end
+
+  test "should destroy item" do
+    assert_difference('Item.count', -1) do
+      delete :destroy, :id => @item.to_param
+    end
+
+    assert_redirected_to items_path
+  end
+end

data/full-examples/rest_from_scratch/part_3/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionDispatch::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/full-examples/rest_from_scratch/part_3/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/full-examples/rest_from_scratch/part_3/test/unit/helpers/items_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class ItemsHelperTest < ActionView::TestCase
+end

data/full-examples/rest_from_scratch/part_3/test/unit/item_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class ItemTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'lib', 'restfulie')

data/lib/restfulie/client/README.textile

@@ -0,0 +1,33 @@
+Retrieving resources
+ 
+There are 2 ways to initially access a resource:
+
+* Directly accessing an entry point, without using any class: 
+
+<pre>
+   book = Restfulie.at("http://resource.entrypoint.com/book/5").as('application/atom+xml').get!
+   book.title #=> "Hello world!"
+</pre>
+
+With this usage, there is no need to create a class, because Restfulie will return a model which respond to each representation's attribute.
+
+Within the REST style, clients should not expect type safety, therefore the above example is the best way to access a REST server.
+
+* Using an existing class:
+
+<pre>
+   class Book                                                        
+     include Restfulie::Client::Base                                 
+                                                                 
+     uses_restfulie do |config|                                      
+       config.entry_point     = 'http://restfulie.com/books'
+       config.default_headers = {                                    
+         :get  => { 'Accept'       => 'application/atom+xml' },      
+         :post => { 'Content-Type' => 'application/atom+xml' }       
+       }                                                             
+     end                                                             
+   end
+
+   books = Book.get!
+   p books.length #=> 5
+</pre>

data/lib/restfulie/client/feature/fake_response.rb

@@ -0,0 +1,13 @@
+module Restfulie
+  module Client
+    module Feature
+      class FakeResponse
+        attr_reader :code, :body
+        def initialize(code, body)
+          @code = code
+          @body = body
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/client/feature/follow_request.rb

@@ -17,24 +17,42 @@ class Restfulie::Client::Feature::FollowRequest
     if !resp.respond_to?(:code)
       return resp
     end
-    code = resp.code.to_i
-    if follow_codes.include?(code)
-      if code==201 && !resp.body.empty?
-        resp
-      else
-        location = resp.response.headers['location'] || resp.response.headers['Location']
-        raise Error::AutoFollowWithoutLocationError.new(request, resp) unless location
-        # use the first location available
-        location = location[0]
-        Restfulie.at(location).accepts(request.headers['Accept']).get
-      end
+    
+    if should_follow?(resp)
+      follow_this resp, request
     else
       resp
     end
   end
 
   protected
+  
+  def should_follow?(response)
+    code = response.code.to_i
+    if code==201 && !response.body.empty?
+      false
+    else
+      follow_codes.include?(code)
+    end
+  end
+  
+  def follow_this(response, request)
+    location = extract_location(response)
+    req = Restfulie.at(location)
+    if accept = request.headers['Accept']
+      req.accepts(accept)
+    end
+    req.get
+  end
 
+  def extract_location(response)
+    location = response.response.headers['location'] || response.response.headers['Location']
+    if location.nil?
+      raise Restfulie::Client::HTTP::Error::AutoFollowWithoutLocationError.new(request, response)
+    end
+    location.first
+  end
+  
     def follow_codes
       @follow_codes ||= [201,301,302,303,307]        
     end

data/lib/restfulie/client/feature/{throw_error.rb → throw_error_request.rb}

@@ -2,12 +2,13 @@
 #
 # To use it, load it in your dsl:
 # Restfulie.at("http://localhost:3000/product/2").throw_error.get
-class Restfulie::Client::Feature::ThrowError
+class Restfulie::Client::Feature::ThrowErrorRequest
   def execute(flow, request, env)
     result = flow.continue(request, env)
     if result.kind_of? Exception
       Restfulie::Common::Logger.logger.error(result)
-      raise Restfulie::Client::HTTP::Error::ServerNotAvailableError.new(request, Restfulie::Client::HTTP::Response.new(request.verb, request.path, 503, nil, {}), result )
+      response = Restfulie::Client::Feature::FakeResponse.new(503, "")
+      raise Restfulie::Client::HTTP::Error::ServerNotAvailableError.new(request, response, result )
     end
     case result.response.code
     when 100..299

data/lib/restfulie/client/feature/verb.rb

@@ -56,19 +56,16 @@ module Restfulie::Client::Feature::Verb
   # * <tt>path: '/posts'</tt>
   # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
   def get!(params = {})
-    @verb = :get
-    at query_string(params)
-    request :throw_error
-    request_flow 
+    request :throw_error_request
+    get params
   end
 
   # HEAD HTTP verb {Error}
   # * <tt>path: '/posts'</tt>
   # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
   def head!
-    @verb = :head
-    request :throw_error
-    request_flow 
+    request :throw_error_request
+    head
   end
 
   # POST HTTP verb {Error}
@@ -76,9 +73,8 @@ module Restfulie::Client::Feature::Verb
   # * <tt>payload: 'some text'</tt>
   # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
   def post!(payload, options = {:recipe => nil})
-    @verb = :post
-    request :throw_error
-    request_flow :body => payload
+    request :throw_error_request
+    post payload
   end
 
   # PATCH HTTP verb {Error}
@@ -86,9 +82,8 @@ module Restfulie::Client::Feature::Verb
   # * <tt>payload: 'some text'</tt>
   # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
   def patch!(payload)
-    @verb = :patch
-    request :throw_error
-    request_flow :body => payload
+    request :throw_error_request
+    patch payload
   end
 
   # PUT HTTP verb {Error}
@@ -96,18 +91,16 @@ module Restfulie::Client::Feature::Verb
   # * <tt>payload: 'some text'</tt>
   # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
   def put!(payload)
-    @verb = :put
-    request :throw_error
-    request_flow :body => payload
+    request :throw_error_request
+    put payload
   end
 
   # DELETE HTTP verb {Error}
   # * <tt>path: '/posts'</tt>
   # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
   def delete!
-    @verb = :delete
-    request :throw_error
-    request_flow 
+    request :throw_error_request
+    delete
   end
 
   protected

data/lib/restfulie/common.rb

@@ -2,7 +2,7 @@ require 'net/http'
 require 'uri'
 
 require 'rubygems'
-require 'tokamak'
+require 'hypertemplate'
 require 'medie'
 
 module Restfulie

data/lib/restfulie/server.rb

@@ -9,7 +9,7 @@ module Restfulie
   end
 end
 
-require 'restfulie/server/tokamak'
+require 'restfulie/server/hypertemplate'
 require 'restfulie/server/core_ext'
 
 if defined? ::ActionController

data/lib/restfulie/server/action_controller/base.rb

@@ -7,8 +7,6 @@ module Restfulie
           # Needs to require responder_legacy.rb
           base.responder = Restfulie::Server::ActionController::RestfulResponder
           base.extend(Restfulie::Server::ActionController::Base::ClassMethods)
-          # Atom representation is added by default
-          Restfulie::Server::ActionController::ParamsParser.register('application/atom+xml', Tokamak::Atom)
         end
 
         module ClassMethods

data/lib/restfulie/server/action_controller/restful_responder.rb

@@ -3,8 +3,8 @@ module Restfulie
     module ActionController
       class RestfulResponder < ::ActionController::Responder
         
-        include CacheableResponder
-        include CreatedResponder
+        include Trait::Cacheable
+        include Trait::Created
 
       end
     end

data/lib/restfulie/server/action_controller/trait/cacheable.rb

@@ -43,14 +43,11 @@ module Restfulie::Server::ActionController
   module Trait
     module Cacheable
       
-      CACHES = [::Expires.new, ::LastModifieds.new]
-      
       def to_format
-        headers = cache_control_headers
-        cached = CACHES.inject(false) do |cached, cache|
-          cached || cache.do_http_cache(self, headers)
-        end
-        if ::ActionController::Base.perform_caching && cached
+
+        cache_request()
+
+        if is_cached?
           set_public_cache_control(headers)
           controller.response.headers["Cache-Control"] = headers.join(', ')
           fresh = request.fresh?(controller.response)
@@ -63,9 +60,25 @@ module Restfulie::Server::ActionController
           super
         end
       end
-      
+
+      def caches
+        [::Expires.new, ::LastModifieds.new]
+      end
+
+
       private
-        
+
+      def cache_request
+        headers = cache_control_headers
+        cached = caches.inject(false) do |cached, cache|
+          cached || cache.do_http_cache(self, headers)
+        end
+      end
+
+      def is_cached?
+        ::ActionController::Base.perform_caching && cached
+      end
+
       def set_public_cache_control(headers)
         headers.delete("private")
         headers.delete("no-cache")

data/lib/restfulie/server/hypertemplate.rb

@@ -0,0 +1,3 @@
+if defined? ::ActionView and ::ActionController
+  require 'hypertemplate/hook/rails'
+end

data/lib/restfulie/version.rb

@@ -2,9 +2,9 @@ module Restfulie
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 0
-    TINY  = 0
+    TINY  = 3
 
-    STRING = [MAJOR, MINOR, TINY].join('.') + ".beta4"
+    STRING = [MAJOR, MINOR, TINY].join('.')
 
     # Restfulie's version
     def self.to_s

data/restfulie.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "restfulie/version"
+
+Gem::Specification.new do |s|
+	s.name        = "restfulie"
+	s.version     = Restfulie::VERSION
+	s.platform    = Gem::Platform::RUBY
+	s.authors     = ["Guilherme Silveira, Caue Guerra, Luis Cipriani, Everton Ribeiro, George Guimaraes, Paulo Ahagon, and many more!"]
+	s.email       = %q{guilherme.silveira@caelum.com.br}
+	s.homepage    = %q{http://restfulie.caelumobjects.com}
+	s.summary     = %q{Hypermedia aware resource based library in ruby (client side) and ruby on rails (server side).}
+	s.description = %q{restfulie}
+
+	s.rubyforge_project = "restfulie"
+
+	s.files         = `git ls-files`.split("\n")
+	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+	s.require_paths = ["lib"]
+
+	if s.respond_to? :specification_version then
+		current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+		s.specification_version = 3
+	end
+
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    s.add_runtime_dependency("nokogiri", [">= 1.4.2"])
+    s.add_runtime_dependency("json_pure", [">= 1.2.4"])
+    s.add_development_dependency("sqlite3-ruby")
+  else
+    s.add_dependency("nokogiri", [">= 1.4.2"])
+    s.add_dependency("json_pure", [">= 1.2.4"])
+    s.add_dependency("sqlite3-ruby")
+  end
+
+  s.add_dependency("rack-conneg")
+  s.add_dependency("sqlite3-ruby")
+  s.add_dependency('hypertemplate', "~> 1.2.0")
+  s.add_dependency('medie', "~> 1.0.0")
+  s.add_dependency('respondie', "~> 0.9.0")
+end