js-routes 1.3.3 → 1.4.0

data/lib/routes.js

@@ -4,7 +4,7 @@ Based on Rails routes of APP_CLASS
  */
 
 (function() {
-  var DeprecatedBehavior, NodeTypes, ParameterMissing, ReservedOptions, SpecialOptionsKey, Utils, createGlobalJsRoutesObject, defaults, root,
+  var DeprecatedBehavior, NodeTypes, ParameterMissing, ReservedOptions, SpecialOptionsKey, Utils, root,
     hasProp = {}.hasOwnProperty,
     slice = [].slice;
 
@@ -16,20 +16,21 @@ Based on Rails routes of APP_CLASS
 
   ParameterMissing.prototype = new Error();
 
-  defaults = {
-    prefix: "PREFIX",
-    default_url_options: DEFAULT_URL_OPTIONS
-  };
-
   NodeTypes = NODE_TYPES;
 
-  SpecialOptionsKey = "SPECIAL_OPTIONS_KEY";
+  SpecialOptionsKey = SPECIAL_OPTIONS_KEY;
 
   DeprecatedBehavior = DEPRECATED_BEHAVIOR;
 
   ReservedOptions = ['anchor', 'trailing_slash', 'host', 'port', 'protocol'];
 
   Utils = {
+    configuration: {
+      prefix: PREFIX,
+      default_url_options: DEFAULT_URL_OPTIONS,
+      special_options_key: SPECIAL_OPTIONS_KEY,
+      serializer: SERIALIZER
+    },
     default_serializer: function(object, prefix) {
       var element, i, j, key, len, prop, s;
       if (prefix == null) {
@@ -74,10 +75,11 @@ Based on Rails routes of APP_CLASS
       }
       return s.join("&");
     },
-    custom_serializer: SERIALIZER,
     serialize: function(object) {
-      if ((this.custom_serializer != null) && this.get_object_type(this.custom_serializer) === "function") {
-        return this.custom_serializer(object);
+      var custom_serializer;
+      custom_serializer = this.configuration.serializer;
+      if ((custom_serializer != null) && this.get_object_type(custom_serializer) === "function") {
+        return custom_serializer(object);
       } else {
         return this.default_serializer(object);
       }
@@ -94,14 +96,14 @@ Based on Rails routes of APP_CLASS
       last_el = args[args.length - 1];
       if ((args.length > number_of_params && last_el === void 0) || ((last_el != null) && "object" === this.get_object_type(last_el) && !this.looks_like_serialized_model(last_el))) {
         options = args.pop() || {};
-        delete options[SpecialOptionsKey];
+        delete options[this.configuration.special_options_key];
         return options;
       } else {
         return {};
       }
     },
     looks_like_serialized_model: function(object) {
-      return !object[SpecialOptionsKey] && ("id" in object || "to_param" in object);
+      return !object[this.configuration.special_options_key] && ("id" in object || "to_param" in object);
     },
     path_identifier: function(object) {
       var property;
@@ -187,7 +189,7 @@ Based on Rails routes of APP_CLASS
           parts_options[key] = value;
         }
       }
-      options = this.merge(defaults.default_url_options, default_options, options);
+      options = this.merge(this.configuration.default_url_options, default_options, options);
       result = {};
       url_parameters = {};
       result['url_parameters'] = url_parameters;
@@ -323,7 +325,7 @@ Based on Rails routes of APP_CLASS
     },
     get_prefix: function() {
       var prefix;
-      prefix = defaults.prefix;
+      prefix = this.configuration.prefix;
       if (prefix !== "") {
         prefix = (prefix.match("/$") ? prefix : prefix + "/");
       }
@@ -428,36 +430,56 @@ Based on Rails routes of APP_CLASS
         }
       }
       return result;
+    },
+    namespace: function(root, namespace, routes) {
+      var index, j, len, part, parts;
+      parts = namespace.split(".");
+      if (parts.length === 0) {
+        return routes;
+      }
+      for (index = j = 0, len = parts.length; j < len; index = ++j) {
+        part = parts[index];
+        if (index < parts.length - 1) {
+          root = (root[part] || (root[part] = {}));
+        } else {
+          return root[part] = routes;
+        }
+      }
+    },
+    configure: function(new_config) {
+      return this.configuration = this.merge(this.configuration, new_config);
+    },
+    config: function() {
+      return this.clone(this.configuration);
+    },
+    make: function() {
+      var routes;
+      routes = ROUTES;
+      routes.configure = function(config) {
+        return Utils.configure(config);
+      };
+      routes.config = function() {
+        return Utils.config();
+      };
+      Object.defineProperty(routes, 'defaults', {
+        get: function() {
+          throw new Error(NAMESPACE + ".defaults is removed. Use " + NAMESPACE + ".configure() instead.");
+        },
+        set: function(value) {}
+      });
+      routes.default_serializer = function(object, prefix) {
+        return Utils.default_serializer(object, prefix);
+      };
+      return Utils.namespace(root, NAMESPACE, routes);
     }
   };
 
