bebop 0.1.0

data/README.markdown

@@ -0,0 +1,111 @@
+Bebop
+=====
+
+Bebop is small Sinatra/Monk extension for DRY resource based routing. It provides targeted filters, path helpers, nested resources, printable routing information, and familiar action methods like new, show, destroy, update, and index.
+
+The name comes from its happy partnering with the [Monk](http://monkrb.com) glue framework, as Thelonius Monk is considered to be the father of bebop.
+
+
+dependencies
+------------
+
+* Sinatra
+* ActiveSupport
+
+install
+-------
+
+Make sure you have gemcutter.org as one of your sources:
+     
+    gem sources -a http://gemcutter.org
+
+Then:
+
+	gem install bebop
+
+verify
+------
+	
+Requires rspec version 1.2.9 or higher
+
+	cd /path/to/bebop; spec spec
+
+sample
+------
+
+If you were using an Active Record model Foo:
+
+	require 'bebop'
+	require 'sinatra'
+	require 'foo'
+
+	class MyApp < Sinatra::Base
+	  register Bebop	
+	  
+	  resource :foos do |foos|
+	    
+	    # GET /foos/:foo_id
+	    foos.show do
+	      @foo = Foo.find(params[:foo_id])
+	      haml :'foos/show'
+	    end
+
+	    # GET /foos/new
+	    foos.new do
+	      @foo = Foo.new
+	      haml :'foos/new'
+	    end
+	  end
+	end
+
+more detail
+-----------
+
+See the examples directory. You can play with each of the examples as follows:
+
+    $ pwd
+	/path/to/bebop
+	$ ruby examples/routes.rb 
+	== Sinatra/0.9.4 has taken the stage on 4567 for development with backup from Thin
+	>> Thin web server (v1.2.4 codename Flaming Astroboy)
+	>> Maximum connections set to 1024
+	>> Listening on 0.0.0.0:4567, CTRL+C to stop
+
+routes
+------
+
+Run your sinatra/monk app with the PROUTES env variable set to view the routes created with the resource method
+
+	$ ruby my_app.rb PROUTES=true
+	
+or 
+
+	$ thor monk:start PROUTES=true
+
+NOTE: planning to change the formatting soon, as it currently sucks
+	
+license
+-------
+
+(The MIT License)
+
+Copyright (c) 2010 FIX
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('specs_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude spec', '--exclude "gems/*"', '--exclude "bebop.rb"' ]
+end

data/bebop.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.name = 'bebop'
+  s.version = '0.1.0'
+  s.date = '2010-1-10'
+ 
+  s.summary = s.description = "A small Sinatra/Monk extension for resource routing"
+ 
+  s.authors = ["John Bender"]
+  s.homepage = 'http://github.com/johnbender/bebop'
+  s.email = 'john.m.bender@gmail.com'
+ 
+  # = MANIFEST =
+  s.files = %w[ 
+README.markdown
+Rakefile
+bebop.gemspec
+examples/filters.rb
+examples/routes.rb
+lib/bebop/ext.rb
+lib/bebop.rb
+spec/bebop_spec.rb
+]
+  # = MANIFEST = 
+  s.add_dependency 'sinatra', '>= 0.9.4'
+  s.add_dependency 'activesupport', '>= 2.3.5'
+
+  s.add_development_dependency 'rspec', '>=1.2.9'
+  
+  s.has_rdoc = false
+  s.require_paths = %w[lib]
+  s.rubyforge_project = 'bebop'
+  s.rubygems_version = '1.3.5'
+end

data/examples/filters.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'bebop')
+require 'sinatra'
+
+class MyApp < Sinatra::Base
+  register Bebop
+
+  resource :foos do |foos|
+    # Bebop provides some simple targeting for before and after filters, with the 
+    # caveat that they must be defined before the routes they target within the resource block    
+    # To have your filter run before all routes under a given resource and its child resources
+    # pass :all as the first parameter
+    # 
+    foos.before :all do
+      @all = 'all'
+    end
+    
+    # To have your filter run before a specific route, the route must be one of the seven helper
+    # routes (see example/routes.rb) or specify the :identifier parameter
+    #
+    foos.before :new do
+      @new = 'new'
+    end
+
+    foos.new do
+      "#{@all} #{@new}" # => 'all new'
+    end
+   
+    # You can target the vanila methods by providing the :identifier hash option
+    #
+    # GET /foos/baz
+    foos.get '/baz', :identifier => :new do
+      @new # => 'new'
+    end
+
+    # You can also specify a before filter for nested routes by using the child resource name
+    # 
+    foos.before :bars do
+      @bars = 'some bars'
+    end
+    
+    foos.resource :bars do |bars|
+      bars.get '/some_bars' do
+        @bars # => 'some bars'
+      end
+    end
+
+    foos.get '/bak' do
+      @bars # => nil
+    end
+
+    # Finally you can specify many different methods in your filters by passing many identifiers
+    # 
+    foos.before :bak, :baz do
+      @bak_baz = "bak 'n' baz"
+    end
+
+    foos.get('/something', :identifier => :bak) { @bak_baz }
+    foos.get('/anything', :identifier => :baz) { @bak_baz }    
+  end
+end

