js-routes 1.4.14 → 2.0.4

data/package.json

@@ -0,0 +1,36 @@
+{
+  "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": {
+    "lint:fix": "yarn eslint --fix && yarn prettier --write lib/routes.ts",
+    "postinstall": "yarn husky-upgrade"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "yarn lint:fix"
+    }
+  },
+  "lint-staged": {
+    "*.ts": ["yarn lint:fix" ]
+  }
+
+}

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}))
   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}

@@ -24,14 +24,11 @@ describe JsRoutes, "compatibility with AMD/require.js"  do
     };
 EOF
     evaljs(strRequire)
-    evaljs(JsRoutes.generate({}))
+    evaljs(JsRoutes.generate({module_type: 'AMD'}))
   end
 
   it "should working from require" do
     expect(evaljs("require(['js-routes'], function(r){ return r.inboxes_path(); })")).to eq(test_routes.inboxes_path())
   end
 
-  it "should define default export for es6 modules" do
-    expect(evaljs("require(['js-routes'], function(r){ return r.default.inboxes_path(); })")).to eq(test_routes.inboxes_path())
-  end
 end

data/spec/js_routes/{common_js_compatibility_spec.rb → module_types/cjs_spec.rb}

@@ -1,9 +1,12 @@
 require "spec_helper"
 
-describe JsRoutes, "compatibility with CommonJS (node)"  do
+describe JsRoutes, "compatibility with CJS"  do
   before(:each) do
     evaljs("module = { exports: null }")
