js-routes 1.4.9 → 2.2.0

data/lib/tasks/js_routes.rake

@@ -1,8 +1,14 @@
 namespace :js do
-  desc "Make a js file that will have functions that will return restful routes/urls."
+  desc "Make a js file with all rails route URL helpers"
   task routes: :environment do
     require "js-routes"
-
     JsRoutes.generate!
   end
+
+  namespace :routes do
+    desc "Make a js file with all rails route URL helpers and typescript definitions for them"
+    task typescript: "js:routes" do
+      JsRoutes.definitions!
+    end
+  end
 end

data/lib/templates/erb.js

@@ -0,0 +1,11 @@
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.erb$/,
+        enforce: 'pre',
+        loader: 'rails-erb-loader'
+      },
+    ]
+  }
+};

data/lib/templates/initializer.rb

@@ -0,0 +1,5 @@
+JsRoutes.setup do |c|
+  # Setup your JS module system:
+  # ESM, CJS, AMD, UMD or nil
+  # c.module_type = "ESM"
+end

data/lib/templates/routes.js.erb

@@ -0,0 +1 @@
+<%= JsRoutes.generate %>

data/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "js-routes",
+  "version": "1.0.0",
+  "main": "index.js",
+  "repository": "git@github.com:railsware/js-routes.git",
+  "author": "Bogdan Gusiev <agresso@gmail.com>, Alexey Vasiliev <https://leopard.in.ua> ",
+  "license": "MIT",
+  "private": false,
+  "devDependencies": {
+    "typescript": "^4.1.2"
+  },
+  "dependencies": {
+    "@typescript-eslint/eslint-plugin": "^4.9.0",
+    "@typescript-eslint/parser": "^4.9.0",
+    "eslint": "^7.14.0",
+    "eslint-config-prettier": "^6.15.0",
+    "eslint-plugin-import": "^2.22.1",
+    "husky": "^4.3.0",
+    "lint-staged": "^10.5.2",
+    "pinst": "^2.1.1",
+    "prettier": "^2.2.1"
+  },
+  "scripts": {
+    "build": "tsc && yarn lint:fix",
+    "lint:fix": "yarn eslint --fix && yarn prettier --write lib/routes.ts",
+    "postinstall": "yarn husky-upgrade"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "yarn lint:fix"
+    }
+  },
+  "lint-staged": {
+    "./lib/routes.ts": ["yarn lint:fix" ]
+  }
+
+}

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,2 @@
+//= link_tree ../images
+//= link_directory ../stylesheets .css

data/spec/js_routes/default_serializer_spec.rb

@@ -1,15 +1,31 @@
 require "spec_helper"
 
-describe JsRoutes, "#default_serializer" do
+describe JsRoutes, "#serialize" do
 
   before(:each) do
-    evaljs(JsRoutes.generate({}))
+    evaljs(JsRoutes.generate({module_type: nil, namespace: 'Routes'}))
   end
 
   it "should provide this method" do
