js-routes 2.2.8 → 2.2.10

data/lib/js_routes/instance.rb

@@ -1,26 +1,36 @@
+# typed: strict
 require "js_routes/configuration"
 require "js_routes/route"
+require "js_routes/types"
+require 'fileutils'
 
 module JsRoutes
   class Instance # :nodoc:
+    include JsRoutes::Types
+    extend T::Sig
 
+    sig { returns(JsRoutes::Configuration) }
     attr_reader :configuration
     #
     # Implementation
     #
 
-    def initialize(options = {})
-      @configuration = JsRoutes.configuration.merge(options)
+    sig { params(options: T.untyped).void }
+    def initialize(**options)
+      options = T.let(options, Options)
+      @configuration = T.let(JsRoutes.configuration.merge(options), JsRoutes::Configuration)
     end
 
+    sig {returns(String)}
     def generate
       # Ensure routes are loaded. If they're not, load them.
-      if named_routes.empty? && application.respond_to?(:reload_routes!)
+      application = T.unsafe(self.application)
+      if named_routes.empty? && application.respond_to?(:reload_routes!, true)
         application.reload_routes!
       end
       content = File.read(@configuration.source_file)
 
-      if !@configuration.dts?
+      unless @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")
@@ -29,11 +39,12 @@ module JsRoutes
       content + routes_export + prevent_types_export
     end
 
+    sig { void }
     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
+      T.unsafe(Rails).configuration.after_initialize do
         file_path = Rails.root.join(@configuration.output_file)
         source_code = generate
 
@@ -47,18 +58,29 @@ module JsRoutes
       end
     end
 
+    sig { void }
+    def remove!
+      path = Rails.root.join(@configuration.output_file)
+      FileUtils.rm_rf(path)
+      FileUtils.rm_rf(path.sub(%r{\.js\z}, '.d.ts'))
+    end
+
     protected
 
+    sig { returns(T::Hash[String, String]) }
     def js_variables
+      version = Rails.version
+      prefix = @configuration.prefix
+      prefix = prefix.call if prefix.is_a?(Proc)
       {
         'GEM_VERSION'         => JsRoutes::VERSION,
         'ROUTES_OBJECT'       => routes_object,
-        'RAILS_VERSION'       => ActionPack.version,
-        'DEPRECATED_GLOBBING_BEHAVIOR' => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
-        'DEPRECATED_FALSE_PARAMETER_BEHAVIOR' => ActionPack::VERSION::MAJOR < 7,
+        'RAILS_VERSION'       => ::Rails.version,
+        'DEPRECATED_GLOBBING_BEHAVIOR' => version >= '4.0.0' && version < '4.1.0',
+        'DEPRECATED_FALSE_PARAMETER_BEHAVIOR' => version < '7.0.0',
         'APP_CLASS'           => application.class.to_s,
         'DEFAULT_URL_OPTIONS' => json(@configuration.default_url_options),
-        'PREFIX'              => json(@configuration.prefix),
+        'PREFIX'              => json(prefix),
         'SPECIAL_OPTIONS_KEY' => json(@configuration.special_options_key),
         'SERIALIZER'          => @configuration.serializer || json(nil),
         'MODULE_TYPE'         => json(@configuration.module_type),
@@ -66,6 +88,7 @@ module JsRoutes
       }
     end
 
+    sig { returns(String) }
     def wrapper_variable
       case @configuration.module_type
       when 'ESM'
@@ -86,18 +109,22 @@ module JsRoutes
       end
     end
 
+    sig { returns(Application) }
     def application
-      @configuration.application
+      @configuration.application.call
     end
 
-    def json(string)
-      JsRoutes.json(string)
+    sig { params(value: T.untyped).returns(String) }
+    def json(value)
+      JsRoutes.json(value)
     end
 
+    sig { returns(T::Hash[Symbol, JourneyRoute]) }
     def named_routes
-      application.routes.named_routes.to_a
+      T.unsafe(application).routes.named_routes.to_h
     end
 
+    sig { returns(String) }
     def routes_object
       return json({}) if @configuration.modern?
       properties = routes_list.map do |comment, name, body|
@@ -106,10 +133,11 @@ module JsRoutes
       "{\n" + properties.join(",\n\n") + "}\n"
     end
 
