js-routes 1.4.1 → 2.1.0

data/Readme.md

@@ -1,8 +1,11 @@
 # JsRoutes
 [![Build Status](https://travis-ci.org/railsware/js-routes.svg?branch=master)](https://travis-ci.org/railsware/js-routes)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Frailsware%2Fjs-routes.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Frailsware%2Fjs-routes?ref=badge_shield)
 
 Generates javascript file that defines all Rails named routes as javascript helpers
 
+[UPGRADE TO 2.0](./VERSION_2_UPGRADE.md)
+
 ## Intallation
 
 Your Rails Gemfile:
@@ -11,9 +14,117 @@ Your Rails Gemfile:
 gem "js-routes"
 ```
 
-### Basic Setup
+## Setup
+
+### Quick Start 
+
+Run:
+
+``` sh
+rake js:routes 
+# OR for typescript support
+rake js:routes:typescript
+```
+
+
+Individual routes can be imported using:
+
+``` javascript
+import {edit_post_path, posts_path} from 'routes';
+console.log(posts_path({format: 'json'})) // => "/posts.json"
+console.log(edit_post_path(1)) // => "/posts/1/edit"
+```
+
+Make routes available globally in `app/javascript/packs/application.js`: 
+
+``` javascript
+import * as Routes from 'routes';
+window.Routes = Routes;
+```
+
+**Note**: that this setup requires `rake js:routes` to be run each time routes file is updated.
+
+<div id='webpacker'></div>
+
+#### 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/webpack/environment.js`:
+
+``` javascript
+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
+import * as Routes from 'routes.js.erb';
+window.Routes = Routes;
+```
+
+<div id='definitions'></div>
+
+#### Typescript Definitions
+
+JsRoutes has typescript support out of the box. In order to generate typscript definitions file (aka `routes.d.ts`) you can call:
+
+``` ruby
+JsRoutes.definitions!
+```
+
+Or create an automatic updates file at `app/javascript/routes.d.ts.erb`:
+
+``` erb
+<%= JsRoutes.defintions %>
+```
 
-Require js routes file in `application.js` or other bundle
+#### Sprockets (Deprecated)
+
+If you are using [Sprockets](https://github.com/rails/sprockets-rails) you may configure js-routes in the following way.
+
+Setup the initializer (e.g. `config/initializers/js_routes.rb`):
+
+``` ruby
+JsRoutes.setup do |config|
+  config.module_type = nil
+  config.namespace = 'Routes'
+end
+```
+
+Require JsRoutes in `app/assets/javascripts/application.js` or other bundle
 
 ``` js
 //= require js-routes
@@ -29,9 +140,9 @@ This cache is not flushed on server restart in development environment.
 
 **Important:** If routes.js file is not updated after some configuration change you need to run this rake task again.
 
-### Advanced Setup
+### Configuration
 
-If you need to customize routes file create initializer, like `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|
@@ -39,107 +150,108 @@ JsRoutes.setup do |config|
 end
 ```
 
-Or make a more dynamic configuration in JavaScript, but only specific options support the possibility of such configuration(see the list below):
+Or dynamically in JavaScript, although only [Formatter Options](#formatter-options) are supported (see below)
 
 ``` js
+import * as Routes from 'routes'
 Routes.configure({
   option: value
 });
 Routes.config(); // current config
 ```
 
-Available options:
+#### Available Options
 
-* `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", :host => "example.com", :port => 3000}
-  * Default: {}
-* `exclude` - Array of regexps to exclude from js routes.
-  * Default: []
+##### Generator Options
+
+Options to configure JavaScript file generator. These options are only available in Ruby context but not JavaScript.
+
+* `module_type` - JavaScript module type for generated code. [Article](https://dev.to/iggredible/what-the-heck-are-cjs-amd-umd-and-esm-ikm)
+  * Options: `ESM`, `UMD`, `CJS`, `AMD`, `DTS`, `nil`.
+  * Default: `ESM`
+  * `nil` option can be used in case you don't want generated code to export anything.
+* `documentation` - specifies if each route should be annotated with [JSDoc](https://jsdoc.app/) comment
+  * Default: `true`
+* `exclude` - Array of regexps to exclude from routes.
+  * 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 js routes.
-  * Default: []
+* `include` - Array of regexps to include in routes.
+  * 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.
+  * Only available if `module_type` option is set to `nil`.
   * 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
+  * Default: `nil`
+* `camel_case` - specifies if route helpers should be generated in camel case instead of underscore case.
+  * Default: `false`
+* `url_links` - specifies if `*_url` helpers should be generated (in addition to the default `*_path` helpers).
+  * 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 js-routes 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.
 
-### Very Advanced Setup
+##### Formatter Options
 
-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:
+Options to configure routes formatting. These options are available both in Ruby and JavaScript context.
 
-```
-# app/assets/javascripts/admin/routes.js.erb
-<%= JsRoutes.generate(namespace: "AdminRoutes", include: /admin/) %>
+* `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`
 
-# app/assets/javascripts/admin.js.coffee
-#= require admin/routes
-```
+### 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:
 
+``` erb
+// app/javascript/admin/routes.js.erb
+<%= JsRoutes.generate(include: /admin/) %>
 ```
-# app/assets/javascripts/application/routes.js.erb
-<%= JsRoutes.generate(namespace: "AppRoutes", exclude: /admin/) %>
 
-# app/assets/javascripts/application.js.coffee
-#= require application/routes
+``` erb
+// app/javascript/customer/routes.js.erb
+<%= JsRoutes.generate(exclude: /admin/) %>
 ```
 
-In order to generate the routes JS code to a string:
+You can manipulate the generated helper manually by injecting ruby into javascript:
 
-```ruby
-routes_js = JsRoutes.generate(options)
+``` erb
+export const routes = <%= JsRoutes.generate(module_type: nil, namespace: nil) %>
 ```
 
 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"})
-```
-
-### Rails relative URL root
+path = Rails.root.join("app/javascript")
 
-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:
+JsRoutes.generate!("#{path}/app_routes.js", exclude: [/^admin_/, /^api_/])
+JsRoutes.generate!("#{path}/adm_routes.js", include: /^admin_/)
+JsRoutes.generate!("#{path}/api_routes.js", include: /^api_/, default_url_options: {format: "json"})
 ```
-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:
 
 ``` js
+import * as Routes from 'routes';
+
 Routes.users_path() // => "/users"
 Routes.user_path(1) // => "/users/1"
 Routes.user_path(1, {format: 'json'}) // => "/users/1.json"
@@ -180,67 +292,87 @@ This function allow to get the same `spec` for route, if you will get string rep
 '' + Routes.user_path // => "/users/:id(.:format)"
 ```
 
-Route function also contain inside attribute `required_params` required param names as array:
+Route function also contain method `requiredParams` inside which returns required param names array:
 
 ```js
-Routes.users_path.required_params // => []
-Routes.user_path.required_params // => ['id']
+Routes.users_path.requiredParams() // => []
+Routes.user_path.requiredParams() // => ['id']
 ```
 
 
-## Rails Compatibilities
+## Rails Compatibility
 
-JsRoutes ties to be as close as possible to rails behaviour in all aspects of routing API.
-Please make and issue in case of any incomtibilities found outside of described below.
+JsRoutes tries to replicate the Rails routing API as closely as possible. If you find any incompatibilities (outside of what is described below), please [open an issue](https://github.com/railsware/js-routes/issues/new).
 
 ### Object and Hash distinction issue
 
-Sometimes the destinction between JS Hash and Object can not be found by js-routes.
+Sometimes the destinction between JS Hash and Object can not be found by JsRoutes.
 In this case you would need to pass a special key to help:
 
 ``` js
-Routes.company_project_path({company_id: 1, id: 2}) // => Not Enough parameters
+Routes.company_project_path({company_id: 1, id: 2}) // => Not enough parameters
 Routes.company_project_path({company_id: 1, id: 2, _options: true}) // => "/companies/1/projects/2"
 ```
 
 
 ## What about security?
 
-js-routes itself do 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_/`
+JsRoutes itself does not have security holes. 
+It makes URLs without access protection more reachable by potential attacker.
+If that is an issue for you, you may use one of the following solutions:
 
-## Spork
+### Explicit Import + ESM Tree shaking
 
-When using Spork and `Spork.trap_method(Rails::Application::RoutesReloader, :reload!)` you should also do:
+Make sure `module_type` is set to `ESM` (the default) and JS files import only required routes into the file like:
 
-``` ruby
-Spork.trap_method(JsRoutes, :generate!)
+``` javascript
+import {
+  inbox_path,
+  inboxes_path,
+  inbox_message_path,
+  inbox_attachment_path,
+  user_path,
+} from 'routes.js.erb'
 ```
 
-## JS-Routes and heroku
+Such import structure allows for moddern JS bundlers like [Webpack](https://webpack.js.org/) to only include explicitly imported routes into JS bundle file.
+See [Tree Shaking](https://webpack.js.org/guides/tree-shaking/) for more information.
 
-Heroku environment has a specific problems with setup. It is impossible to use asset pipeline in this environment. You should use "Very Advanced Setup" schema in this case.
+### Exclude option
 
-For example create routes.js.erb in assets folder with needed content:
+Split your routes into multiple files related to each section of your website like:
 
-``` erb
-<%= JsRoutes.generate(options) %>
+``` javascript
+// admin-routes.js.erb
+<%= JsRoutes.generate(include: /^admin_/) %>
+// app-routes.js.erb
+<%= JsRoutes.generate(exclude: /^admin_/) %>
 ```
 
-This should just work.
-
 ## Advantages over alternatives
 
 There are some alternatives available. Most of them has only basic feature and don't reach the level of quality I accept.
 Advantages of this one are:
 
-* Rails 3-5 support
+* Rails 4,5,6 support
+* [ESM Tree shaking](https://webpack.js.org/guides/tree-shaking/) support
 * Rich options set
 * Full rails compatibility
 * Support Rails `#to_param` convention for seo optimized paths
 * Well tested
 
-#### Thanks to [Contributors](https://github.com/railsware/js-routes/contributors)
+## Version 2 TODO
+
+* Add routes generation .d.ts file
+* Add config option on the output format: js, ts, d.ts
+* Add prettier
+* Add eslint
+* Add development guide
+
+#### Thanks to [contributors](https://github.com/railsware/js-routes/contributors)
 
 #### Have fun
+
+
+## License
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Frailsware%2Fjs-routes.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Frailsware%2Fjs-routes?ref=badge_large)

data/VERSION_2_UPGRADE.md

@@ -0,0 +1,66 @@
+## Version 2.0 upgrade notes
+
+### Using ESM module by default
+
+New version of JsRoutes doesn't try to guess your javascript environment module system because JS has generated a ton of legacy module systems in the past. 
+[ESM+Webpacker](/Readme.md#webpacker) upgrade is recommended. 
+
+However, if you don't want to follow that pass, specify `module_type` configuration option instead based on module system available in your JS environment.
+Here are supported values:
+
+* CJS
+* UMD
+* AMD
+* ESM
+* nil
+
+[Explaination Article](https://dev.to/iggredible/what-the-heck-are-cjs-amd-umd-and-esm-ikm)
+
+If you don't want to use any JS module system and make routes available via a **global variable**, specify `nil` as a `module_type` and use `namespace` option:
+
+``` ruby
+JsRoutes.setup do |config|
+  config.module_type = nil
+  config.namespace = "Routes"
+end
+```
+
+### JSDoc comment
+
+New version of js-routes generates function comment in the [JSDoc](https://jsdoc.app) format.
+If you have any problems with that, you can disable it like this:
+
+
+``` ruby
+JsRoutes.setup do |config|
+  config.documentation = false
+end
+```
+
+### `required_params` renamed
+
+In case you are using `required_params` property, it is now renamed and converted to a method:
+
+``` javascript
+// Old style
+Routes.post_path.required_params  // => ['id']
+// New style
+Routes.post_path.requiredParams() // => ['id']
+```
+
+### ParameterMissing error rework
+
+`ParameterMissing` is renamed to `ParametersMissing` error and now list all missing parameters instead of just first encountered in its message. Missing parameters are now available via `ParametersMissing#keys` property.
+
+``` javascript
+try {
+  return Routes.inbox_path();
+} catch(error) {
+  if (error.name === 'ParametersMissing') {
+    console.warn(`Missing route keys ${error.keys.join(', ')}. Ignoring.`);
+    return "#";
+  } else {
+    throw error;
+  }
+}
+```

data/app/assets/javascripts/js-routes.js.erb

@@ -1,2 +1,2 @@
 <%# encoding: UTF-8 %>
-<%= JsRoutes.assert_usable_configuration! && JsRoutes.generate %>
+<%= JsRoutes.generate %>

data/gemfiles/{rails40.gemfile → rails40_sprockets_2.gemfile}

@@ -3,6 +3,6 @@
 source "http://rubygems.org"
 
 gem "railties", "~> 4.0.13"
-gem "sprockets", "< 3"
+gem "sprockets", "~> 2.0"
 
 gemspec :path => "../"

data/gemfiles/{rails41.gemfile → rails41_sprockets_2.gemfile}

@@ -3,6 +3,6 @@
 source "http://rubygems.org"
 
 gem "railties", "~> 4.1.16"
-gem "sprockets", "< 3"
+gem "sprockets", "~> 2.0"
 
 gemspec :path => "../"

data/gemfiles/{rails32.gemfile → rails42_sprockets_2.gemfile}

@@ -2,7 +2,7 @@
 
 source "http://rubygems.org"
 
-gem "railties", "~> 3.2.22.5"
-gem "tzinfo"
+gem "railties", "~> 4.2.9"
+gem "sprockets", "~> 2.0"
 
 gemspec :path => "../"

data/gemfiles/{rails42_sprockets3.gemfile → rails42_sprockets_3.gemfile}

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

data/gemfiles/{rails50_sprockets3.gemfile → rails50_sprockets_3.gemfile}

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

data/gemfiles/rails51_sprockets_3.gemfile

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

data/gemfiles/rails52_sprockets_3.gemfile

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

data/js-routes.gemspec

@@ -7,30 +7,33 @@ Gem::Specification.new do |s|
   s.name = %q{js-routes}
   s.version = JsRoutes::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  if s.respond_to? :required_rubygems_version=
+    s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  end
   s.authors = ["Bogdan Gusiev"]
   s.description = %q{Generates javascript file that defines all Rails named routes as javascript helpers}
   s.email = %q{agresso@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE.txt"
   ]
+  s.required_ruby_version = '>= 2.4.0'
   s.files = `git ls-files`.split("\n")
   s.homepage = %q{http://github.com/railsware/js-routes}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.summary = %q{Brings Rails named routes to javascript}
 
-  s.add_runtime_dependency(%q<railties>, [">= 3.2"])
-  s.add_runtime_dependency(%q<sprockets-rails>)
-  s.add_development_dependency(%q<rspec>, [">= 3.0.0"])
+  s.add_runtime_dependency(%q<railties>, [">= 4"])
+  s.add_development_dependency(%q<sprockets-rails>)
+  s.add_development_dependency(%q<rspec>, [">= 3.10.0"])
   s.add_development_dependency(%q<bundler>, [">= 1.1.0"])
-  s.add_development_dependency(%q<coffee-script>, [">= 0"])
   s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
+  s.add_development_dependency(%q<bump>, [">= 0.10.0"])
   if defined?(JRUBY_VERSION)
     s.add_development_dependency(%q<therubyrhino>, [">= 2.0.4"])
   else
     s.add_development_dependency(%q<byebug>)
     s.add_development_dependency(%q<pry-byebug>)
-    s.add_development_dependency(%q<therubyracer>, [">= 0.12.3"])
+    s.add_development_dependency(%q<mini_racer>, [">= 0.4.0"])
   end
 end

data/lib/js_routes/engine.rb

@@ -1,4 +1,5 @@
-class JsRoutesSprocketsExtension
+class JsRoutes
+class SprocketsExtension
   def initialize(filename, &block)
     @filename = filename
     @source   = block.call
@@ -41,33 +42,20 @@ class Engine < ::Rails::Engine
                           raise StandardError, "Sprockets version #{sprockets_version} is not supported"
                       end
 
-  is_running_rails = defined?(Rails) && Rails.respond_to?(:version)
-  is_running_rails_32 = is_running_rails && Rails.version.match(/3\.2/)
-
   initializer 'js-routes.dependent_on_routes', initializer_args do
     case sprockets_version
       when  -> (v) { v2.match?('', v) },
             -> (v) { vgte3.match?('', v) }
 
-      # It seems rails 3.2 is not working if
-      # `Rails.application.config.assets.configure` is used for
-      # registering preprocessor
-      if is_running_rails_32
-        Rails.application.assets.register_preprocessor(
+      Rails.application.config.assets.configure do |config|
+        config.register_preprocessor(
           "application/javascript",
-          JsRoutesSprocketsExtension,
+          SprocketsExtension,
         )
-      else
-        # Other rails version, assumed newer
-        Rails.application.config.assets.configure do |config|
-          config.register_preprocessor(
-            "application/javascript",
-            JsRoutesSprocketsExtension,
-          )
-        end
       end
     else
       raise StandardError, "Sprockets version #{sprockets_version} is not supported"
     end
   end
 end
+end

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "1.4.1"
+  VERSION = "2.1.0"
 end