vigetlabs-routing-filter 0.2.4

data/lib/routing_filter/filters/uuid.rb

@@ -0,0 +1,40 @@
+# The Uuid filter extracts an UUID segment from the beginning of the recognized
+# path and exposes the page parameter as params[:page]. When a path is generated
+# the filter adds the segments to the path accordingly if the page parameter is
+# passed to the url helper.
+#
+#   incoming url: /d00fbbd1-82b6-4c1a-a57d-098d529d6854/product/1
+#   filtered url: /product/1
+#   params:       params[:uuid] = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+#
+# You can install the filter like this:
+#
+#   # in config/routes.rb
+#   Rails.application.routes.draw do
+#     filter :uuid
+#   end
+#
+# To make your named_route helpers or url_for add the uuid segment you can use:
+#
+#   product_path(:uuid => uuid)
+#   url_for(product, :uuid => uuid)
+
+module RoutingFilter
+  class Uuid < Filter
+    UUID_SEGMENT = %r(^/?([a-z\d]{8}\-[a-z\d]{4}\-[a-z\d]{4}\-[a-z\d]{4}\-[a-z\d]{12})(/)?)
+    
+    def around_recognize(path, env, &block)
+      uuid = extract_segment!(UUID_SEGMENT, path)
+      yield.tap do |params|
+        params[:uuid] = uuid if uuid
+      end
+    end
+
+    def around_generate(params, &block)
+      uuid = params.delete(:uuid)
+      yield.tap do |result|
+        prepend_segment!(result, uuid) if uuid
+      end
+    end
+  end
+end

data/lib/routing_filter/version.rb

@@ -0,0 +1,3 @@
+module RoutingFilter
+  VERSION = '0.2.4'
+end

data/test/all.rb

@@ -0,0 +1 @@
+Dir[File.expand_path('../**/*_test.rb', __FILE__)].each { |file| require file }

data/test/filters/all_filters/generation.rb

@@ -0,0 +1,42 @@
+module Generation
+  test 'generates the path /some.html (extension)' do
+    params = self.params
+    assert_equal '/some.html', routes.generate(params)
+  end
+  
+  # extension with any
+  
+  test 'generates the path /de/some (extension, locale)' do
+    params = self.params.merge(:locale => 'de')
+    assert_equal '/de/some.html', routes.generate(params)
+  end
+
+  test 'generates the path /some/page/2 (extension, pagination)' do
+    params = self.params.merge(:page => 2)
+    assert_equal '/some/page/2.html', routes.generate(params)
+  end
+
+  test 'generates the path /:uuid/some (extension, uuid)' do
+    params = self.params.merge(:uuid => uuid)
+    assert_equal "/#{uuid}/some.html", routes.generate(params)
+  end
+  
+  # extension, locale with any
+  
+  test 'generates the path /de/some/page/2 (extension, locale, pagination)' do
+    params = self.params.merge(:locale => 'de', :page => 2)
+    assert_equal '/de/some/page/2.html', routes.generate(params)
+  end
+  
+  test 'generates the path /de/:uuid/some (extension, locale, uuid)' do
+    params = self.params.merge(:locale => 'de', :uuid => uuid)
+    assert_equal "/de/#{uuid}/some.html", routes.generate(params)
+  end
+  
+  # all
+  
+  test 'generates the path /de/some/page/2 (extension, pagination, uuid)' do
+    params = self.params.merge(:locale => 'de', :page => 2, :uuid => uuid)
+    assert_equal "/de/#{uuid}/some/page/2.html", routes.generate(params)
+  end
+end

data/test/filters/all_filters/recognition.rb

