js-routes 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c2993fd7d6c758d98b5f7024ab7c21e2be8f600
-  data.tar.gz: d89427d56039f4f6922d4b508672fccd2aaf1497
+  metadata.gz: e61c1a78d1a68a39e174a3459048f939ac1a5491
+  data.tar.gz: 2690497a175312cb4fd282626eae3adf87718cbb
 SHA512:
-  metadata.gz: 85c514ad1542f4d924611c822475b8e667bc4fcc851ddc0239af229bdab77a99c0a625a452af0900050dd90d517cb3696de9e6c26539ba7701f51d960df3b68e
-  data.tar.gz: ee8810fec35db2da1c0f025663d994eea6d700e45cd4fb3a7c32ac9da2ab68719614dd9cdbccbad6f5ed4e8ebf9a7d9b6fdcc2175b474861387c8d48473ff564
+  metadata.gz: 1698494469561e6a34ae36c1f38ae74da0b2a94ecb6e6a4531e25725021772e852f9d1d55f3be7eb9b373c00ad63d57ef67f909c6bbe4ed4dc843096bbc53250
+  data.tar.gz: 04cc89d4715e92eb63c32ff6bd0498c1164d271cab2c976de65a3da3731a6f565691d169f3f1a8dfbf2c336ab6534ce4bdd60bf94cb848753a4082198ede0609

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## master
 
+## 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)

data/Readme.md

@@ -45,8 +45,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: []
@@ -65,7 +64,7 @@ Available options:
 * `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`
@@ -118,6 +117,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"

data/lib/js_routes.rb

@@ -16,7 +16,7 @@ class JsRoutes
     include: //,
     file: DEFAULT_PATH,
     prefix: nil,
-    url_links: nil,
+    url_links: false,
     camel_case: false,
     default_url_options: {},
     compact: false,
@@ -173,45 +173,44 @@ class JsRoutes
 
   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.parts-route.required_parts)
-    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, true)})
+  #{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)
+  def route_js_arguments(route, parent_spec)
+    required_parts, optional_parts = route.required_parts.clone, (route.parts-route.required_parts)
+    optional_parts.push(required_parts.delete :format) if required_parts.include?(:format)
+    [json(required_parts), json(optional_parts), json(serialize(route.path.spec, parent_spec))].join(", ")
+  end
+
+  def generate_url_link(name, route_name, route_arguments, 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)});
-    }
+    defaults = @options[:url_links] == true ? route.defaults.slice(:host, :port, :protocol) : deprecated_base_url
+    <<-JS.strip!
+    #{generate_route_name(name, :url)}: Utils.route(#{route_arguments}, #{json(defaults)})
     JS
   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 deprecated_base_url
+    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
+    {
+      host: uri.host,
+      port: port,
+      protocol: uri.scheme,
+    }
   end
 
   def generate_route_name(name, suffix)
@@ -224,11 +223,11 @@ class JsRoutes
     self.class.json(string)
   end
 
-  def build_params(required_parts)
+  def build_params(required_parts, unprotected = false)
     params = required_parts.map do |name|
       # prepending each parameter name with underscore
       # to prevent conflict with JS reserved words
-      "_#{name}"
+      unprotected ? name : "_#{name}"
     end << LAST_OPTIONS_KEY
     params.join(", ")
   end

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "1.1.2"
+  VERSION = "1.2.0"
 end

data/lib/routes.js

