js-routes 2.2.8 → 2.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dfe30c594c24cf044d0f19342e17cd6b23857da7ec68a0bf68d8f8be9f33def
-  data.tar.gz: 3aefa8fc04221f07996ada7c57f35b22d2ae519575a6df0e20c6d860fe6203ed
+  metadata.gz: f69479723e452f1b4ed09bf940b3150ad45430b5c601f966f05a082bce0a9494
+  data.tar.gz: bd47ceb7b1cba241262b8308e913f7d87aef6304d93d9185026e70dd4980487f
 SHA512:
-  metadata.gz: 652fa60215a5c812e3a0cb0284870bfa63c6eeb1d249940388ade48a3f90a7209559d7cf66750e697ffc317bfcd1bec87e57fed44cad375795ead64fb1bcd254
-  data.tar.gz: a68bdb295fb704a5ed753d0576e700668aecfe30d5ec6d425ed458d029eb084de66ff26e0789c808e655574146973db02226a1a48f2cd81fa6ebda3379b7bc8c
+  metadata.gz: 4f67b2ccc88195647ea7c694f935848aad52ddd9e46ac1a766df0c29b7e123a147169deb5b8207c8d3a598fcf0c0ba01f98b0d24ee30b326737200f02f2f8235
+  data.tar.gz: 9aad6d181099b3fdd7ada0facf1269e08669cd1181f94d3039f0e13f8bf2bc5a44172e13843fec5a8317b4c99e1eee6a2de2343e34fe6c3cddebb7a63f9608fb

data/CHANGELOG.md

@@ -1,5 +1,21 @@
+# Changelog
+
 ## master
 