-  createGlobalJsRoutesObject = function() {
-    var namespace;
-    namespace = function(mainRoot, namespaceString) {
-      var current, parts;
-      parts = (namespaceString ? namespaceString.split(".") : []);
-      if (!parts.length) {
-        return;
-      }
-      current = parts.shift();
-      mainRoot[current] = mainRoot[current] || {};
-      return namespace(mainRoot[current], parts.join("."));
-    };
-    namespace(root, "NAMESPACE");
-    root.NAMESPACE = ROUTES;
-    root.NAMESPACE.options = defaults;
-    root.NAMESPACE.default_serializer = function(object, prefix) {
-      return Utils.default_serializer(object, prefix);
-    };
-    return root.NAMESPACE;
-  };
-
   if (typeof define === "function" && define.amd) {
     define([], function() {
-      return createGlobalJsRoutesObject();
+      return Utils.make();
     });
   } else {
-    createGlobalJsRoutesObject();
+    Utils.make();
   }
 
 }).call(this);

data/lib/routes.js.coffee

@@ -7,12 +7,9 @@ root = (exports ? this)
 
 ParameterMissing = (@message) -> #
 ParameterMissing:: = new Error()
-defaults =
-  prefix: "PREFIX"
-  default_url_options: DEFAULT_URL_OPTIONS
 
 NodeTypes = NODE_TYPES
