js-routes 1.4.1 → 2.1.0

data/spec/js_routes/options_spec.rb

@@ -2,13 +2,26 @@ require 'spec_helper'
 
 describe JsRoutes, "options" do
 
+  let(:generated_js) do
+    JsRoutes.generate({
+      module_type: nil,
+      namespace: 'Routes',
+      **_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
 
+  after(:each) do
+    App.routes.default_url_options = {}
+  end
+
   let(:_presetup) { nil }
   let(:_options) { {} }
   let(:_warnings) { true }
@@ -32,9 +45,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
 
@@ -81,6 +95,18 @@ describe JsRoutes, "options" do
       expect(evaljs("Routes.inboxes_path")).to be_nil
     end
 
+    context "with camel_case option" do
+      let(:_options) { {include: /^admin_/, camel_case: true} }
+
+      it "should exclude specified routes from file" do
+        expect(evaljs("Routes.adminUsersPath()")).not_to be_nil
+      end
+
+      it "should not exclude routes not under specified pattern" do
+        expect(evaljs("Routes.inboxesPath")).to be_nil
+      end
+    end
+
     context "for rails engine" do
       let(:_options) { {:include => /^blog_app_posts/} }
 
@@ -134,12 +160,14 @@ describe JsRoutes, "options" do
     let(:_options) { {:default_url_options => {format: "json"}} }
     let(:_warnings) { nil }
 
-    it "should render routing with default_format" do
-      expect(evaljs("Routes.inbox_path(1)")).to eq(test_routes.inbox_path(1, :format => "json"))
-    end
+    if Rails.version >= "5"
+      it "should render routing with default_format" do
+        expect(evaljs("Routes.inbox_path(1)")).to eq(test_routes.inbox_path(1))
+      end
 
-    it "should render routing with default_format and zero object" do
-      expect(evaljs("Routes.inbox_path(0)")).to eq(test_routes.inbox_path(0, :format => "json"))
+      it "should render routing with default_format and zero object" do
+        expect(evaljs("Routes.inbox_path(0)")).to eq(test_routes.inbox_path(0))
+      end
     end
 
     it "should override default_format when spefified implicitly" do
@@ -147,13 +175,11 @@ describe JsRoutes, "options" do
     end
 
     it "should override nullify implicitly when specified implicitly" do
-      expect(evaljs("Routes.inbox_path(1, {format: null})")).to eq(test_routes.inbox_path(1))
+      expect(evaljs("Routes.inbox_path(1, {format: null})")).to eq(test_routes.inbox_path(1, format: nil))
     end
 
-
     it "shouldn't require the format" do
-      pending if Rails.version < "4.0"
-      expect(evaljs("Routes.json_only_path()")).to eq(test_routes.json_only_path(:format => 'json'))
+      expect(evaljs("Routes.json_only_path()")).to eq(test_routes.json_only_path)
     end
   end
 
@@ -162,36 +188,45 @@ describe JsRoutes, "options" do
     expect(evaljs("Routes.no_format_path({format: 'json'})")).to eq(test_routes.no_format_path(format: 'json'))
   end
 
-  describe "when namespace option is specified" do
+  describe "namespace option" do
     let(:_options) { {:namespace => "PHM"} }
     it "should use this namespace for routing" do
       expect(evaljs("window.Routes")).to be_nil
       expect(evaljs("PHM.inbox_path")).not_to be_nil
     end
-  end
 
-  describe "when nested namespace option is specified" do
-    context "and defined on client" do
-      let(:_presetup) { "window.PHM = {}" }
-      let(:_options) { {:namespace => "PHM.Routes"} }
+    context "is nil" do
+      let(:_options) { {:namespace => nil, include: /^inbox$/} }
       it "should use this namespace for routing" do
-        expect(evaljs("PHM.Routes.inbox_path")).not_to be_nil
+        evaljs("window.zz = #{generated_js}")
+        expect(evaljs("window.zz.inbox_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.inbox_path")).not_to be_nil
+    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.inbox_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.inbox_path")).not_to be_nil
+        end
       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.inbox_path")).not_to be_nil
+      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.inbox_path")).not_to be_nil
+        end
       end
     end
   end
@@ -201,14 +236,14 @@ describe JsRoutes, "options" do
       context "provided" do
         let(:_options) { { :default_url_options => { :optional_id => "12", :format => "json" } } }
         it "should use this opions to fill optional parameters" do
-          expect(evaljs("Routes.things_path()")).to eq(test_routes.things_path(:optional_id => 12, :format => "json"))
+          expect(evaljs("Routes.things_path()")).to eq(test_routes.things_path)
         end
       end
 
       context "not provided" do
         let(:_options) { { :default_url_options => { :format => "json" } } }
         it "breaks" do
-          expect(evaljs("Routes.foo_all_path()")).to eq(test_routes.foo_all_path(:format => "json"))
+          expect(evaljs("Routes.foo_all_path()")).to eq(test_routes.foo_all_path)
         end
       end
     end
@@ -216,7 +251,7 @@ describe JsRoutes, "options" do
     context "with required route parts" do
       let(:_options) { {:default_url_options => {:inbox_id => "12"}} }
       it "should use this opions to fill optional parameters" do
-        expect(evaljs("Routes.inbox_messages_path()")).to eq(test_routes.inbox_messages_path(:inbox_id => 12))
+        expect(evaljs("Routes.inbox_messages_path()")).to eq(test_routes.inbox_messages_path)
       end
     end
 
@@ -248,7 +283,7 @@ describe JsRoutes, "options" do
       end
 
       it "should remove it by params" do
-        expect(evaljs("Routes.inbox_path(1, {trailing_slash: false})")).to eq(test_routes.inbox_path(1))
+        expect(evaljs("Routes.inbox_path(1, {trailing_slash: false})")).to eq(test_routes.inbox_path(1, trailing_slash: false))
       end
     end
 
@@ -349,8 +384,8 @@ describe JsRoutes, "options" do
           expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com:3000" + test_routes.sso_path)
         end
 
-        it "does not override port when specified in route" do
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{test_routes.portals_path}")
+        it "does not override parts when specified in route" do
+          expect(evaljs("Routes.secret_root_url()")).to eq(test_routes.secret_root_url)
         end
       end
 
@@ -358,9 +393,6 @@ describe JsRoutes, "options" do
         let(:_options) { { :camel_case => true, :url_links => true, :default_url_options => {:host => "example.com"} } }
         it "should generate path and url links" do
           expect(evaljs("Routes.inboxUrl(1)")).to eq("http://example.com#{test_routes.inbox_path(1)}")
-          expect(evaljs("Routes.newSessionUrl()")).to eq("https://example.com#{test_routes.new_session_path}")
-          expect(evaljs("Routes.ssoUrl()")).to eq(test_routes.sso_url)
-          expect(evaljs("Routes.portalsUrl()")).to eq("http://example.com:8080#{test_routes.portals_path}")
         end
       end
 
@@ -368,9 +400,6 @@ describe JsRoutes, "options" do
         let(:_options) { { :prefix => "/api", :url_links => true, :default_url_options => {:host => 'example.com'} } }
         it "should generate path and url links" do
           expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com/api#{test_routes.inbox_path(1)}")
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com/api#{test_routes.new_session_path}")
-          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com/api#{test_routes.sso_path}")
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080/api#{test_routes.portals_path}")
         end
       end
 
@@ -378,9 +407,6 @@ describe JsRoutes, "options" do
         let(:_options) { { :compact => true, :url_links => true, :default_url_options => {:host => 'example.com'} } }
         it "does not affect url helpers" do
           expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com#{test_routes.inbox_path(1)}")
-          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{test_routes.new_session_path}")
-          expect(evaljs("Routes.sso_url()")).to eq(test_routes.sso_url)
-          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{test_routes.portals_path}")
         end
       end
     end
@@ -408,20 +434,27 @@ describe JsRoutes, "options" do
           expect(evaljs("Routes.inbox_url(1)")).to eq("http://current.example.com#{test_routes.inbox_path(1)}")
           expect(evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })")).to eq("http://current.example.com#{test_routes.inbox_path(1, :test_key => "test_val")}")
           expect(evaljs("Routes.new_session_url()")).to eq("https://current.example.com#{test_routes.new_session_path}")
-          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com#{test_routes.sso_path}")
 
         end
 
+        it "doesn't use current when specified in the route" do
+          expect(evaljs("Routes.sso_url()")).to eq(test_routes.sso_url)
+        end
+
         it "uses host option as an argument" do
-          expect(evaljs("Routes.portals_url({host: 'another.com'})")).to eq(test_routes.portals_url(host: 'another.com'))
+          expect(evaljs("Routes.secret_root_url({host: 'another.com'})")).to eq(test_routes.secret_root_url(host: 'another.com'))
         end
 
         it "uses port option as an argument" do
-          expect(evaljs("Routes.portals_url({host: 'localhost', port: 8080})")).to eq(test_routes.portals_url(host: 'localhost', port: 8080))
+          expect(evaljs("Routes.secret_root_url({host: 'localhost', port: 8080})")).to eq(test_routes.secret_root_url(host: 'localhost', port: 8080))
         end
 
         it "uses protocol option as an argument" do
-          expect(evaljs("Routes.portals_url({host: 'localhost', protocol: 'https'})")).to eq(test_routes.portals_url(protocol: 'https', host: 'localhost'))
+          expect(evaljs("Routes.secret_root_url({host: 'localhost', protocol: 'https'})")).to eq(test_routes.secret_root_url(protocol: 'https', host: 'localhost'))
+        end
+
+        it "uses subdomain option as an argument" do
+          expect(evaljs("Routes.secret_root_url({subdomain: 'custom'})")).to eq(test_routes.secret_root_url(subdomain: 'custom'))
         end
       end
     end
@@ -478,4 +511,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, namespace: 'Routes'}))
   end
 
   it "should generate collection routing" do
