routing-filter 0.0.1 → 0.1.0

data/lib/routing_filter/adapters/rails_2.rb

@@ -0,0 +1,69 @@
+require 'action_controller'
+
+# allows to install a filter to the route set by calling: map.filter 'locale'
+ActionController::Routing::RouteSet::Mapper.class_eval do
+  def filter(*args)
+    @set.add_filters(*args)
+  end
+end
+
+# same here for the optimized url generation in named routes
+ActionController::Routing::RouteSet::NamedRouteCollection.class_eval do
+  # gosh. monkey engineering optimization code
+  def generate_optimisation_block_with_filtering(*args)
+    code = generate_optimisation_block_without_filtering(*args)
+    if match = code.match(%r(^return (.*) if (.*)))
+      # returned string must not contain newlines, or we'll spill out of inline code comments in
+      # ActionController::Routing::RouteSet::NamedRouteCollection#define_url_helper
+      "returning(#{match[1]}) { |result|" +
+      "  ActionController::Routing::Routes.filters.run(:around_generate, *args, &lambda{ result }) " +
+      "} if #{match[2]}"
+    end
+  end
+  alias_method_chain :generate_optimisation_block, :filtering
+end
+
+ActionController::Routing::RouteSet.class_eval do
+  attr_writer :filters
+
+  def filters
+    @filters ||= RoutingFilter::Chain.new
+  end
+
+  def add_filters(*names)
+    options = names.extract_options!
+    names.each { |name| filters << RoutingFilter.build(name, options) }
+  end
+
+  def recognize_path_with_filtering(path, env = {})
+    path = ::URI.unescape(path.dup) # string is frozen due to memoize
+    filters.run(:around_recognize, path, env, &lambda{ recognize_path_without_filtering(path, env) })
+  end
+  alias_method_chain :recognize_path, :filtering
+
+  def generate_with_filtering(*args)
+    filters.run(:around_generate, args.first, &lambda{ generate_without_filtering(*args) })
+  end
+  alias_method_chain :generate, :filtering
+
+  def clear_with_filtering!
+    @filters.clear if @filters
+    clear_without_filtering!
+  end
+  alias_method_chain :clear!, :filtering
+
+  # add some useful information to the request environment
+  # right, this is from jamis buck's excellent article about routes internals
+  # http://weblog.jamisbuck.org/2006/10/26/monkey-patching-rails-extending-routes-2
+  # TODO move this ... where?
+  alias_method :extract_request_environment_without_host, :extract_request_environment unless method_defined? :extract_request_environment_without_host
+  def extract_request_environment(request)
+    returning extract_request_environment_without_host(request) do |env|
+      env.merge! :host => request.host,
+                 :port => request.port,
+                 :host_with_port => request.host_with_port,
+                 :domain => request.domain,
+                 :subdomain => request.subdomains.first
+    end
+  end
+end

data/lib/routing_filter/adapters/rails_3.rb

@@ -0,0 +1,64 @@
+require 'action_dispatch'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/hash/reverse_merge'
+
+[ActionDispatch::Routing::Mapper, ActionDispatch::Routing::DeprecatedMapper].each do |mapper|
+  mapper.class_eval do
+    def filter(*args)
+      @set.add_filters(*args)
+    end
+  end
+end
+
+ActionDispatch::Routing::RouteSet.class_eval do
+  def add_filters(*names)
+    options = names.extract_options!
+    names.each { |name| @set.filters << RoutingFilter.build(name, options) }
+  end
+
+  def recognize_path_with_filtering(path, env = {})
+    @set.filters.run(:around_recognize, path, env, &lambda{ recognize_path_without_filtering(path, env) })
+  end
+  alias_method_chain :recognize_path, :filtering
+
+  def generate_with_filtering(*args)
+    @set.filters.run(:around_generate, args.first, &lambda{ generate_without_filtering(*args) })
+  end
+  alias_method_chain :generate, :filtering
+
+  def clear_with_filtering!
+    @set.filters.clear if @set
+    clear_without_filtering!
+  end
+  alias_method_chain :clear!, :filtering
+end
+
+require 'rack/mount/route_set'
+require 'rack/mount/code_generation'
+
+Rack::Mount::RouteSet.class_eval do
+  def filters
+    @filters ||= RoutingFilter::Chain.new
+  end
+end
+
+# gah. so who's hoped monkeypatching optimized code wouldn't be necessary with rails 3 anymore?
+Rack::Mount::CodeGeneration.class_eval do
+  def optimize_recognize_with_filtering!
+    optimize_recognize_without_filtering!
+    (class << self; self; end).class_eval do
+      alias_method_chain :recognize, :filtering
+    end
+  end
+  alias :optimize_recognize_without_filtering! :optimize_recognize!
+  alias :optimize_recognize! :optimize_recognize_with_filtering!
+
+  def recognize_with_filtering(request, &block)
+    filters.run(:around_recognize, request.env['PATH_INFO'], {}, &lambda{ recognize_without_filtering(request, &block) })
+  end
+end
+
+
+
+
+

