sinatra-rest 0.3.3

data/README.textile

@@ -0,0 +1,86 @@
+h1. Sinatra-REST
+
+Actually it's a set of templates to introduce RESTful routes in Sinatra. The 
+only thing for you to do is to provide the views. The routes and some 
+url helpers will be provided behind the scenes.
+
+
+h2. Installation
+
+Guess what!
+
+    sudo gem source --add http://gems.github.com
+    sudo gem install blindgaenger-sinatra-rest
+
+
+h2. Usage
+
+Of course you need to require the gem in your Sinatra application:
+
+    require 'rubygems'
+    require 'sinatra'
+    require 'sinatra/rest'
+
+It's very similar to defining routes in Sinatra (@get@, @post@, ...). But this 
+time you don't define the routes by yourself, but use the model's name for 
+convention.
+
+For example, if the model's class is called @Person@ you only need to add this 
+line:
+
+    rest Person
+
+Which will add the following RESTful routes to your application. (Note the 
+pluralization of @Person@ to the @/people/*@ routes.)
+
+* GET    /people
+* GET    /people/new
+* POST   /people
+* GET    /people/:id
+* GET    /people/:id/edit
+* PUT    /people/:id
+* DELETE /people/:id
+
+But the real benefit is, that these *routes define a restful standard behaviour* 
+on your model, *appropriate routing and redirecting* and *named url helpers*. 
+
+For instance, you can imagine the following code to be added for the @/people@ 
+and @/people/:id@ routes.
+
+<pre><code>
+# simply add this line
+
+rest Person, :renderer => :erb
+
+# and this is generated for you
+
+get '/people' do
+  @people = Person.all
+  erb :"people/index", options
+end
+
+put '/people/:id' do
+  @person = Person.find_by_id(params[:id])
+  redirect url_for_people_show(@person), 'person updated'
+end
+
+# further restful routes for Person ...
+</code></pre>
+
+That's only half the truth! The routes are generated dynamically, so all 
+defaults can be overridden (the behaviour, after/before callbacks, used renderer, 
+which routes are added).
+
+For more details and options, please have a look at the pages in the  
+"Sinatra-REST Wiki":http://github.com/blindgaenger/sinatra-rest/wikis on Github.
+
+h2. Links
+
+* "Documentation @ rdoc.info":http://rdoc.info/projects/blindgaenger/sinatra-rest
+* "Continuous Integration @ RunCodeRun":http://runcoderun.com/blindgaenger/sinatra-rest
+
+h2. Contact
+
+You can contact me via mail at blindgaenger at gmail dot com, or leave me a 
+message on my "Github profile":http://github.com/blindgaenger.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'spec/rake/spectask'
+
+task :default => :test
+
+desc "Run tests"
+Spec::Rake::SpecTask.new :test do |t|
+  t.spec_opts = %w(--format specdoc --color) #--backtrace
+  t.spec_files = FileList['test/*_spec.rb']
+end
+

data/lib/sinatra/rest.rb

@@ -0,0 +1,210 @@
+require 'sinatra/base'
+require 'english/inflect'
+
+libdir = File.dirname(__FILE__) + "/rest"
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+require 'adapters'
+require 'yaml'
+
+module Sinatra
+
+  module REST
+
+    #
+    # adds restful routes and url helpers for the model
+    def rest(model_class, options={}, &block)
+      parse_args(model_class, options)
+      read_config('rest/rest.yaml')
+
+      # register model specific helpers
+      helpers generate_helpers
+      
+      # create an own module, to override the template with custom methods
+      # this way, you can still use #super# in the overridden methods
+      controller = generate_controller
+      if block_given?
+        custom = CustomController.new(@plural)
+        custom.instance_eval &block
+        custom.module.send :include, controller
+        controller = custom.module
+      end
+      helpers controller
+      
+      # register routes as DSL extension
+      instance_eval generate_routes
+    end
+
+  protected
+
+    ROUTES = {
+      :all       => [:index, :new, :create, :show, :edit, :update, :destroy],
+      :readable  => [:index, :show],
+      :writeable => [:index, :show, :create, :update, :destroy],      
+      :editable  => [:index, :show, :create, :update, :destroy, :new, :edit],                        
+    }
+
+    def parse_args(model_class, options)
+      @model, @singular, @plural = conjugate(model_class)
+      @renderer = (options.delete(:renderer) || :haml).to_s
+      @route_flags = parse_routes(options.delete(:routes) || :all)
+    end
+    
+    def parse_routes(routes)
+      routes = [*routes].map {|route| ROUTES[route] || route}.flatten.uniq
+      # keep the order of :all routes
+      ROUTES[:all].select{|route| routes.include? route}
+    end
+    
+    def read_config(filename)
+      file = File.read(File.join(File.dirname(__FILE__), filename))
+      @config = YAML.load file
+    end
+
+    #
+    # creates the necessary forms of the model name
+    # pretty much like ActiveSupport's inflections, but don't like to depend on
+    def conjugate(model_class)
+      model = model_class.to_s.match(/(\w+)$/)[0]
+      singular = model.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      return model, singular, singular.pluralize
+    end
+
+    def replace_variables(t, route=nil)
+      if route
+        t.gsub!('NAME', route.to_s)
+        t.gsub!('VERB', @config[route][:verb].downcase)
+        t.gsub!('URL', @config[route][:url])
+        t.gsub!('CONTROL', @config[route][:control])
+        t.gsub!('RENDER', @config[route][:render]) 
+      end    
+      t.gsub!(/PLURAL/, @plural)
+      t.gsub!(/SINGULAR/, @singular)
+      t.gsub!(/MODEL/, @model)
+      t.gsub!(/RENDERER/, @renderer)
+      t    
+    end
+
+    def generate_routes
+      @route_flags.map{|r| route_template(r)}.join("\n\n")
+    end
+    
+    def route_template(route)
+      t = <<-RUBY
+        VERB 'URL' do
+          PLURAL_before :NAME
+          PLURAL_NAME
+          PLURAL_after :NAME   
+          RENDER
+        end
+      RUBY
+      replace_variables(t, route)
+    end
+
+    def generate_helpers
+      m = Module.new
+      @route_flags.each {|r|
+        m.module_eval helpers_template(r)
+      }
+      m
+    end
+    
+    def helpers_template(route)
+      t = <<-RUBY
+        def url_for_PLURAL_NAME(model=nil)
+          "URL"
+        end
+      RUBY
+      helper_route = @config[route][:url].gsub(':id', '#{escape_model_id(model)}')
+      t.gsub!('URL', helper_route)
+      replace_variables(t, route)
+    end
+
+    def generate_controller
+      m = Module.new
+      t = <<-RUBY
+        def PLURAL_before(name); end
+        def PLURAL_after(name); end
+      RUBY
+      m.module_eval replace_variables(t)
+
+      @route_flags.each {|route|
+        m.module_eval controller_template(route)
+      }
+      m
+    end
+    
+    def controller_template(route)
+      t = <<-RUBY
+        def PLURAL_NAME(options=params)
+          mp = filter_model_params(options)
+          CONTROL
+        end
+      RUBY
+      replace_variables(t, route)
+    end
+    
+    #
+    # model unspecific helpers, will be included once
+    module Helpers
+      # for example _method will be removed
+      def filter_model_params(params)
+        params.reject {|k, v| k =~ /^_/}
+      end
+    
+      def escape_model_id(model)
+        if model.nil?
+          raise 'can not generate url for nil'
+        elsif model.kind_of?(String)
+          Rack::Utils.escape(model)
+        elsif model.kind_of?(Fixnum)
+          model
+        elsif model.id.kind_of? String
+          Rack::Utils.escape(model.id)
+        else
+          model.id
+        end
+      end
+
+      def call_model_method(model_class, name, options={})
+        method = model_class.method(name)
+        if options.nil? || method.arity == 0
+          Kernel.warn "warning: calling #{model_class.to_s}##{name} with args, although it doesn't take args" if options
+          method.call
+        else
+          method.call(options)
+        end
+      end
+    end
+
+    #
+    # used as context to evaluate the controller's module
+    class CustomController
+      attr_reader :module
+
+      def initialize(prefix)
+        @prefix = prefix
+        @module = Module.new
+      end
+
+      def before(options={}, &block)  prefix :before,  &block; end
+      def after(options={}, &block)   prefix :after,   &block; end      
+      def index(options={}, &block)   prefix :index,   &block; end
+      def new(options={}, &block)     prefix :new,     &block; end
+      def create(options={}, &block)  prefix :create,  &block; end
+      def show(options={}, &block)    prefix :show,    &block; end
+      def edit(options={}, &block)    prefix :edit,    &block; end
+      def update(options={}, &block)  prefix :update,  &block; end
+      def destroy(options={}, &block) prefix :destroy, &block; end                        
+
+    private 
+      def prefix(name, &block)
+        @module.send :define_method, "#{@prefix}_#{name}", &block if block_given?
+      end
+    end
+
+  end # REST
+
+  helpers REST::Helpers
+  register REST
+
+end # Sinatra

data/lib/sinatra/rest/adapters.rb

@@ -0,0 +1,37 @@
+module Stone
+  module Resource
+    def find_by_id(id)
+      get(id)
+    end
+    
+    def delete(id)
+      model = self.find_by_id(id)
+      model.destroy if model
+    end
+  end
+end
+
+module DataMapper
+  module Model
+    def find_by_id(id)
+      get(id)
+    end
+    
+    def delete(id)
+      model = self.find_by_id(id)
+      model.destroy if model
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    class << self
+      def find_by_id(id)
+        find(id)
+      end
+    end
+  end
+end
+
+

data/lib/sinatra/rest/rest.yaml

@@ -0,0 +1,67 @@
+--- 
+:index:
+  :verb: GET
+  :url: /PLURAL
+  :control: |-
+    @PLURAL = call_model_method(MODEL, :all, mp)
+  :render: |-
+    RENDERER :'PLURAL/index', options  
+
+:new:
+  :verb: GET
+  :url: /PLURAL/new
+  :control: |-
+    @SINGULAR = call_model_method(MODEL, :new, mp)
+  :render: |-
+    RENDERER :'PLURAL/new', options
+
+:create:
+  :verb: POST
+  :url: /PLURAL
+  :control: |-
+    @SINGULAR = call_model_method(MODEL, :new, mp)
+    @SINGULAR.save
+  :render: |-
+    redirect url_for_PLURAL_show(@SINGULAR), 'SINGULAR created'
+
+:show:
+  :verb: GET
+  :url: /PLURAL/:id
+  :control: |-
+    @SINGULAR = call_model_method(MODEL, :find_by_id, mp[:id])
+  :render: |-
+    if @SINGULAR.nil?
+      throw :halt, [404, 'SINGULAR not found']
+    else
+      RENDERER :'PLURAL/show', options
+    end
+
+:edit:
+  :verb: GET
+  :url: /PLURAL/:id/edit
+  :control: |-
+    @SINGULAR = call_model_method(MODEL, :find_by_id, mp[:id])
+  :render: |-
+    RENDERER :'PLURAL/edit', options
+
+:update:
+  :verb: PUT
+  :url: /PLURAL/:id
+  :control: |-
+    @SINGULAR = call_model_method(MODEL, :find_by_id, mp[:id])
+    @SINGULAR.update_attributes(mp) unless @SINGULAR.nil?
+  :render: |-
+    if @SINGULAR.nil?
+      throw :halt, [404, 'SINGULAR not found']
+    else
+      redirect url_for_PLURAL_show(@SINGULAR), 'SINGULAR updated'
+    end
+
+:destroy:
+  :verb: DELETE
+  :url: /PLURAL/:id
+  :control: |-
+    call_model_method(MODEL, :delete, mp[:id])
+  :render: |-
+    redirect url_for_PLURAL_index, 'SINGULAR destroyed'
+

data/test/call_order_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'call order' do
+
+  def called_routes
+    @app.call_order.map {|r, m| r}.uniq
+  end
+
+  def called_methods
+    @app.call_order.map {|r, m| m}
+  end
+
+  before(:each) do
+    mock_app {
+      configure do
+        set :call_order, []
+      end
+    
+      rest Person do
+        before do |route|
+          options.call_order << [route, :before]
+          super
+        end
+
+        after do |route|
+          options.call_order << [route, :after]
+          super
+        end
+
+        index do
+          options.call_order << [:index, :index]
+          super
+        end
+
+        new do
+          options.call_order << [:new, :new]
+          super
+        end
+
+        create do
+          options.call_order << [:create, :create]
+          super
+        end
+
+        show do
+          options.call_order << [:show, :show]
+          super
+        end
+
+        edit do
+          options.call_order << [:edit, :edit]
+          super
+        end
+
+        update do
+          options.call_order << [:update, :update]
+          super
+        end
+
+        destroy do
+          options.call_order << [:destroy, :destroy]
+          super
+        end
+      end
+    }
+  end
+
+  it 'should call :index in the right order' do
+    index '/people'
+    called_methods.should == [:before, :index, :after]
+    called_routes.should  == [:index]
+  end
+
+  it 'should call :new in the right order' do
+    new '/people/new'
+    called_methods.should == [:before, :new, :after]
+    called_routes.should  == [:new]
+  end
+
+  it 'should call :create in the right order' do
+    create('/people', :name => 'initial name')
+    called_methods.should == [:before, :create, :after]
+    called_routes.should  == [:create]
+  end
+
+  it 'should call :show in the right order' do
+    show '/people/1'
+    called_methods.should == [:before, :show, :after]
+    called_routes.should  == [:show]    
+  end
+
+  it 'should call :edit in the right order' do
+    edit '/people/1/edit'
+    called_methods.should == [:before, :edit, :after]
+    called_routes.should  == [:edit]    
+  end
+
+  it 'should call :update in the right order' do
+    update '/people/1', :name => 'new name'
+    called_methods.should == [:before, :update, :after]
+    called_routes.should  == [:update]    
+  end
+
+  it 'should call :destroy in the right order' do
+    destroy '/people/1'
+    called_methods.should == [:before, :destroy, :after]
+    called_routes.should  == [:destroy]    
+  end
+
+end
+

data/test/crud_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'some use cases' do
+
+  def total_models
+    Person.all.size
+  end
+
+  require "rexml/document"
+  def doc(xml)
+    REXML::Document.new(xml.gsub(/>\s+</, '><').strip)
+  end
+
+  before(:each) do
+    Person.reset!
+    mock_rest Person
+  end
+
+  it 'should list all persons' do
+    get '/people'
+    normalized_response.should == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+    total_models.should == 3
+  end
+
+  it 'should create a new person' do
+    get '/people'
+    normalized_response.should == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+    total_models.should == 3
+
+    get '/people/new'
+    normalized_response.should == [200, '<person><id></id><name></name></person>']
+    total_models.should == 3
+
+    post '/people', {:name => 'four'}
+    normalized_response.should == [302, 'person created']
+    total_models.should == 4
+
+    get '/people'
+    normalized_response.should == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person><person><id>4</id></person></people>']
+    total_models.should == 4
+  end
+
+  it 'should read all persons' do
+    get '/people'
+
+    el_people = doc(body).elements.to_a("*/person/id")
+    el_people.size.should == 3
+    total_models.should == 3
+
+    get "/people/#{el_people[0].text}"
+    normalized_response.should == [200, '<person><id>1</id><name>one</name></person>']
+    total_models.should == 3
+
+    get "/people/#{el_people[1].text}"
+    normalized_response.should == [200, '<person><id>2</id><name>two</name></person>']
+    total_models.should == 3
+
+    get "/people/#{el_people[2].text}"
+    normalized_response.should == [200, '<person><id>3</id><name>three</name></person>']
+    total_models.should == 3
+    
+    get "/people/99"
+    normalized_response.should == [404, 'route not found']
+    total_models.should == 3
+  end
+
+  it 'should update a person' do
+    get '/people/2'
+    normalized_response.should == [200, '<person><id>2</id><name>two</name></person>']
+    total_models.should == 3
+
+    put '/people/2', {:name => 'tomorrow'}
+    normalized_response.should == [302, 'person updated']
+    total_models.should == 3
+
+    get '/people/2'
+    normalized_response.should == [200, '<person><id>2</id><name>tomorrow</name></person>']
+    total_models.should == 3
+  end
+
+  it 'should destroy a person' do
+    get '/people'
+    normalized_response.should == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+    total_models.should == 3
+
+    delete '/people/2'
+    normalized_response.should == [302, 'person destroyed']
+    total_models.should == 2
+
+    get '/people'
+    normalized_response.should == [200, '<people><person><id>1</id></person><person><id>3</id></person></people>']
+    total_models.should == 2
+
+    get '/people/2'
+    normalized_response.should == [404, 'route not found']
+    total_models.should == 2
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,153 @@
+require 'spec'
+require 'spec/interop/test'
+require 'sinatra/test'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'sinatra/base'
+require 'sinatra/rest'
+
+Sinatra::Default.set(:environment, :test)
+Test::Unit::TestCase.send :include, Sinatra::Test
+
+#
+# Sets up a Sinatra::Base subclass defined with the block
+# given. Used in setup or individual spec methods to establish
+# the application.
+def mock_app(&block)
+  base = Sinatra::Application
+  @app = Sinatra.new(base) do
+    set :views, File.dirname(__FILE__) + '/views'
+          
+    not_found do
+      'route not found'
+    end
+  end
+  @app.instance_eval(&block) if block_given?
+end
+
+#
+# sets rest in a sinatra instance
+# and returns the block's result, if a block is given
+def mock_rest(model, options={}, &block)
+  mock_app do
+    rest model, options
+
+    self.new.instance_eval do
+      @app.instance_eval(&block) if block_given?
+    end
+  end
+end
+
+
+#
+# normalize for easier testing
+def normalized_response
+  return status, body.gsub(/>\s+</, '><').strip
+end
+
+# index GET /models
+def index(url)
+  get url
+  normalized_response
+end
+
+# new GET /models/new
+def new(url)
+  get url
+  normalized_response
+end
+
+# create POST /models
+def create(url, params={})
+  post url, params
+  normalized_response
+end
+
+# show GET /models/1
+def show(url)
+  get url
+  normalized_response
+end
+
+# edit GET /models/1/edit
+def edit(url)
+  get url
+  normalized_response
+end
+
+# update PUT /models/1
+def update(url, params={})
+  put url, params
+  normalized_response
+end
+
+# destroy DELETE /models/1
+def destroy(url)
+  delete url
+  normalized_response
+end
+
+
+##
+## kind of a 'minimal model'
+class Person
+  attr_accessor :id
+  attr_accessor :name
+
+  def initialize(*args)
+    #puts "new #{args.inspect}"
+    if args.size == 0
+      @id = nil
+      @name = nil
+    elsif args.size == 2
+      @id = args[0].to_i
+      @name = args[1]
+    else args.size == 1
+      update_attributes(args[0])
+    end
+  end
+
+  def save
+    #puts "save #{@id}"
+    @@people << self
+    self.id = @@people.size
+  end
+
+  def update_attributes(hash)
+    #puts "update_attributes #{hash.inspect}"
+    unless hash.empty?
+      @id = hash['id'].to_i if hash.include?('id')
+      @name = hash['name'] if hash.include?('name')
+    end
+  end
+
+  def self.delete(id)
+    #puts "delete #{id}"
+    @@people.delete_if {|person| person.id == id.to_i}
+  end
+
+  @@people = []
+
+  def self.all(criteria={})
+    #puts 'all'
+    return @@people
+  end
+
+  def self.find_by_id(id)
+    #puts "find_by_id #{id}"
+    all.find {|f| f.id == id.to_i}
+  end
+
+  def self.clear!
+    @@people = []
+  end
+
+  def self.reset!
+    clear!
+    Person.new(1, 'one').save
+    Person.new(2, 'two').save
+    Person.new(3, 'three').save
+  end
+end
+
+

data/test/helpers_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'url helpers' do
+
+  it 'should generate the correct urls for the model' do
+    mock_rest Person do
+      person = Person.new(99, 'foo')
+      url_for_people_create.should == '/people'
+      url_for_people_destroy(person).should == '/people/99'
+      url_for_people_edit(person).should == '/people/99/edit'
+      url_for_people_index.should == '/people'
+      url_for_people_new.should == '/people/new'
+      url_for_people_show(person).should == '/people/99'
+      url_for_people_update(person).should == '/people/99'
+    end
+  end
+
+  it 'should add :all helpers' do
+    mock_rest(Person) { methods.grep(/^url_for_people_/).sort }.should == [
+          "url_for_people_create",
+          "url_for_people_destroy",
+          "url_for_people_edit",
+          "url_for_people_index",
+          "url_for_people_new",
+          "url_for_people_show",
+          "url_for_people_update",
+    ]
+  end
+
+  it 'should add :readable helpers' do
+      mock_rest(Person, :routes => :readable) { methods.grep(/^url_for_people_/).sort }.should == [
+          "url_for_people_index",
+          "url_for_people_show",
+      ]
+  end
+
+  it 'should add :writeable helpers' do
+      mock_rest(Person, :routes => :writeable) { methods.grep(/^url_for_people_/).sort }.should == [
+          "url_for_people_create",
+          "url_for_people_destroy",
+          "url_for_people_index",
+          "url_for_people_show",
+          "url_for_people_update",
+      ]
+  end
+
+  it 'should add :editable helpers' do
+      mock_rest(Person, :routes => :editable) { methods.grep(/^url_for_people_/).sort }.should == [
+          "url_for_people_create",
+          "url_for_people_destroy",
+          "url_for_people_edit",
+          "url_for_people_index",
+          "url_for_people_new",
+          "url_for_people_show",
+          "url_for_people_update",
+      ]
+  end
+
+  it 'should add helpers by name' do
+      mock_rest(Person, :routes => [:new, :create, :destroy]) { methods.grep(/^url_for_people_/).sort }.should == [
+          "url_for_people_create",
+          "url_for_people_destroy",
+          "url_for_people_new",
+      ]
+  end
+  
+  it 'should add helpers by mixing aliases and names' do
+      mock_rest(Person, :routes => [:readable, :create, :destroy]) { methods.grep(/^url_for_people_/).sort }.should == [
+          "url_for_people_create",
+          "url_for_people_destroy",
+          "url_for_people_index",
+          "url_for_people_show",          
+      ]
+  end
+
+end

data/test/inflection_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'model inflection' do
+
+  def conjugate(model)
+    mock_app {
+      include Sinatra::REST
+      conjugate(model)
+    }
+  end
+
+  it "should conjugate a simple model name" do
+    conjugate(Person).should == %w(Person person people)
+  end
+
+  it "should conjugate a String as model name" do
+    conjugate('Person').should == %w(Person person people)  
+  end
+
+  it "should conjugate a model name in camel cases" do
+    conjugate('SomePerson').should == %w(SomePerson some_person some_people)
+  end
+
+  it "should conjugate a model name without module" do
+    conjugate('MyModule::ModulePerson').should == %w(ModulePerson module_person module_people)
+  end
+
+end
+

data/test/routes_spec.rb

@@ -0,0 +1,112 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'routes' do
+
+  before(:each) do
+    Person.reset!
+  end
+
+  describe 'one by one' do
+
+    before(:each) do
+      mock_rest Person    
+    end
+
+    it 'should list all people on index by their id' do
+      index('/people').should == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+    end
+
+    it 'should prepare an empty item on new' do
+      new('/people/new').should == [200, '<person><id></id><name></name></person>']
+    end
+
+    it 'should create an item on post' do
+      create('/people', :name => 'new resource').should == [302, 'person created']
+    end
+
+    it 'should show an item on get' do
+      show('/people/1').should == [200, '<person><id>1</id><name>one</name></person>']
+    end
+
+    it 'should get the item for editing' do
+      edit('/people/1/edit').should == [200, '<person><id>1</id><name>one</name></person>']
+    end
+
+    it 'should update an item on put' do
+      update('/people/1', :name => 'another name').should == [302, 'person updated']
+    end
+
+    it 'should destroy an item on delete' do
+      destroy('/people/1').should == [302, 'person destroyed']
+    end
+
+  end
+
+  describe 'options' do
+
+    it 'should add :all routes' do
+      mock_rest Person
+
+      index('/people').should                         == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+      new('/people/new').should                       == [200, '<person><id></id><name></name></person>']
+      create('/people', :name => 'new person').should == [302, "person created"]
+      show('/people/1').should                        == [200, '<person><id>1</id><name>one</name></person>']
+      edit('/people/1/edit').should                   == [200, "<person><id>1</id><name>one</name></person>"]
+      update('/people/1', :name => 'new name').should == [302, "person updated"]
+      destroy('/people/1').should                     == [302, "person destroyed"]
+    end
+
+    it 'should add :readable routes' do
+      mock_rest Person, :routes => :readable
+
+      index('/people').should                         == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+      show('/people/1').should                        == [200, '<person><id>1</id><name>one</name></person>']
+      
+      new('/people/new').should                       == [404, "route not found"]
+      create('/people', :name => 'new person').should == [404, "route not found"]
+      edit('/people/1/edit').should                   == [404, "route not found"]
+      update('/people/1', :name => 'new name').should == [404, "route not found"]
+      destroy('/people/1').should                     == [404, "route not found"]
+    end
+
+    it 'should add :writeable routes' do
+      mock_rest Person, :routes => :writeable
+
+      index('/people').should                         == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+      show('/people/1').should                        == [200, '<person><id>1</id><name>one</name></person>']
+      create('/people', :name => 'new person').should == [302, "person created"]
+      update('/people/1', :name => 'new name').should == [302, "person updated"]
+      destroy('/people/1').should                     == [302, "person destroyed"]
+
+      new('/people/new').should                       == [404, "route not found"]
+      edit('/people/1/edit').should                   == [404, "route not found"]
+    end
+
+    it 'should add :editable routes' do
+      mock_rest Person, :routes => :editable
+
+      index('/people').should                         == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+      new('/people/new').should                       == [200, '<person><id></id><name></name></person>']
+      create('/people', :name => 'new person').should == [302, "person created"]
+      show('/people/1').should                        == [200, '<person><id>1</id><name>one</name></person>']
+      edit('/people/1/edit').should                   == [200, "<person><id>1</id><name>one</name></person>"]
+      update('/people/1', :name => 'new name').should == [302, "person updated"]
+      destroy('/people/1').should                     == [302, "person destroyed"]
+    end
+
+    it 'should add routes by name' do
+      mock_rest Person, :routes => [:readable, :new, :create]
+
+      index('/people').should                         == [200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>']
+      show('/people/1').should                        == [200, '<person><id>1</id><name>one</name></person>']
+      new('/people/new').should                       == [200, '<person><id></id><name></name></person>']
+      create('/people', :name => 'new person').should == [302, "person created"]
+      
+      edit('/people/1/edit').should                   == [404, "route not found"]
+      update('/people/1', :name => 'new name').should == [404, "route not found"]
+      destroy('/people/1').should                     == [404, "route not found"]
+    end
+
+  end
+
+end

data/test/test_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'test helpers' do
+
+  it 'should work with mock_app' do
+    Person.clear!
+    mock_app {
+      rest Person
+    }
+    index('/people').should == [200, '<people></people>']
+  end
+
+  it 'should work with mock_rest' do
+    Person.clear!
+    mock_rest Person
+    index('/people').should == [200, '<people></people>']
+  end
+
+end

data/test/views/people/edit.haml

@@ -0,0 +1,4 @@
+%person
+  %id= @person.id
+  %name= @person.name
+

data/test/views/people/index.haml

@@ -0,0 +1,7 @@
+%people
+  - @people.each do |person|
+    %person
+      %id= person.id
+
+
+

data/test/views/people/new.haml

@@ -0,0 +1,4 @@
+%person
+  %id= @person.id
+  %name= @person.name
+

data/test/views/people/show.haml

@@ -0,0 +1,4 @@
+%person
+  %id= @person.id
+  %name= @person.name
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-rest
+version: !ruby/object:Gem::Version 
+  version: 0.3.3
+platform: ruby
+authors: 
+- blindgaenger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-25 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.0.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: english
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.1
+    version: 
+description: 
+email: blindgaenger@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- README.textile
+- lib/sinatra/rest.rb
+- lib/sinatra/rest/adapters.rb
+- lib/sinatra/rest/rest.yaml
+- test/call_order_spec.rb
+- test/crud_spec.rb
+- test/helper.rb
+- test/helpers_spec.rb
+- test/inflection_spec.rb
+- test/routes_spec.rb
+- test/test_spec.rb
+- test/views/people/edit.haml
+- test/views/people/index.haml
+- test/views/people/new.haml
+- test/views/people/show.haml
+has_rdoc: true
+homepage: http://github.com/blindgaenger/sinatra-rest
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Generates RESTful routes for the models of a Sinatra application (ActiveRecord, DataMapper, Stone)
+test_files: []
+