@@ -14,15 +14,31 @@ describe JsRoutes, "compatibility with Rails"  do
     expect(evaljs("Routes.inbox_path(1)")).to eq(test_routes.inbox_path(1))
   end
 
-  it "should raise error if required argument is not passed" 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
+     stacktrace = evaljs("
+        (function(){
+          try {
+            Routes.thing_path()
+          } catch(e) {
+            return e.stack;
+          }
+        })()
+      ")
+    expect(stacktrace).to include "thing_path"
   end
 
   it "should support 0 as a member parameter" do
@@ -57,6 +73,10 @@ 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 parameters given as options hash" do
+    expect(evaljs("Routes.search_path({q: 'hello'})")).to eq(test_routes.search_path(:q => 'hello'))
+  end
+
   it "should use irregular ActiveSupport pluralizations" do
     expect(evaljs("Routes.budgies_path()")).to eq(test_routes.budgies_path)
     expect(evaljs("Routes.budgie_path(1)")).to eq(test_routes.budgie_path(1))
@@ -64,6 +84,16 @@ describe JsRoutes, "compatibility with Rails"  do
     expect(evaljs("Routes.budgie_descendents_path(1)")).to eq(test_routes.budgie_descendents_path(1))
   end
 
+  it "should support route with parameters containing symbols that need URI-encoding", :aggregate_failures do
+    expect(evaljs("Routes.inbox_path('#hello')")).to eq(test_routes.inbox_path('#hello'))
+    expect(evaljs("Routes.inbox_path('some param')")).to eq(test_routes.inbox_path('some param'))
+    expect(evaljs("Routes.inbox_path('some param with more & more encode symbols')")).to eq(test_routes.inbox_path('some param with more & more encode symbols'))
+  end
+  it "should support route with parameters containing symbols not need URI-encoding", :aggregate_failures do
+    expect(evaljs("Routes.inbox_path(':some_id')")).to eq(test_routes.inbox_path(':some_id'))
+    expect(evaljs("Routes.inbox_path('.+')")).to eq(test_routes.inbox_path('.+'))
+  end
+
   describe "when route has defaults" do
     it "should support route default format" do
       expect(evaljs("Routes.api_purchases_path()")).to eq(test_routes.api_purchases_path)
@@ -83,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
 
@@ -104,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
@@ -122,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
@@ -131,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")
@@ -145,6 +194,9 @@ describe JsRoutes, "compatibility with Rails"  do
       expect(evaljs("Routes.inboxes_path({uri: 'http://example.com'})")).to eq(test_routes.inboxes_path(:uri => 'http://example.com'))
     end
 
+    it "should support nested object null parameters" do
+      expect(evaljs("Routes.inboxes_path({hello: {world: null}})")).to eq(test_routes.inboxes_path(:hello => {:world => nil}))
+    end
   end
 
 
@@ -157,14 +209,18 @@ describe JsRoutes, "compatibility with Rails"  do
       expect(evaljs("Routes.book_path(['thrillers'], 1)")).to eq(test_routes.book_path(['thrillers'], 1))
     end
 
-    it "should bee support routes globbing as array" do
+    it "should support routes globbing as array" do
       expect(evaljs("Routes.book_path([1, 2, 3], 1)")).to eq(test_routes.book_path([1, 2, 3], 1))
     end
 
-    it "should bee support routes globbing as hash" do
+    it "should support routes globbing with slash" do
       expect(evaljs("Routes.book_path('a_test/b_test/c_test', 1)")).to eq(test_routes.book_path('a_test/b_test/c_test', 1))
     end
 
+    it "should support routes globbing as hash" do
+      expect(evaljs("Routes.book_path('a%b', 1)")).to eq(test_routes.book_path('a%b', 1))
+    end
+
     it "should support routes globbing as array with optional params" do
       expect(evaljs("Routes.book_path([1, 2, 3, 5], 1, {c: '1'})")).to eq(test_routes.book_path([1, 2, 3, 5], 1, { :c => "1" }))
     end
@@ -176,14 +232,6 @@ describe JsRoutes, "compatibility with Rails"  do
     it "should support routes globbing in book_title route as array with optional params" do
       expect(evaljs("Routes.book_title_path('john', ['thrillers', 'comedian'], {some_key: 'some_value'})")).to eq(test_routes.book_title_path('john', ['thrillers', 'comedian'], {:some_key => 'some_value'}))
     end
-
-    it "should support required paramters given as options hash" do
-      expect(evaljs("Routes.search_path({q: 'hello'})")).to eq(test_routes.search_path(:q => 'hello'))
-    end
-
-    it "should support nested object null parameters" do
-      expect(evaljs("Routes.inboxes_path({hello: {world: null}})")).to eq(test_routes.inboxes_path(:hello => {:world => nil}))
-    end
   end
 
   context "using optional path fragments" do
@@ -199,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
@@ -209,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
@@ -221,19 +278,13 @@ describe JsRoutes, "compatibility with Rails"  do
       end
 
       it "should skip leading and trailing optional parts" do
-        skip if Rails.version < '4'
         expect(evaljs("Routes.thing_deep_path(1, 2)")).to eq(test_routes.thing_deep_path(1, 2))
       end
     end
 
     context "and including them" do
-      if Rails.version < '4'
-        it "should fail when insufficient arguments are given" do
-          expect { evaljs("Routes.thing_deep_path(1)")}
-            .to raise_error('Route parameter missing: second_required')
-          expect { evaljs("Routes.thing_deep_path(1,2)")}
-            .to raise_error('Route parameter missing: third_required')
-        end
+      it "should fail when insufficient arguments are given" do
+        expect { evaljs("Routes.thing_deep_path(2)") }.to raise_error(/Route missing required keys: third_required/)
       end
 
       it "should include the optional parts" do
@@ -245,6 +296,7 @@ describe JsRoutes, "compatibility with Rails"  do
         expect(evaljs("Routes.thing_deep_path(3, { first_optional: 1, second_required: 2 })")).to eq(test_routes.thing_deep_path(3, first_optional: 1, second_required: 2))
         expect(evaljs("Routes.thing_deep_path(3, { first_optional: 1, second_required: 2, forth_optional: 4 })")).to eq(test_routes.thing_deep_path(3, first_optional: 1, second_required: 2, forth_optional: 4))
         expect(evaljs("Routes.thing_deep_path(4, { first_optional: 1, second_required: 2, third_required: 3 })")).to eq(test_routes.thing_deep_path(4, first_optional: 1, second_required: 2, third_required: 3))
+        expect(evaljs("Routes.thing_deep_path(2, 3)")).to eq(test_routes.thing_deep_path(2, 3))
         expect(evaljs("Routes.thing_deep_path(1, 2, { third_required: 3 })")).to eq(test_routes.thing_deep_path(1, 2, third_required: 3))
         expect(evaljs("Routes.thing_deep_path(1,2, {third_required: 3, q: 'bogdan'})")).to eq(test_routes.thing_deep_path(1,2, {third_required: 3, q: 'bogdan'}))
         expect(evaljs("Routes.thing_deep_path(1, 2, { forth_optional: 4, third_required: 3 })")).to eq(test_routes.thing_deep_path(1, 2, forth_optional: 4, third_required: 3))
@@ -281,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
@@ -320,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
@@ -332,9 +390,6 @@ describe JsRoutes, "compatibility with Rails"  do
       expect(evaljs("Routes.inbox_message_path(5, {id: 7, q: 'hello', _options: true})")).to eq(test_routes.inbox_message_path(5, id: 7, q: 'hello'))
     end
 
-    it "should check for options special key" do
-    end
-
     it "should support 0 as an id option" do
       expect(evaljs("Routes.inbox_path({id: 0})")).to eq(test_routes.inbox_path(0))
     end
@@ -361,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))
@@ -380,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
@@ -400,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