+## v2.2.10
+
+* Remove sorbet files from repo
+* Clearly define files included in gem
+* Fix Middleware and Middleware generator bugs [#316](https://github.com/railsware/js-routes/issue/316)
+* Remove empty object linter warning on DTS module
+* Generators: Add `.ts` extension when searching for main JS file of the project
+
+## v2.2.9
+
+* Fix middleware error for non-modern setup.
+* Added [Sorbet](https://sorbet.org/) method signatures.
+* Always use DTS module type when calling JsRoutes.definitions or .definitions!. [#313](https://github.com/railsware/js-routes/issues/313)
+
 ## v2.2.8
 
 * Leave emoji symbols intact when encoding URI fragment [#312](https://github.com/railsware/js-routes/issues/312)
@@ -28,10 +44,10 @@
 ## v2.2.3
 
 * Fixed NIL module type namespace defintion [#297](https://github.com/railsware/js-routes/issues/297).
-  * The patch may cause a problem with nested `namespace` option 
+  * The patch may cause a problem with nested `namespace` option.
   * Ex. Value like `MyProject.Routes` requires to define `window.MyProject` before importing the routes file
 
-## v2.2.2.
+## v2.2.2
 
 * Fix custom file path [#295](https://github.com/railsware/js-routes/issues/295)
 
@@ -156,10 +172,9 @@ See [UPGRADE TO 2.0](./VERSION_2_UPGRADE.md) for guidance.
 
 * Fixed bug when js-routes is used in envs without window.location #224
 
-
 ## v1.4.0
 
-* __breaking change!__ Implemented Routes.config() and Routes.configure instead of Routes.defaults
+* Implemented Routes.config() and Routes.configure instead of Routes.defaults
 
 New methods support 4 options at the moment:
 
@@ -245,7 +260,7 @@ Routes.configure({
 
 * 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
+* Remove all incompatibilities between Actiondispatch and js-routes
 
 ## v1.1.2
 
@@ -271,10 +286,10 @@ Routes.configure({
 
 ## v1.0.0
 
- * Add the compact mode [#125](https://github.com/railsware/js-routes/pull/125)
- * Add support for host, protocol, and port configuration [#137](https://github.com/railsware/js-routes/pull/137)
- * Routes path specs [#135](https://github.com/railsware/js-routes/pull/135)
- * Support Rails 4.2 and Ruby 2.2 [#140](https://github.com/railsware/js-routes/pull/140)
+* Add the compact mode [#125](https://github.com/railsware/js-routes/pull/125)
+* Add support for host, protocol, and port configuration [#137](https://github.com/railsware/js-routes/pull/137)
+* Routes path specs [#135](https://github.com/railsware/js-routes/pull/135)
+* Support Rails 4.2 and Ruby 2.2 [#140](https://github.com/railsware/js-routes/pull/140)
 
 ## v0.9.9
 

data/Readme.md

@@ -16,22 +16,22 @@ gem "js-routes"
 
 There are several possible ways to setup JsRoutes:
 
-* [Quick and easy](#quick-start) - Recommended
+1. [Quick and easy](#quick-start) - Recommended
   * Uses Rack Middleware to automatically update routes locally
   * Automatically generates routes files on javascript build
   * Works great for a simple Rails application
-* [Advanced Setup](#advanced-setup)
+2. [Advanced Setup](#advanced-setup)
   * Allows very custom setups
   * Automatic updates need to be customized
-* [Webpacker ERB Loader](#webpacker) - Legacy
+3. [Webpacker ERB Loader](#webpacker) - Legacy
   * Requires ESM module system (the default)
   * Doesn't support typescript definitions
-* [Sprockets](#sprockets) - Legacy
+4. [Sprockets](#sprockets) - Legacy
   * Deprecated and not recommended for modern apps
 
-<div id='quick-start'></div>
+<div id="quick-start"></div>
 
-### Quick Start 
+### Quick Start
 
 Setup [Rack Middleware](https://guides.rubyonrails.org/rails_on_rack.html#action-dispatcher-middleware-stack) 
 to automatically generate and maintain `routes.js` file and corresponding 
@@ -77,13 +77,12 @@ Add js-routes files to `.gitignore`:
 /app/javascript/routes.d.ts
 ```
 
-<div id='webpacker'></div>
+<div id="webpack"></div>
 
 ### Webpacker ERB loader
 
 **IMPORTANT**: the setup doesn't support IDE autocompletion with [Typescript](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html)
 
-
 #### Use a Generator
 
 Run a command:
@@ -133,7 +132,7 @@ Create routes file `app/javascript/routes.js.erb`:
 <%= JsRoutes.generate() %>
 ```
 
-Use routes wherever you need them: 
+Use routes wherever you need them:
 
 ``` javascript
 import {post_path} from 'routes.js.erb';
@@ -141,62 +140,78 @@ import {post_path} from 'routes.js.erb';
 alert(post_path(2));
 ```
 
-<div id='advanced-setup'></div>
+<div id="advanced-setup"></div>
 
 ### Advanced Setup
 
-**IMPORTANT**: that this setup requires the JS routes file to be updates manually
-
-Routes file can be generated with a `rake` task:
+In case you need multiple route files for different parts of your application, there are low level methods:
 
-``` sh
-rake js:routes 
-# OR for typescript support
-rake js:routes:typescript
+``` ruby
+# Returns a routes file as a string
+JsRoutes.generate(options)
+# Writes routes to specific file location
+JsRoutes.generate!(file_name, options)
+# Writes Typescript definitions file for routes
+JsRoutes.definitions!(file_name, 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:
-
-**IMPORTANT**: Requires [Webpacker ERB Loader](#webpacker) setup.
+They can also be used in ERB context
 
 ``` erb
-// app/javascript/admin/routes.js.erb
-<%= JsRoutes.generate(include: /admin/) %>
+<script>
+    var AdminRoutes = <%= JsRoutes.generate(
+      include: /admin/, module_type: nil, namespace: nil
+    ) %>;
+</script>
 ```
 
-``` erb
-// app/javascript/customer/routes.js.erb
-<%= JsRoutes.generate(exclude: /admin/) %>
-```
+Routes can be returns via API:
 
-You can manipulate the generated helper manually by injecting ruby into javascript:
+``` ruby
+class Api::RoutesController < Api::BaseController
+  def index
+    options = {
+      include: /\Aapi_/,
+      default_url_options: { format: 'json' },
+    }
+    render json: {
+      routes: {
+        source: JsRoutes.generate(options),
+        definitions: JsRoutes.definitions(options),
+      }
+    }
+  end
+end
 
-``` erb
-export const routes = <%= JsRoutes.generate(module_type: nil, namespace: nil) %>
 ```
 
-If you want to generate the routes files manually with custom options, you can use `JsRoutes.generate!`:
+Default auto-update middleware for development
+doesn't support configuration out of the box,
+but it can be extended through inheritence:
 
 ``` ruby
-path = Rails.root.join("app/javascript")
-
-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"}
-)
+class AdvancedJsRoutesMiddleware < JsRoutes::Middleware
+  def regenerate
+    path = Rails.root.join("app/javascript")
+
+    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"}
+    )
+  end
+end
 ```
 
-<div id='definitions'></div>
+<div id="definitions"></div>
 
 #### Typescript Definitions
 
-JsRoutes has typescript support out of the box. 
+JsRoutes has typescript support out of the box.
 
 Restrictions:
 
@@ -208,7 +223,7 @@ More advanced setup would involve calling manually:
 
 ``` ruby
 JsRoutes.definitions! # to output to file
-# or 
+# or
 JsRoutes.definitions # to output to string
 ```
 

data/lib/js_routes/configuration.rb

@@ -1,81 +1,122 @@
+# typed: strict
 require "pathname"
+require "js_routes/types"
 
 module JsRoutes
   class Configuration
-    DEFAULTS = {
-      namespace: nil,
-      exclude: [],
-      include: //,
-      file: nil,
-      prefix: -> { Rails.application.config.relative_url_root || "" },
-      url_links: false,
-      camel_case: false,
-      default_url_options: {},
-      compact: false,
-      serializer: nil,
-      special_options_key: "_options",
-      application: -> { Rails.application },
-      module_type: 'ESM',
-      documentation: true,
-    } #:nodoc:
-
-    attr_accessor(*DEFAULTS.keys)
-
+    include JsRoutes::Types
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :namespace
+    sig { returns(Clusivity) }
+    attr_accessor :exclude
+    sig { returns(Clusivity) }
+    attr_accessor :include
+    sig { returns(FileName) }
+    attr_accessor :file
+    sig { returns(Prefix) }
+    attr_accessor :prefix
+    sig { returns(T::Boolean) }
+    attr_accessor :url_links
+    sig { returns(T::Boolean) }
+    attr_accessor :camel_case
+    sig { returns(Options) }
+    attr_accessor :default_url_options
+    sig { returns(T::Boolean) }
+    attr_accessor :compact
+    sig { returns(T.nilable(String)) }
+    attr_accessor :serializer
+    sig { returns(Literal) }
+    attr_accessor :special_options_key
+    sig { returns(ApplicationCaller) }
+    attr_accessor :application
+    sig { returns(T::Boolean) }
+    attr_accessor :documentation
+    sig { returns(T.nilable(String)) }
+    attr_accessor :module_type
+
+    sig {params(attributes: T.nilable(Options)).void }
     def initialize(attributes = nil)
-      assign(DEFAULTS)
+      @namespace = nil
+      @exclude = T.let([], Clusivity)
+      @include = T.let([//], Clusivity)
+      @file = T.let(nil, FileName)
+      @prefix = T.let(-> { Rails.application.config.relative_url_root || "" }, T.untyped)
+      @url_links = T.let(false, T::Boolean)
+      @camel_case = T.let(false, T::Boolean)
+      @default_url_options = T.let(T.unsafe({}), Options)
+      @compact = T.let(false, T::Boolean)
+      @serializer = T.let(nil, T.nilable(String))
+      @special_options_key = T.let("_options", Literal)
+      @application = T.let(-> { Rails.application }, ApplicationCaller)
+      @module_type = T.let('ESM', T.nilable(String))
+      @documentation = T.let(true, T::Boolean)
+
       return unless attributes
       assign(attributes)
     end
 
-    def assign(attributes = nil, &block)
-      if !attributes && !block
-        raise "Provide attributes or block"
-      end
-      tap(&block) if block
+    sig do
+      params(
+        attributes: Options,
+      ).returns(JsRoutes::Configuration)
+    end
+    def assign(attributes)
       if attributes
         attributes.each do |attribute, value|
-          value = value.call if value.is_a?(Proc)
-          send(:"#{attribute}=", value)
+          public_send(:"#{attribute}=", value)
         end
       end
       normalize_and_verify
       self
     end
 
+    sig { params(block: ConfigurationBlock).returns(T.self_type) }
+    def setup(&block)
+      tap(&block)
+    end
+
+    sig { params(attribute: Literal).returns(T.untyped) }
     def [](attribute)
-      send(attribute)
+      public_send(attribute)
     end
 
+    sig { params(attributes: Options).returns(JsRoutes::Configuration) }
     def merge(attributes)
       clone.assign(attributes)
     end
 
-    def to_hash
-      Hash[*members.zip(values).flatten(1)].symbolize_keys
-    end
-
+    sig {returns(T::Boolean)}
     def esm?
       module_type === 'ESM'
     end
 
+    sig {returns(T::Boolean)}
     def dts?
       self.module_type === 'DTS'
     end
 
+    sig {returns(T::Boolean)}
     def modern?
       esm? || dts?
     end
 
+    sig { void }
     def require_esm
       raise "ESM module type is required" unless modern?
     end
 
+    sig { returns(String) }
     def source_file
       File.dirname(__FILE__) + "/../" + default_file_name
     end
 
+    sig { returns(Pathname) }
     def output_file
-      webpacker_dir = defined?(Webpacker) ? Webpacker.config.source_path : pathname('app', 'javascript')
+      webpacker_dir = defined?(::Webpacker) ?
+        T.unsafe(::Webpacker).config.source_path :
+        pathname('app', 'javascript')
       sprockets_dir = pathname('app','assets','javascripts')
       file_name = file || default_file_name
       sprockets_file = sprockets_dir.join(file_name)
@@ -85,23 +126,28 @@ module JsRoutes
 
     protected
 
+    sig { void }
     def normalize_and_verify
       normalize
       verify
     end
 
+    sig { params(parts: String).returns(Pathname) }
     def pathname(*parts)
-      Pathname.new(File.join(*parts))
+      Pathname.new(File.join(*T.unsafe(parts)))
     end
 
+    sig { returns(String) }
     def default_file_name
       dts? ? "routes.d.ts" : "routes.js"
     end
 
+    sig {void}
     def normalize
       self.module_type = module_type&.upcase || 'NIL'
     end
 
+    sig { void }
     def verify
       if module_type != 'NIL' && namespace
         raise "JsRoutes namespace option can only be used if module_type is nil"

data/lib/js_routes/engine.rb

@@ -1,3 +1,5 @@
+require "rails/engine"
+
 module JsRoutes
 class SprocketsExtension
   def initialize(filename, &block)

data/lib/js_routes/generators/base.rb

@@ -3,14 +3,33 @@ require "rails/generators"
 
 class JsRoutes::Generators::Base < Rails::Generators::Base
 
+  def self.inherited(subclass)
+    super
+    subclass.source_root(File.expand_path(__FILE__ + "/../../../templates"))
+  end
+
   protected
 
   def application_js_path
     [
+      "app/javascript/packs/application.ts",
       "app/javascript/packs/application.js",
+      "app/javascript/controllers/application.ts",
       "app/javascript/controllers/application.js",
     ].find do |path|
       File.exist?(Rails.root.join(path))
     end
   end
+
+  def depends_on?(gem_name)
+    !!Bundler.load.gems.find {|g| g.name == gem_name}
+  end
+
+  def depends_on_js_bundling?
+    depends_on?('jsbundling-rails')
+  end
+
+  def depends_on_webpacker?
+    depends_on?('webpacker')
+  end
 end

data/lib/js_routes/generators/middleware.rb

@@ -2,8 +2,6 @@ require "js_routes/generators/base"
 
 class JsRoutes::Generators::Middleware < JsRoutes::Generators::Base
 
-  source_root File.expand_path(__FILE__ + "/../../../templates")
-
   def create_middleware
     copy_file "initializer.rb", "config/initializers/js_routes.rb"
     inject_into_file "config/environments/development.rb", middleware_content, before: /^end\n\z/
@@ -13,15 +11,15 @@ class JsRoutes::Generators::Middleware < JsRoutes::Generators::Base
       inject_into_file path, pack_content
     end
     JsRoutes.generate!
-    JsRoutes.definitions!
+    JsRoutes.definitions! if JsRoutes.configuration.modern?
   end
 
   protected
 
   def pack_content
     <<-JS
-import * as Routes from '../routes';
-window.Routes = Routes;
+import {root_path} from '../routes';
+alert(`JsRoutes installed.\\nYour root path is ${root_path()}`)
     JS
   end
 
@@ -35,11 +33,11 @@ window.Routes = Routes;
   end
 
   def rakefile_content
-    enhanced_task = Bundler.load.gems.find {|g| g.name = 'jsbundling-rails'} ?
-      "javascript:build" : "assets:precompile"
+    enhanced_task = depends_on_js_bundling? ? "javascript:build" : "assets:precompile"
+    dependency_task = JsRoutes.configuration.modern? ? "js:routes:typescript" : 'js:routes'
     <<-RB
 # Update js-routes file before javascript build
-task "#{enhanced_task}" => "js:routes:typescript"
+task "#{enhanced_task}" => "#{dependency_task}"
     RB
   end
 

data/lib/js_routes/generators/webpacker.rb

@@ -2,8 +2,6 @@ require "rails/generators"
 
 class JsRoutes::Generators::Webpacker < Rails::Generators::Base
 
-  source_root File.expand_path(__FILE__ + "/../../../templates")
-
   def create_webpack
     copy_file "initializer.rb", "config/initializers/js_routes.rb"
     copy_file "erb.js", "config/webpack/loaders/erb.js"
@@ -21,7 +19,7 @@ class JsRoutes::Generators::Webpacker < Rails::Generators::Base
   def pack_content
     <<-JS
 import * as Routes from 'routes.js.erb';
-window.Routes = Routes;
+alert(Routes.root_path())
     JS
   end