-SpecialOptionsKey = "SPECIAL_OPTIONS_KEY"
+SpecialOptionsKey = SPECIAL_OPTIONS_KEY
 DeprecatedBehavior = DEPRECATED_BEHAVIOR
 
 ReservedOptions = [
@@ -25,6 +22,13 @@ ReservedOptions = [
 
 Utils =
 
+  configuration:
+    prefix: PREFIX
+    default_url_options: DEFAULT_URL_OPTIONS
+    special_options_key: SPECIAL_OPTIONS_KEY
+    serializer: SERIALIZER
+
+
   default_serializer: (object, prefix = null) ->
     return "" unless object?
     if !prefix and !(@get_object_type(object) is "object")
@@ -50,10 +54,10 @@ Utils =
     return "" unless s.length
     s.join("&")
 
-  custom_serializer: SERIALIZER
   serialize: (object) ->
-    if @custom_serializer? and @get_object_type(@custom_serializer) is "function"
-      @custom_serializer(object)
+    custom_serializer = @configuration.serializer
+    if custom_serializer? and @get_object_type(custom_serializer) is "function"
+      custom_serializer(object)
     else
       @default_serializer(object)
 
@@ -67,13 +71,13 @@ Utils =
     last_el = args[args.length - 1]
     if (args.length > number_of_params and last_el == undefined) or (last_el? and "object" is @get_object_type(last_el) and !@looks_like_serialized_model(last_el))
       options = args.pop() || {}
-      delete options[SpecialOptionsKey]
+      delete options[@configuration.special_options_key]
       options
     else
       {}
 
   looks_like_serialized_model: (object) ->
-    !object[SpecialOptionsKey] and ("id" of object or "to_param" of object)
+    !object[@configuration.special_options_key] and ("id" of object or "to_param" of object)
 
 
   path_identifier: (object) ->
@@ -119,7 +123,7 @@ Utils =
       if @indexOf(parts, key) >= 0
         parts_options[key] = value
 
-    options = @merge(defaults.default_url_options, default_options, options)
+    options = @merge(@configuration.default_url_options, default_options, options)
     result = {}
     url_parameters = {}
     result['url_parameters'] = url_parameters
@@ -248,7 +252,7 @@ Utils =
   # This method check and return prefix from options
   #
   get_prefix: ->
-    prefix = defaults.prefix
+    prefix = @configuration.prefix
     prefix = (if prefix.match("/$") then prefix else "#{prefix}/") if prefix isnt ""
     prefix
 
@@ -343,26 +347,38 @@ Utils =
     (result = i for el, i in array when el is element)
     result
 
-# globalJsObject
-createGlobalJsRoutesObject = ->
-  # namespace function, private
-  namespace = (mainRoot, namespaceString) ->
-    parts = (if namespaceString then namespaceString.split(".") else [])
-    return unless parts.length
-    current = parts.shift()
-    mainRoot[current] = mainRoot[current] or {}
-    namespace mainRoot[current], parts.join(".")
-  # object
-  namespace(root, "NAMESPACE")
-  root.NAMESPACE = ROUTES
-  root.NAMESPACE.options = defaults
-  root.NAMESPACE.default_serializer = (object, prefix) ->
-    Utils.default_serializer(object, prefix)
-  root.NAMESPACE
+  namespace: (root, namespace, routes) ->
+    parts = namespace.split(".")
+    return routes if parts.length == 0
+    for part, index in parts
+      if index < parts.length - 1
+        root = (root[part] or= {})
+      else
+        return root[part] = routes
+
+  configure: (new_config) ->
+    @configuration = @merge(@configuration, new_config)
+
+  config: ->
+    @clone(@configuration)
+
+  make: ->
+    routes = ROUTES
+    routes.configure = (config) -> Utils.configure(config)
+    routes.config = -> Utils.config()
+    Object.defineProperty routes, 'defaults',
+      get: ->
+        throw new Error("#{NAMESPACE}.defaults is removed. Use #{NAMESPACE}.configure() instead.")
+      set: (value) ->
+
+    routes.default_serializer = (object, prefix) ->
+      Utils.default_serializer(object, prefix)
+    Utils.namespace(root, NAMESPACE, routes)
+  
 # Set up Routes appropriately for the environment.
 if typeof define is "function" and define.amd
   # AMD
-  define [], -> createGlobalJsRoutesObject()
+  define [], -> Utils.make()
 else
   # Browser globals
-  createGlobalJsRoutesObject()
+  Utils.make()

data/spec/js_routes/amd_compatibility_spec.rb

@@ -28,7 +28,7 @@ EOF
   end
 
   it "should working from global scope" do
-    expect(evaljs("Routes.inboxes_path()")).to eq(routes.inboxes_path())
+    expect(evaljs("Routes.inboxes_path()")).to eq(test_routes.inboxes_path())
   end
 
   it "should working from define function" do
@@ -36,7 +36,7 @@ EOF
   end
 
   it "should working from require" do
-    expect(evaljs("require(['js-routes'], function(r){ return r.inboxes_path(); })")).to eq(routes.inboxes_path())
+    expect(evaljs("require(['js-routes'], function(r){ return r.inboxes_path(); })")).to eq(test_routes.inboxes_path())
   end
 
 end

data/spec/js_routes/default_serializer_spec.rb

@@ -1,5 +1,7 @@
+require "spec_helper"
+
 describe JsRoutes, "#default_serializer" do
-  
+
   before(:each) do
     evaljs(JsRoutes.generate({}))
   end

data/spec/js_routes/generated_javascript_spec.rb

@@ -10,10 +10,6 @@ describe JsRoutes do
   describe "generated js" do
     subject { JsRoutes.generate }
 
-    it "should set the default serializer when none is configured" do
-      is_expected.to match(%r(custom_serializer: null,\s+serialize: function\(object\) {\s+if \(\(this\.custom_serializer != null\) && this.get_object_type\(this\.custom_serializer\) === \"function\"\) {\s+return this\.custom_serializer\(object\);\s+} else {\s+return this\.default_serializer\(object\);\s+}\s+},))
-    end
-
     it "should include a comment in the header" do
       app_class = "App"
 

data/spec/js_routes/options_spec.rb

@@ -3,37 +3,48 @@ require 'spec_helper'
 describe JsRoutes, "options" do
 
   before(:each) do
-    evaljs(_presetup)
+    evaljs(_presetup) if _presetup
     with_warnings(_warnings) do
       evaljs(JsRoutes.generate(_options))
     end
   end
 
-  let(:_presetup) { "this;" }
+  let(:_presetup) { nil }
   let(:_options) { {} }
   let(:_warnings) { true }
 
-  context "when serializer is specified" do
-    # define custom serializer
-    # this is a nonsense serializer, which always returns foo=bar
-    # for all inputs
-    let(:_presetup){ %q(function myCustomSerializer(object, prefix) { return "foo=bar"; }) }
-    let(:_options) { {:serializer => "myCustomSerializer"} }
+  describe "serializer" do
+    context "when specified" do
+      # define custom serializer
+      # this is a nonsense serializer, which always returns foo=bar
+      # for all inputs
+      let(:_presetup){ %q(function myCustomSerializer(object, prefix) { return "foo=bar"; }) }
+      let(:_options) { {:serializer => "myCustomSerializer"} }
 
-    it "should set configurable serializer" do
-      # expect the nonsense serializer above to have appened foo=bar
-      # to the end of the path
-      expect(evaljs(%q(Routes.inboxes_path()))).to eql("/inboxes?foo=bar")
+      it "should set configurable serializer" do
+        # expect the nonsense serializer above to have appened foo=bar
+        # to the end of the path
+        expect(evaljs(%q(Routes.inboxes_path()))).to eql("/inboxes?foo=bar")
+      end
     end
-  end
 
-  context "when serializer is specified, but not function" do
-    let(:_presetup){ %q(var myCustomSerializer = 1) }
-    let(:_options) { {:serializer => "myCustomSerializer"} }
+    context "when specified, but not function" do
+      let(:_presetup){ %q(var myCustomSerializer = 1) }
+      let(:_options) { {:serializer => "myCustomSerializer"} }
 
-    it "should set configurable serializer" do
-      # expect to use default
-      expect(evaljs(%q(Routes.inboxes_path({a: 1})))).to eql("/inboxes?a=1")
+      it "should set configurable serializer" do
+        # expect to use default
+        expect(evaljs(%q(Routes.inboxes_path({a: 1})))).to eql("/inboxes?a=1")
+      end
+    end
+
+    context "when configured in js" do
+      let(:_options) { {:serializer =>%q(function (object, prefix) { return "foo=bar"; })} }
+
+      it "uses JS serializer" do
+        evaljs("Routes.configure({serializer: function (object, prefix) { return 'bar=baz'; }})")
+        expect(evaljs(%q(Routes.inboxes_path({a: 1})))).to eql("/inboxes?bar=baz")
+      end
     end
   end
 
@@ -84,12 +95,13 @@ describe JsRoutes, "options" do
     let(:_options) { {:prefix => "/myprefix/" } }
 
     it "should render routing with prefix" do
-        expect(evaljs("Routes.inbox_path(1)")).to eq("/myprefix#{routes.inbox_path(1)}")
+        expect(evaljs("Routes.inbox_path(1)")).to eq("/myprefix#{test_routes.inbox_path(1)}")
     end
 
     it "should render routing with prefix set in JavaScript" do
-      evaljs("Routes.options.prefix = '/newprefix/'")
-      expect(evaljs("Routes.inbox_path(1)")).to eq("/newprefix#{routes.inbox_path(1)}")
+      evaljs("Routes.configure({prefix: '/newprefix/'})")
+      expect(evaljs("Routes.config().prefix")).to eq("/newprefix/")
+      expect(evaljs("Routes.inbox_path(1)")).to eq("/newprefix#{test_routes.inbox_path(1)}")
     end
 
   end
@@ -99,7 +111,7 @@ describe JsRoutes, "options" do
     let(:_options) { {:prefix => "http://localhost:3000" } }
 
     it "should render routing with prefix" do
-      expect(evaljs("Routes.inbox_path(1)")).to eq(_options[:prefix] + routes.inbox_path(1))
+      expect(evaljs("Routes.inbox_path(1)")).to eq(_options[:prefix] + test_routes.inbox_path(1))
     end
   end
 
@@ -108,46 +120,46 @@ describe JsRoutes, "options" do
     let(:_options) { {:prefix => "/myprefix" } }
 
     it "should render routing with prefix" do
-      expect(evaljs("Routes.inbox_path(1)")).to eq("/myprefix#{routes.inbox_path(1)}")
+      expect(evaljs("Routes.inbox_path(1)")).to eq("/myprefix#{test_routes.inbox_path(1)}")
     end
 
     it "should render routing with prefix set in JavaScript" do
-      evaljs("Routes.options.prefix = '/newprefix'")
-      expect(evaljs("Routes.inbox_path(1)")).to eq("/newprefix#{routes.inbox_path(1)}")
+      evaljs("Routes.configure({prefix: '/newprefix/'})")
+      expect(evaljs("Routes.inbox_path(1)")).to eq("/newprefix#{test_routes.inbox_path(1)}")
     end
 
   end
 
-  context "when default_format is specified" do
-    let(:_options) { {:default_format => "json"} }
+  context "when default format is specified" do
+    let(:_options) { {:default_url_options => {format: "json"}} }
     let(:_warnings) { nil }
 
     it "should render routing with default_format" do
-      expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1, :format => "json"))
+      expect(evaljs("Routes.inbox_path(1)")).to eq(test_routes.inbox_path(1, :format => "json"))
     end
 
     it "should render routing with default_format and zero object" do
-      expect(evaljs("Routes.inbox_path(0)")).to eq(routes.inbox_path(0, :format => "json"))
+      expect(evaljs("Routes.inbox_path(0)")).to eq(test_routes.inbox_path(0, :format => "json"))
     end
 
     it "should override default_format when spefified implicitly" do
-      expect(evaljs("Routes.inbox_path(1, {format: 'xml'})")).to eq(routes.inbox_path(1, :format => "xml"))
+      expect(evaljs("Routes.inbox_path(1, {format: 'xml'})")).to eq(test_routes.inbox_path(1, :format => "xml"))
     end
 
     it "should override nullify implicitly when specified implicitly" do
-      expect(evaljs("Routes.inbox_path(1, {format: null})")).to eq(routes.inbox_path(1))
+      expect(evaljs("Routes.inbox_path(1, {format: null})")).to eq(test_routes.inbox_path(1))
     end
 
 
     it "shouldn't require the format" do
       pending if Rails.version < "4.0"
-      expect(evaljs("Routes.json_only_path()")).to eq(routes.json_only_path(:format => 'json'))
+      expect(evaljs("Routes.json_only_path()")).to eq(test_routes.json_only_path(:format => 'json'))
     end
   end
 
   it "shouldn't include the format when {:format => false} is specified" do
-    expect(evaljs("Routes.no_format_path()")).to eq(routes.no_format_path())
-    expect(evaljs("Routes.no_format_path({format: 'json'})")).to eq(routes.no_format_path(format: 'json'))
+    expect(evaljs("Routes.no_format_path()")).to eq(test_routes.no_format_path())
+    expect(evaljs("Routes.no_format_path({format: 'json'})")).to eq(test_routes.no_format_path(format: 'json'))
   end
 
   describe "when namespace option is specified" do
@@ -189,14 +201,14 @@ describe JsRoutes, "options" do
       context "provided" do
         let(:_options) { { :default_url_options => { :optional_id => "12", :format => "json" } } }
         it "should use this opions to fill optional parameters" do
-          expect(evaljs("Routes.things_path()")).to eq(routes.things_path(:optional_id => 12, :format => "json"))
+          expect(evaljs("Routes.things_path()")).to eq(test_routes.things_path(:optional_id => 12, :format => "json"))
         end
       end
 
       context "not provided" do
         let(:_options) { { :default_url_options => { :format => "json" } } }
         it "breaks" do
-          expect(evaljs("Routes.foo_all_path()")).to eq(routes.foo_all_path(:format => "json"))
+          expect(evaljs("Routes.foo_all_path()")).to eq(test_routes.foo_all_path(:format => "json"))
         end
       end
     end
@@ -204,7 +216,15 @@ describe JsRoutes, "options" do
     context "with required route parts" do
       let(:_options) { {:default_url_options => {:inbox_id => "12"}} }
       it "should use this opions to fill optional parameters" do
-        expect(evaljs("Routes.inbox_messages_path()")).to eq(routes.inbox_messages_path(:inbox_id => 12))
+        expect(evaljs("Routes.inbox_messages_path()")).to eq(test_routes.inbox_messages_path(:inbox_id => 12))
+      end
+    end
+
+    context "when overwritten on JS level" do
+        let(:_options) { { :default_url_options => { :format => "json" } } }
+      it "uses JS defined value" do
+        evaljs("Routes.configure({default_url_options: {format: 'xml'}})")
+        expect(evaljs("Routes.inboxes_path()")).to eq(test_routes.inboxes_path(format: 'xml'))
       end
     end
   end
@@ -213,33 +233,33 @@ describe JsRoutes, "options" do
     context "with default option" do
       let(:_options) { Hash.new }
       it "should working in params" do
-        expect(evaljs("Routes.inbox_path(1, {trailing_slash: true})")).to eq(routes.inbox_path(1, :trailing_slash => true))
+        expect(evaljs("Routes.inbox_path(1, {trailing_slash: true})")).to eq(test_routes.inbox_path(1, :trailing_slash => true))
       end
 
       it "should working with additional params" do
-        expect(evaljs("Routes.inbox_path(1, {trailing_slash: true, test: 'params'})")).to eq(routes.inbox_path(1, :trailing_slash => true, :test => 'params'))
+        expect(evaljs("Routes.inbox_path(1, {trailing_slash: true, test: 'params'})")).to eq(test_routes.inbox_path(1, :trailing_slash => true, :test => 'params'))
       end
     end
 
     context "with default_url_options option" do
       let(:_options) { {:default_url_options => {:trailing_slash => true}} }
       it "should working" do
-        expect(evaljs("Routes.inbox_path(1, {test: 'params'})")).to eq(routes.inbox_path(1, :trailing_slash => true, :test => 'params'))
+        expect(evaljs("Routes.inbox_path(1, {test: 'params'})")).to eq(test_routes.inbox_path(1, :trailing_slash => true, :test => 'params'))
       end
 
       it "should remove it by params" do
-        expect(evaljs("Routes.inbox_path(1, {trailing_slash: false})")).to eq(routes.inbox_path(1))
+        expect(evaljs("Routes.inbox_path(1, {trailing_slash: false})")).to eq(test_routes.inbox_path(1))
       end
     end
 
     context "with disabled default_url_options option" do
       let(:_options) { {:default_url_options => {:trailing_slash => false}} }
       it "should not use trailing_slash" do
-        expect(evaljs("Routes.inbox_path(1, {test: 'params'})")).to eq(routes.inbox_path(1, :test => 'params'))
+        expect(evaljs("Routes.inbox_path(1, {test: 'params'})")).to eq(test_routes.inbox_path(1, :test => 'params'))
       end
 
       it "should use it by params" do
-        expect(evaljs("Routes.inbox_path(1, {trailing_slash: true})")).to eq(routes.inbox_path(1, :trailing_slash => true))
+        expect(evaljs("Routes.inbox_path(1, {trailing_slash: true})")).to eq(test_routes.inbox_path(1, :trailing_slash => true))
       end
     end
   end
@@ -248,7 +268,7 @@ describe JsRoutes, "options" do
     context "with default option" do
       let(:_options) { Hash.new }
       it "should use snake case routes" do
-        expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1))
+        expect(evaljs("Routes.inbox_path(1)")).to eq(test_routes.inbox_path(1))
         expect(evaljs("Routes.inboxPath")).to be_nil
       end
     end
@@ -258,8 +278,8 @@ describe JsRoutes, "options" do
       it "should generate camel case routes" do
         expect(evaljs("Routes.inbox_path")).to be_nil
         expect(evaljs("Routes.inboxPath")).not_to be_nil
-        expect(evaljs("Routes.inboxPath(1)")).to eq(routes.inbox_path(1))
-        expect(evaljs("Routes.inboxMessagesPath(10)")).to eq(routes.inbox_messages_path(:inbox_id => 10))
+        expect(evaljs("Routes.inboxPath(1)")).to eq(test_routes.inbox_path(1))
+        expect(evaljs("Routes.inboxMessagesPath(10)")).to eq(test_routes.inbox_messages_path(:inbox_id => 10))
       end
     end
   end
@@ -268,74 +288,29 @@ describe JsRoutes, "options" do
     context "with default option" do
       let(:_options) { Hash.new }
       it "should generate only path links" do
-        expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1))
+        expect(evaljs("Routes.inbox_path(1)")).to eq(test_routes.inbox_path(1))
         expect(evaljs("Routes.inbox_url")).to be_nil
       end
     end
 
