blindgaenger-sinatra-rest 0.2 → 0.3.0

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

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: blindgaenger-sinatra-rest
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: 0.3.0
 platform: ruby
 authors: 
 - blindgaenger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-28 00:00:00 -08:00
+date: 2009-04-10 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,12 +43,22 @@ extra_rdoc_files: []
 files: 
 - Rakefile
 - README.textile
-- lib/rest.rb
-- spec/rest_spec.rb
-- spec/views/people/edit.erb
-- spec/views/people/index.erb
-- spec/views/people/new.erb
-- spec/views/people/show.erb
+- lib/sinatra/rest.rb
+- lib/sinatra/rest/adapters.rb
+- lib/sinatra/rest/controller.tpl.rb
+- lib/sinatra/rest/helpers.tpl.rb
+- lib/sinatra/rest/routes.tpl.rb
+- 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: "false"
 homepage: http://github.com/blindgaenger/sinatra-rest
 post_install_message: 
@@ -74,6 +84,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Generates RESTful routes for the models of a Sinatra application
+summary: Generates RESTful routes for the models of a Sinatra application (ActiveRecord, DataMapper, Stone)
 test_files: []
 

data/lib/rest.rb

@@ -1,278 +0,0 @@
-require 'english/inflect'
-require 'cgi'
-
-module Stone
-  module Resource
-    def find_by_id(id)
-      get(id)
-    end
-  end
-end
-
-module DataMapper
-  module Model
-    def find_by_id(id)
-      get(id)
-    end
-  end
-end
-
-module ActiveRecord
-  module Base
-    def find_by_id(id)
-      first(id)
-    end
-  end
-end
-
-module Sinatra
-  module REST
-
-    #
-    # adds restful routes and url helpers for the model
-    def rest(model_class, options={}, &block)
-      model, singular, plural = conjugate(model_class)
-
-      renderer = options.delete(:renderer)
-      renderer ||= :haml
-
-      # @false@ will remove the @POST@, @PUT@ and @DELETE@ routes
-      # by dfault this is enabled
-      # :editable => true
-      editable = options.delete(:editable)
-      editable = true if editable.nil?
-
-      # @true@ will add the @/models/new@ and @/models/edit@ routes
-      # by default this is disabled
-      # :inputable => false
-      inputable = options.delete(:inputable)
-      inputable = true if inputable.nil?
-
-
-      # add some url_for_* helpers
-      Sinatra::Default.class_eval <<-XXX
-        public
-
-        # index GET /models
-        def url_for_#{plural}_index
-          '/#{plural}'
-        end
-
-        # new GET /models/new
-        if editable && inputable
-          def url_for_#{plural}_new
-            '/#{plural}/new'
-          end
-        end
-
-        # create POST /models
-        if editable
-          def url_for_#{plural}_create
-            '/#{plural}'
-          end
-        end
-
-        # show GET /models/1
-        def url_for_#{plural}_show(model)
-          "/#{plural}/\#{escape_model_id(model)}"
-        end
-
-        # edit GET /models/1/edit
-        if editable && inputable
-          def url_for_#{plural}_edit(model)
-            "/#{plural}/\#{escape_model_id(model)}/edit"
-          end
-        end
-
-        # update PUT /models/1
-        if editable
-          def url_for_#{plural}_update(model)
-            "/#{plural}/\#{escape_model_id(model)}"
-          end
-        end
-
-        # destroy DELETE /models/1
-        if editable
-          def url_for_#{plural}_destroy(model)
-            "/#{plural}/\#{escape_model_id(model)}"
-          end
-        end
-
-        private
-
-        def escape_model_id(model)
-          if model.nil?
-            raise 'can not generate url for nil'
-          elsif model.kind_of?(String)
-            CGI.escape(model)
-          elsif model.kind_of?(Fixnum)
-            model
-          elsif model.id.kind_of? String
-            CGI.escape(model.id)
-          else
-            model.id
-          end
-        end
-
-        public
-      XXX
-
-      # create an own module and fill it with the template
-      controller_template = Module.new
-      controller_template.class_eval <<-XXX
-        def call(name)
-          before name
-          send name
-          after name
-        end
-
-        def after(name)
-          # should be overridden
-        end
-
-        def before(name)
-          # should be overridden
-        end
-
-
-        # index GET /models
-        def index
-          @#{plural} = #{model}.all
-        end
-
-        # new GET /models/new
-        if editable && inputable
-          def new
-            @#{singular} = #{model}.new
-          end
-        end
-
-        # create POST /models
-        if editable
-          def create
-            @#{singular} = #{model}.new(params)
-            @#{singular}.save
-          end
-        end
-
-        # show GET /models/1
-        def show
-          @#{singular} = #{model}.find_by_id(params[:id])
-        end
-
-        # edit GET /models/1/edit
-        if editable && inputable
-          def edit
-            @#{singular} = #{model}.find_by_id(params[:id])
-          end
-        end
-
-        # update PUT /models/1
-        if editable
-          def update
-            @#{singular} = #{model}.find_by_id(params[:id])
-            @#{singular}.update_attributes(params)
-          end
-        end
-
-        # destroy DELETE /models/1
-        if editable
-          def destroy
-            #{model}.delete(params[:id])
-          end
-        end
-      XXX
-
-      # create an own module, to override the template with custom methods
-      # this way, you can still use #super# in the overridden methods
-      if block_given?
-        controller_custom = Module.new &block
-      end
-
-      # create the restful routes
-      Sinatra::Application.instance_eval <<-XXX
-        # add the correct modules to the EventContext
-        # use a metaclass so it isn't included again next time
-        before do
-          if request.path_info =~ /^\\/#{plural}\\b/
-            metaclass = class << self; self; end
-            metaclass.send(:include, controller_template)
-            metaclass.send(:include, controller_custom) if controller_custom
-          end
-        end
-
-        # index GET /models
-        get '/#{plural}' do
-          call :index
-          #{renderer.to_s} :"#{plural}/index", options
-        end
-
-        # new GET /models/new
-        if editable && inputable
-          get '/#{plural}/new' do
-            call :new
-            #{renderer.to_s} :"#{plural}/new", options
-          end
-        end
-
-        # create POST /models
-        if editable
-          post '/#{plural}' do
-            call :create
-            redirect url_for_#{plural}_show(@#{singular}), '#{singular} created'
-          end
-        end
-
-        # show GET /models/1
-        get '/#{plural}/:id' do
-          call :show
-          if @#{singular}.nil?
-            throw :halt, [404, '#{singular} not found']
-          else
-            #{renderer.to_s} :"#{plural}/show", options
-          end
-        end
-
-        # edit GET /models/1/edit
-        if editable && inputable
-          get '/#{plural}/:id/edit' do
-            call :edit
-            #{renderer.to_s} :"#{plural}/edit", options
-          end
-        end
-
-        # update PUT /models/1
-        if editable
-          put '/#{plural}/:id' do
-            call :update
-            redirect url_for_#{plural}_show(@#{singular}), '#{singular} updated'
-          end
-        end
-
-        # destroy DELETE /models/1
-        if editable
-          delete '/#{plural}/:id' do
-            call :destroy
-            redirect url_for_#{plural}_index, '#{singular} deleted'
-          end
-        end
-      XXX
-
-    end
-
-  protected
-    #
-    # 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
-
-  end # REST
-end # Sinatra
-
-include Sinatra::REST
-
-

