js-routes 1.4.7 → 1.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f1f7818deadc1efdc9737ec8a149e42c22ae25b32c441e2a72617cd62725611
-  data.tar.gz: 2a9bb8fe0e342c6ff6601b0bd3addcdf909aa9221e0b0c5712ef7ce757f5fcd5
+  metadata.gz: 597119aa17518bd0b078b80c99c5f2e2a4cb4f5fa58526872b8d960acb9b6102
+  data.tar.gz: 285c6f0aca0c140822e89b65afead328bbddc6eb3a08ef85944b68e8c3068515
 SHA512:
-  metadata.gz: 141847fb1eb1fb8c70392a8ab54a094a5a3b2a3d0ec3dcfeb86e9bae416c4ac4311ab5395c3f295b0d527d7ecd23c35585354a62eda2befa5f12fa3a3e3514eb
-  data.tar.gz: 57e2939986d82f88c4ed48be556c06e611cc8f6f0f03c232bc7ba2146d7ba3f417cb891b5c50cc97046eb02300233316ad00236c71712790fa5c377c6e9c6f3e
+  metadata.gz: 501157d25557db0b0511acaa3226ca0fefbb3520bbec48ca9f1005e7300eb2dc0c115e9eae42ef085c17a78c8f2c0822c8b226cb8df639f20a81d9b62de6a421
+  data.tar.gz: fecba94667f0a316142d03b8c5b4ca3a95790278a65de6c2b247805d82c16adece41d1a5f395af38913dbd811cdd2c6ad4a8b80c3cae2b30ecc5eec96a27a1c3

data/.gitignore

@@ -15,6 +15,8 @@ log
 # jeweler generated
 pkg
 
+node_modules
+
 # Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
 #
 # * Create a file at ~/.gitignore

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## master
 
+## v1.4.13
+
+* Improve compatibility with node environment #269.
+* Change default file location configuration to Webpacker if both Webpacker and Sprockets are loaded
+
+## v1.4.11
+
+* Use app/javascript/routes.js as a default file location if app/javascript directory exists
+* Add `default` export for better experience when used as es6 module
+
+## v1.4.10
+
+* Require engine only when sprockets is loaded #257.
+
+## v1.4.9
+
+* Allow to specify null namespace and receive routes as an object without assigning it anywhere #247
+
 ## v1.4.7
 
 * Fix a LocalJumpError on secondary initialization of the app #248

data/Readme.md

@@ -12,9 +12,80 @@ Your Rails Gemfile:
 gem "js-routes"
 ```
 
-### Basic Setup
+## Setup
 
-Require JsRoutes in `application.js` or other bundle
+Run:
+
+```
+rake js:routes 
+```
+
+Make routes available globally in `app/javascript/packs/application.js`: 
+
+``` javascript
+window.Routes = require('routes');
+```
+
+Individual routes can be imported using:
+
+``` javascript
+import {edit_post_path, new_post_path} from 'routes';
+```
+
+**Note**: that this setup requires `rake js:routes` to be run each time routes file is updated.
+
+#### Webpacker + automatic updates
+
+This setup can automatically update your routes without `rake js:routes` being called manually.
+It requires [rails-erb-loader](https://github.com/usabilityhub/rails-erb-loader) npm package to work.
+
+Add `erb` loader to webpacker:
+
+``` sh
+yarn add rails-erb-loader
+rm -f app/javascript/routes.js # delete static file if any
+```
+
+Create webpack ERB config `config/webpack/loaders/erb.js`:
+
+``` javascript
+module.exports = {
+  test: /\.js\.erb$/,
+  enforce: 'pre',
+  exclude: /node_modules/,
+  use: [{
+    loader: 'rails-erb-loader',
+    options: {
+      runner: (/^win/.test(process.platform) ? 'ruby ' : '') + 'bin/rails runner'
+    }
+  }]
+}
+```
+
+Enable `erb` extension in `config/webpacker/environment.js`:
+
+```
+const erb = require('./loaders/erb')
+environment.loaders.append('erb', erb)
+```
+
+Create routes file `app/javascript/routes.js.erb`:
+
+``` erb
+<%= JsRoutes.generate() %>
+```
+
+Use routes wherever you need them `app/javascript/packs/application.js`: 
+
+``` javascript
+window.Routes = require('routes.js.erb');
+```
+
+#### Sprockets (Deprecated)
+
+If you are using [Sprockets](https://github.com/rails/sprockets-rails) you may configure js-routes in the following way.
+
+Require JsRoutes in `app/assets/javascripts/application.js` or other bundle
 
 ``` js
 //= require js-routes