-    expect(evaljs("Routes.default_serializer({a: 1, b: [2,3], c: {d: 4, e: 5}, f: ''})")).to eq(
+    expect(evaljs("Routes.serialize({a: 1, b: [2,3], c: {d: 4, e: 5}, f: ''})")).to eq(
       "a=1&b%5B%5D=2&b%5B%5D=3&c%5Bd%5D=4&c%5Be%5D=5&f="
     )
   end
 
+  it "should provide this method" do
+    expect(evaljs("Routes.serialize({a: 1, b: [2,3], c: {d: 4, e: 5}, f: ''})")).to eq(
+      "a=1&b%5B%5D=2&b%5B%5D=3&c%5Bd%5D=4&c%5Be%5D=5&f="
+    )
+  end
+
+  it "works with JS suckiness" do
+    expect(evaljs(
+      [
+        "const query = Object.create(null);",
+        "query.a = 1;",
+        "query.b = 2;",
+        "Routes.serialize(query);",
+      ].join("\n")
+    )).to eq("a=1&b=2")
+  end
 end

data/spec/js_routes/{amd_compatibility_spec.rb → module_types/amd_spec.rb}

@@ -3,11 +3,12 @@ require "spec_helper"
 describe JsRoutes, "compatibility with AMD/require.js"  do
 
   before(:each) do
-    evaljs("window.GlobalCheck = {};")
-    evaljs("window.define = function (requirs, callback) { window.GlobalCheck['js-routes'] = callback.call(this); return window.GlobalCheck['js-routes']; };")
-    evaljs("window.define.amd = { jQuery: true };")
+    evaljs("var global = this;", {force: true})
+    evaljs("global.GlobalCheck = {};")
+    evaljs("global.define = function (requirs, callback) { global.GlobalCheck['js-routes'] = callback.call(this); return global.GlobalCheck['js-routes']; };")
+    evaljs("global.define.amd = { jQuery: true };")
     strRequire =<<EOF
-    window.require = function (r, callback) {
+    global.require = function (r, callback) {
       var allArgs, i;
 
       allArgs = (function() {
@@ -15,7 +16,7 @@ describe JsRoutes, "compatibility with AMD/require.js"  do
         _results = [];
         for (_i = 0, _len = r.length; _i < _len; _i++) {
           i = r[_i];
-          _results.push(window.GlobalCheck[i]);
+          _results.push(global.GlobalCheck[i]);
         }
         return _results;
       })();
@@ -24,15 +25,7 @@ describe JsRoutes, "compatibility with AMD/require.js"  do
     };
 EOF
     evaljs(strRequire)
-    evaljs(JsRoutes.generate({}))
-  end
-
-  it "should working from global scope" do
-    expect(evaljs("Routes.inboxes_path()")).to eq(test_routes.inboxes_path())
-  end
-
-  it "should working from define function" do
-    expect(evaljs("Routes.inboxes_path()")).to eq(evaljs("GlobalCheck['js-routes'].inboxes_path()"))
+    evaljs(JsRoutes.generate({module_type: 'AMD'}))
   end
 
   it "should working from require" do

data/spec/js_routes/module_types/cjs_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe JsRoutes, "compatibility with CJS"  do
+  before(:each) do
+    evaljs("module = { exports: null }")
+    evaljs(JsRoutes.generate(
+      module_type: 'CJS',
+      include: /^inboxes/
+    ))
+  end
+
+  it "should define module exports" do
+    expect(evaljs("module.exports.inboxes_path()")).to eq(test_routes.inboxes_path())
+  end
+end

data/spec/js_routes/module_types/dts/routes.spec.d.ts

@@ -0,0 +1,114 @@
+/**
+ * File generated by js-routes RubyVariables.GEM_VERSION
+ * Based on Rails RubyVariables.RAILS_VERSION routes of RubyVariables.APP_CLASS
+ */
+declare type Optional<T> = {
+    [P in keyof T]?: T[P] | null;
+};
+declare type BaseRouteParameter = string | boolean | Date | number;
+declare type MethodRouteParameter = BaseRouteParameter | (() => BaseRouteParameter);
+declare type ModelRouteParameter = {
+    id: MethodRouteParameter;
+} | {
+    to_param: MethodRouteParameter;
+} | {
+    toParam: MethodRouteParameter;
+};
+declare type RequiredRouteParameter = BaseRouteParameter | ModelRouteParameter;
+declare type OptionalRouteParameter = undefined | null | RequiredRouteParameter;
+declare type QueryRouteParameter = OptionalRouteParameter | QueryRouteParameter[] | {
+    [k: string]: QueryRouteParameter;
+};
+declare type RouteParameters = Record<string, QueryRouteParameter>;
+declare type Serializable = Record<string, unknown>;
+declare type Serializer = (value: Serializable) => string;
+declare type RouteHelperExtras = {
+    requiredParams(): string[];
+    toString(): string;
+};
+declare type RequiredParameters<T extends number> = T extends 1 ? [RequiredRouteParameter] : T extends 2 ? [RequiredRouteParameter, RequiredRouteParameter] : T extends 3 ? [RequiredRouteParameter, RequiredRouteParameter, RequiredRouteParameter] : T extends 4 ? [
+    RequiredRouteParameter,
+    RequiredRouteParameter,
+    RequiredRouteParameter,
+    RequiredRouteParameter
+] : RequiredRouteParameter[];
+declare type RouteHelperOptions<T extends string> = RouteOptions & Optional<Record<T, OptionalRouteParameter>>;
+declare type RouteHelper<T extends number = number, U extends string = string> = ((...args: [...RequiredParameters<T>, RouteHelperOptions<U>]) => string) & RouteHelperExtras;
+declare type RouteHelpers = Record<string, RouteHelper>;
+declare type Configuration = {
+    prefix: string;
+    default_url_options: RouteParameters;
+    special_options_key: string;
+    serializer: Serializer;
+};
+interface RouterExposedMethods {
+    config(): Configuration;
+    configure(arg: Partial<Configuration>): Configuration;
+    serialize: Serializer;
+}
+declare type KeywordUrlOptions = Optional<{
+    host: string;
+    protocol: string;
+    subdomain: string;
+    port: string | number;
+    anchor: string;
+    trailing_slash: boolean;
+}>;
+declare type RouteOptions = KeywordUrlOptions & RouteParameters;
+declare type PartsTable = Record<string, {
+    r?: boolean;
+    d?: OptionalRouteParameter;
+}>;
+declare type ModuleType = "CJS" | "AMD" | "UMD" | "ESM" | "DTS" | "NIL";
+declare const RubyVariables: {
+    PREFIX: string;
+    DEPRECATED_GLOBBING_BEHAVIOR: boolean;
+    SPECIAL_OPTIONS_KEY: string;
+    DEFAULT_URL_OPTIONS: RouteParameters;
+    SERIALIZER: Serializer;
+    NAMESPACE: string;
+    ROUTES_OBJECT: RouteHelpers;
+    MODULE_TYPE: ModuleType;
+    WRAPPER: <T>(callback: T) => T;
+};
+declare const define: undefined | (((arg: unknown[], callback: () => unknown) => void) & {
+    amd?: unknown;
+});
+declare const module: {
+    exports: any;
+} | undefined;
+export const configure: RouterExposedMethods['configure'];
+
+export const config: RouterExposedMethods['config'];
+
+export const serialize: RouterExposedMethods['serialize'];
+
+/**
+ * Generates rails route to
+ * /inboxes/:inbox_id/messages/:message_id/attachments/:id(.:format)
+ * @param {any} inbox_id
+ * @param {any} message_id
+ * @param {any} id
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inbox_message_attachment_path: ((
+  inbox_id: RequiredRouteParameter,
+  message_id: RequiredRouteParameter,
+  id: RequiredRouteParameter,
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras;
+
+/**
+ * Generates rails route to
+ * /inboxes(.:format)
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inboxes_path: ((
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras;
+
+// By some reason this line prevents all types in a file
+// from being automatically exported
+export {};

data/spec/js_routes/module_types/dts/test.spec.ts

@@ -0,0 +1,56 @@
+import {
+  inbox_message_attachment_path,
+  inboxes_path,
+  serialize,
+  configure,
+  config,
+} from "./routes.spec";
+
+// Route Helpers
+inboxes_path();
+inboxes_path({
+  locale: "en",
+  search: {
+    q: "ukraine",
+    page: 3,
+    keywords: ["large", "small", { advanced: true }],
+  },
+});
+
+inbox_message_attachment_path(1, "2", true);
+inbox_message_attachment_path(
+  { id: 1 },
+  { to_param: () => "2" },
+  { toParam: () => true }
+);
+inbox_message_attachment_path(1, "2", true, { format: "json" });
+inboxes_path.toString();
+inboxes_path.requiredParams();
+
+// serialize test
+const SerializerArgument = {
+  locale: "en",
+  search: {
+    q: "ukraine",
+    page: 3,
+    keywords: ["large", "small", { advanced: true }],
+  },
+};
+serialize(SerializerArgument);
+config().serializer(SerializerArgument);
+
+// configure test
+configure({
+  default_url_options: { port: 1, host: null },
+  prefix: "",
+  special_options_key: "_options",
+  serializer: (value) => JSON.stringify(value),
+});
+
+// config tests
+const Config = config();
+console.log(
+  Config.prefix,
+  Config.default_url_options,
+  Config.special_options_key
+);

data/spec/js_routes/module_types/dts_spec.rb

@@ -0,0 +1,111 @@
+
+require "active_support/core_ext/string/strip"
+require "fileutils"
+require "open3"
+require "spec_helper"
+
+describe JsRoutes, "compatibility with DTS"  do
+
+  OPTIONS = {module_type: 'DTS', include: [/^inboxes$/, /^inbox_message_attachment$/]}
+  let(:extra_options) do
+    {}
+  end
+
+  let(:generated_js) do
+    JsRoutes.generate({**OPTIONS, **extra_options})
+  end
+
+  context "when file is generated" do
+    let(:dir_name) do
+       File.expand_path(__dir__ + "/dts")
+    end
+
+    let(:file_name) do
+      dir_name + "/routes.spec.d.ts"
+    end
+
+    before do
+      FileUtils.mkdir_p(dir_name)
+      File.write(file_name, generated_js)
+    end
+
+    it "has no compile errors", :slow do
+      command = "yarn tsc --strict --noEmit -p spec/tsconfig.json"
+      stdout, stderr, status = Open3.capture3(command)
+      expect(stderr).to eq("")
+      expect(stdout).to include("Done in ")
+      expect(status).to eq(0)
+    end
+  end
+
+  context "when camel case is enabled" do
+    let(:extra_options) { {camel_case: true} }
+
+    it "camelizes route name and arguments" do
+
+      expect(generated_js).to include(<<-DOC.rstrip)
+/**
+ * Generates rails route to
+ * /inboxes/:inbox_id/messages/:message_id/attachments/:id(.:format)
+ * @param {any} inboxId
+ * @param {any} messageId
+ * @param {any} id
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inboxMessageAttachmentPath: ((
+  inboxId: RequiredRouteParameter,
+  messageId: RequiredRouteParameter,
+  id: RequiredRouteParameter,
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras;
+DOC
+    end
+  end
+
+  it "exports route helpers" do
+    expect(generated_js).to include(<<-DOC.rstrip)
+/**
+ * Generates rails route to
+ * /inboxes(.:format)
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inboxes_path: ((
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras;
+DOC
+    expect(generated_js).to include(<<-DOC.rstrip)
+/**
+ * Generates rails route to
+ * /inboxes/:inbox_id/messages/:message_id/attachments/:id(.:format)
+ * @param {any} inbox_id
+ * @param {any} message_id
+ * @param {any} id
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inbox_message_attachment_path: ((
+  inbox_id: RequiredRouteParameter,
+  message_id: RequiredRouteParameter,
+  id: RequiredRouteParameter,
+  options?: {format?: OptionalRouteParameter} & RouteOptions
+) => string) & RouteHelperExtras
+DOC
+  end
+
+  it "exports utility methods" do
+    expect(generated_js).to include("export const serialize: RouterExposedMethods['serialize'];")
+  end
+
+  it "prevents all types from automatic export" do
+    expect(generated_js).to include("export {};")
+  end
+
+  describe "compiled javascript asset" do
+    subject { ERB.new(File.read("app/assets/javascripts/js-routes.js.erb")).result(binding) }
+    it "should have js routes code" do
+      is_expected.to include("export const inbox_message_path = __jsr.r(")
+    end
+  end
+end

data/spec/js_routes/module_types/esm_spec.rb

@@ -0,0 +1,45 @@
+require "active_support/core_ext/string/strip"
+require "spec_helper"
+
+describe JsRoutes, "compatibility with ESM"  do
+
+  let(:generated_js) {
+    JsRoutes.generate(module_type: 'ESM')
+  }
+
+  before(:each) do
+    # export keyword is not supported by a simulated js environment
+    evaljs(generated_js.gsub("export const ", "const "))
+  end
+
+  it "defines route helpers" do
+    expect(evaljs("inboxes_path()")).to eq(test_routes.inboxes_path())
+  end
+
+  it "exports route helpers" do
+    expect(generated_js).to include(<<-DOC.rstrip)
+/**
+ * Generates rails route to
+ * /inboxes(.:format)
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+export const inboxes_path = __jsr.r
+DOC
+  end
+
+  it "exports utility methods" do
+    expect(generated_js).to include("export const serialize = ")
+  end
+
+  it "defines utility methods" do
+    expect(evaljs("serialize({a: 1, b: 2})")).to eq({a: 1, b: 2}.to_param)
+  end
+
+  describe "compiled javascript asset" do
+    subject { ERB.new(File.read("app/assets/javascripts/js-routes.js.erb")).result(binding) }
+    it "should have js routes code" do
+      is_expected.to include("export const inbox_message_path = __jsr.r(")
+    end
+  end
+end

data/spec/js_routes/module_types/nil_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe JsRoutes, "compatibility with NIL (legacy browser)" do
+  let(:generated_js) do
+    JsRoutes.generate(
+      module_type: nil,
+      include: /book|inboxes|inbox_message/,
+      **_options
+    )
+  end
+
+  let(:_options) { {} }
+  describe "generated js" do
+    subject do
+      generated_js
+    end
+
+    it "should call route function for each route" do
+      is_expected.to include("inboxes_path: __jsr.r(")
+    end
+    it "should have correct function without arguments signature" do
+      is_expected.to include('inboxes_path: __jsr.r({"format":{}}')
+    end
+    it "should have correct function with arguments signature" do
+      is_expected.to include('inbox_message_path: __jsr.r({"inbox_id":{"r":true},"id":{"r":true},"format":{}}')
+    end
+    it "should have correct function signature with unordered hash" do
+      is_expected.to include('inbox_message_attachment_path: __jsr.r({"inbox_id":{"r":true},"message_id":{"r":true},"id":{"r":true},"format":{}}')
+    end
+  end
+
+  describe "inline generation" do
+    let(:_options) { {namespace: nil} }
+    before do
+      evaljs("const r = #{generated_js}")
+    end
+
+    it "should be possible" do
+      expect(evaljs("r.inboxes_path()")).to eq(test_routes.inboxes_path())
+    end
+  end
+
+  describe "namespace option" do
+    let(:_options) { {namespace: "PHM"} }
+    let(:_presetup) { "" }
+    before do
+      evaljs("var window = this;")
+      evaljs(_presetup)
+      evaljs(generated_js)
+    end
+    it "should use this namespace for routing" do
+      expect(evaljs("window.Routes")).to be_nil
+      expect(evaljs("window.PHM.inboxes_path")).not_to be_nil
+    end
+
+    describe "is nested" do
+      context "and defined on client" do
+        let(:_presetup) { "window.PHM = {}" }
+        let(:_options) { {namespace: "PHM.Routes"} }
+
+        it "should use this namespace for routing" do
+          expect(evaljs("PHM.Routes.inboxes_path")).not_to be_nil
+        end
+      end
+
+      context "but undefined on client" do
+        let(:_options) { {namespace: "PHM.Routes"} }
+
+        it "should initialize namespace" do
+          expect(evaljs("window.PHM.Routes.inboxes_path")).not_to be_nil
+        end
+      end
+
+      context "and some parts are defined" do
+        let(:_presetup) { "window.PHM = { Utils: {} };" }
+        let(:_options) { {namespace: "PHM.Routes"} }
+
+        it "should not overwrite existing parts" do
+          expect(evaljs("window.PHM.Utils")).not_to be_nil
+          expect(evaljs("window.PHM.Routes.inboxes_path")).not_to be_nil
+        end
+      end
+    end
+  end
+end
+

data/spec/js_routes/{generated_javascript_spec.rb → module_types/umd_spec.rb}

@@ -1,14 +1,15 @@
-require 'spec_helper'
+require "active_support/core_ext/string/strip"
 require "fileutils"
+require 'spec_helper'
 
-
-describe JsRoutes do
-  before(:each) do
-    evaljs(JsRoutes.generate)
-  end
-
+describe JsRoutes, "compatibility with UMD" do
   describe "generated js" do
-    subject { JsRoutes.generate }
+    subject do
+      JsRoutes.generate(
+        module_type: 'UMD',
+        include: /book|inboxes|inbox_message/,
+      )
+    end
 
     it "should include a comment in the header" do
       app_class = "App"
@@ -18,23 +19,41 @@ describe JsRoutes do
     end
 
     it "should call route function for each route" do
-      is_expected.to include("inboxes_path: Utils.route(")
+      is_expected.to include("inboxes_path: __jsr.r(")
     end
     it "should have correct function without arguments signature" do
-      is_expected.to include("inboxes_path: Utils.route([[\"format\",false]]")
+      is_expected.to include('inboxes_path: __jsr.r({"format":{}}')
     end
     it "should have correct function with arguments signature" do
-      is_expected.to include("inbox_message_path: Utils.route([[\"inbox_id\",true],[\"id\",true],[\"format\",false]]")
+      is_expected.to include('inbox_message_path: __jsr.r({"inbox_id":{"r":true},"id":{"r":true},"format":{}}')
     end
     it "should have correct function signature with unordered hash" do
-      is_expected.to include("inbox_message_attachment_path: Utils.route([[\"inbox_id\",true],[\"message_id\",true],[\"id\",true],[\"format\",false]]")
+      is_expected.to include('inbox_message_attachment_path: __jsr.r({"inbox_id":{"r":true},"message_id":{"r":true},"id":{"r":true},"format":{}}')
     end
 
     it "should have correct function comment with options argument" do
-      is_expected.to include("// function(options)\n  inboxes_path: Utils.route")
+      is_expected.to include(<<-DOC.rstrip)
+  /**
+   * Generates rails route to
+   * /inboxes(.:format)
+   * @param {object | undefined} options
+   * @returns {string} route path
+   */
+  inboxes_path: __jsr.r
+DOC
     end
     it "should have correct function comment with arguments" do
-      is_expected.to include("// function(inbox_id, message_id, options)\n  new_inbox_message_attachment_path: Utils.route")
+      is_expected.to include(<<-DOC.rstrip)
+  /**
+   * Generates rails route to
+   * /inboxes/:inbox_id/messages/:message_id/attachments/new(.:format)
+   * @param {any} inbox_id
+   * @param {any} message_id
+   * @param {object | undefined} options
+   * @returns {string} route path
+   */
+  new_inbox_message_attachment_path: __jsr.r
+  DOC
     end
 
     it "routes should be sorted in alphabetical order" do
@@ -60,20 +79,7 @@ describe JsRoutes do
     end
 
     it "should not generate file before initialization" do
-      # This method is alread fixed in Rails master
-      # But in 3.2 stable we need to hack it like this
-      if Rails.application.instance_variable_get("@initialized")
-        pending
-      end
       expect(File.exists?(name)).to be_falsey
     end
-
-  end
-
-  describe "compiled javascript asset" do
-    subject { ERB.new(File.read("app/assets/javascripts/js-routes.js.erb")).result(binding) }
-    it "should have js routes code" do
-      is_expected.to include("inbox_message_path: Utils.route([[\"inbox_id\",true],[\"id\",true],[\"format\",false]]")
-    end
   end
 end