rack-rewrite-dynamic 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rack-rewrite-dynamic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Michal Olah
+
+MIT License
+
+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/README.md

@@ -0,0 +1,162 @@
+# rack-rewrite-dynamic
+
+Rack rewrite is a great tool if you have static based rewrites. What do
+you do when dynamic slug based rewrites are needed to make your SEO
+seeking client happy?
+
+Consider the following requirements:
+
+/slug_name/another_slug_name should be rendered by /controller/id
+/filter_slug-another_filter_slug-resources_name should be renderd by
+/resources_name?color_ids[]=42&color_ids[]=43&category_ids[]=42
+
+You could try to setup custom routing using
+[rack-rewrite arbitrary rewriting feature](https://github.com/jtrupiano/rack-rewrite#arbitrary-rewriting).
+Rack-rewrite-dynamic wraps these use cases and provides an easy way to
+create your own if you need to do so.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rack-rewrite-dynamic'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rack-rewrite-dynamic
+
+## Usage
+
+Rack-rewrite-dynamic currently assumes its being used as a middleware. It also assumes you have a Slug
+model using the [friendly_id](https://github.com/norman/friendly_id)
+gem. The slug model should have a polymorphic association to the models
+that are used for SEO urls.
+
+```ruby
+class Slug < ActiveRecord::Base
+  extend FriendlyId
+  friendly_id :content, use: [:slugged, :history]
+  belongs_to :sluggable, :polymorphic => true
+end
+```
+
+Rack-rewrite-dynamic provides two types of slug based url matchers:
+
+### Show page URL rewrites
+
+To set up the rewrites, hook into rack-rewrite middleware in config/application.rb
+
+```ruby
+config.middleware.insert_after "ActiveRecord::QueryCache", 'Rack::Rewrite' do |base|
+  rewriter = 'Rack::Rewrite::Dynamic::Rewrites'.constantize.new do
+    rewrite url_parts: [{'Category' => 'slug', 'IceCream' => 'slug'}]
+  end
+  rewriter.apply_rewrites(base)
+end
+```
+
+The example rewrites /category_slug/ice_cream_slug to /ice_creams/42 so
+the rails app can have 
+```ruby
+resources :ice_creams
+```
+defined as usual.
+
+### Filter URL rewrites
+
+To set up a url rewriter use
+
+```ruby
+config.middleware.insert_after "ActiveRecord::QueryCache", 'Rack::Rewrite' do |base|
+  rewriter = 'Rack::Rewrite::Dynamic::Rewrites'.constantize.new do
+    rewrite_filter separator: '-', target: 'cars', suffix: 'cars'
+  end
+  rewriter.apply_rewrites(base)
+end
+```
+
+The example rewrites /color_slug-another_color_slug-category_slug-cars
+to /cars?color_ids[]=42&color_ids[]=43&category_ids[]=42 so the rails
+app can have
+```ruby
+resources :cars
+```
+defined as usual and use the filter attributes on the index page.
+
+### Custom rewrites
+
+If the two built in rewrites do not fit your need, you can create your
+own. You can use one of our own rewriters as a template.
+The only requirement is to have a perform instance method that
+receives a match object of the url and a rack_env object containing the
+request information from the rack environment. To bring in some
+functionality that should be useful include our base module.
+
+```ruby
+class MyRewriter
+  include Rack::Rewrite::Dynamic::Base
+
+  def perform(match, rack_env)
+    # some awesome rewriting
+  end
+end
+```
+
+You can then pass them in as an argument to the rewrite method.
+
+```ruby
+config.middleware.insert_after "ActiveRecord::QueryCache", 'Rack::Rewrite' do |base|
+  rewriter = 'Rack::Rewrite::Dynamic::Rewrites'.constantize.new do
+    rewrite {option: 'value'}, MyRewriter
+  end
+  rewriter.apply_rewrites(base)
+end
+```
+
+### Configuration
+
+If you wish to use a different slug class you may pass it in as an
+argument when defining the rewrite.
+
+```ruby
+config.middleware.insert_after "ActiveRecord::QueryCache", 'Rack::Rewrite' do |base|
+  rewriter = 'Rack::Rewrite::Dynamic::Rewrites'.constantize.new do
+    rewrite url_parts: [{'Category' => 'slug', 'IceCream' => 'slug'}], slug_name: 'AnotherSlug'
+  end
+  rewriter.apply_rewrites(base)
+end
+```
+
+By default the rewrites assume you have a rails application to generate
+the routing. If you with to have a custom route generator, you can
+supply it when defining the rewrite. It needs to respond to a
+route_for(slug) message and return a string representing the url.
+
+```ruby
+class TestGenerator
+  def self.route_for slug
+    'some/path'
+  end
+end
+
+config.middleware.insert_after "ActiveRecord::QueryCache", 'Rack::Rewrite' do |base|
+  rewriter = 'Rack::Rewrite::Dynamic::Rewrites'.constantize.new do
+    rewrite url_parts: [{'Category' => 'slug', 'IceCream' => 'slug'}], route_generator_name: 'TestGenerator'
+  end
+  rewriter.apply_rewrites(base)
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/lib/rack-rewrite-dynamic.rb

@@ -0,0 +1,5 @@
+require 'rack/rewrite/dynamic/rails_route_generator'
+require 'rack/rewrite/dynamic/base'
+require 'rack/rewrite/dynamic/filter_rewrite'
+require 'rack/rewrite/dynamic/rewrite'
+require 'rack/rewrite/dynamic/rewrites'

data/lib/rack/rewrite/dynamic/base.rb

@@ -0,0 +1,47 @@
+module Rack
+  class Rewrite
+    module Dynamic
+      module Base
+        attr_reader :opts
+        def initialize(opts)
+          @opts = opts
+          @opts[:slug_name] ||= 'Slug'
+          @opts[:route_generator_name] ||= 'Rack::Rewrite::Dynamic::RailsRouteGenerator'
+        end
+
+        def apply_rewrite(base)
+          base.send :rewrite, %r{#{build_match_string}}, lambda { |match, rack_env|
+            perform(match, rack_env)
+          }
+        end
+
+        def slug_type?(slug_name, slug_type)
+          slug = find_sluggable(slug_name)
+          slug if slug && slug[:sluggable_type] == slug_type
+        end
+        def find_sluggable(friendly_id)
+          slug_klass.find(friendly_id)
+        rescue ActiveRecord::RecordNotFound
+          # :)
+        end
+        def slug_klass
+          @slug_klass ||= @opts[:slug_name].constantize
+        end
+        def route_generator_klass
+          @route_generator_klass ||= @opts[:route_generator_name].constantize
+        end
+        def slug_path_if_present(slug, rack_env)
+          if slug
+            route_generator_klass.route_for slug
+          else
+            rack_env['REQUEST_URI'] || rack_env['PATH_INFO']
+          end
+        end
+        def original_path(rack_env)
+          rack_env['REQUEST_URI'] || rack_env['PATH_INFO']
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/rewrite/dynamic/filter_rewrite.rb

@@ -0,0 +1,46 @@
+require_relative 'base'
+require 'active_support/all'
+module Rack
+  class Rewrite
+    module Dynamic
+      class FilterRewrite
+        include Base
+
+        def perform(match, rack_env)
+          if !(match[1] =~ /assets/)
+            filter_parts = match[1].split(@opts[:separator])
+            if filter_parts.present?
+              slugs = filter_parts.map do |slug_candidate|
+                find_sluggable(slug_candidate)
+              end
+              if !slugs.include?(nil)
+                filter_params = {}
+                slugs.each do |s|
+                  filter_params["#{s[:sluggable_type].underscore}_ids"] ||= []
+                  filter_params["#{s[:sluggable_type].underscore}_ids"] << s[:sluggable_id]
+                end
+                return "/#{@opts[:target]}?#{filter_params.to_query}"
+              end
+            end
+          else
+            rack_env['REQUEST_URI'] || rack_env['PATH_INFO']
+          end
+        end
+
+        private
+          def build_match_string
+            match_string = '^'
+            match_string << "#{@opts[:prefix]}" if @opts[:prefix]
+            match_string << '\/' + "#{filter_string}"
+            match_string << "#{@opts[:separator]}#{@opts[:suffix]}" if @opts[:suffix] && @opts[:separator]
+            match_string << "\/?$"
+            match_string
+          end
+          def filter_string
+            '([^\/]+)'
+          end
+      end
+    end
+  end
+end
+

data/lib/rack/rewrite/dynamic/rails_route_generator.rb

@@ -0,0 +1,11 @@
+module Rack
+  class Rewrite
+    module Dynamic
+      class RailsRouteGenerator
+        def self.route_for slug
+          Rails.application.routes.url_helpers.send("#{slug[:sluggable_type].underscore}_path", slug[:sluggable_id])
+        end
+      end
+    end
+  end
+end

data/lib/rack/rewrite/dynamic/rewrite.rb

@@ -0,0 +1,66 @@
+require_relative 'base'
+module Rack
+  class Rewrite
+    module Dynamic
+      class Rewrite
+        include Base
+
+        def perform(match, rack_env)
+          if !(match[1] =~ /assets/)
+            urls = find_urls(match, rack_env)
+            if urls.length > 0
+              urls.first
+            else
+              original_path(rack_env)
+            end
+          else
+            original_path(rack_env)
+          end
+        end
+
+        def find_urls(match, rack_env)
+          @opts[:url_parts].map do |url_def|
+            find_url(url_def, match, rack_env)
+          end.compact
+        end
+
+        def find_url(url_parts, match, rack_env)
+          slugs = url_parts.each_with_index.map do |url_part, index|
+            if url_part[1] == 'slug'
+              slug_type?(match[index+1], url_part[0])
+            else
+              'static'
+            end
+          end
+          if !slugs.include?(nil)
+            slug_path_if_present(slugs[url_parts.length-1], rack_env)
+          else
+            nil
+          end
+        end
+
+        private
+          def build_match_string
+            match_string = "^\/"
+            match_string << @opts[:url_parts].first.map do |url_value, url_type|
+              if url_type == 'static'
+                "(#{url_value})"
+              else
+                suburl_string
+              end
+            end.join(suburl_separator)
+            match_string << @opts[:suffix] if @opts[:suffix]
+            match_string << "\/?$"
+            match_string
+          end
+          def suburl_string
+            '([^\/]+)'
+          end
+          def suburl_separator
+            '\/'
+          end
+      end
+    end
+  end
+end
+

data/lib/rack/rewrite/dynamic/rewrites.rb

@@ -0,0 +1,30 @@
+require_relative 'rewrite'
+require_relative 'filter_rewrite'
+
+module Rack
+  class Rewrite
+    module Dynamic
+      class Rewrites
+        attr_reader :rewrites
+        def initialize &rewrite_block
+          instance_eval(&rewrite_block) if block_given?
+        end
+
+        def rewrite_filter(opts = {})
+          rewrite(opts, FilterRewrite)
+        end
+        def rewrite(opts = {}, rewrite_klass = Rewrite)
+          @rewrites ||= []
+          @rewrites << rewrite_klass.new(opts)
+        end
+
+        def apply_rewrites(base)
+          @rewrites.each do |rewrite|
+            rewrite.apply_rewrite(base)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rack/rewrite/dynamic/version.rb

@@ -0,0 +1,8 @@
+module Rack
+  class Rewrite
+    module Dynamic
+      VERSION = "0.0.2"
+    end
+  end
+end
+

data/rack-rewrite-dynamic.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/rewrite/dynamic/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rack-rewrite-dynamic"
+  gem.version       = Rack::Rewrite::Dynamic::VERSION
+  gem.authors       = ["Michal Olah"]
+  gem.email         = ["olahmichal@gmail.com"]
+  gem.description   = %q{Dynamic SEO urls}
+  gem.summary       = %q{SEO urls based on slugs}
+  gem.homepage      = "https://github.com/bonetics/rack-rewrite-dynamic"
+
+  gem.add_dependency 'rack-rewrite'
+  gem.add_dependency 'activesupport'
+  gem.add_development_dependency 'rack'
+  gem.add_development_dependency "rspec"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/rack/rewrite/dynamic/filter_rewrite_spec.rb

@@ -0,0 +1,52 @@
+require_relative '../../../../lib/rack/rewrite/dynamic/filter_rewrite'
+
+describe Rack::Rewrite::Dynamic::FilterRewrite do
+
+  before(:each) do
+    unless defined?(ActiveRecord::RecordNotFound)
+      module ActiveRecord
+        module RecordNotFound; end
+      end
+    end
+    unless defined?(Slug)
+      class Slug; end
+    end
+  end
+
+  let(:opts) do
+    {
+      separator: '-', target: 'outfits', suffix: 'outfits'
+    }
+  end
+  subject { Rack::Rewrite::Dynamic::FilterRewrite.new(opts) }
+  let(:base) { mock(:base) }
+
+  its(:opts) { should eq(opts) }
+
+  it 'should apply rewrite' do
+    base.should_receive(:rewrite)
+    subject.apply_rewrite(base)
+  end
+
+  describe '#perform' do
+    let(:match) { ['', 'filter_slug-outfits'] }
+    let(:rack_env) { { 'REQUEST_URI' => 'some/path' } }
+    it 'should perform rewrite' do
+      subject.stub(:find_sluggable) { { sluggable_type: 'color', sluggable_id: 42 } }
+      subject.perform(match, rack_env).should eq('/outfits?color_ids%5B%5D=42&color_ids%5B%5D=42')
+    end
+
+    it 'should return the original request if assets' do
+      match[1] = 'assets'
+      subject.perform(match, rack_env).should eq('some/path')
+    end
+
+    it 'should not return path if slug wasn not found' do
+      subject.stub(:find_sluggable)
+      subject.perform(match, rack_env).should be_nil
+    end
+
+  end
+
+end
+

data/spec/rack/rewrite/dynamic/rewrite_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../../../lib/rack/rewrite/dynamic/rewrite'
+
+describe Rack::Rewrite::Dynamic::Rewrite do
+  before(:each) do
+    unless defined?(ActiveRecord::RecordNotFound)
+      module ActiveRecord
+        module RecordNotFound; end
+      end
+    end
+    unless defined?(Slug)
+      class Slug; end
+    end
+  end
+
+  let(:opts) do
+    {
+      url_parts: [{'online-shops' => 'static',
+                  'Merchant' => 'slug'}]
+    }
+  end
+  subject { Rack::Rewrite::Dynamic::Rewrite.new(opts) }
+  let(:base) { mock(:base) }
+
+  its(:opts) { should eq(opts) }
+
+  it 'should apply rewrite' do
+    base.should_receive(:rewrite)
+    subject.apply_rewrite(base)
+  end
+
+  describe '#perform' do
+    let(:match) { ['', 'merchant-slug'] }
+    let(:rack_env) { { 'REQUEST_URI' => 'some/path' } }
+
+    it 'should return the original request if assets' do
+      match[1] = 'assets'
+      subject.perform(match, rack_env).should eq('some/path')
+    end
+
+    it 'should parse the url_parts and return first match' do
+      subject.stub(:find_urls) { ['some/path', 'some_other/path'] }
+      subject.perform(match, rack_env).should eq('some/path')
+    end
+
+    it 'should find urls' do
+      subject.stub(:find_url) { 'some/path' }
+      subject.find_urls(match, rack_env).should == ['some/path']
+    end
+
+    it 'should find url' do
+      subject.stub(:slug_type?) { stub }
+      subject.stub(:slug_path_if_present) { 'some/path' }
+      subject.find_url(opts[:url_parts].first, match, rack_env).should eq('some/path')
+    end
+
+    it 'should not return path if slug wasn not found' do
+      subject.stub(:slug_type?) { stub }
+      subject.stub(:slug_path_if_present)
+      subject.find_url(opts[:url_parts].first, match, rack_env).should be_nil
+    end
+  end
+end

data/spec/rack/rewrite/dynamic/rewrites_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../../../lib/rack/rewrite/dynamic/rewrites'
+
+describe Rack::Rewrite::Dynamic::Rewrites do
+
+  it 'adds a rewrite' do
+    subject.rewrite
+    subject.rewrites.size.should > 0
+  end
+  it 'adds a rewrite_filter' do
+    subject.rewrite_filter
+    subject.rewrites.size.should > 0
+  end
+
+  it 'applies rewrites' do
+    base = stub
+
+    subject.rewrite
+    subject.rewrites.each {|rewrite| rewrite.should_receive(:apply_rewrite).with(base) }
+    subject.apply_rewrites(base)
+  end
+
+end

data/spec/rack/rewrite/dynamic_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../../../lib/rack/rewrite/dynamic/rewrites'
+
+require 'rack'
+require 'rack-rewrite'
+
+class Slug
+  def self.create!(attrs)
+    @attrs = attrs
+  end
+  def self.find(slug)
+    @attrs
+  end
+end
+
+class TestSlug
+  def self.create!(attrs)
+    @attrs = attrs
+  end
+  def self.find(slug)
+    @attrs
+  end
+end
+
+
+class TestGenerator
+  def self.route_for slug
+    'some/path'
+  end
+end
+
+describe Rack::Rewrite::Dynamic do
+
+  let(:app) { mock(:app)}
+  let(:env) { { 'PATH_INFO' => '/online-shops/murdar'} }
+  before :each do
+    Slug.create!(sluggable_type: 'Merchant', sluggable_id: 42, content: 'Murdar')
+  end
+
+  it 'uses dynamic rewrites' do
+    Rack::Rewrite::Dynamic::Rewrite.any_instance.stub(:slug_path_if_present) { '/merchants/42' }
+    subject = Rack::Rewrite.new(app) do |base|
+      rewriter = Rack::Rewrite::Dynamic::Rewrites.new do
+        rewrite url_parts: [{'online-shops' => 'static', 'Merchant' => 'slug'}]
+      end
+      rewriter.apply_rewrites(base)
+    end
+    app.should_receive(:call).with({"PATH_INFO"=>"/merchants/42", "REQUEST_URI"=>"/merchants/42", "QUERY_STRING"=>""})
+    subject.call(env)
+  end
+
+  it 'accepts a different route generator' do
+    subject = Rack::Rewrite.new(app) do |base|
+      rewriter = Rack::Rewrite::Dynamic::Rewrites.new do
+        rewrite url_parts: [{'online-shops' => 'static', 'Merchant' => 'slug'}], route_generator_name: 'TestGenerator'
+      end
+      rewriter.apply_rewrites(base)
+    end
+    app.should_receive(:call).with({"PATH_INFO"=>"some/path", "REQUEST_URI"=>"some/path", "QUERY_STRING"=>""})
+    subject.call(env)
+  end
+
+  it 'accepts a different slug class' do
+    TestSlug.create!(sluggable_type: 'Merchant', sluggable_id: 42, content: 'Murdar')
+    Rack::Rewrite::Dynamic::Rewrite.any_instance.stub(:slug_path_if_present) { '/merchants/42' }
+    subject = Rack::Rewrite.new(app) do |base|
+      rewriter = Rack::Rewrite::Dynamic::Rewrites.new do
+        rewrite url_parts: [{'online-shops' => 'static', 'Merchant' => 'slug'}], slug_name: 'TestSlug'
+      end
+      rewriter.apply_rewrites(base)
+    end
+    app.should_receive(:call).with({"PATH_INFO"=>"/merchants/42", "REQUEST_URI"=>"/merchants/42", "QUERY_STRING"=>""})
+    subject.call(env)
+  end
+
+
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: rack-rewrite-dynamic
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Michal Olah
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack-rewrite
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Dynamic SEO urls
+email:
+- olahmichal@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rack-rewrite-dynamic.rb
+- lib/rack/rewrite/dynamic/base.rb
+- lib/rack/rewrite/dynamic/filter_rewrite.rb
+- lib/rack/rewrite/dynamic/rails_route_generator.rb
+- lib/rack/rewrite/dynamic/rewrite.rb
+- lib/rack/rewrite/dynamic/rewrites.rb
+- lib/rack/rewrite/dynamic/version.rb
+- rack-rewrite-dynamic.gemspec
+- spec/rack/rewrite/dynamic/filter_rewrite_spec.rb
+- spec/rack/rewrite/dynamic/rewrite_spec.rb
+- spec/rack/rewrite/dynamic/rewrites_spec.rb
+- spec/rack/rewrite/dynamic_spec.rb
+homepage: https://github.com/bonetics/rack-rewrite-dynamic
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: SEO urls based on slugs
+test_files:
+- spec/rack/rewrite/dynamic/filter_rewrite_spec.rb
+- spec/rack/rewrite/dynamic/rewrite_spec.rb
+- spec/rack/rewrite/dynamic/rewrites_spec.rb
+- spec/rack/rewrite/dynamic_spec.rb