js-routes 2.2.0 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 315ddd617bc6630cf5858afc5ba38d2c204f6167a7984ccdaf7171a50404e418
-  data.tar.gz: 676d2d36107ee524c07517143499173c0658731cc06d1c52753e3ab2f4e6cb81
+  metadata.gz: b706c51040d12aaa69182dad9d25304ba947fe1e80cc5171775864a27d6f4ed8
+  data.tar.gz: 1a105e8a4dbc9cfde5a787a0714b6e0bf0758b6291f6945f0a16ca9c1e7a47a9
 SHA512:
-  metadata.gz: 6c7f715e9afd02d1daebb882381e328595beca59a6a6d8c10a3a1518801522090e986c6b362174aaa9c51faf91508ee8e1cc6fff8ba118a08c32eb26c7205ba1
-  data.tar.gz: 7f70bfa95a1fb42092f20118bb3f22f07e459ccc6f95b8d3b0651faf0457266152465873da6a4dfddc4d52df006d6f5b991e3608a083c1eb524fef5ed77ff0c8
+  metadata.gz: f053d1f48cb8a4f9f7ac7f1e68d37f4816d09e42e0a91660fb84c1e9f4ad36d439019f6f402f1e2fce30467e6b0d5b799fd08bbe70bfc2aa8423c63f053f0bdb
+  data.tar.gz: bdcf72700542350da423e9cf62b4abcc0ba326400c4077c70c5f6174edb75a7e61b6b6a765a0454b4cd1a2fc5ddbf91f3a16294ce995d9ab31d9984153c29b4c

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## master
 
