sayso-routing-filter 0.2.2.001

data/lib/routing_filter/chain.rb

@@ -0,0 +1,22 @@
+module RoutingFilter
+  class Chain < Array
+    def <<(filter)
+      filter.previous, last.next = last, filter if last
+      super
+    end
+    alias push <<
+
+    def unshift(filter)
+      filter.next, first.previous = first, filter if first
+      super
+    end
+
+    def run(method, *args, &final)
+      active? ? first.run(method, *args, &final) : final.call
+    end
+
+    def active?
+      RoutingFilter.active? && !empty?
+    end
+  end
+end

data/lib/routing_filter/filter.rb

@@ -0,0 +1,37 @@
+module RoutingFilter
+  class Filter
+    attr_accessor :next, :previous, :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def run(method, *args, &block)
+      _next = self.next ? proc {|path, env| self.next.run(method, *args, &block) } : block
+      RoutingFilter.active? ? send(method, *args, &_next) : _next.call(*args)
+    end
+
+    def run_reverse(method, *args, &block)
+      _prev = previous ? lambda { previous.run_reverse(method, *args, &block) } : block
+      RoutingFilter.active? ? send(method, *args, &_prev) : _prev.call(*args)
+    end
+
+    protected
+
+      def extract_segment!(pattern, path)
+        path.sub!(pattern) { $2 || '' }
+        path.replace('/') if path.empty?
+        $1
+      end
+
+      def prepend_segment!(result, segment)
+        url = result.is_a?(Array) ? result.first : result
+        url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{segment}#{$2 == '/' ? '' : $2}" }
+      end
+
+      def append_segment!(result, segment)
+        url = result.is_a?(Array) ? result.first : result
+        url.sub!(%r(/?($|\?))) { "/#{segment}#{$1}" }
+      end
+  end
+end

data/lib/routing_filter/filters/extension.rb