@@ -32,7 +103,7 @@ This cache is not flushed on server restart in development environment.
 
 ### Configuration
 
-You can configure JsRoutes in two main ways. Either with an initializer (e.g. `config/initializers/jsroutes.rb`):
+You can configure JsRoutes in two main ways. Either with an initializer (e.g. `config/initializers/js_routes.rb`):
 
 ``` ruby
 JsRoutes.setup do |config|
@@ -40,7 +111,7 @@ JsRoutes.setup do |config|
 end
 ```
 
-Or dynamically in JavaScript, although not all configuration options are supported:
+Or dynamically in JavaScript, although only [Formatter Options](#formatter-options) are supported (see below)
 
 ``` js
 Routes.configure({
@@ -49,93 +120,84 @@ Routes.configure({
 Routes.config(); // current config
 ```
 
-Available options:
+#### Available Options
+
+##### Generator Options
+
+Options to configure JavaScript file generator. These options are only available in Ruby context but not JavaScript.
 
-* `default_url_options` - default parameters used when generating URLs
-  * Option is configurable at JS level with `Routes.configure()`
-  * Example: {:format => "json", :trailing\_slash => true, :protocol => "https", :subdomain => "api", :host => "example.com", :port => 3000}
-  * Default: {}
 * `exclude` - Array of regexps to exclude from routes.
-  * Default: []
+  * Default: `[]`
   * The regexp applies only to the name before the `_path` suffix, eg: you want to match exactly `settings_path`, the regexp should be `/^settings$/`
 * `include` - Array of regexps to include in routes.
-  * Default: []
+  * Default: `[]`
   * The regexp applies only to the name before the `_path` suffix, eg: you want to match exactly `settings_path`, the regexp should be `/^settings$/`
 * `namespace` - global object used to access routes.
   * Supports nested namespace like `MyProject.routes`
   * Default: `Routes`
-* `prefix` - String representing a url path to prepend to all paths.
-  * Option is configurable at JS level with `Routes.configure()`
-  * Example: `http://yourdomain.com`. This will cause route helpers to generate full path only.
-  * 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
+* `camel_case` - Generate camel case route names.
+  * Default: `false`
+* `url_links` - Generate `*_url` helpers (in addition to the default `*_path` helpers).
+  * Example: `true`
+  * Default: `false`
   * 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
+* `compact` - 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
-  * Option is configurable at JS level with `Routes.configure()`
-  * 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.
-
-* `special_options_key` - a special key that helps JsRoutes to destinguish serialized model from options hash
-  * This option is required because JS doesn't provide a difference between an object and a hash
-  * Option is configurable at JS level with `Routes.configure()`
-  * Default: `_options`
 * `application` - a key to specify which rails engine you want to generate routes too.
   * This option allows to only generate routes for a specific rails engine, that is mounted into routes instead of all Rails app routes
   * Default: `Rails.application`
+* `file` - a file location where generated routes are stored
+  * Default: `app/javascript/routes.js` if setup with Webpacker, otherwise `app/assets/javascripts/routes.js` if setup with Sprockets.
+
+##### Formatter Options
+
+Options to configure routes formatting. These options are available both in Ruby and JavaScript context.
 
-### Very Advanced Setup
+* `default_url_options` - default parameters used when generating URLs
+  * Example: `{format: "json", trailing_slash: true, protocol: "https", subdomain: "api", host: "example.com", port: 3000}`
+  * Default: `{}`
+* `prefix` - string that will prepend any generated URL. Usually used when app URL root includes a path component.
+  * Example: `/rails-app`
+  * Default: `Rails.application.config.relative_url_root`
+* `serializer` - a JS function that serializes a Javascript Hash object into URL paramters like `{a: 1, b: 2} => "a=1&b=2"`.
+  * Default: `nil`. Uses built-in serializer compatible with Rails
+  * Example: `jQuery.param` - use jQuery's serializer algorithm. You can attach serialize function from your favorite AJAX framework.
+  * Example: `function (object) { ... }` - use completely custom serializer of your application.
+* `special_options_key` - a special key that helps JsRoutes to destinguish serialized model from options hash
+  * This option exists because JS doesn't provide a difference between an object and a hash
+  * Default: `_options`
+
+### Advanced Setup
 
 In case you need multiple route files for different parts of your application, you have to create the files manually.
 If your application has an `admin` and an `application` namespace for example:
 
 ```
-# app/assets/javascripts/admin/routes.js.erb
+# app/javascript/admin/routes.js.erb
 <%= JsRoutes.generate(namespace: "AdminRoutes", include: /admin/) %>
-
-# app/assets/javascripts/admin.js.coffee
-#= require admin/routes
 ```
 
 ```
-# app/assets/javascripts/application/routes.js.erb
-<%= JsRoutes.generate(namespace: "AppRoutes", exclude: /admin/) %>
-
-# app/assets/javascripts/application.js.coffee
-#= require application/routes
+# app/javascript/customer/routes.js.erb
+<%= JsRoutes.generate(namespace: "CustomerRoutes", exclude: /admin/) %>
 ```
 
 In order to generate the routes JS code to a string:
 
-```ruby
+``` ruby
 routes_js = JsRoutes.generate(options)
 ```
 
 If you want to generate the routes files outside of the asset pipeline, you can use `JsRoutes.generate!`:
 
 ``` ruby
-path = "app/assets/javascripts"
-JsRoutes.generate!("#{path}/app_routes.js", :namespace => "AppRoutes", :exclude => [/^admin_/, /^api_/])
-JsRoutes.generate!("#{path}/adm_routes.js", :namespace => "AdmRoutes", :include => /^admin_/)
-JsRoutes.generate!("#{path}/api_routes.js", :namespace => "ApiRoutes", :include => /^api_/, :default_url_options => {:format => "json"})
+path = "app/javascript"
+JsRoutes.generate!("#{path}/app_routes.js", namespace: "AppRoutes", exclude: [/^admin_/, /^api_/])
+JsRoutes.generate!("#{path}/adm_routes.js", namespace: "AdmRoutes", include: /^admin_/)
+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:
@@ -206,7 +268,7 @@ Routes.company_project_path({company_id: 1, id: 2, _options: true}) // => "/comp
 
 ## What about security?
 
-JsRoutes itself do not have security holes. It makes URLs
+JsRoutes itself does not have security holes. It makes URLs
 without access protection more reachable by potential attacker.
 In order to prevent this use `:exclude` option for sensitive urls like `/admin_/`
 

data/js-routes.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.summary = %q{Brings Rails named routes to javascript}
 
   s.add_runtime_dependency(%q<railties>, [">= 4"])
-  s.add_runtime_dependency(%q<sprockets-rails>)
+  s.add_development_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<coffee-script>, [">= 0"])

