routing-filter 0.2.1 → 0.2.2

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_3_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+if ActionPack::VERSION::MAJOR == 3
+  require "rails"
+  require 'rack/test'
+
+  class Rails3Test < Test::Unit::TestCase
+    include ::Rack::Test::Methods
+
+    I18n.available_locales = [:en, :de]
+
+    APP = Class.new(Rails::Application).tap do |app|
+      app.config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
+      app.config.session_store :cookie_store, :key => "_myapp_session"
+      app.config.active_support.deprecation = :log
+      app.routes.draw do
+        match "/" => "rails3_test/tests#index"
+        filter :uuid, :pagination ,:locale, :extension
+      end
+      app.initialize!
+    end
+
+    class TestsController < ActionController::Base
+      include Rails.application.routes.url_helpers
+
+      def index
+        url = url_for(params.merge(:only_path => true))
+        render :text => params.merge(:url => url).inspect
+      end
+    end
+
+    def app
+      APP
+    end
+
+    def params
+      last_response.status == 200 ? eval(last_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 /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 /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 /: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
+  end
+end

data/test/routes_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class RoutesTest < Test::Unit::TestCase
+  class RoutingFilter::Test < Filter
+    def around_recognize(path, env, &block)
+      'recognized'
+    end
+
+    def around_generate(*args, &block)
+      'generated'
+    end
+  end
+
+  attr_reader :routes
+
+  def setup
+    @routes = draw_routes { |set| set.filter :test }
+  end
+
+  test "routes.filter instantiates and registers a filter" do
+    assert routes.instance_variable_get(:@set).filters.first.is_a?(RoutingFilter::Test)
+  end
+
+  # test "filter.around_recognize is being called" do
+  #   assert_equal 'recognized', routes.recognize_path('/')
+  # end
+
+  test "filter.around_generate is being called" do
+    assert_equal 'generated', routes.generate({})
+  end
+end

data/test/routing_filter_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+include RoutingFilter
+
+class RoutingFilterTest < Test::Unit::TestCase
+  class FooFilter < Filter
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def foo(log, &block)
+      log << name
+      yield
+    end
+  end
+
+  attr_reader :chain
+
+  def setup
+    @chain = Chain.new
+    @chain.unshift FooFilter.new('custom filter')
+    @chain.unshift FooFilter.new('common filter')
+  end
+
+  test "filter.previous is nil for the first filter in the chain" do
+    assert_nil chain.first.previous
+  end
+
+  test "filter.previous returns the previous filter in the chain" do
+    assert_equal chain.first, chain.last.previous
+  end
+
+  test "filter.next is nil for the last filter in the chain" do
+    assert_nil chain.last.next
+  end
+
+  test "filter.next returns the next filter in the chain" do
+    assert_equal chain.last, chain.first.next
+  end
+
+  test "chain.run calls the given method on registered filters in reverse order" do
+    log = []
+    assert_equal 'common filter, custom filter, finalizer', chain.run(:foo, log, &lambda { log << 'finalizer' }).join(', ')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,42 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'rubygems'
+# gem 'actionpack', '~> 2.3' if ENV['RAILS_2']
+require 'test/unit'
+require 'bundler/setup'
+
+require 'i18n'
+require 'action_pack'
+require 'active_support'
+require 'action_controller'
+require 'active_support/core_ext/enumerable.rb'
+require 'test_declarative'
+require 'routing_filter'
+
+include RoutingFilter
+
+class SomeController < ActionController::Base
+end
+
+class Test::Unit::TestCase
+  def draw_routes(&block)
+    normalized_block = rails_2? ? lambda { |set| set.instance_eval(&block) } : block
+    klass = rails_2? ? ActionController::Routing::RouteSet : ActionDispatch::Routing::RouteSet
+    klass.new.tap { |set| set.draw(&normalized_block) }
+  end
+
+  def rails_2?
+    ActionPack::VERSION::MAJOR == 2
+  end
+end
+
+if ActionPack::VERSION::MAJOR == 2
+  ActionController::Routing::RouteSet::Mapper.class_eval do
+    def match(pattern, options)
+      pattern.gsub!('(.:format)', '.:format')
+      controller, action = options.delete(:to).split('#')
+      options.merge!(:controller => controller, :action => action)
+      connect(pattern, options)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: routing-filter
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -82,8 +82,34 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- lib/routing-filter.rb
+- lib/routing_filter/adapters/rails_2.rb
+- lib/routing_filter/adapters/rails_3.rb
+- lib/routing_filter/chain.rb
+- lib/routing_filter/filter.rb
+- lib/routing_filter/filters/extension.rb
+- lib/routing_filter/filters/locale.rb
+- lib/routing_filter/filters/pagination.rb
+- lib/routing_filter/filters/uuid.rb
+- lib/routing_filter/version.rb
+- lib/routing_filter.rb
+- test/all.rb
+- test/filters/all_filters/generation.rb
+- test/filters/all_filters/recognition.rb
+- test/filters/all_filters_test.rb
+- test/filters/extension_test.rb
+- test/filters/locale_test.rb
+- test/filters/pagination_test.rb
+- test/filters/uuid_test.rb
+- test/rails_3_test.rb
+- test/routes_test.rb
+- test/routing_filter_test.rb
+- test/test_helper.rb
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.markdown
 has_rdoc: true
 homepage: http://github.com/svenfuchs/routing-filter
 licenses: []