data/lib/routing_filter/chain.rb

@@ -0,0 +1,16 @@
+module RoutingFilter
+  class Chain < Array
+    def <<(filter)
+      filter.previous, last.next = last, filter if last
+      super
+    end
+    
+    def run(method, *args, &final)
+      RoutingFilter.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,19 @@
+module RoutingFilter
+  class Filter
+    attr_accessor :next, :previous, :options
+    
+    def initialize(options = {})
+      @options = options
+    end
+
+    def run(method, *args, &block)
+      _next = self.next ? lambda { 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
+  end
+end

data/lib/routing_filter/{force_extension.rb → filters/extension.rb}

@@ -1,13 +1,32 @@
-require 'routing_filter/base'
+# 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 ForceExtension < Base
+  class Extension < Filter
     attr_reader :extension, :exclude
 
     def initialize(*args)
       super
-      @extension ||= 'html'
-      @exclude = %r(^(http.?://[^/]+)?\/?$) if @exclude.nil?
+      @exclude   = options[:exclude]
+      @extension = options[:extension] || 'html'
     end
 
     def around_recognize(path, env, &block)
@@ -16,21 +35,29 @@ module RoutingFilter
     end
 
     def around_generate(*args, &block)
-      returning yield do |result|
+      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}$/, ''
+        path.sub!(/\.#{extension}$/, '')
         $1
       end
       
       def append_extension?(url)
-        !(url.blank? || excluded?(url) || mime_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)
@@ -45,13 +72,5 @@ module RoutingFilter
       def mime_extension?(url)
         url =~ /\.#{Mime::EXTENSION_LOOKUP.keys.join('|')}(\?|$)/
       end
-      
-      def append_extension!(url)
-        url.replace url.sub(/(\?|$)/, ".#{extension}\\1")
-      end
-
-      def append_page!(url, page)
-        url.replace "#{url}/pages/#{page}"
-      end
   end
 end

data/lib/routing_filter/{locale.rb → filters/locale.rb}

@@ -1,8 +1,29 @@
+# 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'
-require 'routing_filter/base'
 
 module RoutingFilter
-  class Locale < Base
+  class Locale < Filter
     @@include_default_locale = true
     cattr_writer :include_default_locale
 
@@ -26,7 +47,7 @@ module RoutingFilter
 
     def around_recognize(path, env, &block)
       locale = extract_locale!(path)                 # remove the locale from the beginning of the path
-      returning yield do |params|                    # invoke the given block (calls more filters and finally routing)
+      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
@@ -36,25 +57,18 @@ module RoutingFilter
       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
 
-      returning yield do |result|
-        if locale && prepend_locale?(locale)
-          url = result.is_a?(Array) ? result.first : result
-          prepend_locale!(url, locale)
-        end
+      yield.tap do |result|
+        prepend_locale!(result, locale) if prepend_locale?(locale)
       end
     end
 
     protected
 
       def extract_locale!(path)
-        path.sub! self.class.locales_pattern, ''
+        path.sub!(self.class.locales_pattern, '')
         $1
       end
 
-      def prepend_locale?(locale)
-        self.class.include_default_locale? || !default_locale?(locale)
-      end
-
       def valid_locale?(locale)
         locale && self.class.locales.include?(locale.to_sym)
       end
@@ -63,7 +77,12 @@ module RoutingFilter
         locale && locale.to_sym == I18n.default_locale.to_sym
       end
 
-      def prepend_locale!(url, locale)
+      def prepend_locale?(locale)
+        locale && (self.class.include_default_locale? || !default_locale?(locale))
+      end
+
+      def prepend_locale!(result, locale)
+        url = result.is_a?(Array) ? result.first : result
         url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{locale}#{$2}" }
       end
   end

data/lib/routing_filter/filters/pagination.rb

@@ -0,0 +1,51 @@
+# 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
+    def around_recognize(path, env, &block)
+      page = extract_page!(path)
+      yield(path, env).tap do |params|
+        params[:page] = page.to_i if page
+      end
+    end
+
+    def around_generate(*args, &block)
+      page = args.extract_options!.delete(:page)
+      yield.tap do |result|
+        append_page!(result, page) if page && page.to_i != 1
+      end
+    end
+
+    protected
+
+      def extract_page!(path)
+        path.sub! %r(/page/([\d]+)/?$), ''
+        $1
+      end
+
+      def append_page!(result, page)
+        url = result.is_a?(Array) ? result.first : result
+        url.sub!(/($|\?)/) { "/page/#{page}#{$1}" }
+      end
+  end
+end

data/lib/routing_filter/filters/uuid.rb

@@ -0,0 +1,52 @@
+# 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_uuid!(path)
+      yield.tap do |params|
+        params[:uuid] = uuid if uuid
+      end
+    end
+
+    def around_generate(*args, &block)
+      uuid = args.extract_options!.delete(:uuid)
+      yield.tap do |result|
+        prepend_uuid!(result, uuid) if uuid
+      end
+    end
+
+    protected
+
+      def extract_uuid!(path)
+        path.sub!(UUID_SEGMENT, '/')
+        $1
+      end
+
+      def prepend_uuid!(result, uuid)
+        url = result.is_a?(Array) ? result.first : result
+        url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{uuid}#{$2}" }
+      end
+  end
+end

data/lib/routing_filter/version.rb

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

data/lib/routing_filter.rb

@@ -1,94 +1,27 @@
-module RoutingFilter
-  mattr_accessor :active
-  @@active = true
-
-  class Chain < Array
-    def << (filter)
-      filter.chain = self
-      super
-    end
-
-    def run(method, *args, &final)
-      RoutingFilter.active && !first.nil? ? first.run(method, *args, &final) : final.call
-    end
-
-    def run_reverse(method, *args, &final)
-      RoutingFilter.active && !last.nil? ? last.run_reverse(method, *args, &final) : final.call
-    end
+require 'action_pack'
+require 'active_support/core_ext/string/inflections'
 
-    def predecessor(filter)
-      ix = index(filter)
-      ix > 0 ? self[ix - 1] : nil
+module RoutingFilter
+  autoload :Filter,     'routing_filter/filter'
+  autoload :Chain,      'routing_filter/chain'
+  autoload :Extension,  'routing_filter/filters/extension'
+  autoload :Locale,     'routing_filter/filters/locale'
+  autoload :Pagination, 'routing_filter/filters/pagination'
+  autoload :Uuid,       'routing_filter/filters/uuid'
+
+  class << self
+    def build(name, options)
+      const_get(name.to_s.camelize).new(options)
     end
 
-    def successor(filter)
-      ix = index(filter)
-      ix < length - 1 ? self[ix + 1] : nil
+    def active=(active)
+      @@active = active
     end
-  end
-end
-
-# allows to install a filter to the route set by calling: map.filter 'locale'
-ActionController::Routing::RouteSet::Mapper.class_eval do
-  def filter(name, options = {})
-    require options.delete(:file) || "routing_filter/#{name}"
-    klass = RoutingFilter.const_get(name.to_s.camelize)
-    @set.filters << klass.new(options)
-  end
-end
 
-# same here for the optimized url generation in named routes
-ActionController::Routing::RouteSet::NamedRouteCollection.class_eval do
-  # gosh. monkey engineering optimization code
-  def generate_optimisation_block_with_filtering(*args)
-    code = generate_optimisation_block_without_filtering(*args)
-    if match = code.match(%r(^return (.*) if (.*)))
-      # returned string must not contain newlines, or we'll spill out of inline code comments in
-      # ActionController::Routing::RouteSet::NamedRouteCollection#define_url_helper
-      "returning(#{match[1]}) { |result|" +
-      "  ActionController::Routing::Routes.filters.run_reverse(:around_generate, *args, &lambda{ result }) " +
-      "} if #{match[2]}"
+    def active?
+      defined?(@@active) ? @@active : @@active = true
     end
   end
-  alias_method_chain :generate_optimisation_block, :filtering
 end
 
-ActionController::Routing::RouteSet.class_eval do
-  def clear_with_filtering!
-    @filters.clear if @filters
-    clear_without_filtering!
-  end
-  alias_method_chain :clear!, :filtering
-
-  attr_writer :filters
-
-  def filters
-    @filters ||= RoutingFilter::Chain.new
-  end
-
-  def recognize_path_with_filtering(path, env = {})
-    path = ::URI.unescape(path.dup) # string is frozen due to memoize
-    filters.run(:around_recognize, path, env, &lambda{ recognize_path_without_filtering(path, env) })
-  end
-  alias_method_chain :recognize_path, :filtering
-
-  def generate_with_filtering(*args)
-    filters.run_reverse(:around_generate, args.first, &lambda{ generate_without_filtering(*args) })
-  end
-  alias_method_chain :generate, :filtering
-
-  # add some useful information to the request environment
-  # right, this is from jamis buck's excellent article about routes internals
-  # http://weblog.jamisbuck.org/2006/10/26/monkey-patching-rails-extending-routes-2
-  # TODO move this ... where?
-  alias_method :extract_request_environment_without_host, :extract_request_environment unless method_defined? :extract_request_environment_without_host
-  def extract_request_environment(request)
-    returning extract_request_environment_without_host(request) do |env|
-      env.merge! :host => request.host,
-                 :port => request.port,
-                 :host_with_port => request.host_with_port,
-                 :domain => request.domain,
-                 :subdomain => request.subdomains.first
-    end
-  end
-end
+require "routing_filter/adapters/rails_#{ActionPack::VERSION::MAJOR}"