data/lib/js_routes.rb

@@ -1,5 +1,7 @@
 require 'uri'
-require 'js_routes/engine' if defined?(Rails)
+if defined?(::Rails) && defined?(::Sprockets::Railtie)
+  require 'js_routes/engine'
+end
 require 'js_routes/version'
 
 class JsRoutes
@@ -8,13 +10,17 @@ class JsRoutes
   # OPTIONS
   #
 
-  DEFAULT_PATH = File.join('app','assets','javascripts','routes.js')
-
   DEFAULTS = {
-    namespace: "Routes",
+    namespace: -> { defined?(Webpacker) ? nil : "Routes" },
     exclude: [],
     include: //,
-    file: DEFAULT_PATH,
+    file: -> do
+      webpacker_dir = Rails.root.join('app', 'javascript')
+      sprockets_dir = Rails.root.join('app','assets','javascripts')
+      sprockets_file = sprockets_dir.join('routes.js')
+      webpacker_file = webpacker_dir.join('routes.js')
+      !Dir.exists?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
+    end,
     prefix: -> { Rails.application.config.relative_url_root || "" },
     url_links: false,
     camel_case: false,
@@ -23,7 +29,7 @@ class JsRoutes
     serializer: nil,
     special_options_key: "_options",
     application: -> { Rails.application }
-  }
+  } #:nodoc:
 
   NODE_TYPES = {
     GROUP: 1,
@@ -34,11 +40,11 @@ class JsRoutes
     LITERAL: 6,
     SLASH: 7,
     DOT: 8
-  }
+  } #:nodoc:
 
