js-routes 2.2.1 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54158654106dece477c1fdf36afa52b504a43b8210c4c8d30f98d41ccd0ef600
-  data.tar.gz: a67b36754269392839bb6d2e86a20899ec2575437ac9667f10cdd9feb7306185
+  metadata.gz: 66ff94f5c78d966f76e2a9f47d1c838c757c3e243c37f03599b24c286b15b9b7
+  data.tar.gz: c5803e4a35b99923769970149f07a6893a84c6343f10f76c8a89645974dce959
 SHA512:
-  metadata.gz: 582b6a39a062f6fcfd7b2cb4a57b4fd4573e343f93d5751ef764b7e3617cb7243801caf61ee971224a2c1a41e43a2f51221e5d3a40c12d5db21af98f47467044
-  data.tar.gz: f54b26ed68ed8ef2a6b4ad5ebf2e0322bfbec7385756a8578b5c11c01eca646d42baa5634d16cef6d16520e3eed4d1b1a37260e4ade943ee568b6b4755153cea
+  metadata.gz: a34c75f950a02a6634687889e4072f7d88f37520a6dc2ba5bfd2ccbbb71962159a70170bf7ac55b22db45de2727f7c573dfce8c80debc33f34abbd9cb1132c1f
+  data.tar.gz: 779b340c9dac721c8b427a16011ed961a05dde4d15594838649fb0860bac42e60344a682718a0b94f35f785350126ca59c7f739dac43cb47e0a7b84e45fa468a

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## master
 
+## v2.2.5
+
+* Fix middleware generator [#300](https://github.com/railsware/js-routes/issues/300)
+* Support `params` special parameter
+
+## 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)

data/Readme.md

@@ -20,6 +20,7 @@ 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 ERB Loader](#webpacker)
   * Requires ESM module system (the default)
@@ -61,7 +62,7 @@ import * as Routes from '../routes';
 alert(Routes.post_path(1))
 ```
 
-Upgrade `rake assets:precompile` to update js-routes files: 
+Upgrade `rake assets:precompile` to update js-routes files in `Rakefile`: 
 
 ``` ruby
 namespace :assets do

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

@@ -52,7 +52,7 @@ end
       {},
       {module_type: 'DTS'}
     ].map do |config|
-      File.join('/', JsRoutes.new(config).configuration.output_file) + "\n"
+      File.join('/', JsRoutes::Configuration.new(config).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 # :nodoc:
+
+    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
   #
@@ -21,12 +21,16 @@ class JsRoutes
     def update_js_routes
       new_mtime = routes_mtime
       unless new_mtime == @mtime
-        JsRoutes.generate!
-        JsRoutes.definitions!
+        regenerate
         @mtime = new_mtime
       end
     end
 
+    def regenerate
+      JsRoutes.generate!
+      JsRoutes.definitions!
+    end
+
     def routes_mtime
       File.mtime(@routes_file)
     rescue Errno::ENOENT

data/lib/js_routes/route.rb

@@ -1,4 +1,4 @@
-class JsRoutes
+module JsRoutes
   class Route #:nodoc:
     FILTERED_DEFAULT_PARTS = [:controller, :action]
     URL_OPTIONS = [:protocol, :domain, :host, :port, :subdomain]

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
-class JsRoutes
-  VERSION = "2.2.1"
+module JsRoutes
+  VERSION = "2.2.4"
 end