data/spec/js_routes/zzz_last_post_rails_init_spec.rb

@@ -5,7 +5,7 @@
 require 'spec_helper'
 require "fileutils"
 
-describe "after Rails initialization" do
+describe "after Rails initialization", :slow do
   NAME = Rails.root.join('app', 'assets', 'javascripts', 'routes.js').to_s
 
   def sprockets_v3?
@@ -43,6 +43,21 @@ describe "after Rails initialization" do
     expect(File.exists?(NAME)).to be_truthy
   end
 
+  it "should not rewrite routes file if nothing changed" do
+    routes_file_mtime = File.mtime(NAME)
+    JsRoutes.generate!(NAME)
+    expect(File.mtime(NAME)).to eq(routes_file_mtime)
+  end
+
+  it "should rewrite routes file if file content changed" do
+    # Change content of existed routes file (add space to the end of file).
+    File.open(NAME, 'a') { |f| f << ' ' }
+    routes_file_mtime = File.mtime(NAME)
+    sleep(1)
+    JsRoutes.generate!(NAME)
+    expect(File.mtime(NAME)).not_to eq(routes_file_mtime)
+  end
+
   context "JsRoutes::Engine" do
     TEST_ASSET_PATH = Rails.root.join('app','assets','javascripts','test.js')
 
@@ -78,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
@@ -86,11 +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
-              if 3 == Rails::VERSION::MAJOR
-                expect { evaluate(ctx, 'js-routes.js') }.to raise_error(/Cannot precompile/)
-              else
-                expect(evaluate(ctx, 'js-routes.js')).to match(/routes = /)
-              end
+              expect(evaluate(ctx, 'js-routes.js')).to match(/Utils\.define_module/)
             end
           end
 
@@ -111,7 +122,7 @@ describe "after Rails initialization" do
   end
 end
 
-describe "JSRoutes thread safety" do
+describe "JSRoutes thread safety", :slow do
   before do
     begin
       Rails.application.initialize!