js-routes 2.2.7 → 2.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc558c858345b705d2ca048eaab529acf4d4ffe20299e152f1c23fcbeb31388e
-  data.tar.gz: 70dc5ab9c6f629d3236d45a5cf202c6bb8f00893041857f137b9569a3467d48c
+  metadata.gz: d890e17e32f816311de89a16506fca4b8ff905ea773c7a8d198343e0270eb50a
+  data.tar.gz: 934c79a8b93e7129778e07789f93ac90d4183bd39ea578551f4ea9ca6cab22d2
 SHA512:
-  metadata.gz: 0536cff5b25734ae0c0399cba8d65fb48503e7038c6e5f7396acb69497505ab8849b109e3348bc2c7a010b073cb3cd4aebed1798c538e8bd0e0270f8949dd53c
-  data.tar.gz: 99e9d0487c9062cf3789a8018beba7bcc0b9f985251921cb6f042c20c571d74fab8a4c79f82ad0a6530dde42ee8a678fb5dbfae184dd64e8756ef47d06805b0b
+  metadata.gz: 6adcfbfefbbf13c8f46198f9bf2ca47efdac35aa8d28a8b17be7b8af65d321a3ba0da30dd26e40c4a329c359f1a02b865adb74a1d5e3d024b61bae7fd6f8d9e0
+  data.tar.gz: 9cc86f32f79975aace5a264ef94d7bbe1afb41a7a141c738969c762479789fa74b1fb752139320f8ddd7c25b2eb164fe14cbcc3c6eb1a40046549538c3a6eb33

data/CHANGELOG.md

@@ -1,5 +1,22 @@
+# Changelog
+
 ## master
 
+## v2.2.10
+
+* Fix middleware error for non-modern setup.
+
+## v2.2.9
+
+* 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)
+* Use webpacker config variable instead of hardcode [#309](https://github.com/railsware/js-routes/issues/309)
+* Use `File.exist?` to be compatible with all versions of ruby [#310](https://github.com/railsware/js-routes/issues/310)
+
 ## v2.2.7
 
 * Fix ESM Tree Shaking [#306](https://github.com/railsware/js-routes/issues/306)
@@ -22,10 +39,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)
 
@@ -150,10 +167,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:
 
@@ -239,7 +255,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
 
@@ -265,10 +281,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/Gemfile

@@ -2,3 +2,8 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in js-routes.gemspec
 gemspec
+
+group :development do
+  gem 'sorbet', '>= 0.5.11518'
+  gem 'tapioca'
+end

data/Readme.md

@@ -16,21 +16,22 @@ gem "js-routes"
 
 There are several possible ways to setup JsRoutes:
 
-* [Quick and easy](#quick-start)
+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
-* [Webpacker ERB Loader](#webpacker)
+2. [Advanced Setup](#advanced-setup)
+  * Allows very custom setups
+  * Automatic updates need to be customized
+3. [Webpacker ERB Loader](#webpacker) - Legacy
   * Requires ESM module system (the default)
   * Doesn't support typescript definitions
-* [Advanced Setup](#advanced-setup)
-  * Allows very custom setups
-* [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 
@@ -76,12 +77,11 @@ Add js-routes files to `.gitignore`:
 /app/javascript/routes.d.ts
 ```
 
-<div id='webpacker'></div>
+<div id="webpack"></div>
 
 ### Webpacker ERB loader
 
-**IMPORTANT**: this setup doesn't support IDE autocompletion with [Typescript](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html)
-
+**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
 
@@ -132,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';
@@ -140,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:
 
@@ -207,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/bin/tapioca

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'tapioca' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("tapioca", "tapioca")

data/js-routes.gemspec

@@ -22,11 +22,14 @@ Gem::Specification.new do |s|
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.summary = %q{Brings Rails named routes to javascript}
+  s.metadata = { "github_repo" => "ssh://github.com/railsware/js-routes" }
 
   s.add_runtime_dependency(%q<railties>, [">= 4"])
+  s.add_runtime_dependency(%q<sorbet-runtime>)
+
   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<bundler>, [">= 2.2.25"])
   s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
   s.add_development_dependency(%q<bump>, [">= 0.10.0"])
   if defined?(JRUBY_VERSION)

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 = 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,6 +3,8 @@ require "rails/generators"
 
 class JsRoutes::Generators::Base < Rails::Generators::Base
 
+  source_root File.expand_path(__FILE__ + "/../../../templates")
+
   protected
 
   def application_js_path
@@ -10,7 +12,19 @@ class JsRoutes::Generators::Base < Rails::Generators::Base
       "app/javascript/packs/application.js",
       "app/javascript/controllers/application.js",
     ].find do |path|
-      File.exists?(Rails.root.join(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/
@@ -20,8 +18,8 @@ class JsRoutes::Generators::Middleware < JsRoutes::Generators::Base
 
   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,8 +33,7 @@ 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"
     <<-RB
 # Update js-routes file before javascript build
 task "#{enhanced_task}" => "js:routes:typescript"

data/lib/js_routes/generators/webpacker.rb

@@ -2,12 +2,10 @@ 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"
-    copy_file "routes.js.erb", "app/javascript/routes.js.erb"
+    copy_file "routes.js.erb", "#{Webpacker.config.source_path}/routes.js.erb"
     inject_into_file "config/webpack/environment.js", loader_content
     if path = application_js_path
       inject_into_file path, pack_content
@@ -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