-    evaljs(JsRoutes.generate({}))
+    evaljs(JsRoutes.generate(
+      module_type: 'CJS',
+      include: /^inboxes/
+    ))
   end
 
   it "should define module exports" do

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/{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 "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
@@ -62,13 +81,5 @@ describe JsRoutes do
     it "should not generate file before initialization" do
       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

data/spec/js_routes/options_spec.rb

@@ -2,10 +2,14 @@ require 'spec_helper'
 
 describe JsRoutes, "options" do
 
+  let(:generated_js) do
+    JsRoutes.generate({module_type: nil, **_options})
+  end
+
   before(:each) do
     evaljs(_presetup) if _presetup
     with_warnings(_warnings) do
-      evaljs(JsRoutes.generate(_options))
+      evaljs(generated_js)
       App.routes.default_url_options = _options[:default_url_options] || {}
     end
   end
@@ -37,9 +41,10 @@ describe JsRoutes, "options" do
       let(:_presetup){ %q(var myCustomSerializer = 1) }
       let(:_options) { {:serializer => "myCustomSerializer"} }
 
-      it "should set configurable serializer" do
-        # expect to use default
-        expect(evaljs(%q(Routes.inboxes_path({a: 1})))).to eql("/inboxes?a=1")
+      it "should throw error" do
+      expect {
+        evaljs(%q(Routes.inboxes_path({a: 1})))
+      }.to raise_error(js_error_class)
       end
     end
 
@@ -177,8 +182,7 @@ describe JsRoutes, "options" do
     context "is nil" do
       let(:_options) { {:namespace => nil} }
       it "should use this namespace for routing" do
-        evaljs("window.zz = #{JsRoutes.generate(namespace: nil)}")
-        expect(evaljs("window.Routes")).to be_nil
+        evaljs("window.zz = #{JsRoutes.generate(module_type: nil, namespace: nil)}")
         expect(evaljs("window.zz.inbox_path")).not_to be_nil
       end
 
@@ -491,4 +495,13 @@ describe JsRoutes, "options" do
       expect(evaljs("Routes.posts_path()")).not_to be_nil
     end
   end
+
+  describe "documentation option" do
+    let(:_options) { {documentation: false} }
+
+    it "disables documentation generation" do
+      expect(generated_js).not_to include("@param")
+      expect(generated_js).not_to include("@returns")
+    end
+  end
 end

data/spec/js_routes/rails_routes_compatibility_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe JsRoutes, "compatibility with Rails"  do
 
   before(:each) do
-    evaljs(JsRoutes.generate({}))
+    evaljs(JsRoutes.generate({module_type: nil}))
   end
 
   it "should generate collection routing" do
@@ -16,13 +16,16 @@ describe JsRoutes, "compatibility with Rails"  do
 
   it "should raise error if required argument is not passed", :aggregate_failures do
     expect { evaljs("Routes.thing_path()") }
-      .to raise_error(/Route parameter missing: id/)
+      .to raise_error(/Route missing required keys: id/)
     expect { evaljs("Routes.search_path()") }
-      .to raise_error(/Route parameter missing: q/)
+      .to raise_error(/Route missing required keys: q/)
     expect { evaljs("Routes.book_path()") }
-      .to raise_error(/Route parameter missing: title/)
+      .to raise_error(/Route missing required keys: section, title/)
     expect { evaljs("Routes.book_title_path()") }
-      .to raise_error(/Route parameter missing: title/)
+      .to raise_error(/Route missing required keys: title/)
+
+    expect( evaljs("try {Routes.thing_path()} catch (e) { e.name }") ).to eq('ParametersMissing')
+    expect( evaljs("try {Routes.thing_path()} catch (e) { e.keys }") ).to eq(['id'])
   end
 
   it "should produce error stacktraces including function names" do
@@ -70,7 +73,7 @@ describe JsRoutes, "compatibility with Rails"  do
     expect(evaljs("Routes.inbox_path(1, {expanded: true, anchor: 'hello'})")).to eq(test_routes.inbox_path(1, :expanded => true, :anchor => "hello"))
   end
 
-  it "should support required paramters given as options hash" do
+  it "should support required parameters given as options hash" do
     expect(evaljs("Routes.search_path({q: 'hello'})")).to eq(test_routes.search_path(:q => 'hello'))
   end
 
@@ -110,6 +113,7 @@ describe JsRoutes, "compatibility with Rails"  do
 
     it "doesn't apply defaults to path" do
       expect(evaljs("Routes.with_defaults_path()")).to eq(test_routes.with_defaults_path)
+      expect(evaljs("Routes.with_defaults_path({format: 'json'})")).to eq(test_routes.with_defaults_path(format: 'json'))
     end
   end
 
@@ -131,6 +135,11 @@ describe JsRoutes, "compatibility with Rails"  do
     it "should support single route mapping" do
       expect(evaljs("Routes.support_path({page: 3})")).to eq(test_routes.support_path(:page => 3))
     end
+
+    it 'works' do
+      expect(evaljs("Routes.planner_manage_path({locale: 'ua'})")).to eq(planner_routes.manage_path(locale: 'ua'))
+      expect(evaljs("Routes.planner_manage_path()")).to eq(planner_routes.manage_path)
+    end
   end
 
   it "shouldn't require the format" do
@@ -149,7 +158,7 @@ describe JsRoutes, "compatibility with Rails"  do
     expect(evaljs("Routes.root_path()")).to eq(test_routes.root_path)
   end
 
-  describe "get paramters" do
+  describe "get parameters" do
     it "should support simple get parameters" do
       expect(evaljs("Routes.inbox_path(1, {format: 'json', lang: 'ua', q: 'hello'})")).to eq(test_routes.inbox_path(1, :lang => "ua", :q => "hello", :format => "json"))
     end
@@ -158,6 +167,19 @@ describe JsRoutes, "compatibility with Rails"  do
       expect(evaljs("Routes.inbox_path(1, {hello: ['world', 'mars']})")).to eq(test_routes.inbox_path(1, :hello => [:world, :mars]))
     end
 
+    context "object without prototype" do
+      before(:each) do
+        evaljs("let params = Object.create(null); params.q = 'hello';")
+        evaljs("let inbox = Object.create(null); inbox.to_param = 1;")
+      end
+
+      it "should still work correctly" do
+        expect(evaljs("Routes.inbox_path(inbox, params)")).to eq(
+          test_routes.inbox_path(1, q: "hello")
+        )
+      end
+    end
+
     it "should support nested get parameters" do
       expect(evaljs("Routes.inbox_path(1, {format: 'json', env: 'test', search: { category_ids: [2,5], q: 'hello'}})")).to eq(
         test_routes.inbox_path(1, :env => 'test', :search => {:category_ids => [2,5], :q => "hello"}, :format => "json")
@@ -225,6 +247,15 @@ describe JsRoutes, "compatibility with Rails"  do
         expect(evaljs("Routes.things_path({ q: 'hello' })")).to eq(test_routes.things_path(q: 'hello'))
       end
 
+      it "treats false as absent optional part" do
+        pending("https://github.com/rails/rails/issues/42280")
+        expect(evaljs("Routes.things_path(false)")).to eq(test_routes.things_path(false))
+      end
+
+      it "treats false as absent optional part when default is specified" do
+        expect(evaljs("Routes.campaigns_path(false)")).to eq(test_routes.campaigns_path(false))
+      end
+
       it "should not require the optional parts as arguments" do
         expect(evaljs("Routes.thing_path(null, 5)")).to eq(test_routes.thing_path(nil, 5))
       end
@@ -235,7 +266,7 @@ describe JsRoutes, "compatibility with Rails"  do
 
       it "should raise error when passing non-full list of arguments and some query params" do
         expect { evaljs("Routes.thing_path(5, {q: 'hello'})") }
-          .to raise_error(/Route parameter missing: id/)
+          .to raise_error(/Route missing required keys: id/)
       end
 
       it "should treat null as non-given optional part" do
@@ -253,7 +284,7 @@ describe JsRoutes, "compatibility with Rails"  do
 
     context "and including them" do
       it "should fail when insufficient arguments are given" do
-        expect { evaljs("Routes.thing_deep_path(2)") }.to raise_error(/Route parameter missing: third_required/)
+        expect { evaljs("Routes.thing_deep_path(2)") }.to raise_error(/Route missing required keys: third_required/)
       end
 
       it "should include the optional parts" do
@@ -302,27 +333,22 @@ describe JsRoutes, "compatibility with Rails"  do
         evaljs("Routes.inbox_path()")
       }.to raise_error(js_error_class)
     end
+
     it "should throw Exception if required parameter is not defined" do
       expect {
         evaljs("Routes.inbox_path(null)")
       }.to raise_error(js_error_class)
     end
 
-    it "should throw Exceptions if when there is too many parameters" do
-      expect {
-        evaljs("Routes.inbox_path(1,2,3)")
-      }.to raise_error(js_error_class)
-    end
-
-    it "should throw Exceptions if when pass id with null" do
+    it "should throw Exception if required parameter is not defined" do
       expect {
-        evaljs("Routes.inbox_path({id: null})")
+        evaljs("Routes.inbox_path(undefined)")
       }.to raise_error(js_error_class)
     end
 
-    it "should throw Exceptions if when pass to_param with null" do
+    it "should throw Exceptions if when there is too many parameters" do
       expect {
-        evaljs("Routes.inbox_path({to_param: null})")
+        evaljs("Routes.inbox_path(1,2,3)")
       }.to raise_error(js_error_class)
     end
   end
@@ -341,8 +367,19 @@ describe JsRoutes, "compatibility with Rails"  do
     let(:klass) { Struct.new(:id, :to_param) }
     let(:inbox) { klass.new(1,"my") }
 
+    it "should throw Exceptions if when pass id with null" do
+      expect {
+        evaljs("Routes.inbox_path({id: null})")
+      }.to raise_error(js_error_class)
+    end
+
+    it "should throw Exceptions if when pass to_param with null" do
+      expect {
+        evaljs("Routes.inbox_path({to_param: null})")
+      }.to raise_error(js_error_class)
+    end
     it "should support 0 as a to_param option" do
-      expect(evaljs("Routes.inbox_path({to_param: 0})")).to eq(test_routes.inbox_path(0))
+      expect(evaljs("Routes.inbox_path({to_param: 0})")).to eq(test_routes.inbox_path(Struct.new(:to_param).new('0')))
     end
 
     it "should check for options special key" do
@@ -379,6 +416,14 @@ describe JsRoutes, "compatibility with Rails"  do
       )).to eq(test_routes.inbox_message_path(inbox, 2, :custom => true, :format => "json"))
     end
 