data/examples/routes.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'bebop')
+require 'sinatra'
+
+class MyApp < Sinatra::Base
+  register Bebop
+
+  resource :foos do |foos|
+
+    # Any of the traditional sinatra methods called on the block parameter
+    # will take the first argument (or an empty string) and apply it to
+    # the resource base
+    #
+    # GET /foos/baz
+    foos.get '/baz' do
+      'baz'
+    end
+    
+    # There are 7 helper methods for the traditional resource actions. They
+    # are index, new, create, update, edit, destroy, and show. Each is a wrapper
+    # for the corresponding Sinatra method
+    #
+    # GET /foos
+    foos.index {}
+
+    # For actions that require parameters the parameter name is derived from the singularized
+    # name of the resource with '_id' appended.
+    #
+    # GET /foos/:foo_id
+    foos.show {}
+
+    # GET /foos/new
+    foos.new {}
+
+    # POST /foos
+    foos.create {}
+
+    # PUT /foos/:foo_id
+    foos.update {}
+    
+    # GET /foos/:foo_id/edit
+    foos.edit {}
+
+    # DELETE /foos/:foo_id
+    foos.destroy {}
+
+    # For each of the helper methods, and any generic method (eg foos.get) that specifies the :identifier
+    # option, bebop will define a relative path helper. See the nested resource below for the nameing of those
+    # methods
+    # 
+    # POST /foos/do/redirect
+    foos.get 'do/redirect' do
+      # Redirects to /foos/1
+      redirect foos_show_path(1)
+    end
+
+    # If you want to represent the relationship of your models through nested resources use
+    # the resource method with the block parameter and all new routes will be nested and 
+    # parameterized properly
+    #
+    # Prefix all with /foos/:foo_id
+    foos.resource :bars do |bars|
+      
+      # GET /foos/:foo_id/bars/:bar_id/edit
+      bars.edit do
+        "foo: #{params[:foo_id]} bar: #{params[:bar_id]}"
+      end 
+      
+      bars.get '/redirect' do
+     
+        # The route helper method naming convention is simple and easy to remember as it follows
+        # the order of nesting for the given route starting with the original parent resource and
+        # ending with the method identifier. 
+        #
+        # Redirects to /foos/1/bars/2/edit
+        redirect foos_bars_edit_path(1, 2)
+      end
+    end
+  end
+end

data/lib/bebop.rb

@@ -0,0 +1,4 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'bebop/ext'

data/lib/bebop/ext.rb