-  LAST_OPTIONS_KEY = "options".freeze
-  FILTERED_DEFAULT_PARTS = [:controller, :action]
-  URL_OPTIONS = [:protocol, :domain, :host, :port, :subdomain]
+  LAST_OPTIONS_KEY = "options".freeze #:nodoc:
+  FILTERED_DEFAULT_PARTS = [:controller, :action] #:nodoc:
+  URL_OPTIONS = [:protocol, :domain, :host, :port, :subdomain] #:nodoc:
 
   class Configuration < Struct.new(*DEFAULTS.keys)
     def initialize(attributes = nil)
@@ -118,18 +124,18 @@ class JsRoutes
     end
 
     {
-      "GEM_VERSION"         => JsRoutes::VERSION,
-      "ROUTES"              => js_routes,
-      "NODE_TYPES"          => json(NODE_TYPES),
-      "RAILS_VERSION"       => ActionPack.version,
-      "DEPRECATED_GLOBBING_BEHAVIOR" => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
-
-      "APP_CLASS"           => application.class.to_s,
-      "NAMESPACE"           => json(@configuration.namespace),
-      "DEFAULT_URL_OPTIONS" => json(@configuration.default_url_options),
-      "PREFIX"              => json(@configuration.prefix),
-      "SPECIAL_OPTIONS_KEY" => json(@configuration.special_options_key),
-      "SERIALIZER"          => @configuration.serializer || json(nil),
+      'GEM_VERSION'         => JsRoutes::VERSION,
+      'ROUTES'              => js_routes,
+      'NODE_TYPES'          => json(NODE_TYPES),
+      'RAILS_VERSION'       => ActionPack.version,
+      'DEPRECATED_GLOBBING_BEHAVIOR' => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
+
+      'APP_CLASS'           => application.class.to_s,
+      'NAMESPACE'           => json(@configuration.namespace),
+      'DEFAULT_URL_OPTIONS' => json(@configuration.default_url_options),
+      'PREFIX'              => json(@configuration.prefix),
+      'SPECIAL_OPTIONS_KEY' => json(@configuration.special_options_key),
+      'SERIALIZER'          => @configuration.serializer || json(nil),
     }.inject(File.read(File.dirname(__FILE__) + "/routes.js")) do |js, (key, value)|
       js.gsub!(key, value.to_s)
     end
@@ -173,7 +179,8 @@ class JsRoutes
 
   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
+    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
@@ -183,7 +190,8 @@ class JsRoutes
   end
 
   def get_app_from_route(route)
-    # rails engine in Rails 4.2 use additional ActionDispatch::Routing::Mapper::Constraints, which contain app
+    # 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)
       route.app.app
     else
@@ -191,8 +199,9 @@ class JsRoutes
     end
   end
 
-  def build_route_if_match(route, parent_route=nil)
-    if any_match?(route, parent_route, @configuration[:exclude]) || !any_match?(route, parent_route, @configuration[:include])
+  def build_route_if_match(route, parent_route = nil)
+    if any_match?(route, parent_route, @configuration[:exclude]) ||
+       !any_match?(route, parent_route, @configuration[:include])
       nil
     else
       build_js(route, parent_route)
@@ -203,7 +212,7 @@ class JsRoutes
     full_route = [parent_route.try(:name), route.name].compact.join('_')
 
     matchers = Array(matchers)
-    matchers.any? {|regex| full_route =~ regex}
+    matchers.any? { |regex| full_route =~ regex }
   end
 
   def build_js(route, parent_route)
@@ -211,8 +220,8 @@ class JsRoutes
     route_name = generate_route_name(name, (:path unless @configuration[:compact]))
     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!
+    url_link = generate_url_link(name, route_arguments)
+    <<-JS.strip!
   // #{name.join('.')} => #{parent_spec}#{route.path.spec}
   // function(#{build_params(route.required_parts)})
   #{route_name}: Utils.route(#{route_arguments})#{",\n" + url_link if url_link.length > 0}
@@ -225,7 +234,8 @@ class JsRoutes
       hash[part] = required_parts.include?(part)
     end
     default_options = route.defaults.select do |part, _|