+## v2.2.4
+
+* Fix rails engine loading if sprockets is not in Gemfile. Fixes [#294](https://github.com/railsware/js-routes/issues/294)
+
+## 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 
+  * Ex. Value like `MyProject.Routes` requires to define `window.MyProject` before importing the routes file
+
+## v2.2.2.
+
+* Fix custom file path [#295](https://github.com/railsware/js-routes/issues/295)
+
+## v2.2.1
+
+* Improve generator to update route files on `assets:precompile` and add them to `.gitignore by default` [#288](https://github.com/railsware/js-routes/issues/288#issuecomment-1012182815)
+
 ## v2.2.0
 
 * Use Rack Middleware to automatically update routes file in development [#288](https://github.com/railsware/js-routes/issues/288)

data/Readme.md

@@ -16,12 +16,13 @@ gem "js-routes"
 
 ## Setup
 
-There are 3 possible ways to setup JsRoutes:
+There are several possible ways to setup JsRoutes:
 
 * [Quick and easy](#quick-start)
   * Uses Rack Middleware to automatically update routes locally
+  * Automatically generates routes files on `assets:precompile` in production
   * Works great for a simple Rails application
-* [Webpacker](#webpacker) automatic updates
+* [Webpacker ERB Loader](#webpacker)
   * Requires ESM module system (the default)
   * Doesn't support typescript definitions
 * [Advanced Setup](#advanced-setup)
@@ -33,18 +34,52 @@ There are 3 possible ways to setup JsRoutes:
 
 ### 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 [Typescript definitions](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html) `routes.d.ts`:
+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 
+[Typescript definitions](https://www.typescriptlang.org/docs/handbook/declaration-files/templates/module-d-ts.html) `routes.d.ts`:
 
-Run:
+#### Use a Generator
+
+Run a command:
 
 ``` sh
 rails generate js_routes:middleware
 ```
 
+#### Setup Manually
+
+Add the following to `config/environments/development.rb`:
+
+``` ruby
+  config.middleware.use(JsRoutes::Middleware)
+```
+
+Use it in `app/javascript/packs/application.js`:
+
+``` javascript
+import * as Routes from '../routes';
+// window.Routes = Routes;
+alert(Routes.post_path(1))
+```
+
+Upgrade `rake assets:precompile` to update js-routes files: 
+
+``` ruby
+namespace :assets do
+  task :precompile => "js:routes:typescript"
+end
+```
+
+Add js-routes files to `.gitignore`:
+
+```
+/app/javascript/routes.js
+/app/javascript/routes.d.ts
+```
 
 <div id='webpacker'></div>
 
-### Webpacker + automatic updates - Typescript
+### 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)
 
@@ -111,7 +146,7 @@ window.Routes = Routes;
 
 **IMPORTANT**: that this setup requires the JS routes file to be updates manually
 
-You can run every time you want to generate a routes file:
+Routes file can be generated with a `rake` task:
 
 ``` sh
 rake js:routes 
@@ -122,6 +157,8 @@ rake js:routes:typescript
 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.
+
 ``` erb
 // app/javascript/admin/routes.js.erb
 <%= JsRoutes.generate(include: /admin/) %>

data/lib/js_routes/configuration.rb

@@ -0,0 +1,111 @@
+require "pathname"
+
+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)
+
+    def initialize(attributes = nil)
+      assign(DEFAULTS)
+      return unless attributes
+      assign(attributes)
+    end
+
+    def assign(attributes = nil, &block)
+      if !attributes && !block
+        raise "Provide attributes or block"
+      end
+      tap(&block) if block
+      if attributes
+        attributes.each do |attribute, value|
+          value = value.call if value.is_a?(Proc)
+          send(:"#{attribute}=", value)
+        end
+      end
+      normalize_and_verify
+      self
+    end
+
+    def [](attribute)
+      send(attribute)
+    end
+
+    def merge(attributes)
+      clone.assign(attributes)
+    end
+
+    def to_hash
+      Hash[*members.zip(values).flatten(1)].symbolize_keys
+    end
+
+    def esm?
+      module_type === 'ESM'
+    end
+
+    def dts?
+      self.module_type === 'DTS'
+    end
+
+    def modern?
+      esm? || dts?
+    end
+
+    def require_esm
+      raise "ESM module type is required" unless modern?
+    end
+
+    def source_file
+      File.dirname(__FILE__) + "/../" + default_file_name
+    end
+
+    def output_file
+      webpacker_dir = pathname('app', 'javascript')
+      sprockets_dir = pathname('app','assets','javascripts')
+      file_name = file || default_file_name
+      sprockets_file = sprockets_dir.join(file_name)
+      webpacker_file = webpacker_dir.join(file_name)
+      !Dir.exist?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
+    end
+
+    protected
+
+    def normalize_and_verify
+      normalize
+      verify
+    end
+
+    def pathname(*parts)
+      Pathname.new(File.join(*parts))
+    end
+
+    def default_file_name
+      dts? ? "routes.d.ts" : "routes.js"
+    end
+
+    def normalize
+      self.module_type = module_type&.upcase || 'NIL'
+    end
+
+    def verify
+      if module_type != 'NIL' && namespace
+        raise "JsRoutes namespace option can only be used if module_type is nil"
+      end
+    end
+  end
+end

data/lib/js_routes/engine.rb

@@ -1,4 +1,4 @@
-class JsRoutes
+module JsRoutes
 class SprocketsExtension
   def initialize(filename, &block)
     @filename = filename
@@ -29,32 +29,34 @@ end
 
 
 class Engine < ::Rails::Engine
-  require 'sprockets/version'
-  v2                = Gem::Dependency.new('', ' ~> 2')
-  vgte3             = Gem::Dependency.new('', ' >= 3')
-  sprockets_version = Gem::Version.new(::Sprockets::VERSION).release
-  initializer_args  = case sprockets_version
-                        when -> (v) { v2.match?('', v) }
-                          { after: "sprockets.environment" }
-                        when -> (v) { vgte3.match?('', v) }
-                          { after: :engines_blank_point, before: :finisher_hook }
-                        else
-                          raise StandardError, "Sprockets version #{sprockets_version} is not supported"
-                      end
-
-  initializer 'js-routes.dependent_on_routes', initializer_args do
-    case sprockets_version
-      when  -> (v) { v2.match?('', v) },
-            -> (v) { vgte3.match?('', v) }
-
-      Rails.application.config.assets.configure do |config|
-        config.register_preprocessor(
-          "application/javascript",
-          SprocketsExtension,
-        )
+  if defined?(::Sprockets::Railtie)
+    require 'sprockets/version'
+    v2                = Gem::Dependency.new('', ' ~> 2')
+    vgte3             = Gem::Dependency.new('', ' >= 3')
+    sprockets_version = Gem::Version.new(::Sprockets::VERSION).release
+    initializer_args  = case sprockets_version
+                          when -> (v) { v2.match?('', v) }
+                            { after: "sprockets.environment" }
+                          when -> (v) { vgte3.match?('', v) }
+                            { after: :engines_blank_point, before: :finisher_hook }
+                          else
+                            raise StandardError, "Sprockets version #{sprockets_version} is not supported"
+                        end
+
+    initializer 'js-routes.dependent_on_routes', initializer_args do
+      case sprockets_version
+        when  -> (v) { v2.match?('', v) },
+              -> (v) { vgte3.match?('', v) }
+
+        Rails.application.config.assets.configure do |config|
+          config.register_preprocessor(
+            "application/javascript",
+            SprocketsExtension,
+          )
+        end
+      else
+        raise StandardError, "Sprockets version #{sprockets_version} is not supported"
       end
-    else
-      raise StandardError, "Sprockets version #{sprockets_version} is not supported"
     end
   end
 end

data/lib/js_routes/generators/middleware.rb

@@ -6,11 +6,12 @@ class JsRoutes::Generators::Middleware < Rails::Generators::Base
 
   def create_middleware
     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"
-    # inject_into_file "config/webpack/environment.js", loader_content
     inject_into_file "app/javascript/packs/application.js", pack_content
     inject_into_file "config/environments/development.rb", middleware_content, before: /^end\n\z/
+    inject_into_file "Rakefile", rakefile_content
+    inject_into_file ".gitignore", gitignore_content
+    JsRoutes.generate!
+    JsRoutes.definitions!
   end
 
   protected
@@ -25,9 +26,33 @@ window.Routes = Routes;
   def middleware_content
     <<-RB
 
-  # Automatically update routes.js file
+  # Automatically update js-routes file
   # when routes.rb is changed
   config.middleware.use(JsRoutes::Middleware)
     RB
   end
+
+  def rakefile_content
+    <<-RB
+
+# Update js-routes file before assets precompile
+namespace :assets do
+  task :precompile => "js:routes:typescript"
+end
+    RB
+  end
+
+  def gitignore_content
+    banner = <<-TXT
+
+# Ignore automatically generated js-routes files.
+    TXT
+
+    banner + [
+      {},
+      {module_type: 'DTS'}
+    ].map do |config|
+      File.join('/', JsRoutes.new(config).configuration.output_file) + "\n"
+    end.join
+  end
 end

data/lib/js_routes/instance.rb

@@ -0,0 +1,173 @@
+require "js_routes/configuration"
+require "js_routes/route"
+
+module JsRoutes
+  class Instance
+
+    attr_reader :configuration
+    #
+    # Implementation
+    #
+
+    def initialize(options = {})
+      @configuration = JsRoutes.configuration.merge(options)
+    end
+
+    def generate
+      # Ensure routes are loaded. If they're not, load them.
+      if named_routes.empty? && application.respond_to?(:reload_routes!)
+        application.reload_routes!
+      end
+      content = File.read(@configuration.source_file)
+
+      if !@configuration.dts?
+        content = js_variables.inject(content) do |js, (key, value)|
+          js.gsub!("RubyVariables.#{key}", value.to_s) ||
+          raise("Missing key #{key} in JS template")
+        end
+      end
+      content + routes_export + prevent_types_export
+    end
+
+    def generate!
+      # Some libraries like Devise did not load their routes yet
+      # so we will wait until initialization process finishes
+      # https://github.com/railsware/js-routes/issues/7
+      Rails.configuration.after_initialize do
+        file_path = Rails.root.join(@configuration.output_file)
+        source_code = generate
+
+        # We don't need to rewrite file if it already exist and have same content.
+        # It helps asset pipeline or webpack understand that file wasn't changed.
+        next if File.exist?(file_path) && File.read(file_path) == source_code
+
+        File.open(file_path, 'w') do |f|
+          f.write source_code
+        end
+      end
+    end
+
+    protected
+
+    def js_variables
+      {
+        'GEM_VERSION'         => JsRoutes::VERSION,
+        'ROUTES_OBJECT'       => routes_object,
+        'RAILS_VERSION'       => ActionPack.version,
+        'DEPRECATED_GLOBBING_BEHAVIOR' => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
+
+        'APP_CLASS'           => application.class.to_s,
+        '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),
+        'MODULE_TYPE'         => json(@configuration.module_type),
+        'WRAPPER'             => wrapper_variable,
+      }
+    end
+
+    def wrapper_variable
+      case @configuration.module_type
+      when 'ESM'
+        'const __jsr = '
+      when 'NIL'
+        namespace = @configuration.namespace
+        if namespace
+          if namespace.include?('.')
+            "#{namespace} = "
+          else
+            "(typeof window !== 'undefined' ? window : this).#{namespace} = "
+          end
+        else
+          ''
+        end
+      else
+        ''
+      end
+    end
+
+    def application
+      @configuration.application
+    end
+
+    def json(string)
+      JsRoutes.json(string)
+    end
+
+    def named_routes
+      application.routes.named_routes.to_a
+    end
+
+    def routes_object
+      return json({}) if @configuration.modern?
+      properties = routes_list.map do |comment, name, body|
+        "#{comment}#{name}: #{body}".indent(2)
+      end
+      "{\n" + properties.join(",\n\n") + "}\n"
+    end
+
+    def static_exports
+      [:configure, :config, :serialize].map do |name|
+        [
+          "", name,
+          @configuration.dts? ?
+          "RouterExposedMethods['#{name}']" :
+          "__jsr.#{name}"
+        ]
+      end
+    end
+
+    def routes_export
+      return "" unless @configuration.modern?
+      [*static_exports, *routes_list].map do |comment, name, body|
+        "#{comment}export const #{name}#{export_separator}#{body};\n\n"
+      end.join
+    end
+
+    def prevent_types_export
+      return "" unless @configuration.dts?
+      <<-JS
+// By some reason this line prevents all types in a file
+// from being automatically exported
+export {};
+      JS
+    end
+
+    def export_separator
+      @configuration.dts? ? ': ' : ' = '
+    end
+
+    def routes_list
+      named_routes.sort_by(&:first).flat_map do |_, route|
+        route_helpers_if_match(route) + mounted_app_routes(route)
+      end
+    end
+
+    def mounted_app_routes(route)
+      rails_engine_app = app_from_route(route)
+      if rails_engine_app.respond_to?(:superclass) &&
+          rails_engine_app.superclass == Rails::Engine && !route.path.anchored
+        rails_engine_app.routes.named_routes.flat_map do |_, engine_route|
+          route_helpers_if_match(engine_route, route)
+        end
+      else
+        []
+      end
+    end
+
+    def app_from_route(route)
+      app = route.app
+      # rails engine in Rails 4.2 use additional
+      # ActionDispatch::Routing::Mapper::Constraints, which contain app
+      if app.respond_to?(:app) && app.respond_to?(:constraints)
+        app.app
+      else
+        app
+      end
+    end
+
+    def route_helpers_if_match(route, parent_route = nil)
+      Route.new(@configuration, route, parent_route).helpers
+    end
+  end
+end

data/lib/js_routes/middleware.rb

@@ -1,4 +1,4 @@
-class JsRoutes
+module JsRoutes
   # A Rack middleware that automatically updates routes file
   # whenever routes.rb is modified
   #