@@ -0,0 +1,184 @@
+require 'active_support'
+
+module Bebop
+  class InvalidPathArgumentError < ArgumentError; end
+  PARAM_REGEX = /:[a-zA-Z0-9_]+/
+
+  def resource(name, &block)
+    resource = ResourceRouter.new
+    resource.resource(name, &block)
+    resource.routes.each do |method, route, options, block, helper|
+      send(method, route, options, &block)
+      define_route_helper(helper, route) if helper
+    end
+    resource.print if ENV['PROUTES']
+  end
+
+  def define_route_helper(helper, route)
+    define_method helper do |*args|
+      unless route.scan(PARAM_REGEX).length == args.length
+        raise InvalidPathArgumentError.new("invalid number of parameters #{args.length} for: #{route}")
+      end
+      
+      args.inject(route.dup) do |acc, arg|
+        #handle fixnums and ar objects
+        arg = (arg.kind_of?(Fixnum) ? arg : arg.id)
+        acc.sub!(PARAM_REGEX, arg.to_s) 
+      end
+    end
+  end
+  
+  
+  class ResourceRouter
+    attr_accessor :routes 
+    
+    def initialize(parent_resources=[], before_all=[], after_all=[])
+      @current_resource = parent_resources.pop
+      @parent_resources = parent_resources
+      @before, @after, @routes = before_all, after_all, []
+    end
+    
+    def get(route, options={}, &block)
+      add_route(:get, route, options, block)
+    end
+
+    def put(route, options={}, &block)
+      add_route(:put, route, options, block)
+    end
+    
+    def post(route, options={}, &block)
+      add_route(:post, route, options, block)
+    end
+
+    def delete(route, options={}, &block)
+      add_route(:delete, route, options,  block)
+    end
+
+    def head(route, options={}, &block)
+      add_route(:head,  route, options,  block)
+    end
+
+    def new(options={}, &block)
+      get 'new', options.merge(:identifier => :new), &block
+    end
+    
+    def create(options={}, &block)
+      post '' , options.merge(:identifier => :create), &block
+    end
+
+    def edit(options={}, &block)
+      get append_token(resource_identifier, 'edit') , options.merge(:identifier => :edit), &block
+    end
+
+    def index(options={}, &block)
+      get '', options.merge(:identifier => :index), &block
+    end
+
+    def show(route=nil, options={}, &block)
+      get append_token(resource_identifier, (route || '').to_s), options.merge(:identifier => route || :show), &block
+    end
+
+    def destroy(options={}, &block)
+      delete resource_identifier, options.merge(:identifier => :destroy), &block
+    end
+
+    def update(options={}, &block)
+      put resource_identifier, options.merge(:identifier => :update), &block
+    end
+
+    def before(*params, &block)
+      add_filter(@before, params, block)
+    end
+
+    def after(*params, &block)
+      add_filter(@after, params, block)
+    end
+
+    def resource(name, &block)
+      before_filters = filters(@before, :all, name)
+      after_filters = filters(@after, :all, name)
+      
+      router = self.class.new(all_resources + [name], before_filters, after_filters)
+      yield(router)
+      @routes += router.routes
+    end
+
+    def print
+      #TODO 6! 6! Block parameters, Ah Ah Ah! -> probably need route objects
+      @routes.each do |method, route, options, block, helper, identifier|
+        puts "#{route}"
+        puts "  method:     #{method.to_s.upcase}"
+        puts "  helper:     #{helper}" if helper
+        puts "  identifier: #{identifier}" if identifier
+        puts
+      end
+    end
+    
+    private
+    
+    def all_resources
+      #in the initial call to resource there is current_resource
+      @current_resource ? @parent_resources + [@current_resource] : @parent_resources
+    end
+
+    def resource_identifier(resource=@current_resource)
+      ":#{resource.to_s.singularize}_id"
+    end
+
+    def add_filter(type, params, block)
+      params = [:all] if params.empty?
+      type << {:routes => params, :block => block}
+    end
+    
+    def add_route(method, route, options, block) 
+      identifier =options[:identifier]
+      route = append_to_path(route)
+      block = add_filters_to_block(block, identifier, method)
+      helper = route_helper(identifier)
+
+      #Sinatra doesn't like the spurious options
+      options.delete(:identifier)
+
+      @routes << [method, route, options, block, helper]
+    end
+
+    def append_to_path(str)
+      append_token(append_token(parent_resource_path, @current_resource), str)
+    end
+
+    def parent_resource_path
+      @parent_resources.inject('') do |acc, x|
+        append_token(append_token(acc, x), resource_identifier(x))
+      end
+    end
+
+    def append_token(l, tkn)
+      tkn = tkn.to_s
+      tkn = "/#{tkn}" unless tkn.empty? || tkn =~ /^\//
+      "#{l}#{tkn}"
+    end
+
+    def route_helper(identifier)
+      helper_tokens = (@parent_resources.dup << @current_resource) << identifier
+      "#{helper_tokens.join('_')}_path".to_sym
+    end
+
+    def add_filters_to_block(block, identifier, method)
+      before = filters(@before, identifier, method, :all, @current_resource)
+      after = filters(@after, identifier, method, :all, @current_resource)
+      Proc.new do
+        before.each { |f| instance_eval( &f[:block] ) }
+        result = instance_eval(&block)
+        after.each { |f| instance_eval(&f[:block]) }
+        result
+      end
+    end
+
+    def filters(list, *identifiers)
+      list.select do |filter|
+        rs = filter[:routes]
+        !(rs & identifiers).empty?
+      end
+    end
+  end
+end