-      FILTERED_DEFAULT_PARTS.exclude?(part) && URL_OPTIONS.include?(part) || parts_table[part]
+      FILTERED_DEFAULT_PARTS.exclude?(part) &&
+        URL_OPTIONS.include?(part) || parts_table[part]
     end
     [
       # JS objects don't preserve the order of properties which is crucial,
@@ -235,19 +245,19 @@ class JsRoutes
       serialize(route.path.spec, parent_spec)
     ].map do |argument|
       json(argument)
-    end.join(", ")
+    end.join(', ')
   end
 
-  def generate_url_link(name, route_name, route_arguments, route)
-    return "" unless @configuration[:url_links]
+  def generate_url_link(name, route_arguments)
+    return '' unless @configuration[:url_links]
+
     <<-JS.strip!
     #{generate_route_name(name, :url)}: Utils.route(#{route_arguments}, true)
     JS
   end
 
-  def generate_route_name(name, suffix)
-    route_name = name.join('_')
-    route_name << "_#{ suffix }" if suffix
+  def generate_route_name(*parts)
+    route_name = parts.compact.join('_')
     @configuration[:camel_case] ? route_name.camelize(:lower) : route_name
   end
 
@@ -257,7 +267,7 @@ class JsRoutes
 
   def build_params(required_parts)
     params = required_parts + [LAST_OPTIONS_KEY]
-    params.join(", ")
+    params.join(', ')
   end
 
   # This function serializes Journey route into JSON structure
@@ -266,7 +276,9 @@ class JsRoutes
   # Routes.js file will be smaller.
   def serialize(spec, parent_spec=nil)
     return nil unless spec
-    return spec.tr(':', '') if spec.is_a?(String)
+    # Rails 4 globbing requires * removal
+    return spec.tr(':*', '') if spec.is_a?(String)
+
     result = serialize_spec(spec, parent_spec)
     if parent_spec && result[1].is_a?(String)
       result = [
@@ -280,7 +292,7 @@ class JsRoutes
     result
   end
 
-  def serialize_spec(spec, parent_spec=nil)
+  def serialize_spec(spec, parent_spec = nil)
     [
       NODE_TYPES[spec.type],
       serialize(spec.left, parent_spec),
@@ -288,4 +300,3 @@ class JsRoutes
     ]
   end
 end
-

data/lib/js_routes/engine.rb

@@ -47,7 +47,6 @@ class Engine < ::Rails::Engine
       when  -> (v) { v2.match?('', v) },
             -> (v) { vgte3.match?('', v) }
 
-      # Other rails version, assumed newer
       Rails.application.config.assets.configure do |config|
         config.register_preprocessor(
           "application/javascript",

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "1.4.7"
+  VERSION = "1.4.13"
 end

data/lib/routes.js

@@ -4,12 +4,10 @@ Based on Rails RAILS_VERSION routes of APP_CLASS
  */
 
 (function() {
-  var DeprecatedGlobbingBehavior, NodeTypes, ParameterMissing, ReservedOptions, SpecialOptionsKey, UriEncoderSegmentRegex, Utils, root,
+  var DeprecatedGlobbingBehavior, NodeTypes, ParameterMissing, ReservedOptions, SpecialOptionsKey, UriEncoderSegmentRegex, Utils, result,
     hasProp = {}.hasOwnProperty,
     slice = [].slice;
 
-  root = typeof exports !== "undefined" && exports !== null ? exports : this;
-
   ParameterMissing = function(message, fileName, lineNumber) {
     var instance;
     instance = new Error(message, fileName, lineNumber);
@@ -336,9 +334,6 @@ Based on Rails RAILS_VERSION 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, "");
-      }
       value = parameters[left];
       delete parameters[left];
       if (value == null) {
@@ -440,8 +435,8 @@ Based on Rails RAILS_VERSION routes of APP_CLASS
       return this._classToTypeCache;
     },
     get_object_type: function(obj) {
-      if (root.jQuery && (root.jQuery.type != null)) {
-        return root.jQuery.type(obj);
+      if (this.jQuery && (this.jQuery.type != null)) {
+        return this.jQuery.type(obj);
       }
       if (obj == null) {
         return "" + obj;
@@ -472,7 +467,7 @@ Based on Rails RAILS_VERSION routes of APP_CLASS
     },
     namespace: function(root, namespace, routes) {
       var index, j, len, part, parts;
-      parts = namespace.split(".");
+      parts = namespace ? namespace.split(".") : [];
       if (parts.length === 0) {
         return routes;
       }
@@ -500,25 +495,27 @@ Based on Rails RAILS_VERSION routes of APP_CLASS
       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);
+      return Object.assign({
+        "default": routes
+      }, routes);
     }
   };
 
+  result = Utils.make();
+
   if (typeof define === "function" && define.amd) {
     define([], function() {
-      return Utils.make();
+      return result;
     });
+  } else if (typeof module !== "undefined" && module !== null) {
+    module.exports = result;
   } else {
-    Utils.make();
+    Utils.namespace(this, NAMESPACE, result);
   }
 
+  return result;
+
 }).call(this);

data/lib/routes.js.coffee

@@ -2,7 +2,6 @@
 File generated by js-routes GEM_VERSION
 Based on Rails RAILS_VERSION routes of APP_CLASS
 ###
-root = (exports ? this)
 
 ParameterMissing = (message, fileName, lineNumber) ->
   instance = new Error(message, fileName, lineNumber)
@@ -258,8 +257,6 @@ Utils =
   #
   visit_globbing: (route, parameters, optional) ->
     [type, left, right] = route
-    # fix for rails 4 globbing
-    route[1] = left = left.replace(/^\*/i, "") if left.replace(/^\*/i, "") isnt left
     value = parameters[left]
     delete parameters[left]
     return @visit(route, parameters, optional) unless value?
@@ -365,7 +362,7 @@ Utils =
       @_classToTypeCache["[object #{name}]"] = name.toLowerCase()
     @_classToTypeCache
   get_object_type: (obj) ->
-    return root.jQuery.type(obj) if root.jQuery and root.jQuery.type?
+    return this.jQuery.type(obj) if this.jQuery and this.jQuery.type?
     return "#{obj}" unless obj?
     (if typeof obj is "object" or typeof obj is "function" then @_classToType()[Object::toString.call(obj)] or "object" else typeof obj)
 
@@ -377,7 +374,7 @@ Utils =
     result
 
   namespace: (root, namespace, routes) ->
-    parts = namespace.split(".")
+    parts = if namespace then namespace.split(".") else []
     return routes if parts.length == 0
     for part, index in parts
       if index < parts.length - 1
@@ -395,19 +392,21 @@ Utils =
     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)