-    context 'with deprecated, non-boolean config value' do
-      around(:each) do |example|
-        ActiveSupport::Deprecation.silence do
-          example.run
-        end
-      end
-
-      context "with host" do
-        let(:_options) { { :url_links => "http://localhost" } }
-        it "should generate path and url links" do
-          expect(evaljs("Routes.inbox_path")).not_to be_nil
-          expect(evaljs("Routes.inbox_url")).not_to be_nil
-          expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1))
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
-          expect(evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })")).to eq("http://localhost#{routes.inbox_path(1, :test_key => "test_val")}")
-        end
-      end
-
-      context "with invalid host" do
-        it "should raise error" do
-          expect { JsRoutes.generate({ :url_links => "localhost" }) }.to raise_error RuntimeError
-        end
-      end
-
-      context "with host and camel_case" do
-        let(:_options) { { :camel_case => true, :url_links => "http://localhost" } }
-        it "should generate path and url links" do
-          expect(evaljs("Routes.inboxPath")).not_to be_nil
-          expect(evaljs("Routes.inboxUrl")).not_to be_nil
-          expect(evaljs("Routes.inboxPath(1)")).to eq(routes.inbox_path(1))
-          expect(evaljs("Routes.inboxUrl(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
-        end
-      end
-
-      context "with host and prefix" do
-        let(:_options) { { :prefix => "/api", :url_links => "https://example.com" } }
-        it "should generate path and url links" do
-          expect(evaljs("Routes.inbox_path")).not_to be_nil
-          expect(evaljs("Routes.inbox_url")).not_to be_nil
-          expect(evaljs("Routes.inbox_path(1)")).to eq("/api#{routes.inbox_path(1)}")
-          expect(evaljs("Routes.inbox_url(1)")).to eq("https://example.com/api#{routes.inbox_path(1)}")
-        end
-      end
-    end
-
     context "when configuring with default_url_options" do
       context "when only host option is specified" do
         let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com"} } }
 
         it "uses the specified host, defaults protocol to http, defaults port to 80 (leaving it blank)" do
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com#{test_routes.inbox_path(1)}")
         end
 
         it "does not override protocol when specified in route" do
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{routes.new_session_path}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{test_routes.new_session_path}")
         end
 
         it "does not override host when specified in route" do
-          expect(evaljs("Routes.sso_url()")).to eq(routes.sso_url)
+          expect(evaljs("Routes.sso_url()")).to eq(test_routes.sso_url)
         end
 
         it "does not override port when specified in route" do
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{routes.portals_path}")
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{test_routes.portals_path}")
         end
       end
 
@@ -343,19 +318,19 @@ describe JsRoutes, "options" do
         let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com", :protocol => "ftp"} } }
 
         it "uses the specified protocol and host, defaults port to 80 (leaving it blank)" do
-          expect(evaljs("Routes.inbox_url(1)")).to eq("ftp://example.com#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("ftp://example.com#{test_routes.inbox_path(1)}")
         end
 
         it "does not override protocol when specified in route" do
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{routes.new_session_path}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{test_routes.new_session_path}")
         end
 
         it "does not override host when host is specified in route" do
-          expect(evaljs("Routes.sso_url()")).to eq("ftp://sso.example.com#{routes.sso_path}")
+          expect(evaljs("Routes.sso_url()")).to eq("ftp://sso.example.com#{test_routes.sso_path}")
         end
 
         it "does not override port when specified in route" do
-          expect(evaljs("Routes.portals_url()")).to eq("ftp://example.com:8080#{routes.portals_path}")
+          expect(evaljs("Routes.portals_url()")).to eq("ftp://example.com:8080#{test_routes.portals_path}")
         end
       end
 
@@ -363,49 +338,49 @@ describe JsRoutes, "options" do
         let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com", :port => 3000} } }
 
         it "uses the specified host and port, defaults protocol to http" do
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com:3000#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com:3000#{test_routes.inbox_path(1)}")
         end
 
         it "does not override protocol when specified in route" do
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com:3000#{routes.new_session_path}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com:3000#{test_routes.new_session_path}")
         end
 
         it "does not override host, protocol, or port when host is specified in route" do
-          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com:3000" + routes.sso_path)
+          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com:3000" + test_routes.sso_path)
         end
 
         it "does not override port when specified in route" do
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{routes.portals_path}")
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{test_routes.portals_path}")
         end
       end
 
       context "with camel_case option" do
         let(:_options) { { :camel_case => true, :url_links => true, :default_url_options => {:host => "example.com"} } }
         it "should generate path and url links" do
-          expect(evaljs("Routes.inboxUrl(1)")).to eq("http://example.com#{routes.inbox_path(1)}")
-          expect(evaljs("Routes.newSessionUrl()")).to eq("https://example.com#{routes.new_session_path}")
-          expect(evaljs("Routes.ssoUrl()")).to eq(routes.sso_url)
-          expect(evaljs("Routes.portalsUrl()")).to eq("http://example.com:8080#{routes.portals_path}")
+          expect(evaljs("Routes.inboxUrl(1)")).to eq("http://example.com#{test_routes.inbox_path(1)}")
+          expect(evaljs("Routes.newSessionUrl()")).to eq("https://example.com#{test_routes.new_session_path}")
+          expect(evaljs("Routes.ssoUrl()")).to eq(test_routes.sso_url)
+          expect(evaljs("Routes.portalsUrl()")).to eq("http://example.com:8080#{test_routes.portals_path}")
         end
       end
 
       context "with prefix option" do
         let(:_options) { { :prefix => "/api", :url_links => true, :default_url_options => {:host => 'example.com'} } }
         it "should generate path and url links" do
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com/api#{routes.inbox_path(1)}")
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com/api#{routes.new_session_path}")
-          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com/api#{routes.sso_path}")
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080/api#{routes.portals_path}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com/api#{test_routes.inbox_path(1)}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com/api#{test_routes.new_session_path}")
+          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com/api#{test_routes.sso_path}")
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080/api#{test_routes.portals_path}")
         end
       end
 
       context "with compact option" do
         let(:_options) { { :compact => true, :url_links => true, :default_url_options => {:host => 'example.com'} } }
         it "does not affect url helpers" do
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com#{routes.inbox_path(1)}")
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{routes.new_session_path}")
-          expect(evaljs("Routes.sso_url()")).to eq(routes.sso_url)
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{routes.portals_path}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com#{test_routes.inbox_path(1)}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{test_routes.new_session_path}")
+          expect(evaljs("Routes.sso_url()")).to eq(test_routes.sso_url)
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{test_routes.portals_path}")
         end
       end
     end
@@ -430,23 +405,23 @@ describe JsRoutes, "options" do
         it "uses the current host" do
           expect(evaljs("Routes.inbox_path")).not_to be_nil
           expect(evaljs("Routes.inbox_url")).not_to be_nil
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://current.example.com#{routes.inbox_path(1)}")
-          expect(evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })")).to eq("http://current.example.com#{routes.inbox_path(1, :test_key => "test_val")}")
-          expect(evaljs("Routes.new_session_url()")).to eq("https://current.example.com#{routes.new_session_path}")
-          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com#{routes.sso_path}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://current.example.com#{test_routes.inbox_path(1)}")
+          expect(evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })")).to eq("http://current.example.com#{test_routes.inbox_path(1, :test_key => "test_val")}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://current.example.com#{test_routes.new_session_path}")
+          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com#{test_routes.sso_path}")
 
         end
 
         it "uses host option as an argument" do
-          expect(evaljs("Routes.portals_url({host: 'another.com'})")).to eq(routes.portals_url(host: 'another.com'))
+          expect(evaljs("Routes.portals_url({host: 'another.com'})")).to eq(test_routes.portals_url(host: 'another.com'))
         end
 
         it "uses port option as an argument" do
-          expect(evaljs("Routes.portals_url({host: 'localhost', port: 8080})")).to eq(routes.portals_url(host: 'localhost', port: 8080))
+          expect(evaljs("Routes.portals_url({host: 'localhost', port: 8080})")).to eq(test_routes.portals_url(host: 'localhost', port: 8080))
         end
 
         it "uses protocol option as an argument" do
-          expect(evaljs("Routes.portals_url({host: 'localhost', protocol: 'https'})")).to eq(routes.portals_url(protocol: 'https', host: 'localhost'))
+          expect(evaljs("Routes.portals_url({host: 'localhost', protocol: 'https'})")).to eq(test_routes.portals_url(protocol: 'https', host: 'localhost'))
         end
       end
     end
@@ -456,23 +431,21 @@ describe JsRoutes, "options" do
     let(:_options) { { :compact => true } }
     it "removes _path suffix from path helpers" do
       expect(evaljs("Routes.inbox_path")).to be_nil
-      expect(evaljs("Routes.inboxes()")).to eq(routes.inboxes_path())
-      expect(evaljs("Routes.inbox(2)")).to eq(routes.inbox_path(2))
+      expect(evaljs("Routes.inboxes()")).to eq(test_routes.inboxes_path())
+      expect(evaljs("Routes.inbox(2)")).to eq(test_routes.inbox_path(2))
     end
 
     context "with url_links option" do
-      context "with deprecated url_links config value" do
-        around(:each) do |example|
-          ActiveSupport::Deprecation.silence do
-            example.run
-          end
+      around(:each) do |example|
+        ActiveSupport::Deprecation.silence do
+          example.run
         end
+      end
 
-        let(:_options) { { :compact => true, :url_links => "http://localhost" } }
-        it "should not strip urls" do
-          expect(evaljs("Routes.inbox(1)")).to eq(routes.inbox_path(1))
-          expect(evaljs("Routes.inbox_url(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
-        end
+      let(:_options) { { :compact => true, :url_links => true, default_url_options: {host: 'localhost'} } }
+      it "should not strip urls" do
+        expect(evaljs("Routes.inbox(1)")).to eq(test_routes.inbox_path(1))
+        expect(evaljs("Routes.inbox_url(1)")).to eq("http://localhost#{test_routes.inbox_path(1)}")
       end
     end
   end
@@ -483,7 +456,7 @@ describe JsRoutes, "options" do
       expect {
         expect(evaljs("Routes.inbox_message_path({inbox_id: 1, id: 2, _options: true})")).to eq("")
       }.to raise_error(js_error_class)
-      expect(evaljs("Routes.inbox_message_path({inbox_id: 1, id: 2, __options__: true})")).to eq(routes.inbox_message_path(inbox_id: 1, id: 2))
+      expect(evaljs("Routes.inbox_message_path({inbox_id: 1, id: 2, __options__: true})")).to eq(test_routes.inbox_message_path(inbox_id: 1, id: 2))
     end
   end