js-routes 1.4.14 → 2.0.0

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,20 @@
 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
 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
@@ -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
 
@@ -235,7 +239,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 +257,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 +306,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 +340,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 +389,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 +416,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,13 +437,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
 

data/spec/js_routes/zzz_last_post_rails_init_spec.rb

@@ -93,7 +93,7 @@ describe "after Rails initialization" do
               Rails.application.config.assets.initialize_on_precompile = true
             end
             it "should render some javascript" do
-              expect(evaluate(ctx, 'js-routes.js')).to match(/routes = /)
+              expect(evaluate(ctx, 'js-routes.js')).to match(/Utils\.define_module/)
             end
           end
           context "and not initialize on precompile" do
@@ -101,7 +101,7 @@ describe "after Rails initialization" do
               Rails.application.config.assets.initialize_on_precompile = false
             end
             it "should raise an exception if 3 version" do
-              expect(evaluate(ctx, 'js-routes.js')).to match(/routes = /)
+              expect(evaluate(ctx, 'js-routes.js')).to match(/Utils\.define_module/)
             end
           end
 

data/spec/spec_helper.rb

@@ -6,7 +6,14 @@ require 'rspec'
 require 'rails/all'
 require 'js-routes'
 require 'active_support/core_ext/hash/slice'
-require 'coffee-script'
+
+unless ENV['TRAVIS_CI']
+  code = system("yarn tsc")
+  unless code
+    exit(1)
+  end
+end
+
 
 if defined?(JRUBY_VERSION)
   require 'rhino'
@@ -32,8 +39,15 @@ def js_error_class
   end
 end
 
-def evaljs(string, force = false)
-  jscontext(force).eval(string)
+def evaljs(string, force: false, filename: 'context.js')
+  jscontext(force).eval(string, filename: filename)
+rescue MiniRacer::ParseError => e
+  message = e.message
+  _, _, line, _ = message.split(':')
+  code = line && string.split("\n")[line.to_i-1]
+  raise "#{message}. Code: #{code.strip}";
+rescue MiniRacer::RuntimeError => e
+  raise e
 end
 
 def test_routes
@@ -79,28 +93,22 @@ RSpec.configure do |config|
     c.syntax = :expect
   end
 
-  config.before(:all) do
-    # compile all js files begin
-    Dir["#{File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))}/**/*.coffee"].each do |coffee|
-      File.open(coffee.gsub(/\.coffee$/, ""), 'w') do |f|
-        f.write(CoffeeScript.compile(File.read(coffee)).lstrip)
-      end
-    end
-    # compile all js files end
+  config.before(:suite) do
     draw_routes
   end
 
   config.before :each do
-    evaljs("var window = this;", true)
+    evaljs("var window = this;", {force: true})
 
+    log = proc do |*values|
+      puts values.map(&:inspect).join(", ")
+    end
     if defined?(JRUBY_VERSION)
-      jscontext[:log] = lambda do |context, value|
-        puts value.inspect
+      jscontext[:"console.log"] = lambda do |context, *values|
+        log(*values)
       end
     else
-      jscontext.attach("log", proc do |value|
-        puts value.inspect
-      end)
+      jscontext.attach("console.log", log)
     end
   end
 end