strikeroff-routing-filter 0.0.2 → 0.1.0

data/MIT-LICENSE

@@ -1,20 +1,20 @@
-Copyright (c) 2008 Sven Fuchs
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+Copyright (c) 2008 Sven Fuchs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Manifest

@@ -0,0 +1,20 @@
+init.rb
+lib/routing_filter/base.rb
+lib/routing_filter/force_extension.rb
+lib/routing_filter/locale.rb
+lib/routing_filter/pagination.rb
+lib/routing_filter.rb
+Manifest
+MIT-LICENSE
+Rakefile
+README.markdown
+routing-filter.gemspec
+spec/force_extension_spec.rb
+spec/generation_spec.rb
+spec/pagination_extension_spec.rb
+spec/recognition_spec.rb
+spec/routing_filter_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+strikeroff-routing-filter.gemspec
+VERSION

data/README.markdown

@@ -1,147 +1,151 @@
-## Routing Filter
-
-This plugin is a wild hack that wraps around the complex beast that the Rails
-routing system is to allow for unseen flexibility and power in Rails URL
-recognition and generation.
-
-As powerful and awesome the Rails' routes are, when you need to design your
-URLs in a manner that only slightly leaves the paved cowpaths of Rails
-conventions, you're usually unable to use all the goodness of helpers and
-convenience that Rails ships with.
-
-## Usage
-
-This plugin comes with a locale routing filter that demonstrates the
-implementation of a custom filter. 
-
-The following would be a sceleton of an empty filter:
-
-    module RoutingFilter
-      class Awesomeness < Base
-        def around_recognize(route, path, env)
-          # Alter the path here before it gets recognized. 
-          # Make sure to yield (calls the next around filter if present and 
-          # eventually `recognize_path` on the routeset):
-          returning yield do |params|
-            # You can additionally modify the params here before they get passed
-            # to the controller.
-          end
-        end
-    
-        def around_generate(controller, *args, &block)
-          # Alter arguments here before they are passed to `url_for`. 
-          # Make sure to yield (calls the next around filter if present and 
-          # eventually `url_for` on the controller):
-          returning yield do |result|
-            # You can change the generated url_or_path here. Make sure to use
-            # one of the "in-place" modifying String methods though (like sub! 
-            # and friends).
-          end
-        end
-      end
-    end
-
-You then have to specify the filter explicitely in your routes.rb:
-
-    ActionController::Routing::Routes.draw do |map|
-      map.filter 'awesomeness'
-    end
-
-(I am not sure if it makes sense to provide more technical information than
-this because the usage of this plugin definitely requires some advanced
-knowledge about Rails internals and especially its routing system. So, I
-figure, anyone who could use this should also be able to read the code and
-figure out what it's doing much better then from any lengthy documentation.
-
-If I'm mistaken on this please drop me an email with your suggestions.)
-
-
-## Rationale: Two example usecases
-
-An early usecase from which this originated was the need to define a locale
-at the beginning of an URL in a way so that 
-
-* the locale can be omitted when it is the default locale
-* all the url\_helpers that are generated by named routes continue to work in 
-a concise manner (i.e. without specifying all parameters again and again)
-* ideally also plays nicely with default route helpers in tests/specs
-
-You can read about this struggle and two possible, yet unsatisfying solutions
-[here](http://www.artweb-design.de/2007/5/13/concise-localized-rails-url-helpers-solved-twice).
-The conclusion so far is that Rails itself does not provide the tools to solve
-this problem in a clean and dry way.
-
-Another usecase that eventually spawned the manifestation of this plugin was 
-the need to map an arbitrary count of path segments to a certain model 
-instance. In an application that I've been working on recently I needed to 
-map URL paths to a nested tree of models like so:
-
-    root
-    + docs
-      + api
-      + wiki
-  
-E.g. the docs section should map to the path `/docs`, the api section to 
-the path `/docs/api` and so on. Furthermore, after these paths there need to be 
-more things to be specified. E.g. the wiki needs to define a whole Rails 
-resource with URLs like `/docs/wiki/pages/1/edit`.
-
-The only way to solve this problem with Rails' routing toolkit is to map
-a big, bold `/*everything` catch-all ("globbing") route and process the whole 
-path in a custom dispatcher.
-
-This, of course, is a really unsatisfying solution because one has to
-reimplement everything that Rails routes are here to help with: regarding both 
-URL recognition (like parameter mappings, resources, ...) and generation 
-(url\_helpers).
-
-## Solution
-
-This plugin offers a solution that takes exactly the opposite route. 
-
-Instead of trying to change things *between* the URL recognition and
-generation stages to achieve the desired result it *wraps around* the whole
-routing system and allows to pre- and post-filter both what goes into it 
-(URL recognition) and what comes out of it (URL generation).
-
-This way we can leave *everything* else completely untouched. 
-
-* We can tinker with the URLs that we receive from the server and feed URLs to 
-Rails that perfectly match the best breed of Rails' conventions. 
-* Inside of the application we can use all the nice helper goodness and 
-conveniences that rely on these conventions being followed. 
-* Finally we can accept URLs that have been generated by the url\_helpers and,
-again, mutate them in the way that matches our requirements.
-
-So, even though the plugin itself is a blatant monkey-patch to one of the
-most complex area of Rails internals, this solution seems to be effectively
-less intrusive and pricey than others are.
-
-
-# Difference from origin
-
-1. Locale filter now has option :scip_locale_filter
-    In you routes rb you can 
-    map.change_locale "main/change_locale/:new_locale", :controller=>"main", :action=>"change_locale", :scip_locale_filter=>true
-    And locale filter wouldn't add locale to url while generate
-	
-2. extract_locale! and prepend_locale! methods become class methods aka static. So you can use them outside of gem
-	Usecase:
-	For example   to create  on page language changer without  requests to served. You need only change locale in url
-	
-	Example code:
-			Current locale - :ru,but you need to have a link  with locale = :en. 
-			
-			link_to("EN", url_with_locale(request.request_uri.dup, :en))
-			
-			def url_with_locale(url,locale)
-				RoutingFilter::Locale.extract_locale! url        
-				RoutingFilter::Locale.prepend_locale! url, locale
-			end
-
- 
-
-## Etc
-
-Authors: [Sven Fuchs](http://www.artweb-design.de) <svenfuchs at artweb-design dot de>  
+## Routing Filter
+
+This plugin is a wild hack that wraps around the complex beast that the Rails
+routing system is to allow for unseen flexibility and power in Rails URL
+recognition and generation.
+
+As powerful and awesome the Rails' routes are, when you need to design your
+URLs in a manner that only slightly leaves the paved cowpaths of Rails
+conventions, you're usually unable to use all the goodness of helpers and
+convenience that Rails ships with.
+
+## Usage
+
+This plugin comes with a locale routing filter that demonstrates the
+implementation of a custom filter. 
+
+The following would be a sceleton of an empty filter:
+
+    module RoutingFilter
+      class Awesomeness < Base
+        def around_recognize(route, path, env)
+          # Alter the path here before it gets recognized. 
+          # Make sure to yield (calls the next around filter if present and 
+          # eventually `recognize_path` on the routeset):
+          returning yield do |params|
+            # You can additionally modify the params here before they get passed
+            # to the controller.
+          end
+        end
+    
+        def around_generate(controller, *args, &block)
+          # Alter arguments here before they are passed to `url_for`. 
+          # Make sure to yield (calls the next around filter if present and 
+          # eventually `url_for` on the controller):
+          returning yield do |result|
+            # You can change the generated url_or_path here. Make sure to use
+            # one of the "in-place" modifying String methods though (like sub! 
+            # and friends).
+          end
+        end
+      end
+    end
+
+You then have to specify the filter explicitely in your routes.rb:
+
+    ActionController::Routing::Routes.draw do |map|
+      map.filter 'awesomeness'
+    end
+
+(I am not sure if it makes sense to provide more technical information than
+this because the usage of this plugin definitely requires some advanced
+knowledge about Rails internals and especially its routing system. So, I
+figure, anyone who could use this should also be able to read the code and
+figure out what it's doing much better then from any lengthy documentation.
+
+If I'm mistaken on this please drop me an email with your suggestions.)
+
+
+## Rationale: Two example usecases
+
+An early usecase from which this originated was the need to define a locale
+at the beginning of an URL in a way so that 
+
+* the locale can be omitted when it is the default locale
+* all the url\_helpers that are generated by named routes continue to work in 
+a concise manner (i.e. without specifying all parameters again and again)
+* ideally also plays nicely with default route helpers in tests/specs
+
+You can read about this struggle and two possible, yet unsatisfying solutions
+[here](http://www.artweb-design.de/2007/5/13/concise-localized-rails-url-helpers-solved-twice).
+The conclusion so far is that Rails itself does not provide the tools to solve
+this problem in a clean and dry way.
+
+Another usecase that eventually spawned the manifestation of this plugin was 
+the need to map an arbitrary count of path segments to a certain model 
+instance. In an application that I've been working on recently I needed to 
+map URL paths to a nested tree of models like so:
+
+    root
+    + docs
+      + api
+      + wiki
+  
+E.g. the docs section should map to the path `/docs`, the api section to 
+the path `/docs/api` and so on. Furthermore, after these paths there need to be 
+more things to be specified. E.g. the wiki needs to define a whole Rails 
+resource with URLs like `/docs/wiki/pages/1/edit`.
+
+The only way to solve this problem with Rails' routing toolkit is to map
+a big, bold `/*everything` catch-all ("globbing") route and process the whole 
+path in a custom dispatcher.
+
+This, of course, is a really unsatisfying solution because one has to
+reimplement everything that Rails routes are here to help with: regarding both 
+URL recognition (like parameter mappings, resources, ...) and generation 
+(url\_helpers).
+
+## Solution
+
+This plugin offers a solution that takes exactly the opposite route. 
+
+Instead of trying to change things *between* the URL recognition and
+generation stages to achieve the desired result it *wraps around* the whole
+routing system and allows to pre- and post-filter both what goes into it 
+(URL recognition) and what comes out of it (URL generation).
+
+This way we can leave *everything* else completely untouched. 
+
+* We can tinker with the URLs that we receive from the server and feed URLs to 
+Rails that perfectly match the best breed of Rails' conventions. 
+* Inside of the application we can use all the nice helper goodness and 
+conveniences that rely on these conventions being followed. 
+* Finally we can accept URLs that have been generated by the url\_helpers and,
+again, mutate them in the way that matches our requirements.
+
+So, even though the plugin itself is a blatant monkey-patch to one of the
+most complex area of Rails internals, this solution seems to be effectively
+less intrusive and pricey than others are.
+
+
+# Difference from origin
+
+1. Locale filter now has option :scip_locale_filter.
+    In you routes.rb you can write this
+    
+    map.change_locale "main/change_locale/:new_locale", :controller=>"main", :action=>"change_locale", :scip_locale_filter=>true
+
+    And locale filter wouldn't add locale to url while generate.
+	
+2. extract_locale! and prepend_locale! methods become class methods aka static. So you can use them outside of gem.
+    
+	Usecase:
+
+	For example,   to create  on page language changer without  requests to server. You need only change locale in url.
+	
+	Example code:
+			Current locale - :ru,but you need to have a link  with locale = :en. 
+			
+			link_to("EN", url_with_locale(request.request_uri.dup, :en))
+			
+			def url_with_locale(url,locale)
+				RoutingFilter::Locale.extract_locale! url        
+				RoutingFilter::Locale.prepend_locale! url, locale
+			end
+
+ 
+
+## Etc
+
+Authors: [Sven Fuchs](http://www.artweb-design.de) <svenfuchs at artweb-design dot de>  
 License: MIT 

data/Rakefile

@@ -0,0 +1,21 @@
+# Rakefile
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('strikeroff-routing-filter', '0.1.0') do |p|
+  p.description    = "strikeroff-routing-filter"
+  p.url            = "http://github.com/strikeroff"
+  p.author         = "Vesov Ilya"
+  p.email          = "strikeroff@gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*",".svn",".git"]
+  p.need_tar_gz =     false
+  p.retain_gemspec =  true
+  p.gemspec_name =    'strikeroff-routing-filter.gemspec'
+  p.test_pattern =    ["test/**/*_test.rb"]
+  p.rdoc_pattern =    ["README", "CHANGELOG", "lib/**/*.rb"]
+  p.rdoc_options <<   "-c utf-8"
+  p.ignore_pattern =  [".gitignore", "doc", ".idea",  "*.bat","*.sh"]
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.2

data/lib/routing_filter.rb

@@ -1,94 +1,94 @@
-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
-
-    def predecessor(filter)
-      ix = index(filter)
-      ix > 0 ? self[ix - 1] : nil
-    end
-
-    def successor(filter)
-      ix = index(filter)
-      ix < length - 1 ? self[ix + 1] : nil
-    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]}"
-    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
+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
+
+    def predecessor(filter)
+      ix = index(filter)
+      ix > 0 ? self[ix - 1] : nil
+    end
+
+    def successor(filter)
+      ix = index(filter)
+      ix < length - 1 ? self[ix + 1] : nil
+    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]}"
+    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