js-routes 1.0.1 → 1.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c68aed8760da61aa1ff4977b8d69f09cfc609f18
-  data.tar.gz: f4362dcdb29332048b5a19d3ed40dce4717b6bd9
+  metadata.gz: 33fffcaa3c5d7614a35673b8a53ea0f06030dbed
+  data.tar.gz: b8c5ffa5eb34114667b2d8e3f53dec2809816f2e
 SHA512:
-  metadata.gz: cd44c50605191eda0663671b1d7bf46bcffa7e4e13705e8ca9177fc3c8ac332ea1abac89448a7dfc27e4e9eee5d98ad340f602fea6b082c0af144449e5e46c31
-  data.tar.gz: bc598e7e2a6c51477162b6e76d4d423e4e6bd6454247305593d343934abd04ae20a829301695e7707ed86bc38c8da7ce00a3c224f3b9e3e5e3b3e35e8ce2320c
+  metadata.gz: 989c63812f7821d21fc94b0bd42f43e87be6a933a2f934733a8f30f3b575f566cb43619a3ca64b49e39ec1dc91ea633ab5337f5be133804aa995756e252cc27f
+  data.tar.gz: 880139c994a2f813b4e0c65d16f281626252462010a08f68e4ef234f3743cab1ae141041fb3cb60f4bdc04fe5d2803dbb22694cc08cf1604e5da692bc3f6e6ef

data/.travis.yml

@@ -1,11 +1,14 @@
 language: ruby
 cache: bundler
 
+before_install:
+  - gem install bundler # need for jruby and ruby-head
+
 rvm:
-  - 1.9.3
   - 2.0
   - 2.1
-  - 2.2
+  - 2.2.5
+  - 2.3.1
   - jruby-19mode
   - ruby-head
   - jruby-head
@@ -13,11 +16,13 @@ rvm:
 gemfile:
   - gemfiles/rails32.gemfile
   - gemfiles/rails40.gemfile
-  - gemfiles/rails41.gemfile
-  - gemfiles/rails42.gemfile
   - gemfiles/rails40_sprockets3.gemfile
+  - gemfiles/rails41.gemfile
   - gemfiles/rails41_sprockets3.gemfile
+  - gemfiles/rails42.gemfile
   - gemfiles/rails42_sprockets3.gemfile
+  - gemfiles/rails50.gemfile
+  - gemfiles/rails50_sprockets3.gemfile
 
 sudo: false
 
@@ -34,3 +39,13 @@ matrix:
     - rvm: jruby-19mode
     - rvm: ruby-head
     - rvm: jruby-head
+    - gemfile: gemfiles/rails50.gemfile
+  exclude:
+    - rvm: 2.0
+      gemfile: gemfiles/rails50.gemfile
+    - rvm: 2.0
+      gemfile: gemfiles/rails50_sprockets3.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails50.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails50_sprockets3.gemfile

data/Appraisals

@@ -3,7 +3,7 @@ appraise "rails32" do
   gem 'tzinfo'
 end
 
-{rails40: '4.0.5', rails41: '4.1.1', rails42: '4.2.0'}.each do |rails, version|
+{rails40: '4.0.5', rails41: '4.1.1', rails42: '4.2.1', rails50: '5.0.0'}.each do |rails, version|
   appraise "#{rails}" do
     gem "railties", "~> #{version}"
     gem "sprockets", "< 3"
@@ -13,4 +13,4 @@ end
     gem "railties", "~> #{version}"
     gem "sprockets", "~> 3.0"
   end
-end
+end

data/CHANGELOG.md

@@ -1,5 +1,75 @@
 ## master
 