+    Object.assign({default: routes}, routes)
+
+result = Utils.make()
 
 # Set up Routes appropriately for the environment.
 if typeof define is "function" and define.amd
   # AMD
-  define [], -> Utils.make()
+  define [], -> result
+else if module?
+  # CommonJS
+  module.exports = result
 else
   # Browser globals
-  Utils.make()
+  Utils.namespace(this, NAMESPACE, result)
+
+return result

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,2 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css

data/spec/js_routes/amd_compatibility_spec.rb

@@ -27,16 +27,11 @@ EOF
     evaljs(JsRoutes.generate({}))
   end
 
-  it "should working from global scope" do
-    expect(evaljs("Routes.inboxes_path()")).to eq(test_routes.inboxes_path())
-  end
-
-  it "should working from define function" do
-    expect(evaljs("Routes.inboxes_path()")).to eq(evaljs("GlobalCheck['js-routes'].inboxes_path()"))
-  end
-
   it "should working from require" do
     expect(evaljs("require(['js-routes'], function(r){ return r.inboxes_path(); })")).to eq(test_routes.inboxes_path())
   end
 
+  it "should define default export for es6 modules" do
+    expect(evaljs("require(['js-routes'], function(r){ return r.default.inboxes_path(); })")).to eq(test_routes.inboxes_path())
+  end
 end

data/spec/js_routes/common_js_compatibility_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe JsRoutes, "compatibility with CommonJS (node)"  do
+  before(:each) do
+    evaljs("module = { exports: null }")
+    evaljs(JsRoutes.generate({}))
+  end
+
+  it "should define module exports" do
+    expect(evaljs("module.exports.inboxes_path()")).to eq(test_routes.inboxes_path())
+  end
+end

data/spec/js_routes/generated_javascript_spec.rb