data/spec/bebop_spec.rb

@@ -0,0 +1,201 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'bebop')
+require 'rack/test'
+require 'sinatra'
+
+class TestClass < Sinatra::Base
+  register Bebop
+  def self.global
+    @@global
+  end
+  def self.global=(val)
+    @@global = val
+  end
+end
+
+describe Bebop do
+  include Rack::Test::Methods
+  
+  def app
+    @test_app ||= TestClass.new 
+    @test_app
+  end
+
+  before :all do
+    app
+    @class = TestClass
+    use_bebop 
+  end
+
+  before :each do
+    TestClass.global = nil
+  end
+
+  it "should define route helpers properly for routes specifying an identifier" do
+    @class.instance_methods.should include('foos_bars_index_path')
+    @class.instance_methods.should include('foos_create_path')
+  end  
+
+  it "should provide the correct relative url from the route helpers" do
+    @test_app.foos_bars_index_path(1).should == '/foos/1/bars'
+    @test_app.foos_bars_update_path(1,2).should == '/foos/1/bars/2'
+  end
+
+  it "should raise an error when the wrong number of paramters are passed to a route helper" do
+    lambda {@test_app.foos_bars_update_path(1)}.should raise_error(Bebop::InvalidPathArgumentError)
+  end
+
+  it "should define a route with new for the new method" do
+    get '/foos/new'
+    last_response.body.should == "new"
+  end
+
+  it "should define a route with an identifer and append edit for the edit method" do
+    get '/foos/1/edit'
+    last_response.body.should == 'edit 1'
+  end
+
+  it "shoud define a route with an identifer for show and recieve the proper parameters" do
+    get '/foos/1/bars/2'
+    last_response.body.should == 'show 1 2'
+  end
+
+  it "should respond correctly when the route is consulted" do
+    post '/foos'
+    last_response.body.should match(/#{BEFORE_ALL}/)
+  end
+
+  it "should call before and after blocks correctly based on the identifier" do
+    put '/foos/1'
+    last_response.body.should match(/#{BEFORE_UPDATE}/)
+
+    post '/foos'
+    last_response.body.should_not match(/#{BEFORE_UPDATE}/)
+  end
+
+  it "should correctly append any vanilla sinatra method with the resource prefix" do
+    get '/foos/arbitrary'
+    last_response.body.should == 'baz'
+  end
+
+  it "should not call before and after blocks in a nested resource based on the identifer" do
+    put '/foos/1/bars/1'
+    last_response.body.should_not match(/#{BEFORE_UPDATE}/)
+  end
+
+  it "should call before and after all blocks on all resource routes" do
+    put '/foos/1'
+    last_response.body.should match(/#{BEFORE_ALL}/)
+
+    post '/foos'
+    last_response.body.should match(/#{BEFORE_ALL}/)
+
+    get '/foos/1/bars'
+    last_response.body.should match(/#{BEFORE_ALL}/)
+    
+    delete '/foos/1/bars/1'
+    last_response.body.should match(/#{BEFORE_ALL}/)    
+
+    put '/foos/1/bars/1'
+    last_response.body.should match(/#{BEFORE_ALL}/)
+  end
+  
+  it "should call before and after resource blocks only on the nested resource routes" do
+    get '/foos/1/bars'
+    last_response.body.should match(/#{BEFORE_BARS}/)
+    
+    delete '/foos/1/bars/1'
+    last_response.body.should match(/#{BEFORE_BARS}/)
+  end
+  
+  it "should not call before and after resource blocks on non nested resource blocks" do
+    post '/foos' 
+    last_response.body.should_not match(/#{BEFORE_BARS}/)
+  end
+
+  it "should call before and after filters without any identifier specified before all routes" do
+    put '/foos/1'
+    last_response.body.should match(/#{BEFORE_ALL_2}/)
+
+    post '/foos'
+    last_response.body.should match(/#{BEFORE_ALL_2}/)
+
+    get '/foos/1/bars'
+    last_response.body.should match(/#{BEFORE_ALL_2}/)
+    
+    delete '/foos/1/bars/1'
+    last_response.body.should match(/#{BEFORE_ALL_2}/)    
+
+    put '/foos/1/bars/1'
+    last_response.body.should match(/#{BEFORE_ALL_2}/)
+  end
+  
+  it "should call before and after filters that specify multiple identifiers before the proper routes" do
+    post '/foos'
+    TestClass.global.should == AFTER_VALUE
+
+    put '/foos/1'
+    TestClass.global.should == AFTER_VALUE
+  end
+  
+  it "should not call before and after filters that specify multiple parameters on anyting else" do
+    get '/foos/new'
+    TestClass.global = nil
+  end
+
+  it "should not prepend previous nested routes on non nested routes that follow" do
+    get '/foos/do/something'
+    last_response.body.should == 'success'
+  end
+
+  it "should produce correct routes for more than 2 levels of nesting"
+  
+  BEFORE_BARS = '__before_bars__'
+  BEFORE_UPDATE = '__before_update__'
+  BEFORE_ALL = '__all__'
+  BEFORE_ALL_2 = '__2all__'
+  AFTER_VALUE = '__after__'
+
+  def use_bebop
+    # ENV['PROUTES']='t'
+    @class.resource :foos do |foo|
+      
+      foo.before :all do
+        @all = BEFORE_ALL
+      end
+
+      foo.before do
+        @all2 = BEFORE_ALL_2
+      end
+
+      foo.before :update do
+        @update = BEFORE_UPDATE
+      end
+      
+      foo.before :bars do
+        @bars = BEFORE_BARS
+      end
+
+      foo.after :create, :update do
+        TestClass.global = AFTER_VALUE
+      end
+
+      foo.get(:arbitrary) { 'baz' }        
+
+      foo.create { "#{@all2}#{@all}#{@update}#{@bars}" }
+      foo.update { "#{@all2}#{@all}#{@update}#{@bars}" }
+
+      foo.new { "new" }
+      foo.edit { "edit #{params[:foo_id]}" }
+
+      foo.resource :bars do |bar|
+        bar.index { "#{@all2}#{@all}#{@update}#{@bars}" }
+        bar.update { "#{@all2}#{@all}#{@update}#{@bars}" }
+        bar.destroy { "#{@all2}#{@all}#{@update}#{@bars}" }
+
+        bar.show { "show #{params[:foo_id]} #{params[:bar_id]}" }
+      end
+
+      foo.get('/do/something') { 'success' }
+    end    
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: bebop
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- John Bender
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-10 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.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+description: A small Sinatra/Monk extension for resource routing
+email: john.m.bender@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- Rakefile
+- bebop.gemspec
+- examples/filters.rb
+- examples/routes.rb
+- lib/bebop/ext.rb
+- lib/bebop.rb
+- spec/bebop_spec.rb
+has_rdoc: true
+homepage: http://github.com/johnbender/bebop
+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: bebop
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A small Sinatra/Monk extension for resource routing
+test_files: []
+