blindgaenger-sinatra-rest 0.2

data/README.textile

@@ -0,0 +1,84 @@
+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 '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. 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,11 @@
+require 'spec/rake/spectask'
+
+task :default => [:test]
+task :test => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new :spec do |t|
+  t.spec_opts = %w(--format specdoc --color)
+  t.spec_files = FileList['test/*_spec.rb']
+end
+

data/lib/rest.rb

@@ -0,0 +1,278 @@
+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

@@ -0,0 +1,448 @@
+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
+
+

data/spec/views/people/edit.erb

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

data/spec/views/people/index.erb

@@ -0,0 +1,10 @@
+<people>
+  <% @people.each do |person| %>
+  <person>
+    <id><%= person.id %></id>
+  </person>
+  <% end %>
+</people>
+
+
+

data/spec/views/people/new.erb

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

data/spec/views/people/show.erb

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

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: blindgaenger-sinatra-rest
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- blindgaenger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-28 00:00:00 -08: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/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
+has_rdoc: "false"
+homepage: http://github.com/blindgaenger/sinatra-rest
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Generates RESTful routes for the models of a Sinatra application
+test_files: []
+