+    it "supports camel case property name" do
+      expect(evaljs("Routes.inbox_path({id: 1, toParam: 'my'})")).to eq(test_routes.inbox_path(inbox))
+    end
+
+    it "supports camel case method name" do
+      expect(evaljs("Routes.inbox_path({id: 1, toParam: function(){ return 'my';}})")).to eq(test_routes.inbox_path(inbox))
+    end
+
     context "when globbing" do
       it "should prefer to_param property over id property" do
         expect(evaljs("Routes.book_path({id: 1, to_param: 'my'}, 1)")).to eq(test_routes.book_path(inbox, 1))
@@ -398,6 +443,7 @@ describe JsRoutes, "compatibility with Rails"  do
         )).to eq(test_routes.book_path(inbox, 2, :custom => true, :format => "json"))
       end
     end
+
   end
 
   context "when specs" do
@@ -418,15 +464,13 @@ describe JsRoutes, "compatibility with Rails"  do
     end
   end
 
-  describe "required_params" do
+  describe "requiredParams" do
     it "should show inbox spec" do
-      expect(evaljs("Routes.inbox_path.required_params").to_a).to eq(["id"])
+      expect(evaljs("Routes.inbox_path.requiredParams()").to_a).to eq(["id"])
     end
 
     it "should show inbox message spec" do
-      expect(evaljs("Routes.inbox_message_path.required_params").to_a).to eq(["inbox_id", "id"])
+      expect(evaljs("Routes.inbox_message_path.requiredParams()").to_a).to eq(["inbox_id", "id"])
     end
   end
-
-
 end