rails_friendly_urls 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e2ea43784b8044cc81c72711d18ca5a4c7b6bf9
+  data.tar.gz: 5d7e8cb96eb2d0b28abd5669bc1283e55bc4e471
+SHA512:
+  metadata.gz: e8291e4dbdf95a576394897f5a73a5d946a41581ab8fcd184cd6c652d7de324b53edaa5b9ae332a29e52f9fd52fa8eeed00ce6dc498ef72b9a0b9ac18b2b627b
+  data.tar.gz: 74465748d887ca85fdbf616b21b418b61d3f0b4a3106e2ba5c0b5299c3e2d3b08734dafd8ab3aa8efcaf555672fe6ca7d738494bb7f79c00cd6a954758a4d95f

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Carlos Alonso Pérez
+
+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,89 @@
+#Rails Friendly Urls Engine
+[![Build Status](https://travis-ci.org/calonso/rails_friendly_urls.svg?branch=master)](https://travis-ci.org/calonso/rails_friendly_urls) [![Code Climate](https://codeclimate.com/github/calonso/rails_friendly_urls/badges/gpa.svg)](https://codeclimate.com/github/calonso/rails_friendly_urls) [![Test Coverage](https://codeclimate.com/github/calonso/rails_friendly_urls/badges/coverage.svg)](https://codeclimate.com/github/calonso/rails_friendly_urls/coverage) [![calonso/rails_friendly_urls API Documentation](https://www.omniref.com/github/calonso/rails_friendly_urls.png)](https://www.omniref.com/github/calonso/rails_friendly_urls)
+
+Rails Gem to easily configure any url as a friendlier one.
+
+##Features
+
+* Allows customisation of **ABSOLUTELY** any url into a SEO friendlier one.
+* Takes care of the parameters you defined in your original route and will pass them into the controller when the friendly url is invoked.
+* Takes care of named routes and both url and path helpers so that there's no need to change a single line of code when adding a new friendly url.
+* When a friendly URL is defined to substitute another one. The non-friendly one is automatically configured to redirect to the friendly path so that you're not penalised by search engines.
+* Doesn't force any particular storage for the friendly url's data.
+
+##Example application
+
+You can see the gem running live in the following url: [https://rails-friendly-urls-test.herokuapp.com/](https://rails-friendly-urls-test.herokuapp.com/)
+
+The source code for this example project is available here: [https://github.com/calonso/rails_friendly_urls_test](https://github.com/calonso/rails_friendly_urls_test)
+
+##Installation
+
+Installing this gem only requires you to add the following line to your `Gemfile`
+
+```ruby
+gem 'rails_friendly_urls'
+```
+
+Run
+
+```
+$ bundle install
+$ rails generate rails_friendly_urls:install
+```
+
+##Setup
+
+Here I detail you the steps that I followed to set up the friendly urls engine in the example application, so most of them should be the same for you, some others slightly different, but don't worry, you'll see appropriated explanations while reading this steps.
+
+###1. Friendly URLs Storage
+
+First of all we need to decide our urls storage technology, in my case I decided to use a standard activerecord rails model, but I guess that a YAML file could do the job as well or any other persistence technology.
+
+5 fields are required to be stored to be able to build a friendly url. They are:
+
+1. Path
+2. Slug
+3. Controller
+4. Action
+5. Defaults
+
+Just a reminder that you must make your storage engine to manage the defaults field as a hash.
+
+Once you've done it, remember to include the `RailsFriendlyUrls::FriendlyUrl` module in that class so that you can use `set_destination_data!` method. That method will complete all your `controller`, `action` and `defaults` fields once you've provided `path` and `slug`.
+
+###2. The Manager
+
+After running the bundled installer (`$ rails generate rails_friendly_urls:install`) a new but incomplete file appears at `config/initializers/friendly_urls_manager.rb`. We need to complete the `urls` method in that file to make it return the list of friendly url objects (objects that simply respond to the five methods described above, i.e: path, slug, controller, action and defaults)
+
+In my example project this is the final implementation:
+
+```
+# FriendlyUrls Manager contents
+class RailsFriendlyUrls::Manager
+  def self.urls
+    ::FriendlyUrl.all
+  end
+end
+```
+
+Simple, huh?
+
+###3. URL injection
+
+As part of the installation process, a new line is inserted on top of the `routes.rb` file that simply invokes the friendly urls engine to do its magic.
+
+##Caveats
+
+* At the moment, only GET requests are supported.
+* At the moment, the rails application has to be restarted for the new urls to start working.
+
+## Contributing
+
+1. Fork it ( https://github.com/calonso/rails_friendly_urls/fork )
+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 a new Pull Request
+
+Released under the MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,14 @@
+require "rubygems"
+require "bundler/setup"
+require 'bundler'
+require 'appraisal'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+  task :default => :appraisal
+end

data/lib/generators/rails_friendly_urls/install_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators'
+
+class RailsFriendlyUrls::InstallGenerator < Rails::Generators::Base
+  desc 'Creates a boilerplate Friendly Urls Manager with an empty implementation for you to complete.'
+  def create_friendly_urls_manager
+    create_file "config/initializers/friendly_urls_manager.rb", <<-EOS 
+# FriendlyUrls Manager contents
+class RailsFriendlyUrls::Manager 
+  def self.urls
+    raise NotImplementedError.new 'RailsFriendlyUrls::Manager::urls not implemented at config/initializers/friendly_urls_manager.rb'
+  end
+end
+    EOS
+  end
+
+  def inject_urls
+    insert_into_file "config/routes.rb", "\n  RailsFriendlyUrls::Manager.inject_urls self\n", :after => ".routes.draw do\n"
+  end
+end

data/lib/rails_friendly_urls.rb

@@ -0,0 +1,34 @@
+require 'singleton'
+require 'rails'
+
+#
+# Base gem's module
+#
+# @author Carlos Alonso
+#
+module RailsFriendlyUrls
+
+  #
+  # Method to quickly get the major and minor versions of the current Rails env
+  #
+  # @returns [String] with X.Y format with major and minor versions
+  def self.rails_version
+    "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
+  end
+
+end
+
+require 'rails_friendly_urls/manager'
+require 'rails_friendly_urls/friendly_url'
+require 'rails_friendly_urls/route_sets/route_set'
+
+case RailsFriendlyUrls.rails_version
+when '4.2'
+  require 'rails_friendly_urls/urls/rails4_2'
+when '4.0', '4.1'
+  require 'rails_friendly_urls/urls/rails4_0'
+when '3.2'
+  require 'rails_friendly_urls/route_sets/rails3'
+else
+  raise NotImplementedError.new "Rails Friendly URLs gem doesn't support Rails #{Rails.version}"
+end

data/lib/rails_friendly_urls/friendly_url.rb

@@ -0,0 +1,21 @@
+module RailsFriendlyUrls
+  #
+  # This module is to be included in the client class that represents the Friendly URL
+  #
+  # @author Carlos Alonso
+  #
+  module FriendlyUrl
+    #
+    # This method tries to identify the route contained at self.path to extract
+    # the destination's controller, action and other arguments and save them
+    # into the corresponding controller, action and defaults fields of the
+    # including objects.
+    #
+    def set_destination_data!
+      route_info = Rails.application.routes.recognize_path self.path
+      self.controller = route_info[:controller]
+      self.action = route_info[:action]
+      self.defaults = route_info.reject { |k, v| [:controller, :action].include? k }
+    end
+  end
+end

data/lib/rails_friendly_urls/manager.rb

@@ -0,0 +1,55 @@
+module RailsFriendlyUrls
+  #
+  # This class is responsible for orchestrating the whole gem's functions.
+  #
+  # @author Carlos Alonso
+  #
+  class Manager
+    # It is designed to be a Singleton, only one instance will run per process.
+    include Singleton
+
+    #
+    # Injects the defined urls into the given RouteSet. This method should be invoked
+    # first thing in the routes.rb block
+    #
+    # @param [ActionDispatch::Routing::RouteSet] rails' current RouteSet.
+    def self.inject_urls(mapper)
+      list = self.urls || []
+      Rails.logger.warn "Injecting empty Friendly URLs List!!" if list.empty?
+      list.each do |f_url|
+        mapper.get f_url.slug, to: "#{f_url.controller}##{f_url.action}", defaults: f_url.defaults
+        mapper.get f_url.path, to: mapper.redirect(f_url.slug)
+      end
+    end
+
+    #
+    # Invokes Rails' routes reload. Useful to reload the routes after
+    # modifying the list of SEO Friendly defined ones without having to
+    # restart the application server.
+    #
+    def self.apply_changes!
+      Rails.application.reload_routes!
+    end
+
+    #
+    # This method is used in Rails' URL Helpers to return the corresponding
+    # SEO Friendly URL instead of the default one.
+    #
+    # @param [String] The path we want the URL for.
+    # @returns [String] The SEO Friendly Slug for the required path.
+    def self.url_for(path)
+      self.instance.friendly path
+    end
+
+    #
+    # INTERNAL: Searches the list of SEO Friendly defined substitutions for
+    # the corresponding to the given path
+    #
+    # @param [String] The path we want the substitution for.
+    # @returns [String] The SEO Friendly Slugh for the required path.
+    def friendly(path)
+      @all_friendly ||= Hash[*RailsFriendlyUrls::Manager.urls.map { |f_url| [f_url.path, f_url.slug] }.flatten]
+      @all_friendly[path] || path
+    end
+  end
+end

data/lib/rails_friendly_urls/route_sets/rails3.rb

@@ -0,0 +1,45 @@
+module ActionDispatch
+  module Routing
+    #
+    # Monkey Patched Rails' class ActionDispatch::Routing::RouteSet.
+    #
+    # @author Carlos Alonso
+    #
+    class RouteSet
+      #
+      # Monkey Patched Rails' method: Includes a call to RailsFriendlyUrls::Manager.url_for
+      # when the Rails' URL Helper is building a url for a path to use the
+      # configured SEO Friendly substutition if any.
+      #
+      def url_for(options = {})
+        finalize!
+        options = (options || {}).reverse_merge!(default_url_options)
+
+        handle_positional_args(options)
+
+        user, password = extract_authentication(options)
+        path_segments  = options.delete(:_path_segments)
+        script_name    = options.delete(:script_name)
+
+        path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s
+
+        path_options = options.except(*RESERVED_OPTIONS)
+        path_options = yield(path_options) if block_given?
+
+        path_addition, params = generate(path_options, path_segments || {})
+        path << path_addition
+        params.merge!(options[:params] || {})
+
+        path = RailsFriendlyUrls::Manager.url_for path
+
+        ActionDispatch::Http::URL.url_for(options.merge!({
+          :path => path,
+          :params => params,
+          :user => user,
+          :password => password
+        }))
+      end
+    end
+  end
+end
+

data/lib/rails_friendly_urls/route_sets/route_set.rb

@@ -0,0 +1,97 @@
+module ActionDispatch
+  module Routing
+    #
+    # Monkey Patched Rails' class ActionDispatch::Routing::RouteSet.
+    #
+    # @author Carlos Alonso
+    #
+    class RouteSet
+      #
+      # Monkey Patched Rails' method to recognize redirections as well as, for some
+      # reason, the original Rails' method doesn't.
+      #
+      def recognize_path(path, environment = {})
+        method = (environment[:method] || "GET").to_s.upcase
+        path = Journey::Router::Utils.normalize_path(path) unless path =~ %r{://}
+        extras = environment[:extras] || {}
+
+        begin
+          env = Rack::MockRequest.env_for(path, {:method => method})
+        rescue URI::InvalidURIError => e
+          raise ActionController::RoutingError, e.message
+        end
+
+        req = @request_class.new(env)
+        @router.recognize(req) do |route, _matches, params|
+          params = _matches if params.nil?
+          params.merge!(extras)
+          params.merge!(req.parameters.symbolize_keys)
+          params.each do |key, value|
+            if value.is_a?(String)
+              value = value.dup.force_encoding(Encoding::BINARY)
+              params[key] = URI.parser.unescape(value)
+            end
+          end
+
+          old_params = env[params_key]
+          env[params_key] = (old_params || {}).merge(params)
+          dispatcher = route.app
+          while dispatcher.is_a?(Mapper::Constraints) && dispatcher.matches?(env) do
+            dispatcher = dispatcher.app
+          end
+
+          if dispatcher.is_a?(Dispatcher)
+            if dispatcher.controller(params, false)
+              dispatcher.prepare_params!(params)
+              return params
+            else
+              raise ActionController::RoutingError, "A route matches #{path.inspect}, but references missing controller: #{params[:controller].camelize}Controller"
+            end
+          elsif dispatcher.is_a?(redirect_class)
+            return { status: 301, path: path_from_dispatcher(dispatcher) }
+          end
+        end
+
+        raise ActionController::RoutingError, "No route matches #{path.inspect}"
+      end
+
+      private
+
+      #
+      # INTERNAL: Helps deciding which module take the PARAMETERS_KEY constant
+      # from. This constant was moved in Rails 4.2 from one to another and
+      # using this method here allows us to reuse this file for all Rails 4.x
+      #
+      def params_key
+        defined?(::ActionDispatch::Http::Parameters::PARAMETERS_KEY) ?
+          ::ActionDispatch::Http::Parameters::PARAMETERS_KEY :
+            ::ActionDispatch::Routing::RouteSet::PARAMETERS_KEY
+      end
+
+      #
+      # INTERNAL: Helps reusing code by deciding which class to consider
+      # as the redirection depending on the Rails version running.
+      #
+      # @returns [ActionDispatch::Routing::Redirect] or [ActionDispatch::Routing::PathRedirect]
+      def redirect_class
+        Rails::VERSION::MAJOR == 3 ? Redirect : PathRedirect
+      end
+
+      #
+      # INTERNAL: Helps reusing code by obtaining the path from the Rails'
+      # ActionDispatch::Routing::Dispatcher depending on the Rails version
+      # running.
+      #
+      # @param [ActionDispatch::Routing::Dispatcher] in use.
+      # @return [String] the destination path of the redirection.
+      def path_from_dispatcher(dispatcher)
+        if Rails::VERSION::MAJOR == 3
+          dispatcher.block.call({}, nil)
+        else
+          dispatcher.block
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_friendly_urls/urls/rails4_0.rb

@@ -0,0 +1,36 @@
+module ActionDispatch
+  module Http
+    #
+    # Monkey Patched Rails' module ActionDispatch::Http::URL
+    #
+    # @author Carlos Alonso
+    #
+    module URL
+      #
+      # Monkey Patched Rails' method: Includes a call to RailsFriendlyUrls::Manager.url_for
+      # when the Rails' URL Helper is building a url for a path to use the
+      # configured SEO Friendly substutition if any.
+      #
+      def self.url_for(options = {})
+        options = options.dup
+        path  = options.delete(:script_name).to_s.chomp("/")
+        path << options.delete(:path).to_s
+
+        add_trailing_slash(path) if options[:trailing_slash]
+
+        params = options[:params].is_a?(Hash) ? options[:params] : options.slice(:params)
+        params.reject! { |_,v| v.to_param.nil? }
+
+        result = build_host_url(options)
+
+        path = RailsFriendlyUrls::Manager.url_for path
+
+        result << path
+
+        result << "?#{params.to_query}" unless params.empty?
+        result << "##{Journey::Router::Utils.escape_fragment(options[:anchor].to_param.to_s)}" if options[:anchor]
+        result
+      end
+    end
+  end
+end

data/lib/rails_friendly_urls/urls/rails4_2.rb

@@ -0,0 +1,26 @@
+module ActionDispatch
+  module Http
+    #
+    # Monkey Patched Rails' module ActionDispatch::Http::URL
+    #
+    # @author Carlos Alonso
+    #
+    module URL
+      #
+      # Monkey Patched Rails' method: Includes a call to RailsFriendlyUrls::Manager.url_for
+      # when the Rails' URL Helper is building a url for a path to use the
+      # configured SEO Friendly substutition if any.
+      #
+      def self.path_for(options)
+        path  = options[:script_name].to_s.chomp("/")
+        path << options[:path] if options.key?(:path)
+
+        add_trailing_slash(path) if options[:trailing_slash]
+        add_params(path, options[:params]) if options.key?(:params)
+        add_anchor(path, options[:anchor]) if options.key?(:anchor)
+
+        RailsFriendlyUrls::Manager.url_for path
+      end
+    end
+  end
+end

data/lib/rails_friendly_urls/version.rb

@@ -0,0 +1,3 @@
+module RailsFriendlyUrls
+  VERSION = "0.1.2"
+end

data/spec/apps/rails3_2.rb

@@ -0,0 +1,46 @@
+require "rails"
+require 'rails/all'
+require 'action_view/testing/resolvers'
+
+require 'rails_friendly_urls' # our gem
+
+class RailsFriendlyUrlsApp < Rails::Application
+  config.root = File.expand_path("../../..", __FILE__)
+  config.cache_classes = true
+
+  config.eager_load = false
+  config.serve_static_assets  = true
+  config.static_cache_control = "public, max-age=3600"
+
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  config.action_dispatch.show_exceptions = false
+
+  config.action_controller.allow_forgery_protection = false
+
+  config.active_support.deprecation = :stderr
+
+  config.middleware.delete "Rack::Lock"
+  config.middleware.delete "ActionDispatch::Flash"
+  config.middleware.delete "ActionDispatch::BestStandardsSupport"
+  config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
+  routes.append do
+    get "/" => "welcome#index"
+  end
+end
+
+class ApplicationController < ActionController::Base
+  include Rails.application.routes.url_helpers
+  layout 'application'
+  self.view_paths = [ActionView::FixtureResolver.new(
+    "layouts/application.html.erb" => '<%= yield %>',
+    "welcome/index.html.erb"=> 'Hello from index.html.erb',
+  )]
+
+  def index
+  end
+
+end
+
+RailsFriendlyUrlsApp.initialize!

data/spec/apps/rails4.rb

@@ -0,0 +1,47 @@
+require "rails"
+require 'rails/all'
+require 'action_view/testing/resolvers'
+
+require 'rails_friendly_urls' # our gem
+
+module RailsFriendlyUrlsApp
+  class Application < Rails::Application
+    config.root = File.expand_path("../../..", __FILE__)
+    config.cache_classes = true
+
+    config.eager_load = false
+    config.static_cache_control = "public, max-age=3600"
+
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    config.action_dispatch.show_exceptions = false
+
+    config.action_controller.allow_forgery_protection = false
+
+    config.active_support.deprecation = :stderr
+
+    config.middleware.delete "Rack::Lock"
+    config.middleware.delete "ActionDispatch::Flash"
+    config.middleware.delete "ActionDispatch::BestStandardsSupport"
+    config.secret_key_base = '49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk'
+    routes.append do
+      get "/" => "application#index"
+    end
+  end
+end
+
+class ApplicationController < ActionController::Base
+  include Rails.application.routes.url_helpers
+  layout 'application'
+  self.view_paths = [ActionView::FixtureResolver.new(
+    "layouts/application.html.erb" => '<%= yield %>',
+    "welcome/index.html.erb"=> 'Hello from index.html.erb',
+  )]
+
+  def index
+  end
+
+end
+
+RailsFriendlyUrlsApp::Application.initialize!

data/spec/generators/install_generator_spec.rb

@@ -0,0 +1,33 @@
+
+require 'generators/rails_friendly_urls/install_generator'
+
+describe RailsFriendlyUrls::InstallGenerator, type: :generator do
+  destination File.expand_path("../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+    mkdir File.join(destination_root, 'config')
+    cp routes_file, File.join(destination_root, 'config/routes.rb')
+    run_generator
+  end
+
+  after do
+    rm_rf destination_root
+  end
+
+  it 'creates the Rails Friendly Urls Manager' do
+    assert_file "config/initializers/friendly_urls_manager.rb", <<-EOS 
+# FriendlyUrls Manager contents
+class RailsFriendlyUrls::Manager 
+  def self.urls
+    raise NotImplementedError.new 'RailsFriendlyUrls::Manager::urls not implemented at config/initializers/friendly_urls_manager.rb'
+  end
+end
+    EOS
+  end
+
+  it 'injects the Rails Friendly Urls in routes' do
+    assert_file "config/routes.rb", routes_contents
+  end
+
+end

data/spec/rails_friendly_urls/friendly_url_spec.rb

@@ -0,0 +1,53 @@
+
+describe RailsFriendlyUrls::FriendlyUrl do
+
+  describe '#set_destination_data' do
+
+    let(:path) { '/test' }
+    let(:controller) { 'application' }
+    let(:action) { 'index' }
+
+    before do
+      mapper = ActionDispatch::Routing::Mapper.new Rails.application.routes
+      mapper.get path, to: "#{controller}##{action}"
+    end 
+
+    subject { DummyFriendlyURL.new path }
+
+    it 'successfully assigns controller' do
+      expect(subject.controller).to eq controller
+    end
+
+    it 'successfully assigns action' do
+      expect(subject.action).to eq action
+    end
+
+    describe 'defaults' do
+
+      context 'with no parameters' do
+        it 'works with no parameters' do
+          expect(subject.defaults).to eq({})
+        end
+      end
+
+      context 'using parameters in url' do
+
+        let(:path) { '/:lang/test' }
+
+        subject { DummyFriendlyURL.new '/es-ES/test' }
+
+        it 'successfully assigns defaults' do
+          expect(subject.defaults).to eq lang: 'es-ES'
+        end
+      end
+
+      context 'using parameters in query string' do
+        subject { DummyFriendlyURL.new '/test?lang=es-ES' }
+
+        it 'successfully assigns defaults' do
+          expect(subject.defaults).to eq lang: 'es-ES'
+        end
+      end
+    end
+  end
+end

data/spec/rails_friendly_urls/manager_spec.rb

@@ -0,0 +1,54 @@
+
+shared_examples 'a successfully injected friendly url' do
+  let(:route_set) { Rails.application.routes }
+
+  before do
+    subject.urls = [url]
+    subject.inject_urls ActionDispatch::Routing::Mapper.new route_set
+  end
+
+  it 'successfully injects the url' do
+    route_info = Rails.application.routes.recognize_path url.slug
+    expect(route_info.delete(:controller)).to eq url.controller
+    expect(route_info.delete(:action)).to eq url.action
+    expect(route_info).to eq (url.defaults.reject { |k, v| [:controller, :action].include? k })
+  end
+
+  it 'adds the corresponding redirection route' do
+    route_info = Rails.application.routes.recognize_path url.path
+    expect(route_info[:status]).to eq 301
+    expect(route_info[:path]).to eq url.slug
+  end
+
+  it 'keeps path helpers working without changing code' do
+    expect(route_set.url_helpers.a_b_c_path).to eq url.slug
+  end
+
+  after do
+    route_set.clear!
+  end
+end
+
+describe RailsFriendlyUrls::Manager do
+
+  describe '#inject_urls' do
+
+    subject { RailsFriendlyUrls::Manager }
+
+    context 'with params in the url' do
+      let(:url) {
+        DummyFriendlyURL.new '/a/b/c', '/friendly1', 'application', 'acti', a:1, b:2
+      }
+
+      include_examples 'a successfully injected friendly url'
+    end
+
+    context 'with no params in the url' do
+      let(:url) {
+        DummyFriendlyURL.new '/a/b/c', '/friendly1', 'application', 'acti', {}
+      }
+
+      include_examples 'a successfully injected friendly url'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# Configure Rails Environment
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+Bundler.setup
+
+ENV["RAILS_ENV"] = "test"
+
+require 'rails'
+
+case "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
+when '3.2'
+  ENV['DATABASE_URL'] = 'sqlite3://localhost/:memory:'
+  require 'apps/rails3_2'
+when '4.0'
+  ENV['DATABASE_URL'] = 'sqlite3://localhost/:memory:'
+  require 'apps/rails4'
+when '4.1'
+  ENV['DATABASE_URL'] = 'sqlite3::memory:'
+  require 'apps/rails4'
+when '4.2'
+  ENV['DATABASE_URL'] = 'sqlite3::memory:'
+  require 'apps/rails4'
+else
+  raise NotImplementedError.new "Rails Friendly URLs gem doesn't support Rails #{Rails.version}"
+end
+
+Bundler.require :default
+Bundler.require :development
+
+require 'rspec/rails'
+require 'rails_friendly_urls'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  #config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+end

data/spec/support/dummy_friendly_url.rb

@@ -0,0 +1,19 @@
+
+class DummyFriendlyURL
+  
+  include RailsFriendlyUrls::FriendlyUrl
+
+  attr_accessor :path, :slug, :controller, :action, :defaults
+
+  def initialize(path, slug = nil, controller = nil, action = nil, defaults = nil)
+    @path = path
+    if slug
+      @slug = slug
+      @controller = controller
+      @action = action
+      @defaults = defaults
+    else
+      set_destination_data!
+    end
+  end
+end

data/spec/support/dummy_manager_impl.rb

@@ -0,0 +1,11 @@
+
+class RailsFriendlyUrls::Manager 
+
+  def self.urls=(urls)
+    @urls = urls
+  end
+
+  def self.urls
+    @urls
+  end
+end

data/spec/support/routes.rb

@@ -0,0 +1,33 @@
+if Rails::VERSION::MAJOR == 4
+  require 'support/routes/rails4'
+else
+  require 'support/routes/rails3'
+end
+
+def routes_file
+  if Rails::VERSION::MAJOR == 4
+    'spec/support/routes/rails4.rb'
+  else
+    'spec/support/routes/rails3.rb'
+  end
+end
+
+def routes_contents
+  if Rails::VERSION::MAJOR == 3
+    <<-EOS 
+RailsFriendlyUrlsApp.routes.draw do
+
+  RailsFriendlyUrls::Manager.inject_urls self
+
+end
+    EOS
+  else
+    <<-EOS 
+RailsFriendlyUrlsApp::Application.routes.draw do
+
+  RailsFriendlyUrls::Manager.inject_urls self
+
+end
+    EOS
+  end
+end

data/spec/support/routes/rails3.rb

@@ -0,0 +1,3 @@
+RailsFriendlyUrlsApp.routes.draw do
+
+end

data/spec/support/routes/rails4.rb

@@ -0,0 +1,3 @@
+RailsFriendlyUrlsApp::Application.routes.draw do
+
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: rails_friendly_urls
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Carlos Alonso
+- Maria Turnau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: generator_spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Rails Gem to easily configure any url as a friendlier one.
+email: info@mrcalonso.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/generators/rails_friendly_urls/install_generator.rb
+- lib/rails_friendly_urls.rb
+- lib/rails_friendly_urls/friendly_url.rb
+- lib/rails_friendly_urls/manager.rb
+- lib/rails_friendly_urls/route_sets/rails3.rb
+- lib/rails_friendly_urls/route_sets/route_set.rb
+- lib/rails_friendly_urls/urls/rails4_0.rb
+- lib/rails_friendly_urls/urls/rails4_2.rb
+- lib/rails_friendly_urls/version.rb
+- spec/apps/rails3_2.rb
+- spec/apps/rails4.rb
+- spec/generators/install_generator_spec.rb
+- spec/rails_friendly_urls/friendly_url_spec.rb
+- spec/rails_friendly_urls/manager_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_friendly_url.rb
+- spec/support/dummy_manager_impl.rb
+- spec/support/routes.rb
+- spec/support/routes/rails3.rb
+- spec/support/routes/rails4.rb
+homepage: http://mrcalonso.com/rails-friendly-urls-gem/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: This is a Rails gem that allows to configure friendly urls for any url in
+  your project.
+test_files:
+- spec/apps/rails3_2.rb
+- spec/apps/rails4.rb
+- spec/generators/install_generator_spec.rb
+- spec/rails_friendly_urls/friendly_url_spec.rb
+- spec/rails_friendly_urls/manager_spec.rb
+- spec/spec_helper.rb
+- spec/support/dummy_friendly_url.rb
+- spec/support/dummy_manager_impl.rb
+- spec/support/routes/rails3.rb
+- spec/support/routes/rails4.rb
+- spec/support/routes.rb
+has_rdoc: