blindgaenger-sinatra-rest 0.2 → 0.3.0

data/Rakefile

@@ -1,11 +1,10 @@
 require 'spec/rake/spectask'
 
-task :default => [:test]
-task :test => :spec
+task :default => :test
 
-desc "Run specs"
-Spec::Rake::SpecTask.new :spec do |t|
-  t.spec_opts = %w(--format specdoc --color)
+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,153 @@
+require 'sinatra/base'
+require 'english/inflect'
+
+libdir = File.dirname(__FILE__) + "/rest"
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+require 'adapters'
+
+module Sinatra
+
+  module REST
+
+    #
+    # adds restful routes and url helpers for the model
+    def rest(model_class, options={}, &block)
+      parse_args(model_class, options)
+
+      # register model specific helpers
+      helpers read_module_template('rest/helpers.tpl.rb')
+      
+      # create an own module, to override the template with custom methods
+      # this way, you can still use #super# in the overridden methods
+      controller = read_module_template('rest/controller.tpl.rb')
+      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 read_template('rest/routes.tpl.rb')
+    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].map {|route| ROUTES[route] || route}.flatten.uniq
+    end
+    
+    def gsub_routes(routes, template)
+      routes.each {|route| template.gsub!(/#{route.to_s.upcase}/, true.to_s) }
+      (ROUTES[:all] - routes).each {|route| template.gsub!(/#{route.to_s.upcase}/, false.to_s) }
+    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
+
+    #
+    # read the file and do some substitutions
+    def read_template(filename)
+      t = File.read(File.join(File.dirname(__FILE__), filename))
+      t.gsub!(/PLURAL/, @plural)
+      t.gsub!(/SINGULAR/, @singular)
+      t.gsub!(/MODEL/, @model)
+      t.gsub!(/RENDERER/, @renderer)
+      gsub_routes(@route_flags, t)
+      t
+    end
+
+    #
+    # read the template and put it into an anonymous module
+    def read_module_template(filename)
+      t = read_template(filename)
+      m = Module.new
+      m.module_eval(t, filename)
+      m
+    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 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(&block)  prefix :before,  █ end
+      def after(&block)   prefix :after,   █ end      
+      def index(&block)   prefix :index,   █ end
+      def new(&block)     prefix :new,     █ end
+      def create(&block)  prefix :create,  █ end
+      def show(&block)    prefix :show,    █ end
+      def edit(&block)    prefix :edit,    █ end
+      def update(&block)  prefix :update,  █ end
+      def destroy(&block) prefix :destroy, █ 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,24 @@
+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
+

data/lib/sinatra/rest/controller.tpl.rb

@@ -0,0 +1,65 @@
+def PLURAL_before(name)
+  # override
+end
+
+def PLURAL_after(name)
+  # override
+end
+
+# index GET /models
+if INDEX
+  def PLURAL_index(options=nil)
+    @PLURAL = call_model_method(MODEL, :all, options)
+  end
+end
+
+# new GET /models/new
+if NEW
+  def PLURAL_new(options=nil)
+    @SINGULAR = call_model_method(MODEL, :new, options)
+  end
+end
+
+# create POST /models
+if CREATE
+  def PLURAL_create(options=params)
+    mp = filter_model_params(options)
+    @SINGULAR = call_model_method(MODEL, :new, mp)
+    @SINGULAR.save
+  end
+end
+
+# show GET /models/1
+if SHOW
+  def PLURAL_show(options=params)
+    mp = filter_model_params(options)
+    @SINGULAR = call_model_method(MODEL, :find_by_id, mp[:id])
+  end
+end
+
+# edit GET /models/1/edit
+if EDIT
+  def PLURAL_edit(options=params)
+    mp = filter_model_params(options) 
+    @SINGULAR = call_model_method(MODEL, :find_by_id, mp[:id])
+  end
+end
+
+# update PUT /models/1
+if UPDATE
+  def PLURAL_update(options=params)
+    mp = filter_model_params(options)  
+    @SINGULAR = call_model_method(MODEL, :find_by_id, mp[:id])
+    @SINGULAR.update_attributes(mp) unless @SINGULAR.nil?
+  end
+end
+
+# destroy DELETE /models/1
+if DESTROY
+  def PLURAL_destroy(options=params)
+    mp = filter_model_params(options)  
+    call_model_method(MODEL, :delete, mp[:id])
+  end
+end
+
+

data/lib/sinatra/rest/helpers.tpl.rb

@@ -0,0 +1,49 @@
+# index GET /models
+if INDEX
+  def url_for_PLURAL_index
+    '/PLURAL'
+  end
+end
+
+# new GET /models/new
+if NEW
+  def url_for_PLURAL_new
+    '/PLURAL/new'
+  end
+end
+
+# create POST /models
+if CREATE
+  def url_for_PLURAL_create
+    '/PLURAL'
+  end
+end
+
+# show GET /models/1
+if SHOW
+  def url_for_PLURAL_show(model)
+    "/PLURAL/#{escape_model_id(model)}"
+  end
+end
+
+# edit GET /models/1/edit
+if EDIT
+  def url_for_PLURAL_edit(model)
+    "/PLURAL/#{escape_model_id(model)}/edit"
+  end
+end
+
+# update PUT /models/1
+if UPDATE
+  def url_for_PLURAL_update(model)
+    "/PLURAL/#{escape_model_id(model)}"
+  end
+end
+
+# destroy DELETE /models/1
+if DESTROY
+  def url_for_PLURAL_destroy(model)
+    "/PLURAL/#{escape_model_id(model)}"
+  end
+end
+

data/lib/sinatra/rest/routes.tpl.rb

@@ -0,0 +1,78 @@
+# index GET /models
+if INDEX
+  get '/PLURAL' do
+    PLURAL_before :index
+    PLURAL_index
+    PLURAL_after :index    
+    RENDERER :"PLURAL/index", options  
+  end
+end
+
+# new GET /models/new
+if NEW
+  get '/PLURAL/new' do
+    PLURAL_before :new  
+    PLURAL_new
+    PLURAL_after :new    
+    RENDERER :"PLURAL/new", options
+  end
+end
+
+# create POST /models
+if CREATE
+  post '/PLURAL' do
+    PLURAL_before :create
+    PLURAL_create
+    PLURAL_after :create
+    redirect url_for_PLURAL_show(@SINGULAR), 'SINGULAR created'
+  end
+end
+
+# show GET /models/1
+if SHOW
+  get '/PLURAL/:id' do
+    PLURAL_before :show
+    PLURAL_show
+    PLURAL_after :show
+    if @SINGULAR.nil?
+      throw :halt, [404, 'SINGULAR not found']
+    else
+      RENDERER :"PLURAL/show", options
+    end
+  end
+end
+
+# edit GET /models/1/edit
+if EDIT
+  get '/PLURAL/:id/edit' do
+    PLURAL_before :edit
+    PLURAL_edit
+    PLURAL_after :edit    
+    RENDERER :"PLURAL/edit", options
+  end
+end
+
+# update PUT /models/1
+if UPDATE
+  put '/PLURAL/:id' do
+    PLURAL_before :update  
+    PLURAL_update
+    PLURAL_after :update
+    if @SINGULAR.nil?
+      throw :halt, [404, 'SINGULAR not found']
+    else
+      redirect url_for_PLURAL_show(@SINGULAR), 'SINGULAR updated'
+    end
+  end
+end
+
+# destroy DELETE /models/1
+if DESTROY
+  delete '/PLURAL/:id' do
+    PLURAL_before :destroy
+    PLURAL_destroy
+    PLURAL_after :destroy
+    redirect url_for_PLURAL_index, 'SINGULAR destroyed'
+  end
+end
+

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
+