@@ -0,0 +1,92 @@
+module Recognition
+  # 1 filter
+
+  test 'recognizes the path /some.html (extension)' do
+    params = self.params
+    assert_equal params, routes.recognize_path('/some.html')
+  end
+
+  test 'recognizes the path /de/some (locale)' do
+    params = self.params.merge(:locale => 'de')
+    assert_equal params, routes.recognize_path('/de/some')
+  end
+
+  test 'recognizes the path /some/page/2 (pagination)' do
+    params = self.params.merge(:page => 2)
+    assert_equal params, routes.recognize_path('/some/page/2')
+  end
+
+  test 'recognizes the path /:uuid/some (uuid)' do
+    params = self.params.merge(:uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some")
+  end
+  
+  # extension with any
+
+  test 'recognizes the path /de/some.html (extension, locale)' do
+    params = self.params.merge(:locale => 'de')
+    assert_equal params, routes.recognize_path('/de/some.html')
+  end
+
+  test 'recognizes the path /some/page/2.html (extension, pagination)' do
+    params = self.params.merge(:page => 2)
+    assert_equal params, routes.recognize_path('/some/page/2.html')
+  end
+
+  test 'recognizes the path /:uuid/some.html (extension, uuid)' do
+    params = self.params.merge(:uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some.html")
+  end
+
+  # locale with any
+
+  test 'recognizes the path /de/some/page/2 (locale, pagination)' do
+    params = self.params.merge(:locale => 'de', :page => 2)
+    assert_equal params, routes.recognize_path('/de/some/page/2')
+  end
+
+  test 'recognizes the path /de/:uuid/some (locale, uuid)' do
+    params = self.params.merge(:locale => 'de', :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some")
+  end
+
+  # pagination with any
+
+  test 'recognizes the path /:uuid/some/page/2 (pagination, uuid)' do
+    params = self.params.merge(:page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some/page/2")
+  end
+
+  # extension, locale with any
+
+  test 'recognizes the path /de/some/page/2.html (extension, locale, pagination)' do
+    params = self.params.merge(:locale => 'de', :page => 2)
+    assert_equal params, routes.recognize_path("/de/some/page/2.html")
+  end
+
+  test 'recognizes the path /de/:uuid/some.html (extension, locale, uuid)' do
+    params = self.params.merge(:locale => 'de', :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some.html")
+  end
+  
+  # extension, pagination with any
+
+  test 'recognizes the path /some/page/2.html (extension, pagination, uuid)' do
+    params = self.params.merge(:page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/#{uuid}/some/page/2.html")
+  end
+  
+  # locale, pagination with any
+
+  test 'recognizes the path /de/some/page/2 (locale, pagination, uuid)' do
+    params = self.params.merge(:locale => 'de', :page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some/page/2")
+  end
+  
+  # all
+
+  test 'recognizes the path /de/:uuid/some/page/2.html (extension, locale, pagination, uuid)' do
+    params = self.params.merge(:locale => 'de', :page => 2, :uuid => uuid)
+    assert_equal params, routes.recognize_path("/de/#{uuid}/some/page/2.html")
+  end
+end

data/test/filters/all_filters_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'filters/all_filters/generation'
+require 'filters/all_filters/recognition'
+
+class AllFiltersTest < Test::Unit::TestCase
+  attr_reader :routes, :params, :uuid
+
+  def setup
+    I18n.locale = nil
+    I18n.default_locale = :en
+    I18n.available_locales = %w(de en)
+
+    RoutingFilter::Locale.include_default_locale = false
+
+    @params = { :controller => 'some', :action => 'index' }
+    @uuid   = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+
+    @routes = draw_routes do
+      filter :uuid, :pagination ,:locale, :extension
+      match 'some', :to => 'some#index'
+    end
+  end
+
+  include Recognition, Generation
+end

data/test/filters/extension_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class ForceExtensionTest < Test::Unit::TestCase
+  attr_reader :routes, :params
+
+  def setup
+    @routes = draw_routes do
+      filter :extension, :exclude => %r(^/(admin|$))
+      match '/',                  :to => 'some#index'
+      match 'some/:id(.:format)', :to => 'some#show'
+      match '/admin/some/new',    :to => 'some#new'
+    end
+    @params = { :controller => 'some', :action => 'show', :id => '1' }
+  end
+
+  test 'recognizes the path some/1.html and strips the extension' do
+    assert_nil routes.recognize_path('/some/1.html')[:format]
+  end
+
+  test 'recognizes the path some/1.xml but does not strip the extension' do
+    assert 'xml', routes.recognize_path('/some/1.xml')[:format]
+  end
+
+  test 'appends the extension .html to the generated path' do
+    assert_equal '/some/1.html', routes.generate(params)
+  end
+
+  test 'does not touch existing extensions in generated paths' do
+    assert_equal '/some/1.xml', routes.generate(params.merge(:format => 'xml'))
+  end
+
+  test 'does not touch url query params in generated paths' do
+    assert_equal '/some/1.html?foo=bar', routes.generate(params.merge(:foo => 'bar'))
+  end
+
+  test 'excludes / by default' do
+    assert_equal '/', routes.generate(:controller => 'some', :action => 'index')
+  end
+
+  test 'excludes / by default (with url query params)' do
+    assert_equal '/?foo=bar', routes.generate(:controller => 'some', :action => 'index', :foo => 'bar')
+  end
+
+  test 'excludes with custom regexp' do
+    assert_equal '/admin/some/new', routes.generate(:controller => 'some', :action => 'new')
+  end
+
+  # TODO - why would anyone want to have this?
+  #
+  # test 'does not exclude / when :exclude => false was passed' do
+  #   routes.filters.first.instance_variable_set(:@exclude, false)
+  #   assert_equal '/.html', routes.generate(:controller => 'some', :action => 'index')
+  # end
+end

data/test/filters/locale_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class LocaleTest < Test::Unit::TestCase
+  attr_reader :routes, :show_params, :index_params
+
+  def setup
+    I18n.locale = nil
+    I18n.default_locale = :en
+    I18n.available_locales = %w(de en)
+
+    RoutingFilter::Locale.include_default_locale = true
+
+    @index_params = { :controller => 'some', :action => 'index' }
+    @show_params  = { :controller => 'some', :action => 'show', :id => '1' }
+
+    @routes = draw_routes do
+      filter :locale
+      match 'products/:id', :to => 'some#show'
+      match '/', :to => 'some#index'
+    end
+  end
+
+  test 'recognizes the path /en' do
+    assert_equal index_params.merge(:locale => 'en'), routes.recognize_path('/en')
+  end
+
+  test 'recognizes the path /en/' do
+    assert_equal index_params.merge(:locale => 'en'), routes.recognize_path('/en/')
+  end
+
+  test 'recognizes the path /en/products/1' do
+    assert_equal show_params.merge(:locale => 'en'), routes.recognize_path('/en/products/1')
+  end
+
+  test 'recognizes the path /de/products/1' do
+    assert_equal show_params.merge(:locale => 'de'), routes.recognize_path('/de/products/1')
+  end
+
+
+  test 'prepends the segments /:locale to the generated path / if the current locale is not the default locale' do
+    I18n.locale = 'de'
+    assert_equal '/de', routes.generate(index_params)
+  end
+
+  test 'prepends the segments /:locale to the generated path /products/1 if the current locale is not the default locale' do
+    I18n.locale = 'de'
+    assert_equal '/de/products/1', routes.generate(show_params)
+  end
+
+  test 'prepends the segments /:locale to the generated path if it was passed as a param' do
+    assert_equal '/de/products/1', routes.generate(show_params.merge(:locale => 'de'))
+  end
+
+  test 'prepends the segments /:locale if the given locale is the default_locale and include_default_locale is true' do
+    assert RoutingFilter::Locale.include_default_locale?
+    assert_equal '/en/products/1', routes.generate(show_params.merge(:locale => 'en'))
+  end
+
+  test 'does not prepend the segments /:locale if the current locale is the default_locale and include_default_locale is false' do
+    I18n.locale = 'en'
+    RoutingFilter::Locale.include_default_locale = false
+    assert_equal '/products/1', routes.generate(show_params)
+  end
+
+  test 'does not prepend the segments /:locale if the given locale is the default_locale and include_default_locale is false' do
+    RoutingFilter::Locale.include_default_locale = false
+    assert_equal '/products/1', routes.generate(show_params.merge(:locale => I18n.default_locale))
+  end
+end

data/test/filters/pagination_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase
+  attr_reader :routes, :params
+
+  def setup
+    @routes = draw_routes do
+      filter :pagination
+      match 'some', :to => 'some#index'
+    end
+    @params = { :controller => 'some', :action => 'index', :page => 2 }
+  end
+
+  test 'recognizes the path some/page/2' do
+    assert_equal params, routes.recognize_path('/some/page/2')
+  end
+
+  test 'appends the segments /page/:page to the generated path if the passed :page param does not equal 1' do
+    assert_equal '/some/page/2', routes.generate(params)
+  end
+
+  test 'does not append anything to the generated path if the passed :page param equals 1' do
+    assert_equal '/some', routes.generate(params.merge(:page => 1))
+  end
+
+  test 'appends the segments /page/:page to the generated path but respects url query params' do
+    assert_equal '/some/page/2?foo=bar', routes.generate(params.merge(:foo => 'bar'))
+  end
+end

data/test/filters/uuid_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class UuidTest < Test::Unit::TestCase
+  attr_reader :routes, :uuid, :params
+
+  def setup
+    @routes = draw_routes do
+      filter :uuid
+      match 'some/:id', :to => 'some#show'
+    end
+    @uuid   = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+    @params = { :controller => 'some', :action => 'show', :id => '1', :uuid => uuid }
+  end
+
+  test 'recognizes the path :uuid/product/1' do
+    assert_equal params, routes.recognize_path("/#{uuid}/some/1")
+  end
+
+  test 'prepends the :uuid segment to the generated path if passed as a param' do
+    assert_equal "/#{uuid}/some/1", routes.generate(params)
+  end
+
+  test 'matches uuid segments' do
+    pattern = Uuid::UUID_SEGMENT
+    uuids = %w(
+      d00fbbd1-82b6-4c1a-a57d-098d529d6854 cdb33760-94da-11df-981c-0800200c9a66
+      0c65a6ec-6491-4316-a137-0021cf4e6471 cbbd44c3-c195-48e5-be04-3cc8a6578f51
+    )
+    uuids.each { |uuid| assert pattern.match("/#{uuid}/"), "does not match /#{uuid}/ but should" }
+  end
+
+  test 'does not match non-uuid segments' do
+    pattern = Uuid::UUID_SEGMENT
+    uuids = %w(
+      !aaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa aaaa-aaaaaaaa-aaaa-aaaa-aaaaaaaaaaaa
+      aaaaaaaa_aaaa_aaaa_aaaa_aaaaaaaaaaaa aaaaaaaa-aaaa-aaaa-aaaaaaaaaaaa
+    )
+    uuids.each { |uuid| assert !pattern.match("/#{uuid}/"), "matches /#{uuid}/ but shouldn't" }
+  end
+end

data/test/rails_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+require "test_adapters/rails_#{ActionPack::VERSION::MAJOR}"
+
+class RailsTest < Test::Unit::TestCase
+  include TestRailsAdapter
+
+  I18n.available_locales = [:en, :de]
+
+  class TestsController < ActionController::Base
+    include Rails.application.routes.url_helpers if defined?(Rails)
+
+    def index
+      url = url_for(params.merge(:only_path => true))
+      render :text => params.merge(:url => url).inspect
+    end
+
+    def show
+      url = foo_path(params)
+      render :text => params.merge(:url => url).inspect
+    end
+  end
+
+  def params
+    response.status.to_s.include?('200') ? eval(response.body).symbolize_keys : {}
+  end
+
+  test "get to /" do
+    get '/'
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en.html', params[:url]
+  end
+
+  test "get to /foo/1" do
+    get '/foo/1'
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en/foo/1.html', params[:url]
+  end
+
+  test "get to /de" do
+    get '/de'
+    assert_equal 'de', params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/de.html', params[:url]
+  end
+
+  test "get to /de/foo/1" do
+    get '/de/foo/1'
+    assert_equal 'de', params[:locale]
+    assert_nil params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/de/foo/1.html', params[:url]
+  end
+
+  test "get to /page/2" do
+    get '/page/2'
+    assert_nil params[:locale]
+    assert_equal 2, params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en/page/2.html', params[:url]
+  end
+
+  test "get to /foo/1/page/2" do
+    get '/foo/1/page/2'
+    assert_nil params[:locale]
+    assert_equal 2, params[:page]
+    assert_nil params[:uuid]
+    assert_equal '/en/foo/1/page/2.html', params[:url]
+  end
+
+  test "get to /:uuid" do
+    uuid = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+    get "/#{uuid}"
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_equal uuid, params[:uuid]
+    assert_equal "/en/#{uuid}.html", params[:url]
+  end
+
+  test "get to /foo/1/:uuid" do
+    uuid = 'd00fbbd1-82b6-4c1a-a57d-098d529d6854'
+    get "/#{uuid}/foo/1"
+    assert_nil params[:locale]
+    assert_nil params[:page]
+    assert_equal uuid, params[:uuid]
+    assert_equal "/en/#{uuid}/foo/1.html", params[:url]
+  end
+end