vigetlabs-routing-filter 0.2.4

data/lib/routing-filter.rb

@@ -0,0 +1 @@
+require 'routing_filter'

data/lib/routing_filter.rb

@@ -0,0 +1,27 @@
+require 'action_pack'
+require 'active_support/core_ext/string/inflections'
+
+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 active=(active)
+      @@active = active
+    end
+
+    def active?
+      defined?(@@active) ? @@active : @@active = true
+    end
+  end
+end
+
+require "routing_filter/adapters/rails_#{ActionPack::VERSION::MAJOR}"

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
+      (ActionPack::VERSION::MINOR >= 3 && ActionPack::VERSION::TINY >= 9 ? "#{match[1]}.tap { |result|" : "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.unshift(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)
+    extract_request_environment_without_host(request).tap 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,77 @@
+require 'action_dispatch'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/hash/reverse_merge'
+
+mappers = [ActionDispatch::Routing::Mapper]
+mappers << ActionDispatch::Routing::DeprecatedMapper if defined?(ActionDispatch::Routing::DeprecatedMapper)
+mappers.each do |mapper|
+  mapper.class_eval do
+    def filter(*args)
+      @set.add_filters(*args)
+    end
+  end
+end
+
+ActionDispatch::Routing::RouteSet.class_eval do
+  def filters
+    @set.filters if @set
+  end
+
+  def add_filters(*names)
+    options = names.extract_options!
+    names.each { |name| filters.unshift(RoutingFilter.build(name, options)) }
+  end
+
+  # def recognize_path_with_filtering(path, env = {})
+  #   @set.filters.run(:around_recognize, path.dup, env, &lambda{ recognize_path_without_filtering(path.dup, env) })
+  # end
+  # alias_method_chain :recognize_path, :filtering
+
+  def generate_with_filtering(options, recall = {}, extras = false)
+    filters.run(:around_generate, options, &lambda{ generate_without_filtering(options, recall, extras) })
+  end
+  alias_method_chain :generate, :filtering
+
+  def clear_with_filtering!
+    filters.clear if filters
+    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.tap { |f| @filters = f unless frozen? }
+  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!
+
+  # note: if you overly and unnecessarily use blocks in your lowlevel libraries you make it fricking
+  # hard for your users to hook in anywhere
+  def recognize_with_filtering(request, &block)
+    path, route, matches, params = request.env['PATH_INFO'], nil, nil, nil
+    original_path = path.dup
+
+    filters.run(:around_recognize, path, request.env) do
+      route, matches, params = recognize_without_filtering(request)
+      params || {}
+    end
+
+    request.env['PATH_INFO'] = original_path # hmm ...
+    block.call(route, matches, params) if route
+  end
+end
+

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/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