@@ -60,11 +60,6 @@ describe JsRoutes do
     end
 
     it "should not generate file before initialization" do
-      # This method is alread fixed in Rails master
-      # But in 3.2 stable we need to hack it like this
-      if Rails.application.instance_variable_get("@initialized")
-        pending
-      end
       expect(File.exists?(name)).to be_falsey
     end
 

data/spec/js_routes/options_spec.rb

@@ -167,36 +167,46 @@ describe JsRoutes, "options" do
     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
+  describe "namespace option" do
     let(:_options) { {:namespace => "PHM"} }
     it "should use this namespace for routing" do
       expect(evaljs("window.Routes")).to be_nil
       expect(evaljs("PHM.inbox_path")).not_to be_nil
     end
-  end
 
-  describe "when nested namespace option is specified" do
-    context "and defined on client" do
-      let(:_presetup) { "window.PHM = {}" }
-      let(:_options) { {:namespace => "PHM.Routes"} }
+    context "is nil" do
+      let(:_options) { {:namespace => nil} }
       it "should use this namespace for routing" do
-        expect(evaljs("PHM.Routes.inbox_path")).not_to be_nil
+        evaljs("window.zz = #{JsRoutes.generate(namespace: nil)}")
+        expect(evaljs("window.Routes")).to be_nil
+        expect(evaljs("window.zz.inbox_path")).not_to be_nil
       end
+
     end
 
-    context "but undefined on client" do
-      let(:_options) { {:namespace => "PHM.Routes"} }
-      it "should initialize namespace" do
-        expect(evaljs("window.PHM.Routes.inbox_path")).not_to be_nil
+    describe "is nested" do
+      context "and defined on client" do
+        let(:_presetup) { "window.PHM = {}" }
+        let(:_options) { {:namespace => "PHM.Routes"} }
+        it "should use this namespace for routing" do
+          expect(evaljs("PHM.Routes.inbox_path")).not_to be_nil
+        end
       end
-    end
 
-    context "and some parts are defined" do
-      let(:_presetup) { "window.PHM = { Utils: {} };" }
-      let(:_options) { {:namespace => "PHM.Routes"} }
-      it "should not overwrite existing parts" do
-        expect(evaljs("window.PHM.Utils")).not_to be_nil
-        expect(evaljs("window.PHM.Routes.inbox_path")).not_to be_nil
+      context "but undefined on client" do
+        let(:_options) { {:namespace => "PHM.Routes"} }
+        it "should initialize namespace" do
+          expect(evaljs("window.PHM.Routes.inbox_path")).not_to be_nil
+        end
+      end
+
+      context "and some parts are defined" do
+        let(:_presetup) { "window.PHM = { Utils: {} };" }
+        let(:_options) { {:namespace => "PHM.Routes"} }
+        it "should not overwrite existing parts" do
+          expect(evaljs("window.PHM.Utils")).not_to be_nil
+          expect(evaljs("window.PHM.Routes.inbox_path")).not_to be_nil
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -95,11 +95,11 @@ RSpec.configure do |config|
 
     if defined?(JRUBY_VERSION)
       jscontext[:log] = lambda do |context, value|
-        puts value
+        puts value.inspect
       end
     else
       jscontext.attach("log", proc do |value|
-        puts value
+        puts value.inspect
       end)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js-routes
 version: !ruby/object:Gem::Version
-  version: 1.4.7
+  version: 1.4.13
 platform: ruby
 authors:
 - Bogdan Gusiev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-24 00:00:00.000000000 Z
+date: 2020-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -31,7 +31,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -172,9 +172,11 @@ files:
 - lib/routes.js
 - lib/routes.js.coffee
 - lib/tasks/js_routes.rake
+- spec/dummy/app/assets/config/manifest.js
 - spec/dummy/app/assets/javascripts/.gitkeep
 - spec/dummy/config/routes.rb
 - spec/js_routes/amd_compatibility_spec.rb
+- spec/js_routes/common_js_compatibility_spec.rb
 - spec/js_routes/default_serializer_spec.rb
 - spec/js_routes/generated_javascript_spec.rb
 - spec/js_routes/options_spec.rb
@@ -186,7 +188,7 @@ homepage: http://github.com/railsware/js-routes
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -201,9 +203,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Brings Rails named routes to javascript
 test_files: []