data/spec/rest_spec.rb

@@ -1,448 +0,0 @@
-require 'rubygems'
-require 'spec'
-require 'sinatra'
-require 'sinatra/test/rspec'
-require 'lib/rest'
-require "rexml/document"
-require 'ruby-debug'
-
-#
-# 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 = nil
-
-  def self.all
-    #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.reset!
-    #puts 'reset!'
-    @@people = [
-      Person.new(1, 'one'),
-      Person.new(2, 'two'),
-      Person.new(3, 'three')
-    ]
-  end
-end
-
-
-def doc(xml)
-  REXML::Document.new(xml.gsub(/>\s+</, '><').strip)
-end
-
-def response_should_be(status, body)
-  @response.status.should == status
-  doc(@response.body).to_s.should == body
-end
-
-def model_should_be(size)
-  Person.all.size.should == size
-end
-
-def call_order_should_be(order, &block)
-  Person.call_order = []
-  block.call
-  Person.call_order.map {|c| c[:method]}.should == order
-end
-
-def called_should_be(name, &block)
-  Person.call_order = []
-  block.call
-  called = Person.call_order.map {|c| c[:called]}
-  called.should_not be_nil
-  called.each {|c| c.should == name }
-end
-
-
-describe Sinatra::REST do
-
-  describe 'as inflection generator' do
-    it "should conjugate a simple model name" do
-      Sinatra::REST.conjugate(Person).should eql(%w(Person person people))
-    end
-
-    it "should conjugate a String as model name" do
-      Sinatra::REST.conjugate('Person').should eql(%w(Person person people))
-    end
-
-    it "should conjugate a model name in camel cases" do
-      Sinatra::REST.conjugate('SomePerson').should eql(%w(SomePerson some_person some_people))
-    end
-
-    it "should conjugate a model name without module" do
-      Sinatra::REST.conjugate('MyModule::ModulePerson').should eql(%w(ModulePerson module_person module_people))
-    end
-  end
-
-
-  describe 'as route generator' do
-
-    before(:each) do
-      Sinatra.application = nil
-      @app = Sinatra.application
-
-      response_mock = mock "Response"
-      response_mock.should_receive(:"body=").with(nil).and_return(nil)
-      @context = Sinatra::EventContext.new(nil, response_mock, nil)
-    end
-
-
-    it 'should not add editable url_for_* helpers' do
-      rest Person, :editable => false
-
-      methods = Sinatra::EventContext.instance_methods.grep /^url_for_people_/
-      methods.size.should == 2
-
-      @person = Person.new
-      @person.id = 99
-
-      @context.url_for_people_index.should == '/people'
-      @context.url_for_people_show(@person).should == '/people/99'
-    end
-
-    it 'should not add editable restful routes' do
-      @app.events.clear
-      rest Person, :editable => false
-      @app.events[:get].map {|r| r.path}.should == ["/people", "/people/:id"]
-      @app.events[:post].map {|r| r.path}.should == []
-      @app.events[:put].map {|r| r.path}.should == []
-      @app.events[:delete].map {|r| r.path}.should == []
-    end
-
-
-    it 'should not add inputable url_for_* helpers' do
-      rest Person, :inputable => false
-
-      methods = Sinatra::EventContext.instance_methods.grep /^url_for_people_/
-      methods.size.should == 5
-
-      @person = Person.new
-      @person.id = 99
-
-      @context.url_for_people_index.should == '/people'
-      @context.url_for_people_create.should == '/people'
-      @context.url_for_people_show(@person).should == '/people/99'
-      @context.url_for_people_update(@person).should == '/people/99'
-      @context.url_for_people_destroy(@person).should == '/people/99'
-    end
-
-    it 'should not add inputable restful routes' do
-      @app.events.clear
-      rest Person, :inputable => false
-      @app.events[:get].map {|r| r.path}.should == ["/people", "/people/:id"]
-      @app.events[:post].map {|r| r.path}.should == ["/people"]
-      @app.events[:put].map {|r| r.path}.should == ["/people/:id"]
-      @app.events[:delete].map {|r| r.path}.should == ["/people/:id"]
-    end
-
-
-    it 'should add all url_for_* helpers' do
-      rest Person
-
-      methods = Sinatra::EventContext.instance_methods.grep /^url_for_people_/
-      methods.size.should == 7
-
-      @person = Person.new
-      @person.id = 99
-
-      @context.url_for_people_index.should == '/people'
-      @context.url_for_people_new.should == '/people/new'
-      @context.url_for_people_create.should == '/people'
-      @context.url_for_people_show(@person).should == '/people/99'
-      @context.url_for_people_edit(@person).should == '/people/99/edit'
-      @context.url_for_people_update(@person).should == '/people/99'
-      @context.url_for_people_destroy(@person).should == '/people/99'
-    end
-
-    it 'should add all restful routes' do
-      @app.events.clear
-      rest Person
-      @app.events[:get].map {|r| r.path}.should == ["/people", "/people/new", "/people/:id", "/people/:id/edit"]
-      @app.events[:post].map {|r| r.path}.should == ["/people"]
-      @app.events[:put].map {|r| r.path}.should == ["/people/:id"]
-      @app.events[:delete].map {|r| r.path}.should == ["/people/:id"]
-    end
-
-    it 'should support models, strings and integers' do
-      @person = Person.new('id' => 99)
-
-      @context.url_for_people_show(@person).should == '/people/99'
-      @context.url_for_people_show(99).should == '/people/99'
-      @context.url_for_people_show('99').should == '/people/99'
-      lambda {@context.url_for_people_show(nil)}.should raise_error('can not generate url for nil')
-
-      @context.url_for_people_edit(@person).should == '/people/99/edit'
-      @context.url_for_people_edit(99).should == '/people/99/edit'
-      @context.url_for_people_edit('99').should == '/people/99/edit'
-      lambda {@context.url_for_people_edit(nil)}.should raise_error('can not generate url for nil')
-
-      @context.url_for_people_update(@person).should == '/people/99'
-      @context.url_for_people_update(99).should == '/people/99'
-      @context.url_for_people_update('99').should == '/people/99'
-      lambda {@context.url_for_people_update(nil)}.should raise_error('can not generate url for nil')
-
-      @context.url_for_people_destroy(@person).should == '/people/99'
-      @context.url_for_people_destroy(99).should == '/people/99'
-      @context.url_for_people_destroy('99').should == '/people/99'
-      lambda {@context.url_for_people_destroy(nil)}.should raise_error('can not generate url for nil')
-    end
-  end
-
-
-  describe 'as restful service' do
-
-    before(:each) do
-      Sinatra.application = nil
-      @app = Sinatra.application
-      @app.configure :test do
-        set :views, File.join(File.dirname(__FILE__), "views")
-      end
-
-      Person.reset!
-      rest Person, :renderer => 'erb'
-    end
-
-    describe 'each method' do
-
-      # index GET /models
-      it 'should list all people on index by their id' do
-        get '/people'
-        response_should_be 200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>'
-      end
-
-      # new GET /models/new
-      it 'should prepare an empty item on new' do
-        get '/people/new'
-        response_should_be 200, '<person><id/><name/></person>'
-      end
-
-      # create POST /models
-      it 'should create an item on post' do
-        post '/people', :name => 'new resource'
-        response_should_be 302, 'person created'
-      end
-
-      # show GET /models/1
-      it 'should show an item on get' do
-        get '/people/1'
-        response_should_be 200, '<person><id>1</id><name>one</name></person>'
-      end
-
-      # edit GET /models/1/edit
-      it 'should get the item for editing' do
-        get '/people/1/edit'
-        response_should_be 200, '<person><id>1</id><name>one</name></person>'
-      end
-
-      # update PUT /models/1
-      it 'should update an item on put' do
-        put '/people/1', :name => 'another name'
-        response_should_be 302, 'person updated'
-      end
-
-      # destroy DELETE /models/1
-      it 'should destroy an item on delete' do
-        delete '/people/1'
-        response_should_be 302, 'person deleted'
-      end
-
-    end
-
-    describe 'some use cases' do
-
-      it 'should list all persons' do
-        get '/people'
-        response_should_be 200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>'
-        model_should_be 3
-      end
-
-      it 'should read all persons' do
-        get '/people'
-
-        el_people = doc(body).elements.to_a("*/person/id")
-        el_people.size.should == 3
-        model_should_be 3
-
-        get "/people/#{el_people[0].text}"
-        response_should_be 200, '<person><id>1</id><name>one</name></person>'
-        model_should_be 3
-
-        get "/people/#{el_people[1].text}"
-        response_should_be 200, '<person><id>2</id><name>two</name></person>'
-        model_should_be 3
-
-        get "/people/#{el_people[2].text}"
-        response_should_be 200, '<person><id>3</id><name>three</name></person>'
-        model_should_be 3
-      end
-
-      it 'should create a new person' do
-        get '/people'
-        response_should_be 200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>'
-        model_should_be 3
-
-        get '/people/new'
-        response_should_be 200, '<person><id/><name/></person>'
-        model_should_be 3
-
-        post '/people', {:name => 'four'}
-        response_should_be 302, 'person created'
-        model_should_be 4
-
-        get '/people'
-        response_should_be 200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person><person><id>4</id></person></people>'
-        model_should_be 4
-      end
-
-      it 'should update a person' do
-        get '/people/2'
-        response_should_be 200, '<person><id>2</id><name>two</name></person>'
-        model_should_be 3
-
-        put '/people/2', {:name => 'tomorrow'}
-        response_should_be 302, 'person updated'
-        model_should_be 3
-
-        get '/people/2'
-        response_should_be 200, '<person><id>2</id><name>tomorrow</name></person>'
-        model_should_be 3
-      end
-
-      it 'should delete a person' do
-        get '/people'
-        response_should_be 200, '<people><person><id>1</id></person><person><id>2</id></person><person><id>3</id></person></people>'
-        model_should_be 3
-
-        delete '/people/2'
-        response_should_be 302, 'person deleted'
-        model_should_be 2
-
-        get '/people'
-        response_should_be 200, '<people><person><id>1</id></person><person><id>3</id></person></people>'
-        model_should_be 2
-
-        get '/people/2'
-        response_should_be 404, 'person not found'
-        model_should_be 2
-      end
-
-    end
-
-    describe 'life-cycle' do
-
-      before(:each) do
-        Person.class_eval '@call_order = []; def self.call_order; @call_order; end; def self.call_order=(arr); @call_order = arr; end'
-        rest Person, :renderer => 'erb' do
-          def before(name)
-            Person.call_order << {:method => :before, :called => name}
-          end
-
-          def after(name)
-            Person.call_order << {:method => :after, :called => name}
-          end
-
-          def index
-            Person.call_order << {:method => :index, :called => :index}
-            super
-          end
-
-          def new
-            Person.call_order << {:method => :new, :called => :new}
-            super
-          end
-
-          def create
-            Person.call_order << {:method => :create, :called => :create}
-            super
-          end
-
-          def show
-            Person.call_order << {:method => :show, :called => :show}
-            super
-          end
-
-          def edit
-            Person.call_order << {:method => :edit, :called => :edit}
-            super
-          end
-
-          def update
-            Person.call_order << {:method => :update, :called => :update}
-            super
-          end
-
-          def destroy
-            Person.call_order << {:method => :destroy, :called => :destroy}
-            super
-          end
-        end
-      end
-
-      it 'should call :before and :after in the right order' do
-        call_order_should_be [:before, :index, :after]   do get    '/people' end
-        call_order_should_be [:before, :new, :after]     do get    '/people/new' end
-        call_order_should_be [:before, :create, :after]  do post   '/people', :name => 'initial name' end
-        call_order_should_be [:before, :show, :after]    do get    '/people/1' end
-        call_order_should_be [:before, :edit, :after]    do get    '/people/1/edit' end
-        call_order_should_be [:before, :update, :after]  do put    '/people/1', :name => 'new name' end
-        call_order_should_be [:before, :destroy, :after] do delete '/people/1' end
-      end
-
-      it 'should call :before and :after with the name of the called method' do
-        called_should_be :index   do get    '/people' end
-        called_should_be :new     do get    '/people/new' end
-        called_should_be :create  do post   '/people', :name => 'initial name' end
-        called_should_be :show    do get    '/people/1' end
-        called_should_be :edit    do get    '/people/1/edit' end
-        called_should_be :update  do put    '/people/1', :name => 'new name' end
-        called_should_be :destroy do delete '/people/1' end
-      end
-
-    end
-
-  end
-
-end
-
-