+## v1.2.9
+
+* Fixed deprecation varning on Sprockets 3.7
+
+## v1.2.8
+
+* Bugfix warning on Sprockets 4.0 #202
+
+## v1.2.7
+
+* Drop support 1.9.3
+* Add helper for indexOf, if no native implementation in JS engine
+* Add sprockets3 compatibility
+* Bugfix domain defaults to path #197
+
+## v1.2.6
+
+* Use default prefix from `Rails.application.config.relative_url_root` #186
+* Bugfix route globbing with optional fragments bug #191
+
+## v1.2.5
+
+* Bugfix subdomain default parameter in routes #184
+* Bugfix infinite recursion in some specific route sets #183
+
+## v1.2.4
+
+* Additional bugfixes to support all versions of Sprockets: 2.x and 3.x
+
+## v1.2.3
+
+* Sprockets ~= 3.0 support
+
+## v1.2.2
+
+* Sprockets ~= 3.0 support
+* Support default parameters specified in route.rb file
+
+## v1.2.1
+
+* Fixes for Rails 5
+
+## v1.2.0
+
+* Support host, port and protocol inline parameters
+* Support host, port and protocol parameters given to a route explicitly
+* Remove all incompatibilities between actiondispatch and js-routes in handling route URLs
+
+## v1.1.2
+
+* Bugfix support nested object null parameters #164
+* Bugfix support for nested optional parameters #162 #163
+
+## v1.1.1
+
+* Bugfix regression in serialisation on blank strings caused by [#155](https://github.com/railsware/js-routes/pull/155/files)
+
+## v1.1.0
+
+* Ensure routes are loaded, prior to generating them [#148](https://github.com/railsware/js-routes/pull/148)
+* Use `flat_map` rather than `map{...}.flatten` [#149](https://github.com/railsware/js-routes/pull/149)
+* URL escape routes.rb url to fix bad URI(is not URI?) error [#150](https://github.com/railsware/js-routes/pull/150)
+* Fix for rails 5 - test rails-edge on travis allowing failure [#151](https://github.com/railsware/js-routes/pull/151)
+* Adds `serializer` option [#155](https://github.com/railsware/js-routes/pull/155/files)
+
+## v1.0.1
+
+* Support sprockets-3
+* Performance optimization of include/exclude options
+
 ## v1.0.0
 
  * Add the compact mode [#125](https://github.com/railsware/js-routes/pull/125)

data/Rakefile

@@ -12,9 +12,22 @@ require 'bundler/gem_tasks'
 require 'rspec/core'
 require 'rspec/core/rake_task'
 require 'appraisal'
+load "rails/tasks/routes.rake"
 
 RSpec::Core::RakeTask.new(:spec)
 
 task :test_all => :appraisal # test all rails
 
-task :default => :spec
+task :default => :spec
+
+
+namespace :spec do
+  task :routes do
+    require './spec/spec_helper'
+    require 'action_dispatch/routing/inspector'
+    draw_routes
+    all_routes = Rails.application.routes.routes
+    inspector = ActionDispatch::Routing::RoutesInspector.new(all_routes)
+    puts inspector.format(ActionDispatch::Routing::ConsoleFormatter.new, ENV['CONTROLLER'])
+  end
+end

data/Readme.md

@@ -11,14 +11,12 @@ Your Rails Gemfile:
 gem "js-routes"
 ```
 
-### Basic Setup (Asset Pipeline)
+### Basic Setup
 
 Require js routes file in `application.js` or other bundle
 
 ``` js
-/*
-= require js-routes
-*/
+//= require js-routes
 ```
 
 Also in order to flush asset pipeline cache sometimes you might need to run:
@@ -45,8 +43,7 @@ Available options:
 
 * `default_url_options` - default parameters used when generating URLs
   * Note that only specific options are supported at this time.
-  * Supported options: `:format`, `:trailing_slash`, `:protocol`, `:host`, `:port`
-  * Example: {:format => "json", :trailing_slash => true, :protocol => "https", :host => "example.com", :port => 3000}
+  * Example: {:format => "json", :trailing\_slash => true, :protocol => "https", :host => "example.com", :port => 3000}
   * Default: {}
 * `exclude` - Array of regexps to exclude from js routes.
   * Default: []
@@ -59,16 +56,20 @@ Available options:
   * Default: `Routes`
 * `prefix` - String representing a url path to prepend to all paths.
   * Example: `http://yourdomain.com`. This will cause route helpers to generate full path only.
-  * Default: blank
+  * Default: Rails.application.config.relative_url_root
 * `camel_case` (version >= 0.8.8) - Generate camel case route names.
   * Default: false
 * `url_links` (version >= 0.8.9) - Generate `*_url` helpers (in addition to the default `*_path` helpers).
   * Example: true
   * Default: false
-  * Be sure to specify a default host in `default_url_options`. Routes which specify a specific host, protocol, or port will be used instead of their corresponding default.
+  * Note: generated URLs will first use the protocol, host, and port options specified in the route definition. Otherwise, the URL will be based on the option specified in the `default_url_options` config. If no default option has been set, then the URL will fallback to the current URL based on `window.location`.
 * `compact` (version > 0.9.9) - Remove `_path` suffix in path routes(`*_url` routes stay untouched if they were enabled)
   * Default: false
   * Sample route call when option is set to true: Routes.users() => `/users`
+* `serializer` (version >= 1.1.0) - Puts a JS function here that serializes a Javascript Hash object into URL paramters: `{a: 1, b: 2} => "a=1&b=2"`.
+  * Default: `nil`. Uses built-in serializer
+  * Example: `jQuery.param` - use jQuery's serializer algorithm. You can attach serialize function from your favorite AJAX framework.
+  * Example: `MyApp.custom_serialize` - use completely custom serializer of your application.
 
 ### Very Advanced Setup
 
@@ -91,7 +92,7 @@ If your application has an `admin` and an `application` namespace for example:
 #= require application/routes
 ```
 
-In order to generate the routes to a string:
+In order to generate the routes JS code to a string:
 
 ```ruby
 routes_js = JsRoutes.generate(options)
@@ -106,6 +107,15 @@ JsRoutes.generate!("#{path}/adm_routes.js", :namespace => "AdmRoutes", :include
 JsRoutes.generate!("#{path}/api_routes.js", :namespace => "ApiRoutes", :include => /^api_/, :default_url_options => {:format => "json"})
 ```
 
+### Rails relative URL root
+
+If you've installed your application in a sub-path or sub-URI of your server instead of at the root, you need to set the `RAILS_RELATIVE_URL_ROOT` environment variable to the correct path prefix for your application when you precompile assets. Eg., if your application's base URL is "https://appl.example.com/Application1", the command to precompile assets would be:
+```
+RAILS_RELATIVE_URL_ROOT=/Application1 RAILS_ENV=production bundle exec rake assets:precompile
+```
+The environment variable is only needed for precompilation of assets, at any other time (eg. when assets are compiled on-the-fly as in the development environment) Rails will set the relative URL root correctly on it's own.
+
+
 ## Usage
 
 Configuration above will create a nice javascript file with `Routes` object that has all the rails routes available:
@@ -114,6 +124,7 @@ Configuration above will create a nice javascript file with `Routes` object that
 Routes.users_path() // => "/users"
 Routes.user_path(1) // => "/users/1"
 Routes.user_path(1, {format: 'json'}) // => "/users/1.json"
+Routes.user_path(1, {anchor: 'profile'}) // => "/users/1#profile"
 Routes.new_user_project_path(1, {format: 'json'}) // => "/users/1/projects/new.json"
 Routes.user_project_path(1,2, {q: 'hello', custom: true}) // => "/users/1/projects/2?q=hello&custom=true"
 Routes.user_project_path(1,2, {hello: ['world', 'mars']}) // => "/users/1/projects/2?hello%5B%5D=world&hello%5B%5D=mars"
@@ -178,7 +189,7 @@ Heroku environment has a specific problems with setup. It is impossible to use a
 For example create routes.js.erb in assets folder with needed content:
 
 ``` erb
-<%= JsRoutes.generate({ options }) %>
+<%= JsRoutes.generate(options) %>
 ```
 
 This should just work.
@@ -188,8 +199,9 @@ This should just work.
 There are some alternatives available. Most of them has only basic feature and don't reach the level of quality I accept.
 Advantages of this one are:
 
-* Rails3 & Rails4 support
+* Rails 3-5 support
 * Rich options set
+* Full rails compatibility
 * Support Rails `#to_param` convention for seo optimized paths
 * Well tested
 

data/gemfiles/rails42.gemfile

@@ -2,7 +2,7 @@
 
 source "http://rubygems.org"
 
-gem "railties", "~> 4.2.0"
+gem "railties", "~> 4.2.1"
 gem "sprockets", "< 3"
 
 gemspec :path => "../"

data/gemfiles/rails42_sprockets3.gemfile

@@ -2,7 +2,7 @@
 
 source "http://rubygems.org"
 
-gem "railties", "~> 4.2.0"
+gem "railties", "~> 4.2.1"
 gem "sprockets", "~> 3.0"
 
 gemspec :path => "../"

data/gemfiles/rails50.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "railties", "~> 5.0.0"
+gem "sprockets", "< 3"
+
+gemspec :path => "../"

data/gemfiles/rails50_sprockets3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "railties", "~> 5.0.0"
+gem "sprockets", "~> 3.0"
+
+gemspec :path => "../"

data/js-routes.gemspec

@@ -24,12 +24,12 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency(%q<sprockets-rails>)
   s.add_development_dependency(%q<rspec>, [">= 3.0.0"])
   s.add_development_dependency(%q<bundler>, [">= 1.1.0"])
-  s.add_development_dependency(%q<guard>, [">= 0"])
-  s.add_development_dependency(%q<guard-coffeescript>, [">= 0"])
+  s.add_development_dependency(%q<coffee-script>, [">= 0"])
   s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
   if defined?(JRUBY_VERSION)
     s.add_development_dependency(%q<therubyrhino>, [">= 2.0.4"])
   else
+    s.add_development_dependency(%q<byebug>)
     s.add_development_dependency(%q<therubyracer>, [">= 0.12.1"])
   end
 end

data/lib/js_routes/engine.rb

@@ -1,21 +1,69 @@
-class JsRoutes
-  class Engine < ::Rails::Engine
-    JS_ROUTES_ASSET = 'js-routes'
+class JsRoutesSprocketsExtension
+  def initialize(filename, &block)
+    @filename = filename
+    @source   = block.call
+  end
+
+  def render(context, empty_hash_wtf)
+    self.class.run(@filename, @source, context)
+  end
 
-    initializer 'js-routes.dependent_on_routes', after: "sprockets.environment" do
+  def self.run(filename, source, context)
+    if context.logical_path == 'js-routes'
       routes = Rails.root.join('config', 'routes.rb').to_s
+      context.depend_on(routes)
+    end
+    source
+  end
 
-      if Rails.application.assets.respond_to?(:register_preprocessor)
-        Rails.application.assets.register_preprocessor 'application/javascript', :'js-routes_dependent_on_routes' do |ctx,data|
-          ctx.depend_on(routes) if ctx.logical_path == JS_ROUTES_ASSET
-          data
-        end
-      end
+  def self.call(input)
+    filename = input[:filename]
+    source   = input[:data]
+    context  = input[:environment].context_class.new(input)
 
-      # only sprockets >= 3.0
-      if  Rails.application.assets.respond_to?(:depend_on)
-        Rails.application.assets.depend_on "file-digest://#{routes}"
-      end
+    result = run(filename, source, context)
+    context.metadata.merge(data: result)
+  end
+end
+
+
+class Engine < ::Rails::Engine
+  require 'sprockets/version'
+  v2                = Gem::Dependency.new('', ' ~> 2')
+  v3                = Gem::Dependency.new('', ' >= 3' ,' < 3.7')
+  v37                = Gem::Dependency.new('', ' >= 3.7')
+  sprockets_version = Gem::Version.new(::Sprockets::VERSION).release
+  initializer_args  = case sprockets_version
+                        when -> (v) { v2.match?('', v) }
+                          { after: "sprockets.environment" }
+                        when -> (v) { v3.match?('', v) || v37.match?('', v) }
+                          { after: :engines_blank_point, before: :finisher_hook }
+                        else
+                          raise StandardError, "Sprockets version #{sprockets_version} is not supported"
+                      end
+
+  initializer 'js-routes.dependent_on_routes', initializer_args do
+    case sprockets_version
+      when -> (v) { v2.match?('', v) }
+        if Rails.application.assets.respond_to?(:register_preprocessor)
+          routes = Rails.root.join('config', 'routes.rb').to_s
+          Rails.application.assets.register_preprocessor 'application/javascript', :'js-routes_dependent_on_routes' do |ctx, data|
+            ctx.depend_on(routes) if ctx.logical_path == 'js-routes'
+            data
+          end
+        end
+      when -> (v) { v3.match?('', v) }
+        Rails.application.config.assets.configure do |config|
+          routes = Rails.root.join('config', 'routes.rb').to_s
+          config.register_preprocessor 'application/javascript', :'js-routes_dependent_on_routes' do |ctx, data|
+            ctx.depend_on(routes) if ctx.logical_path == 'js-routes'
+            data
+          end
+        end
+      when -> (v) { v37.match?('', v) }
+        Sprockets.register_preprocessor 'application/javascript', JsRoutesSprocketsExtension
+      else
+        raise StandardError, "Sprockets version #{sprockets_version} is not supported"
     end
   end
 end

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "1.0.1"
+  VERSION = "1.2.9"
 end

data/lib/js_routes.rb

@@ -16,10 +16,11 @@ class JsRoutes
     include: //,
     file: DEFAULT_PATH,
     prefix: nil,
-    url_links: nil,
+    url_links: false,
     camel_case: false,
     default_url_options: {},
-    compact: false
+    compact: false,
+    serializer: nil
   }
 
   NODE_TYPES = {
@@ -34,6 +35,8 @@ class JsRoutes
   }
 
   LAST_OPTIONS_KEY = "options".freeze
+  FILTERED_DEFAULT_PARTS = [:controller, :action, :subdomain]
+  URL_OPTIONS = [:protocol, :domain, :host, :port, :subdomain]
 
   class Options < Struct.new(*DEFAULTS.keys)
     def to_hash
@@ -57,6 +60,11 @@ class JsRoutes
     end
 
     def generate(opts = {})
+      # Ensure routes are loaded. If they're not, load them.
+      if Rails.application.routes.named_routes.to_a.empty?
+        Rails.application.reload_routes!
+      end
+
       new(opts).generate
     end
 
@@ -92,21 +100,40 @@ class JsRoutes
   end
 
   def generate
-    js = File.read(File.dirname(__FILE__) + "/routes.js")
-    js.gsub!("NAMESPACE", @options[:namespace])
-    js.gsub!("DEFAULT_URL_OPTIONS", json(@options[:default_url_options].merge(deprecated_default_format)))
-    js.gsub!("PREFIX", @options[:prefix] || "")
-    js.gsub!("NODE_TYPES", json(NODE_TYPES))
-    js.gsub!("ROUTES", js_routes)
+    {
+      "GEM_VERSION"         => JsRoutes::VERSION,
+      "APP_CLASS"           => Rails.application.class.to_s,
+      "NAMESPACE"           => @options[:namespace],
+      "DEFAULT_URL_OPTIONS" => json(@options[:default_url_options].merge(deprecate_url_options)),
+      "PREFIX"              => @options[:prefix] || Rails.application.config.relative_url_root || "",
+      "NODE_TYPES"          => json(NODE_TYPES),
+      "SERIALIZER"          => @options[:serializer] || "null",
+      "ROUTES"              => js_routes,
+    }.inject(File.read(File.dirname(__FILE__) + "/routes.js")) do |js, (key, value)|
+      js.gsub!(key, value)
+    end
   end
 
-  def deprecated_default_format
+  def deprecate_url_options
+    result = {}
     if @options.key?(:default_format)
       warn("default_format option is deprecated. Use default_url_options = { format: <format> } instead")
-      { format: @options[:default_format] }
-    else
-      {}
+      result.merge!(  format: @options[:default_format]  )
     end
+    if @options[:url_links].is_a?(String)
+      ActiveSupport::Deprecation.warn('js-routes url_links config value must be a boolean. Use default_url_options for specifying a default host.')
+
+      raise "invalid URL format in url_links (ex: http[s]://example.com)" if @options[:url_links].match(URI::Parser.new.make_regexp(%w(http https))).nil?
+      uri = URI.parse(@options[:url_links])
+      default_port = uri.scheme == "https" ? 443 : 80
+      port = uri.port == default_port ? nil : uri.port
+      result.merge!(
+        host: uri.host,
+        port: port,
+        protocol: uri.scheme,
+      )
+    end
+    result
   end
 
   def generate!(file_name = nil)
@@ -124,20 +151,23 @@ class JsRoutes
   protected
 
   def js_routes
-    js_routes = Rails.application.routes.named_routes.routes.sort_by(&:to_s).map do |_, route|
-      rails_engine_app = get_app_from_route(route)
-      if rails_engine_app.respond_to?(:superclass) && rails_engine_app.superclass == Rails::Engine && !route.path.anchored
-        rails_engine_app.routes.named_routes.map do |_, engine_route|
-          build_route_if_match(engine_route, route)
-        end
-      else
-        build_route_if_match(route)
-      end
-    end.flatten.compact
-
+    js_routes = Rails.application.routes.named_routes.to_a.sort_by(&:first).flat_map do |_, route|
+      [build_route_if_match(route)] + mounted_app_routes(route)
+    end.compact
     "{\n" + js_routes.join(",\n") + "}\n"
   end
 
+  def mounted_app_routes(route)
+    rails_engine_app = get_app_from_route(route)
+    if rails_engine_app.respond_to?(:superclass) && rails_engine_app.superclass == Rails::Engine && !route.path.anchored
+      rails_engine_app.routes.named_routes.map do |_, engine_route|
+        build_route_if_match(engine_route, route)
+      end
+    else
+      []
+    end
+  end
+
   def get_app_from_route(route)
     # rails engine in Rails 4.2 use additional ActionDispatch::Routing::Mapper::Constraints, which contain app
     if route.app.respond_to?(:app) && route.app.respond_to?(:constraints)
@@ -157,52 +187,42 @@ class JsRoutes
 
   def any_match?(route, parent_route, matchers)
     full_route = [parent_route.try(:name), route.name].compact.join('_')
-    
+
     matchers = Array(matchers)
     matchers.any? {|regex| full_route =~ regex}
   end
 
   def build_js(route, parent_route)
     name = [parent_route.try(:name), route.name].compact
-    parent_spec = parent_route.try(:path).try(:spec)
-    required_parts, optional_parts = route.required_parts.clone, route.optional_parts.clone
-    optional_parts.push(required_parts.delete :format) if required_parts.include?(:format)
     route_name = generate_route_name(name, (:path unless @options[:compact]))
-    url_link = generate_url_link(name, route_name, required_parts, route)
+    parent_spec = parent_route.try(:path).try(:spec)
+    route_arguments = route_js_arguments(route, parent_spec)
+    url_link = generate_url_link(name, route_name, route_arguments, route)
     _ = <<-JS.strip!
   // #{name.join('.')} => #{parent_spec}#{route.path.spec}
-  // function(#{[required_parts, LAST_OPTIONS_KEY].flatten.join(', ')})
-  #{route_name}: Utils.route(#{json(required_parts)}, #{json(optional_parts)}, #{json(serialize(route.path.spec, parent_spec))}, arguments)#{",\n" + url_link if url_link.length > 0}
+  // function(#{build_params(route.required_parts)})
+  #{route_name}: Utils.route(#{route_arguments})#{",\n" + url_link if url_link.length > 0}
   JS
   end
 
-  def generate_url_link(name, route_name, required_parts, route)
-    return "" unless @options[:url_links]
-    _ = <<-JS.strip!
-    #{generate_route_name(name, :url)}: function(#{build_params(required_parts)}) {
-    return #{generate_base_url_js(route)} + this.#{route_name}(#{build_params(required_parts)});
-    }
-    JS
+  def route_js_arguments(route, parent_spec)
+    required_parts = route.required_parts.clone
+    optional_parts = route.parts - required_parts
+    default_parts = route.defaults.select do |part, _|
+      FILTERED_DEFAULT_PARTS.exclude?(part) && URL_OPTIONS.include?(part) || required_parts.include?(part)
+    end
+    [
+      required_parts, optional_parts, serialize(route.path.spec, parent_spec), default_parts
+    ].map do |argument|
+      json(argument)
+    end.join(", ")
   end
 
-  def generate_base_url_js(route)
-    # preserve and deprecate previous behavior
-    unless @options[:url_links] == true
-      ActiveSupport::Deprecation.warn('js-routes url_links config value must be a boolean. Use default_url_options for specifying a default host.')
-      raise "invalid URL format in url_links (ex: http[s]://example.com)" if @options[:url_links].match(URI::Parser.new.make_regexp(%w(http https))).nil?
-      return "#{@options[:url_links].inspect}"
-    else
-      protocol = route.defaults[:protocol] || @options[:default_url_options][:protocol] || 'http'
-      hostname = route.defaults[:host] || @options[:default_url_options][:host]
-      port = route.defaults[:port] || (@options[:default_url_options][:port] unless route.defaults[:host])
-      port = ":#{port}" if port
-
-      unless hostname
-        raise "A :default_url_options[:host] must be configured in order to generate *_url helpers"
-      end
-
-      return %Q|'#{protocol}://#{hostname}#{port}'|
-    end
+  def generate_url_link(name, route_name, route_arguments, route)
+    return "" unless @options[:url_links]
+    <<-JS.strip!
+    #{generate_route_name(name, :url)}: Utils.route(#{route_arguments}, true)
+    JS
   end
 
   def generate_route_name(name, suffix)
@@ -216,11 +236,7 @@ class JsRoutes
   end
 
   def build_params(required_parts)
-    params = required_parts.map do |name|
-      # prepending each parameter name with underscore
-      # to prevent conflict with JS reserved words
-      "_#{name}"
-    end << LAST_OPTIONS_KEY
+    params = required_parts + [LAST_OPTIONS_KEY]
     params.join(", ")
   end