@@ -0,0 +1,76 @@
+# The Extension filter chops a file extension off from the end of the
+# recognized path. When a path is generated the filter re-adds the extension 
+# to the path accordingly.
+# 
+#   incoming url: /de/products/page/1
+#   filtered url: /de/products
+#   params:       params[:locale] = 'de'
+# 
+# You can install the filter like this:
+#
+#   # in config/routes.rb
+#   Rails.application.routes.draw do
+#     filter :locale
+#   end
+#
+# To make your named_route helpers or url_for add the pagination segments you 
+# can use:
+#
+#   products_path(:locale => 'de')
+#   url_for(:products, :locale => 'de'))
+
+module RoutingFilter
+  class Extension < Filter
+    attr_reader :extension, :exclude
+
+    def initialize(*args)
+      super
+      @exclude   = options[:exclude]
+      @extension = options[:extension] || 'html'
+    end
+
+    def around_recognize(path, env, &block)
+      extract_extension!(path) unless excluded?(path)
+      yield(path, env)
+    end
+
+    def around_generate(params, &block)
+      yield.tap do |result|
+        url = result.is_a?(Array) ? result.first : result
+        append_extension!(url) if append_extension?(url)
+      end
+    end
+
+    protected
+    
+      def extract_extension!(path)
+        path.sub!(/\.#{extension}$/, '')
+        $1
+      end
+      
+      def append_extension?(url)
+        !(blank?(url) || excluded?(url) || mime_extension?(url))
+      end
+      
+      def append_extension!(url)
+        url.replace url.sub(/(\?|$)/, ".#{extension}\\1")
+      end
+      
+      def blank?(url)
+        url.blank? || !!url.match(%r(^/(\?|$)))
+      end
+      
+      def excluded?(url)
+        case exclude
+        when Regexp
+          url =~ exclude
+        when Proc
+          exclude.call(url)
+        end
+      end
+      
+      def mime_extension?(url)
+        url =~ /\.#{Mime::EXTENSION_LOOKUP.keys.join('|')}(\?|$)/
+      end
+  end
+end

data/lib/routing_filter/filters/language.rb

@@ -0,0 +1,88 @@
+# The language filter extracts segments matching /:language 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: /de/products/page/1
+#   filtered url: /de/products
+#   params:       params[:language] = 'de'
+#
+# You can install the filter like this:
+#
+#   # in config/routes.rb
+#   Rails.application.routes.draw do
+#     filter :language
+#   end
+#
+# To make your named_route helpers or url_for add the pagination segments you
+# can use:
+#
+#   products_path(:language => 'de')
+#   url_for(:products, :language => 'de'))
+
+require 'i18n'
+
+module RoutingFilter
+  class Language < Filter
+    @@include_default_language = true
+    cattr_writer :include_default_language
+
+    class << self
+      def include_default_language?
+        @@include_default_language
+      end
+
+      def languages
+        @@languages ||= I18n.available_locales.map{|l| l.to_sym}
+      end
+
+      def languages=(languages)
+        @@languages = languages.map(&:to_sym)
+      end
+
+      #redefine original method to support locales like en-RU etc
+      def languages_pattern
+        @@languages_pattern ||= %r(^/(#{self.languages.map{|l| Regexp.escape(l.to_s).sub(/[A-Z]{2}$/,"[A-Z]{2}")}.join('|')})(?=/|$))
+      end
+
+    end
+
+    def around_recognize(path, env, &block)
+      language = extract_segment!(self.class.languages_pattern, path) # remove the language from the beginning of the path
+      yield.tap do |params|                                       # invoke the given block (calls more filters and finally routing)
+        params[:language] = language if language                  # set recognized language to the resulting params hash
+      end
+    end
+
+    def around_generate(*args, &block)
+      params = args.extract_options!                              # this is because we might get a call like forum_topics_path(forum, topic, :language => :en)
+
+      language = params[:language]                           # extract the passed :language option
+      language = I18n.locale if language.nil?  # default to I18n.locale when language is nil (could also be false)
+      language = I18n.lang_tag(language) if language
+      language = nil unless valid_language?(language)                   # reset to no language when language is not valid
+       
+      params.delete(:language) unless configatron.prevent_deleting_language_param
+
+      args << params
+
+      yield.tap do |result|
+        prepend_segment!(result, language) if prepend_language?(language)
+      end
+    end
+
+    protected
+
+    def valid_language?(language)
+      language && self.class.languages.include?(language.to_sym)
+    end
+
+    def default_language?(language)
+      language && language.to_sym == I18n.lang_tag(I18n.default_locale).to_sym
+    end
+
+    def prepend_language?(language)
+      language && (self.class.include_default_language? || !default_language?(language))
+    end
+  end
+end

data/lib/routing_filter/filters/locale.rb

@@ -0,0 +1,83 @@
+# The Locale filter extracts segments matching /:locale 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: /de/products/page/1
+#   filtered url: /de/products
+#   params:       params[:locale] = 'de'
+#
+# You can install the filter like this:
+#
+#   # in config/routes.rb
+#   Rails.application.routes.draw do
+#     filter :locale
+#   end
+#
+# To make your named_route helpers or url_for add the pagination segments you
+# can use:
+#
+#   products_path(:locale => 'de')
+#   url_for(:products, :locale => 'de'))
+
+require 'i18n'
+
+module RoutingFilter
+  class Locale < Filter
+    @@include_default_locale = true
+    cattr_writer :include_default_locale
+
+    class << self
+      def include_default_locale?
+        @@include_default_locale
+      end
+
+      def locales
+        @@locales ||= I18n.available_locales.map(&:to_sym)
+      end
+
+      def locales=(locales)
+        @@locales = locales.map(&:to_sym)
+      end
+
+      def locales_pattern
+        @@locales_pattern ||= %r(^/(#{self.locales.map { |l| Regexp.escape(l.to_s) }.join('|')})(?=/|$))
+      end
+    end
+
+    def around_recognize(path, env, &block)
+      locale = extract_segment!(self.class.locales_pattern, path) # remove the locale from the beginning of the path
+      yield.tap do |params|                                       # invoke the given block (calls more filters and finally routing)
+        params[:locale] = locale if locale                        # set recognized locale to the resulting params hash
+      end
+    end
+
+    def around_generate(*args, &block)
+      params = args.extract_options!                              # this is because we might get a call like forum_topics_path(forum, topic, :locale => :en)
+
+      locale = params.delete(:locale)                             # extract the passed :locale option
+      locale = I18n.locale if locale.nil?                         # default to I18n.locale when locale is nil (could also be false)
+      locale = nil unless valid_locale?(locale)                   # reset to no locale when locale is not valid
+
+      args << params
+
+      yield.tap do |result|
+        prepend_segment!(result, locale) if prepend_locale?(locale)
+      end
+    end
+
+    protected
+
+      def valid_locale?(locale)
+        locale && self.class.locales.include?(locale.to_sym)
+      end
+
+      def default_locale?(locale)
+        locale && locale.to_sym == I18n.default_locale.to_sym
+      end
+
+      def prepend_locale?(locale)
+        locale && (self.class.include_default_locale? || !default_locale?(locale))
+      end
+  end
+end

data/lib/routing_filter/filters/pagination.rb

@@ -0,0 +1,47 @@
+# The Pagination filter extracts segments matching /page/:page from the end of
+# the recognized url and exposes the page parameter as params[:page]. When a
+# url is generated the filter adds the segments to the url accordingly if the
+# page parameter is passed to the url helper.
+#
+#   incoming url: /products/page/1
+#   filtered url: /products
+#   params:       params[:page] = 1
+#
+# You can install the filter like this:
+#
+#   # in config/routes.rb
+#   Rails.application.routes.draw do
+#     filter :pagination
+#   end
+#
+# To make your named_route helpers or url_for add the pagination segments you
+# can use:
+#
+#   products_path(:page => 1)
+#   url_for(:products, :page => 1)
+
+module RoutingFilter
+  class Pagination < Filter
+    PAGINATION_SEGMENT = %r(/page/([\d]+)/?$)
+
+    def around_recognize(path, env, &block)
+      page = extract_segment!(PAGINATION_SEGMENT, path)
+      yield(path, env).tap do |params|
+        params[:page] = page.to_i if page
+      end
+    end
+
+    def around_generate(params, &block)
+      page = params.delete(:page)
+      yield.tap do |result|
+        append_segment!(result, "page/#{page}") if append_page?(page)
+      end
+    end
+
+    protected
+
+      def append_page?(page)
+        page && page.to_i != 1
+      end
+  end
+end

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.2.001'
+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