+    sig { returns(T::Array[StringArray]) }
     def static_exports
       [:configure, :config, :serialize].map do |name|
         [
-          "", name,
+          "", name.to_s,
           @configuration.dts? ?
           "RouterExposedMethods['#{name}']" :
           "__jsr.#{name}"
@@ -117,6 +145,7 @@ module JsRoutes
       end
     end
 
+    sig { returns(String) }
     def routes_export
       return "" unless @configuration.modern?
       [*static_exports, *routes_list].map do |comment, name, body|
@@ -124,6 +153,7 @@ module JsRoutes
       end.join
     end
 
+    sig { returns(String) }
     def prevent_types_export
       return "" unless @configuration.dts?
       <<-JS
@@ -133,18 +163,21 @@ export {};
       JS
     end
 
+    sig { returns(String) }
     def export_separator
       @configuration.dts? ? ': ' : ' = '
     end
 
+    sig { returns(T::Array[StringArray]) }
     def routes_list
       named_routes.sort_by(&:first).flat_map do |_, route|
         route_helpers_if_match(route) + mounted_app_routes(route)
       end
     end
 
+    sig { params(route: JourneyRoute).returns(T::Array[StringArray]) }
     def mounted_app_routes(route)
-      rails_engine_app = app_from_route(route)
+      rails_engine_app = T.unsafe(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|
@@ -155,6 +188,7 @@ export {};
       end
     end
 
+    sig { params(route: JourneyRoute).returns(T.untyped) }
     def app_from_route(route)
       app = route.app
       # rails engine in Rails 4.2 use additional
@@ -166,6 +200,7 @@ export {};
       end
     end
 
+    sig { params(route: JourneyRoute, parent_route: T.nilable(JourneyRoute)).returns(T::Array[StringArray]) }
     def route_helpers_if_match(route, parent_route = nil)
       Route.new(@configuration, route, parent_route).helpers
     end

data/lib/js_routes/middleware.rb

@@ -1,3 +1,6 @@
+# typed: strict
+require "js_routes/types"
+
 module JsRoutes
   # A Rack middleware that automatically updates routes file
   # whenever routes.rb is modified
@@ -5,12 +8,19 @@ module JsRoutes
   # Inspired by
   # https://github.com/fnando/i18n-js/blob/main/lib/i18n/js/middleware.rb
   class Middleware
+    include JsRoutes::Types
+    include RackApp
+
+    extend T::Sig
+
+    sig { params(app: T.untyped).void }
     def initialize(app)
       @app = app
-      @routes_file = Rails.root.join("config/routes.rb")
-      @mtime = nil
+      @routes_file = T.let(Rails.root.join("config/routes.rb"), Pathname)
+      @mtime = T.let(nil, T.nilable(Time))
     end
 
+    sig { override.params(env: StringHash).returns(UntypedArray) }
     def call(env)
       update_js_routes
       @app.call(env)
@@ -18,6 +28,7 @@ module JsRoutes
 
     protected
 
+    sig { void }
     def update_js_routes
       new_mtime = routes_mtime
       unless new_mtime == @mtime
@@ -26,11 +37,13 @@ module JsRoutes
       end
     end
 
+    sig { void }
     def regenerate
       JsRoutes.generate!
-      JsRoutes.definitions!
+      JsRoutes.definitions! if JsRoutes.configuration.modern?
     end
 
+    sig { returns(T.nilable(Time)) }
     def routes_mtime
       File.mtime(@routes_file)
     rescue Errno::ENOENT

data/lib/js_routes/route.rb

@@ -1,8 +1,16 @@
+# typed: strict
+
+require "js_routes/types"
+require "action_dispatch/journey/route"
+
 module JsRoutes
   class Route #:nodoc:
-    FILTERED_DEFAULT_PARTS = [:controller, :action]
-    URL_OPTIONS = [:protocol, :domain, :host, :port, :subdomain]
-    NODE_TYPES = {
+    include JsRoutes::Types
+    extend T::Sig
+
+    FILTERED_DEFAULT_PARTS = T.let([:controller, :action].freeze, SymbolArray)
+    URL_OPTIONS = T.let([:protocol, :domain, :host, :port, :subdomain].freeze, SymbolArray)
+    NODE_TYPES = T.let({
       GROUP: 1,
       CAT: 2,
       SYMBOL: 3,
@@ -11,84 +19,110 @@ module JsRoutes
       LITERAL: 6,
       SLASH: 7,
       DOT: 8
-    }
+    }.freeze, T::Hash[Symbol, Integer])
 
-    attr_reader :configuration, :route, :parent_route
+    sig {returns(JsRoutes::Configuration)}
+    attr_reader :configuration
 
+    sig {returns(JourneyRoute)}
+    attr_reader :route
+
+    sig {returns(T.nilable(JourneyRoute))}
+    attr_reader :parent_route
+
+    sig { params(configuration: JsRoutes::Configuration, route: JourneyRoute, parent_route: T.nilable(JourneyRoute)).void }
     def initialize(configuration, route, parent_route = nil)
       @configuration = configuration
       @route = route
       @parent_route = parent_route
     end
 
+    sig { returns(T::Array[StringArray]) }
     def helpers
       helper_types.map do |absolute|
         [ documentation, helper_name(absolute), body(absolute) ]
       end
     end
 
+    sig {returns(T::Array[T::Boolean])}
     def helper_types
       return [] unless match_configuration?
-      @configuration[:url_links] ? [true, false] : [false]
+      @configuration.url_links ? [true, false] : [false]
     end
 
+    sig { params(absolute: T::Boolean).returns(String) }
     def body(absolute)
       if @configuration.dts?
         definition_body
       else
         # For tree-shaking ESM, add a #__PURE__ comment informing Webpack/minifiers that the call to `__jsr.r`
         # has no side-effects (e.g. modifying global variables) and is safe to remove when unused.
-        # https://webpack.js.org/guides/tree-shaking/#clarifying-tree-shaking-and-sideeffects
+        # https://webpack.js.org/guides/tree-shaking/#clarifying-tree-shaking-and-sidyeeffects
         pure_comment = @configuration.esm? ? '/*#__PURE__*/ ' : ''
         "#{pure_comment}__jsr.r(#{arguments(absolute).map{|a| json(a)}.join(', ')})"
       end
     end
 
+    sig { returns(String) }
     def definition_body
+      options_type = optional_parts_type ? "#{optional_parts_type} & RouteOptions" : "RouteOptions"
       args = required_parts.map{|p| "#{apply_case(p)}: RequiredRouteParameter"}
-      args << "options?: #{optional_parts_type} & RouteOptions"
+      args << "options?: #{options_type}"
       "((\n#{args.join(",\n").indent(2)}\n) => string) & RouteHelperExtras"
     end
 
+    sig { returns(T.nilable(String)) }
     def optional_parts_type
-      @optional_parts_type ||=
-        "{" + optional_parts.map {|p| "#{p}?: OptionalRouteParameter"}.join(', ') + "}"
+      return nil if optional_parts.empty?
+      @optional_parts_type ||= T.let(
+        "{" + optional_parts.map {|p| "#{p}?: OptionalRouteParameter"}.join(', ') + "}",
+        T.nilable(String)
+      )
     end
 
     protected
 
+
+    sig { params(absolute: T::Boolean).returns(UntypedArray) }
     def arguments(absolute)
       absolute ? [*base_arguments, true] : base_arguments
     end
 
+    sig { returns(T::Boolean) }
     def match_configuration?
-      !match?(@configuration[:exclude]) && match?(@configuration[:include])
+      !match?(@configuration.exclude) && match?(@configuration.include)
     end
 
+    sig { returns(T.nilable(String)) }
     def base_name
-      @base_name ||= parent_route ?
-        [parent_route.name, route.name].join('_') : route.name
+      @base_name ||= T.let(parent_route ?
+        [parent_route&.name, route.name].join('_') : route.name, T.nilable(String))
     end
 
+    sig { returns(T.nilable(RouteSpec)) }
     def parent_spec
       parent_route&.path&.spec
     end
 
+    sig { returns(RouteSpec) }
     def spec
       route.path.spec
     end
 
+    sig { params(value: T.untyped).returns(String) }
     def json(value)
       JsRoutes.json(value)
     end
 
+    sig { params(absolute: T::Boolean).returns(String) }
     def helper_name(absolute)
-      suffix = absolute ? :url : @configuration[:compact] ? nil : :path
+      suffix = absolute ? :url : @configuration.compact ? nil : :path
       apply_case(base_name, suffix)
     end
 
+    sig { returns(String) }
     def documentation
-      return nil unless @configuration[:documentation]
+      return '' unless @configuration.documentation
       <<-JS
 /**
  * Generates rails route to
@@ -99,18 +133,22 @@ module JsRoutes
 JS
     end
 
+    sig { returns(SymbolArray) }
     def required_parts
       route.required_parts
     end
 
+    sig { returns(SymbolArray) }
     def optional_parts
       route.path.optional_names
     end
 
+    sig { returns(UntypedArray) }
     def base_arguments
-      @base_arguments ||= [parts_table, serialize(spec, parent_spec)]
+      @base_arguments ||= T.let([parts_table, serialize(spec, parent_spec)], T.nilable(UntypedArray))
     end
 
+    sig { returns(T::Hash[Symbol, Options]) }
     def parts_table
       parts_table = {}
       route.parts.each do |part, hash|
@@ -131,25 +169,29 @@ JS
       parts_table
     end
 
+    sig { returns(String) }
     def documentation_params
       required_parts.map do |param|
         "\n * @param {any} #{apply_case(param)}"
       end.join
     end
 
+    sig { params(matchers: Clusivity).returns(T::Boolean) }
     def match?(matchers)
       Array(matchers).any? { |regex| base_name =~ regex }
     end
 
+    sig { params(values: T.nilable(Literal)).returns(String) }
     def apply_case(*values)
       value = values.compact.map(&:to_s).join('_')
-      @configuration[:camel_case] ? value.camelize(:lower) : value
+      @configuration.camel_case ? value.camelize(:lower) : value
     end
 
     # This function serializes Journey route into JSON structure
     # We do not use Hash for human readable serialization
     # And preffer Array serialization because it is shorter.
     # Routes.js file will be smaller.
+    sig { params(spec: SpecNode, parent_spec: T.nilable(RouteSpec)).returns(T.nilable(T.any(UntypedArray, String))) }
     def serialize(spec, parent_spec=nil)
       return nil unless spec
       # Rails 4 globbing requires * removal
@@ -168,6 +210,7 @@ JS
       result
     end
 
+    sig { params(spec: RouteSpec, parent_spec: T.nilable(RouteSpec)).returns(UntypedArray) }
     def serialize_spec(spec, parent_spec = nil)
       [
         NODE_TYPES[spec.type],

data/lib/js_routes/types.rb

@@ -0,0 +1,38 @@
+# typed: strict
+require "action_dispatch/journey/route"
+require "pathname"
+require "sorbet-runtime"
+
+module JsRoutes
+  module Types
+    extend T::Sig
+
+    UntypedArray = T.type_alias {T::Array[T.untyped]}
+    StringArray = T.type_alias {T::Array[String]}
+    SymbolArray = T.type_alias {T::Array[Symbol]}
+    StringHash = T.type_alias { T::Hash[String, T.untyped] }
+    Options = T.type_alias { T::Hash[Symbol, T.untyped] }
+    SpecNode = T.type_alias { T.any(String, RouteSpec, NilClass) }
+    Literal = T.type_alias { T.any(String, Symbol) }
+    JourneyRoute = T.type_alias{ActionDispatch::Journey::Route}
+    RouteSpec = T.type_alias {T.untyped}
+    Application = T.type_alias { T.any(T::Class[Rails::Engine], Rails::Application) }
+    ApplicationCaller = T.type_alias { T.proc.returns(Application) }
+    Clusivity = T.type_alias { T.any(Regexp, T::Array[Regexp]) }
+    FileName = T.type_alias { T.any(String, Pathname, NilClass) }
+    ConfigurationBlock = T.type_alias { T.proc.params(arg0: JsRoutes::Configuration).void }
+    Prefix = T.type_alias do
+      T.any(T.proc.returns(String), String, NilClass)
+    end
+
+    module RackApp
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(input: StringHash).returns(UntypedArray) }
+      def call(input); end
+    end
+  end
+end

data/lib/js_routes/version.rb

@@ -1,3 +1,4 @@
+# typed: strict
 module JsRoutes
-  VERSION = "2.2.8"
+  VERSION = "2.2.10"
 end

data/lib/js_routes.rb

@@ -1,45 +1,63 @@
+# typed: strict
 if defined?(::Rails)
   require 'js_routes/engine'
 end
 require 'js_routes/version'
 require "js_routes/configuration"
 require "js_routes/instance"
+require "js_routes/types"
 require 'active_support/core_ext/string/indent'
 
 module JsRoutes
+  extend T::Sig
 
   #
   # API
   #
 
   class << self
+    include JsRoutes::Types
+    extend T::Sig
+
+    sig { params(block: ConfigurationBlock).void }
     def setup(&block)
-      configuration.assign(&block)
+      configuration.setup(&block)
     end
 
+    sig { returns(JsRoutes::Configuration) }
     def configuration
-      @configuration ||= Configuration.new
+      @configuration ||= T.let(Configuration.new, T.nilable(JsRoutes::Configuration))
     end
 
+    sig { params(opts: T.untyped).returns(String) }
     def generate(**opts)
-      Instance.new(opts).generate
+      Instance.new(**opts).generate
     end
 
+    sig { params(file_name: FileName, opts: T.untyped).void }
     def generate!(file_name = configuration.file, **opts)
       Instance.new(file: file_name, **opts).generate!
     end
 
+    sig { params(file_name: FileName, opts: T.untyped).void }
+    def remove!(file_name = configuration.file, **opts)
+      Instance.new(file: file_name, **opts).remove!
+    end
+
+    sig { params(opts: T.untyped).returns(String) }
     def definitions(**opts)
-      generate(module_type: 'DTS', **opts)
+      generate(**opts, module_type: 'DTS',)
     end
 
+    sig { params(file_name: FileName, opts: T.untyped).void }
     def definitions!(file_name = nil, **opts)
       file_name ||= configuration.file&.sub(%r{(\.d)?\.(j|t)s\Z}, ".d.ts")
-      generate!(file_name, module_type: 'DTS', **opts)
+      generate!(file_name, **opts, module_type: 'DTS')
     end
 
-    def json(string)
-      ActiveSupport::JSON.encode(string)
+    sig { params(value: T.untyped).returns(String) }
+    def json(value)
+      ActiveSupport::JSON.encode(value)
     end
   end
   module Generators