@@ -1,11 +1,13 @@
 /*
 File generated by js-routes GEM_VERSION
 Based on Rails routes of APP_CLASS
- */
+*/
+
 
 (function() {
-  var NodeTypes, ParameterMissing, Utils, createGlobalJsRoutesObject, defaults, root,
-    hasProp = {}.hasOwnProperty;
+  var NodeTypes, ParameterMissing, ReservedOptions, Utils, createGlobalJsRoutesObject, defaults, root,
+    __hasProp = {}.hasOwnProperty,
+    __slice = [].slice;
 
   root = typeof exports !== "undefined" && exports !== null ? exports : this;
 
@@ -22,9 +24,12 @@ Based on Rails routes of APP_CLASS
 
   NodeTypes = NODE_TYPES;
 
+  ReservedOptions = ['anchor', 'trailing_slash', 'host', 'port', 'protocol'];
+
   Utils = {
     default_serializer: function(object, prefix) {
-      var element, i, j, key, len, prop, s;
+      var element, i, key, prop, s, _i, _len;
+
       if (prefix == null) {
         prefix = null;
       }
@@ -37,21 +42,21 @@ Based on Rails routes of APP_CLASS
       s = [];
       switch (this.get_object_type(object)) {
         case "array":
-          for (i = j = 0, len = object.length; j < len; i = ++j) {
+          for (i = _i = 0, _len = object.length; _i < _len; i = ++_i) {
             element = object[i];
             s.push(this.default_serializer(element, prefix + "[]"));
           }
           break;
         case "object":
           for (key in object) {
-            if (!hasProp.call(object, key)) continue;
+            if (!__hasProp.call(object, key)) continue;
             prop = object[key];
             if ((prop == null) && (prefix != null)) {
               prop = "";
             }
             if (prop != null) {
               if (prefix != null) {
-                key = prefix + "[" + key + "]";
+                key = "" + prefix + "[" + key + "]";
               }
               s.push(this.default_serializer(prop, key));
             }
@@ -59,7 +64,7 @@ Based on Rails routes of APP_CLASS
           break;
         default:
           if (object != null) {
-            s.push((encodeURIComponent(prefix.toString())) + "=" + (encodeURIComponent(object.toString())));
+            s.push("" + (encodeURIComponent(prefix.toString())) + "=" + (encodeURIComponent(object.toString())));
           }
       }
       if (!s.length) {
@@ -77,57 +82,28 @@ Based on Rails routes of APP_CLASS
     },
     clean_path: function(path) {
       var last_index;
+
       path = path.split("://");
       last_index = path.length - 1;
       path[last_index] = path[last_index].replace(/\/+/g, "/");
       return path.join("://");
     },
-    set_default_url_options: function(optional_parts, options) {
-      var i, j, len, part, results;
-      results = [];
-      for (i = j = 0, len = optional_parts.length; j < len; i = ++j) {
-        part = optional_parts[i];
-        if (!options.hasOwnProperty(part) && defaults.default_url_options.hasOwnProperty(part)) {
-          results.push(options[part] = defaults.default_url_options[part]);
-        }
-      }
-      return results;
-    },
-    extract_anchor: function(options) {
-      var anchor;
-      anchor = "";
-      if (options.hasOwnProperty("anchor")) {
-        anchor = "#" + options.anchor;
-        delete options.anchor;
-      }
-      return anchor;
-    },
-    extract_trailing_slash: function(options) {
-      var trailing_slash;
-      trailing_slash = false;
-      if (defaults.default_url_options.hasOwnProperty("trailing_slash")) {
-        trailing_slash = defaults.default_url_options.trailing_slash;
-      }
-      if (options.hasOwnProperty("trailing_slash")) {
-        trailing_slash = options.trailing_slash;
-        delete options.trailing_slash;
-      }
-      return trailing_slash;
-    },
     extract_options: function(number_of_params, args) {
       var last_el;
+
       last_el = args[args.length - 1];
-      if (args.length > number_of_params || ((last_el != null) && "object" === this.get_object_type(last_el) && !this.look_like_serialized_model(last_el))) {
-        return args.pop();
+      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))) {
+        return args.pop() || {};
       } else {
         return {};
       }
     },
-    look_like_serialized_model: function(object) {
+    looks_like_serialized_model: function(object) {
       return "id" in object || "to_param" in object;
     },
     path_identifier: function(object) {
       var property;
+
       if (object === 0) {
         return "0";
       }
@@ -151,52 +127,99 @@ Based on Rails routes of APP_CLASS
     },
     clone: function(obj) {
       var attr, copy, key;
+
       if ((obj == null) || "object" !== this.get_object_type(obj)) {
         return obj;
       }
       copy = obj.constructor();
       for (key in obj) {
-        if (!hasProp.call(obj, key)) continue;
+        if (!__hasProp.call(obj, key)) continue;
         attr = obj[key];
         copy[key] = attr;
       }
       return copy;
     },
-    prepare_parameters: function(required_parameters, actual_parameters, options) {
-      var i, j, len, result, val;
-      result = this.clone(options) || {};
-      for (i = j = 0, len = required_parameters.length; j < len; i = ++j) {
-        val = required_parameters[i];
+    merge: function() {
+      var tap, xs;
+
+      xs = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+      tap = function(o, fn) {
+        fn(o);
+        return o;
+      };
+      if ((xs != null ? xs.length : void 0) > 0) {
+        return tap({}, function(m) {
+          var k, v, x, _i, _len, _results;
+
+          _results = [];
+          for (_i = 0, _len = xs.length; _i < _len; _i++) {
+            x = xs[_i];
+            _results.push((function() {
+              var _results1;
+
+              _results1 = [];
+              for (k in x) {
+                v = x[k];
+                _results1.push(m[k] = v);
+              }
+              return _results1;
+            })());
+          }
+          return _results;
+        });
+      }
+    },
+    normalize_options: function(url_defaults, required_parameters, optional_parts, actual_parameters) {
+      var i, key, options, result, url_parameters, value, _i, _len;
+
+      options = this.extract_options(required_parameters.length, actual_parameters);
+      if (actual_parameters.length > required_parameters.length) {
+        throw new Error("Too many parameters provided for path");
+      }
+      options = this.merge(defaults.default_url_options, url_defaults, options);
+      result = {};
+      url_parameters = {};
+      result['url_parameters'] = url_parameters;
+      for (key in options) {
+        if (!__hasProp.call(options, key)) continue;
+        value = options[key];
+        if (ReservedOptions.indexOf(key) >= 0) {
+          result[key] = value;
+        } else {
+          url_parameters[key] = value;
+        }
+      }
+      for (i = _i = 0, _len = required_parameters.length; _i < _len; i = ++_i) {
+        value = required_parameters[i];
         if (i < actual_parameters.length) {
-          result[val] = actual_parameters[i];
+          url_parameters[value] = actual_parameters[i];
         }
       }
       return result;
     },
-    build_path: function(required_parameters, optional_parts, route, args) {
-      var anchor, opts, parameters, result, trailing_slash, url, url_params;
+    build_route: function(required_parameters, optional_parts, route, url_defaults, args) {
+      var options, parameters, result, url, url_params;
+
       args = Array.prototype.slice.call(args);
-      opts = this.extract_options(required_parameters.length, args);
-      if (args.length > required_parameters.length) {
-        throw new Error("Too many parameters provided for path");
-      }
-      parameters = this.prepare_parameters(required_parameters, args, opts);
-      this.set_default_url_options(optional_parts, parameters);
-      anchor = this.extract_anchor(parameters);
-      trailing_slash = this.extract_trailing_slash(parameters);
+      options = this.normalize_options(url_defaults, required_parameters, optional_parts, args);
+      parameters = options['url_parameters'];
       result = "" + (this.get_prefix()) + (this.visit(route, parameters));
       url = Utils.clean_path("" + result);
-      if (trailing_slash === true) {
+      if (options['trailing_slash'] === true) {
         url = url.replace(/(.*?)[\/]?$/, "$1/");
       }
       if ((url_params = this.serialize(parameters)).length) {
         url += "?" + url_params;
       }
-      url += anchor;
+      url += options.anchor ? "#" + options.anchor : "";
+      if (url_defaults) {
+        url = this.route_url(options) + url;
+      }
       return url;
     },
     visit: function(route, parameters, optional) {
       var left, left_part, right, right_part, type, value;
+
       if (optional == null) {
         optional = false;
       }
@@ -235,6 +258,7 @@ Based on Rails routes of APP_CLASS
     },
     build_path_spec: function(route, wildcard) {
       var left, right, type;
+
       if (wildcard == null) {
         wildcard = false;
       }
@@ -263,6 +287,7 @@ Based on Rails routes of APP_CLASS
     },
     visit_globbing: function(route, parameters, optional) {
       var left, right, type, value;
+
       type = route[0], left = route[1], right = route[2];
       if (left.replace(/^\*/i, "") !== left) {
         route[1] = left = left.replace(/^\*/i, "");
@@ -283,16 +308,18 @@ Based on Rails routes of APP_CLASS
     },
     get_prefix: function() {
       var prefix;
+
       prefix = defaults.prefix;
       if (prefix !== "") {
-        prefix = (prefix.match("/$") ? prefix : prefix + "/");
+        prefix = (prefix.match("/$") ? prefix : "" + prefix + "/");
       }
       return prefix;
     },
-    route: function(required_parts, optional_parts, route_spec) {
+    route: function(required_parts, optional_parts, route_spec, url_defaults) {
       var path_fn;
+
       path_fn = function() {
-        return Utils.build_path(required_parts, optional_parts, route_spec, arguments);
+        return Utils.build_route(required_parts, optional_parts, route_spec, url_defaults, arguments);
       };
       path_fn.required_params = required_parts;
       path_fn.toString = function() {
@@ -300,16 +327,49 @@ Based on Rails routes of APP_CLASS
       };
       return path_fn;
     },
+    route_url: function(route_defaults) {
+      var hostname, port, protocol;
+
+      if (typeof route_defaults === 'string') {
+        return route_defaults;
+      }
+      protocol = route_defaults.protocol || Utils.current_protocol();
+      hostname = route_defaults.host || window.location.hostname;
+      port = route_defaults.port || (!route_defaults.host ? Utils.current_port() : void 0);
+      port = port ? ":" + port : '';
+      return protocol + "://" + hostname + port;
+    },
+    has_location: function() {
+      return typeof window !== 'undefined' && typeof window.location !== 'undefined';
+    },
+    current_host: function() {
+      return this.has_location() && window.location.hostname;
+    },
+    current_protocol: function() {
+      if (this.has_location() && window.location.protocol !== '') {
+        return window.location.protocol.replace(/:$/, '');
+      } else {
+        return 'http';
+      }
+    },
+    current_port: function() {
+      if (this.has_location() && window.location.port !== '') {
+        return window.location.port;
+      } else {
+        return '';
+      }
+    },
     _classToTypeCache: null,
     _classToType: function() {
-      var j, len, name, ref;
+      var name, _i, _len, _ref;
+
       if (this._classToTypeCache != null) {
         return this._classToTypeCache;
       }
       this._classToTypeCache = {};
-      ref = "Boolean Number String Function Array Date RegExp Object Error".split(" ");
-      for (j = 0, len = ref.length; j < len; j++) {
-        name = ref[j];
+      _ref = "Boolean Number String Function Array Date RegExp Object Error".split(" ");
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        name = _ref[_i];
         this._classToTypeCache["[object " + name + "]"] = name.toLowerCase();
       }
       return this._classToTypeCache;
@@ -331,8 +391,10 @@ Based on Rails routes of APP_CLASS
 
   createGlobalJsRoutesObject = function() {
     var namespace;
+
     namespace = function(mainRoot, namespaceString) {
       var current, parts;
+
       parts = (namespaceString ? namespaceString.split(".") : []);
       if (!parts.length) {
         return;

data/lib/routes.js.coffee

@@ -13,6 +13,14 @@ defaults =
 
 NodeTypes = NODE_TYPES
 
+ReservedOptions = [
+  'anchor'
+  'trailing_slash'
+  'host'
+  'port'
+  'protocol'
+]
+
 Utils =
 
   default_serializer: (object, prefix = null) ->
@@ -53,34 +61,14 @@ Utils =
     path[last_index] = path[last_index].replace(/\/+/g, "/")
     path.join "://"
 
-  set_default_url_options: (optional_parts, options) ->
-    for part, i in optional_parts when (not options.hasOwnProperty(part) and defaults.default_url_options.hasOwnProperty(part))
-      options[part] = defaults.default_url_options[part]
-
-  extract_anchor: (options) ->
-    anchor = ""
-    if options.hasOwnProperty("anchor")
-      anchor = "##{options.anchor}"
-      delete options.anchor
-    anchor
-
-  extract_trailing_slash: (options) ->
-    trailing_slash = false
-    if defaults.default_url_options.hasOwnProperty("trailing_slash")
-      trailing_slash = defaults.default_url_options.trailing_slash
-    if options.hasOwnProperty("trailing_slash")
-      trailing_slash = options.trailing_slash
-      delete options.trailing_slash
-    trailing_slash
-
   extract_options: (number_of_params, args) ->
     last_el = args[args.length - 1]
-    if args.length > number_of_params or (last_el? and "object" is @get_object_type(last_el) and !@look_like_serialized_model(last_el))
-      args.pop()
+    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))
+      args.pop() || {}
     else
       {}
 
-  look_like_serialized_model: (object) ->
+  looks_like_serialized_model: (object) ->
     # consider object a model if it have a path identifier properties like id and to_param
     "id" of object or "to_param" of object
 
@@ -107,33 +95,47 @@ Utils =
     copy[key] = attr for own key, attr of obj
     copy
 
-  prepare_parameters: (required_parameters, actual_parameters, options) ->
-    result = @clone(options) or {}
-    for val, i in required_parameters when i < actual_parameters.length
-      result[val] = actual_parameters[i]
+  merge: (xs...) ->
+    tap = (o, fn) -> fn(o); o
+    if xs?.length > 0
+      tap {}, (m) -> m[k] = v for k, v of x for x in xs
+
+  normalize_options: (url_defaults, required_parameters, optional_parts, actual_parameters) ->
+    options = @extract_options(required_parameters.length, actual_parameters)
+    if actual_parameters.length > required_parameters.length
+      throw new Error("Too many parameters provided for path")
+    options = @merge(defaults.default_url_options, url_defaults, options)
+    result = {}
+    url_parameters = {}
+    result['url_parameters'] = url_parameters
+    for own key, value of options
+      if ReservedOptions.indexOf(key) >= 0
+        result[key] = value
+      else
+        url_parameters[key] = value
+
+    for value, i in required_parameters when i < actual_parameters.length
+      url_parameters[value] = actual_parameters[i]
     result
 
-  build_path: (required_parameters, optional_parts, route, args) ->
+  build_route: (required_parameters, optional_parts, route, url_defaults, args) ->
     args = Array::slice.call(args)
-    opts = @extract_options(required_parameters.length, args)
 
-    if args.length > required_parameters.length
-      throw new Error("Too many parameters provided for path")
-    parameters = @prepare_parameters(required_parameters, args, opts)
-    @set_default_url_options optional_parts, parameters
-    # options
-    anchor = @extract_anchor(parameters)
-    trailing_slash = @extract_trailing_slash(parameters)
+    options = @normalize_options(url_defaults, required_parameters, optional_parts, args)
+    parameters = options['url_parameters']
+
     # path
     result = "#{@get_prefix()}#{@visit(route, parameters)}"
     url = Utils.clean_path("#{result}")
     # set trailing_slash
-    url = url.replace(/(.*?)[\/]?$/, "$1/") if trailing_slash is true
+    url = url.replace(/(.*?)[\/]?$/, "$1/") if options['trailing_slash'] is true
     # set additional url params
     if (url_params = @serialize(parameters)).length
       url += "?#{url_params}"
     # set anchor
-    url += anchor
+    url += if options.anchor then "##{options.anchor}" else ""
+    if url_defaults
+      url = @route_url(options) + url
     url
 
   #
@@ -229,12 +231,43 @@ Utils =
   #
   # route function: create route path function and add spec to it
   #
-  route: (required_parts, optional_parts, route_spec) ->
-    path_fn = -> Utils.build_path(required_parts, optional_parts, route_spec, arguments)
+  route: (required_parts, optional_parts, route_spec, url_defaults) ->
+    path_fn = ->
+      Utils.build_route(required_parts, optional_parts, route_spec, url_defaults, arguments)
     path_fn.required_params = required_parts
     path_fn.toString = -> Utils.build_path_spec(route_spec)
     path_fn
 
+
+  route_url: (route_defaults) ->
+    return route_defaults if typeof route_defaults == 'string'
+    protocol = route_defaults.protocol || Utils.current_protocol()
+    hostname = route_defaults.host || window.location.hostname
+    port = route_defaults.port || (Utils.current_port() unless route_defaults.host)
+    port = if port then ":#{port}" else ''
+
+    protocol + "://" + hostname + port
+
+
+  has_location: ->
+    typeof window != 'undefined' && typeof window.location != 'undefined'
+
+  current_host: ->
+    @has_location() && window.location.hostname
+
+  current_protocol: () ->
+    if @has_location() && window.location.protocol != ''
+      # location.protocol includes the colon character
+      window.location.protocol.replace(/:$/, '')
+    else
+      'http'
+
+  current_port: () ->
+    if @has_location() && window.location.port != ''
+      window.location.port
+    else
+      ''
+
   #
   # This is helper method to define object type.
   # The typeof operator is probably the biggest design flaw of JavaScript, simply because it's basically completely broken.

data/spec/js_routes/options_spec.rb

@@ -138,15 +138,17 @@ describe JsRoutes, "options" do
       expect(evaljs("Routes.inbox_path(1, {format: null})")).to eq(routes.inbox_path(1))
     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)
-    end
 
     it "shouldn't require the format" do
       expect(evaljs("Routes.json_only_path()")).to eq(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'))
+  end
+
   describe "when namespace option is specified" do
     let(:_options) { {:namespace => "PHM"} }
     it "should use this namespace for routing" do
@@ -192,7 +194,6 @@ 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
-        pending
         expect(evaljs("Routes.inbox_messages_path()")).to eq(routes.inbox_messages_path(:inbox_id => 12))
       end
     end
@@ -308,12 +309,6 @@ describe JsRoutes, "options" do
     end
 
     context "when configuring with default_url_options" do
-      context "when default host is not specified" do
-        it "raises an error" do
-          expect { JsRoutes.generate({ :url_links => true }) }.to raise_error RuntimeError
-        end
-      end
-
       context "when only host option is specified" do
         let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com"} } }
 
@@ -366,7 +361,7 @@ describe JsRoutes, "options" do
         end
 
         it "does not override host, protocol, or port when host is specified in route" do
-          expect(evaljs("Routes.sso_url()")).to eq(routes.sso_url)
+          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com:3000" + routes.sso_path)
         end
 
         it "does not override port when specified in route" do
@@ -404,6 +399,54 @@ describe JsRoutes, "options" do
         end
       end
     end
+
+    context 'when window.location is present' do
+      let(:current_protocol) { 'http:' } # window.location.protocol includes the colon character
+      let(:current_hostname) { 'current.example.com' }
+      let(:current_port){ '' } # an empty string means port 80
+      let(:current_host) do
+        host = "#{current_hostname}"
+        host += ":#{current_port}" unless current_port == ''
+        host
+      end
+
+      before do
+        jscontext['window'] = {
+          :location => {
+            :protocol => current_protocol,
+            :hostname => current_hostname,
+            :port => current_port,
+            :host => current_host
+          }
+        }
+      end
+
+      context "without specifying a default host" do
+        let(:_options) { { :url_links => true } }
+
+        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}")
+
+        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'))
+        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))
+        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'))
+        end
+      end
+    end
   end
 
   describe "when the compact mode is enabled" do

data/spec/spec_helper.rb

@@ -147,6 +147,22 @@ RSpec.configure do |config|
 
   config.before :each do
     evaljs("var window = this;", true)
-    jscontext[:log] = lambda {|context, value| puts value.inspect}
+
+    def inspectify(value)
+      case value
+      when V8::Object
+        value.to_h.map do |k,v|
+          [k, inspectify(v)]
+        end.to_h
+      when String, nil
+        value
+      else
+        raise "wtf #{value.class}?"
+      end
+
+    end
+    jscontext[:log] = lambda do |context, value|
+      puts inspectify(value).to_json
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js-routes
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Bogdan Gusiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2015-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties