tred-fancyroutes 0.9.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 The TRED Team
+
+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/README.md

@@ -0,0 +1,155 @@
+FancyRoutes
+===========
+
+Removing the cruft, bringing the HTTP method to the forefront and sporting a
+neat DRYing block syntax--FancyRoutes is a layer on top of the Rails routing
+system which provides an elegant API for mapping requests to your
+application's controllers and actions.
+
+Take for example the following routes from one of Myles' applications:
+
+    map.connect '/orders', :controller => 'orders', :action => 'index, :conditions => { :method => :get }
+
+    map.connect '/:slug/order', :controller => 'orders', :action => :show, :conditions => { :method => :get }
+    map.connect '/:slug/order', :controller => 'orders', :action => :create, :conditions => { :method => :post }
+
+    map.connect 'item_images/:image', :controller => 'item_images', :action => 'show', :conditions => { :method => :get }
+
+Converted to fancyroutes these now look like:
+
+    get / 'orders' >> :orders > :index
+
+    with route / :slug / 'order' >> :orders do
+      get > :show
+      put > :update
+    end
+    
+    get {'item_images' => :controller} / :image > :show
+
+So fancy!
+
+Where'd all the parentheses go?
+-------------------------------
+
+We use three of Ruby's operators to define paths:
+
+* `/` separates the segments
+* `>>` indicates the controller
+* `>` indicates the action
+
+Segments of the path can be strings or symbols. Symbols, such as `:image`, define parameters and strings, such as `'order'`, define static segments.
+
+Controller names in the path
+----------------------------
+
+Quite often the controller name will already be in the path itself.
+
+    map.connect '/playground/:action', :controller => 'playground'
+
+Don't repeat yourself! Provide a hash instead:
+
+    get / {'playground' => :controller} / :action
+
+Named routes
+------------
+
+Simply suffix the get/post/put/delete with the name:
+
+    page.get / '*tree' >> :pages > :show
+
+Now you can generate a path with the route:
+
+    page_path(["help", "where-is-the-any-key"])
+
+Nesting routes
+--------------
+
+Use `with route` to DRY up similar routes. For example:
+
+    get / :slug / 'order' >> :orders > :show
+    put / :slug / 'order' >> :orders > :update
+
+can be rewritten as:
+
+    with route / :slug >> :orders do
+      get / 'order' > :show
+      put / 'order' > :update
+    end
+
+or even better:
+
+    with route / :slug / 'order' >> :orders do
+      get > :show
+      put > :update
+    end
+
+The root route
+--------------
+
+A standard root route looks something like this:
+
+    map.root :controller => 'homepage', :action => 'index'
+
+The fancier version is:
+
+    root >> :homepage > :index
+
+Installing
+----------
+
+Install the gem:
+
+    sudo gem install tred-fancyroutes
+
+add the dependency in your environment.rb:
+
+    config.gem 'tred-fancyroutes'
+
+and then use the FancyRoutes method in your routes.rb:
+
+    ActionController::Routing::Routes.draw do |map|
+    FancyRoutes(map) do
+      # the
+      # fanciest
+      # routes
+      # you
+      # ever
+      # did
+      # see
+    end
+    end
+
+Contributors
+------------
+
+* Myles Byrne
+* Carl Woodward
+* Tim Lucas
+* Chris Lloyd
+* Michael Koukoullis
+* Lincoln Stolli
+* Dave Newman
+
+License (MIT)
+-------------
+
+Copyright (c) 2008-09 The TRED Team
+
+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,54 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = "fancyroutes"
+GEM_VERSION = "0.9.1"
+AUTHOR = "The TRED Team"
+EMAIL = "tred3000@gmail.com"
+HOMEPAGE = "http://tred.github.com/fancyroutes"
+SUMMARY = "Removing the cruft, bringing the HTTP method to the forefront and sporting a neat DRYing block syntax--FancyRoutes is a layer on top of the Rails routing system which provides an elegant API for mapping requests to your application's controllers and actions."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.md', 'LICENSE']
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.summary = SUMMARY
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README.md Rakefile) + Dir.glob("{lib,spec}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/lib/fancyroutes.rb

@@ -0,0 +1,127 @@
+module FancyRoutes
+
+  class Route
+    
+    def initialize
+      @segments = []
+    end
+    
+    def request_method(method)
+      @request_method = method.to_sym
+      self
+    end
+    
+    %w(get put post delete).each do |meth|
+      define_method(meth) { request_method(meth) }
+    end
+    
+    attr_writer :name
+    
+    def segment(segment)
+      segment = case segment
+        when Symbol 
+          ":#{segment}"
+        when Hash
+          self.send(segment.values.first, segment.keys.first)
+          segment.keys.first.to_s
+        else 
+          segment.to_s 
+        end
+      @segments << segment
+      self
+    end
+    alias_method :/, :segment
+    
+    def controller(controller)
+      @controller = controller.to_s
+      self
+    end
+    alias_method :>>, :controller
+    
+    def action(action)
+      @action = action.to_s
+      self
+    end
+    alias_method :>, :action
+    
+    def apply(rails_map)
+      rails_map.send( (@name ? @name : :connect),
+        @segments.join("/"), {
+          :controller => @controller,
+          :action => @action,
+          :conditions => { :method => @request_method }
+        }
+      )
+    end
+    
+    # hacky deep clone
+    def copy
+      Marshal::load(Marshal.dump(self))  
+    end
+    
+  end
+  
+  class RootRoute < Route
+    
+    def apply(rails_map)
+      rails_map.root :controller => @controller,
+                     :action => @action,
+                     :conditions => { :method => @request_method }
+    end
+    
+  end
+
+  # may be clearer to use 3 classes here: RouteSet, MasterSet & NestedSet
+  
+  class RouteSet
+  
+    attr_reader :routes
+    
+    def initialize(template_route = nil)
+      @template_route = template_route
+      @routes = []
+    end
+    
+    def apply(rails_route_map)
+      @routes.each { |route| route.apply(rails_route_map) }
+    end
+    
+    # builds a new route
+    def route(meth = nil, name = nil)
+      route = @template_route ? @template_route.copy : (name == :root ? RootRoute.new : Route.new)
+      route.request_method(meth) if meth
+      route.name = name if name
+      @routes << route
+      route
+    end
+    
+    %w(get put post delete).each do |meth|
+      define_method(meth) { route(meth) }
+    end
+    
+    def root
+      route(:get, :root)
+    end
+    
+    def method_missing(meth,*args)
+      route(nil,meth)
+    end
+    
+    def with(route, &blk)
+      # this route is used as a template, not as an actual route so we remove
+      # it from the routes collection
+      @routes.pop 
+      nested_set = self.class.new(route)
+      nested_set.instance_eval(&blk)
+      @routes += nested_set.routes
+    end
+    
+  end
+  
+end
+
+def FancyRoutes(m, &blk)
+  fr = FancyRoutes::RouteSet.new
+  fr.instance_eval(&blk)
+  fr.apply(m)
+end

data/spec/fancyroutes_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "FancyRoutes" do
+  
+  before(:each) do
+    @map = Object.new
+  end
+
+  # without helpers
+
+  example "route on root, long form" do
+    mock(@map).connect('', {
+      :controller => 'my_controller',
+      :action => 'my_action',
+      :conditions => { :method => :get },
+    })
+    
+    FancyRoutes(@map) do 
+      route(:get).segment('').controller(:my_controller).action(:my_action)
+    end
+  end
+  
+  # an now lets dry up the mocking and route building
+  
+  def fancyroutes(&blk)
+    FancyRoutes(@map,&blk)
+  end
+
+  def expect(meth, path, controller, action)
+    mock(@map).connect(path, {
+      :controller => controller,
+      :action => action,
+      :conditions => { :method => meth },
+    })
+  end
+
+  example "short form route on root" do
+    expect :get, '', 'my_controller', 'my_action'
+    
+    fancyroutes do
+      get / '' >> :my_controller > :my_action
+    end
+  end
+  
+  example "short form route on order" do
+    expect :get, ':slug/order', 'my_controller', 'my_action'
+    
+    fancyroutes do 
+      get / :slug / 'order' >> :my_controller > :my_action
+    end
+  end
+  
+  example "short form route on order as put" do
+    expect :put, ':slug/order', 'my_controller', 'my_action'
+    
+    fancyroutes do
+      put / :slug / 'order' >> :my_controller > :my_action
+    end
+  end
+  
+  example "short form route nested route" do
+    expect :get,  ':slug/order', 'my_controller', 'get_action'
+    expect :post, ':slug/order', 'my_controller', 'post_action'
+    
+    fancyroutes do 
+      with route / :slug >> :my_controller do
+        get / 'order' > :get_action
+        post / 'order' > :post_action
+      end
+    end
+  end
+  
+  example "short form route nested route on method only" do
+    expect :get,  ':slug/order', 'my_controller', 'get_action'
+    expect :post, ':slug/order', 'my_controller', 'post_action'
+    
+    fancyroutes do
+      with route / :slug / 'order' >> :my_controller do
+        get > :get_action
+        post > :post_action
+      end
+    end
+  end
+  
+  example "nested in nested routes" do
+    expect :get,  ':slug/order', 'my_controller', 'get_action'
+    expect :post, ':slug/order', 'my_controller', 'post_action'
+    
+    fancyroutes do
+      with route / :slug do
+        with route >> :my_controller do
+          get / 'order' > :get_action
+          post / 'order' > :post_action
+        end
+      end
+    end
+  end
+  
+  example "with named segment" do
+    expect :get, 'my_controller/:image', 'my_controller', 'my_action'
+    
+    fancyroutes do 
+      get / {'my_controller' => :controller} / :image > :my_action
+    end
+  end
+  
+  example "a named route" do
+    mock(@map).my_name('my_controller/:image', {
+      :controller => 'my_controller',
+      :action => 'my_action',
+      :conditions => { :method => :get }
+    })
+    
+    fancyroutes do 
+      my_name.get / {'my_controller' => :controller} / :image > :my_action
+    end
+  end
+  
+  example "root route" do
+    mock(@map).root(
+      :controller => 'my_controller',
+      :action => 'my_action',
+      :conditions => { :method => :get }
+    )
+    
+    fancyroutes do
+      root >> :my_controller > :my_action
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'fancyroutes'
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: tred-fancyroutes
+version: !ruby/object:Gem::Version 
+  version: 0.9.1
+platform: ruby
+authors: 
+- The TRED Team
+autorequire: fancyroutes
+bindir: bin
+cert_chain: []
+
+date: 2009-03-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: tred3000@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- lib/fancyroutes.rb
+- spec/fancyroutes_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://tred.github.com/fancyroutes
+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: Removing the cruft, bringing the HTTP method to the forefront and sporting a neat DRYing block syntax--FancyRoutes is a layer on top of the Rails routing system which provides an elegant API for mapping requests to your application's controllers and actions.
+test_files: []
+