js-routes 1.3.3 → 1.4.0

data/spec/js_routes/rails_routes_compatibility_spec.rb

@@ -7,11 +7,11 @@ describe JsRoutes, "compatibility with Rails"  do
   end
 
   it "should generate collection routing" do
-    expect(evaljs("Routes.inboxes_path()")).to eq(routes.inboxes_path())
+    expect(evaljs("Routes.inboxes_path()")).to eq(test_routes.inboxes_path())
   end
 
   it "should generate member routing" do
-    expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1))
+    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
@@ -26,63 +26,63 @@ describe JsRoutes, "compatibility with Rails"  do
   end
 
   it "should support 0 as a member parameter" do
-    expect(evaljs("Routes.inbox_path(0)")).to eq(routes.inbox_path(0))
+    expect(evaljs("Routes.inbox_path(0)")).to eq(test_routes.inbox_path(0))
   end
 
   it "should generate nested routing with one parameter" do
-    expect(evaljs("Routes.inbox_messages_path(1)")).to eq(routes.inbox_messages_path(1))
+    expect(evaljs("Routes.inbox_messages_path(1)")).to eq(test_routes.inbox_messages_path(1))
   end
 
   it "should generate nested routing" do
-    expect(evaljs("Routes.inbox_message_path(1,2)")).to eq(routes.inbox_message_path(1, 2))
+    expect(evaljs("Routes.inbox_message_path(1,2)")).to eq(test_routes.inbox_message_path(1, 2))
   end
 
   it "should generate routing with format" do
-    expect(evaljs("Routes.inbox_path(1, {format: 'json'})")).to eq(routes.inbox_path(1, :format => "json"))
+    expect(evaljs("Routes.inbox_path(1, {format: 'json'})")).to eq(test_routes.inbox_path(1, :format => "json"))
   end
 
   it "should support routes with reserved javascript words as parameters" do
-    expect(evaljs("Routes.object_path(1, 2)")).to eq(routes.object_path(1,2))
+    expect(evaljs("Routes.object_path(1, 2)")).to eq(test_routes.object_path(1,2))
   end
 
   it "should support routes with trailing_slash" do
-    expect(evaljs("Routes.inbox_path(1, {trailing_slash: true})")).to eq(routes.inbox_path(1, trailing_slash: true))
+    expect(evaljs("Routes.inbox_path(1, {trailing_slash: true})")).to eq(test_routes.inbox_path(1, trailing_slash: true))
   end
 
   it "should support url anchor given as parameter" do
-    expect(evaljs("Routes.inbox_path(1, {anchor: 'hello'})")).to eq(routes.inbox_path(1, :anchor => "hello"))
+    expect(evaljs("Routes.inbox_path(1, {anchor: 'hello'})")).to eq(test_routes.inbox_path(1, :anchor => "hello"))
   end
 
   it "should support url anchor and get parameters" do
-    expect(evaljs("Routes.inbox_path(1, {expanded: true, anchor: 'hello'})")).to eq(routes.inbox_path(1, :expanded => true, :anchor => "hello"))
+    expect(evaljs("Routes.inbox_path(1, {expanded: true, anchor: 'hello'})")).to eq(test_routes.inbox_path(1, :expanded => true, :anchor => "hello"))
   end
 
   it "should use irregular ActiveSupport pluralizations" do
-    expect(evaljs("Routes.budgies_path()")).to eq(routes.budgies_path)
-    expect(evaljs("Routes.budgie_path(1)")).to eq(routes.budgie_path(1))
+    expect(evaljs("Routes.budgies_path()")).to eq(test_routes.budgies_path)
+    expect(evaljs("Routes.budgie_path(1)")).to eq(test_routes.budgie_path(1))
     expect(evaljs("Routes.budgy_path")).to eq(nil)
-    expect(evaljs("Routes.budgie_descendents_path(1)")).to eq(routes.budgie_descendents_path(1))
+    expect(evaljs("Routes.budgie_descendents_path(1)")).to eq(test_routes.budgie_descendents_path(1))
   end
 
   describe "when route has defaults" do
     it "should support route default format" do
-      expect(evaljs("Routes.api_purchases_path()")).to eq(routes.api_purchases_path)
+      expect(evaljs("Routes.api_purchases_path()")).to eq(test_routes.api_purchases_path)
     end
 
     it 'should support route default subdomain' do
-      expect(evaljs("Routes.backend_root_path()")).to eq(routes.backend_root_path)
+      expect(evaljs("Routes.backend_root_path()")).to eq(test_routes.backend_root_path)
     end
 
     it "should support default format override" do
-      expect(evaljs("Routes.api_purchases_path({format: 'xml'})")).to eq(routes.api_purchases_path(format: 'xml'))
+      expect(evaljs("Routes.api_purchases_path({format: 'xml'})")).to eq(test_routes.api_purchases_path(format: 'xml'))
     end
 
     it "should support default format override by passing it in args" do
-      expect(evaljs("Routes.api_purchases_path('xml')")).to eq(routes.api_purchases_path('xml'))
+      expect(evaljs("Routes.api_purchases_path('xml')")).to eq(test_routes.api_purchases_path('xml'))
     end
 
     it "doesn't apply defaults to path" do
-      expect(evaljs("Routes.with_defaults_path()")).to eq(routes.with_defaults_path)
+      expect(evaljs("Routes.with_defaults_path()")).to eq(test_routes.with_defaults_path)
     end
   end
 
@@ -92,7 +92,7 @@ describe JsRoutes, "compatibility with Rails"  do
     end
 
     it "should support root route" do
-      expect(evaljs("Routes.blog_app_path()")).to eq(routes.blog_app_path())
+      expect(evaljs("Routes.blog_app_path()")).to eq(test_routes.blog_app_path())
     end
 
     it "should support route with parameters" do
@@ -102,47 +102,47 @@ describe JsRoutes, "compatibility with Rails"  do
       expect(evaljs("Routes.blog_app_root_path()")).to eq(blog_routes.root_path)
     end
     it "should support single route mapping" do
-      expect(evaljs("Routes.support_path({page: 3})")).to eq(routes.support_path(:page => 3))
+      expect(evaljs("Routes.support_path({page: 3})")).to eq(test_routes.support_path(:page => 3))
     end
   end
 
   it "shouldn't require the format" do
-    expect(evaljs("Routes.json_only_path({format: 'json'})")).to eq(routes.json_only_path(:format => 'json'))
+    expect(evaljs("Routes.json_only_path({format: 'json'})")).to eq(test_routes.json_only_path(:format => 'json'))
   end
 
   it "should serialize object with empty string value" do
-    expect(evaljs("Routes.inboxes_path({a: '', b: 1})")).to eq(routes.inboxes_path(:a => '', :b => 1))
+    expect(evaljs("Routes.inboxes_path({a: '', b: 1})")).to eq(test_routes.inboxes_path(:a => '', :b => 1))
   end
 
   it "should support utf-8 route" do
-    expect(evaljs("Routes.hello_path()")).to eq(routes.hello_path)
+    expect(evaljs("Routes.hello_path()")).to eq(test_routes.hello_path)
   end
 
   it "should support root_path" do
-    expect(evaljs("Routes.root_path()")).to eq(routes.root_path)
+    expect(evaljs("Routes.root_path()")).to eq(test_routes.root_path)
   end
 
   describe "get paramters" do
     it "should support simple get parameters" do
-      expect(evaljs("Routes.inbox_path(1, {format: 'json', lang: 'ua', q: 'hello'})")).to eq(routes.inbox_path(1, :lang => "ua", :q => "hello", :format => "json"))
+      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
 
     it "should support array get parameters" do
-      expect(evaljs("Routes.inbox_path(1, {hello: ['world', 'mars']})")).to eq(routes.inbox_path(1, :hello => [:world, :mars]))
+      expect(evaljs("Routes.inbox_path(1, {hello: ['world', 'mars']})")).to eq(test_routes.inbox_path(1, :hello => [:world, :mars]))
     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(
-        routes.inbox_path(1, :env => 'test', :search => {:category_ids => [2,5], :q => "hello"}, :format => "json")
+        test_routes.inbox_path(1, :env => 'test', :search => {:category_ids => [2,5], :q => "hello"}, :format => "json")
       )
     end
 
     it "should support null and undefined parameters" do
-      expect(evaljs("Routes.inboxes_path({uri: null, key: undefined})")).to eq(routes.inboxes_path(:uri => nil, :key => nil))
+      expect(evaljs("Routes.inboxes_path({uri: null, key: undefined})")).to eq(test_routes.inboxes_path(:uri => nil, :key => nil))
     end
 
     it "should escape get parameters" do
-      expect(evaljs("Routes.inboxes_path({uri: 'http://example.com'})")).to eq(routes.inboxes_path(:uri => 'http://example.com'))
+      expect(evaljs("Routes.inboxes_path({uri: 'http://example.com'})")).to eq(test_routes.inboxes_path(:uri => 'http://example.com'))
     end
 
   end
@@ -150,61 +150,61 @@ describe JsRoutes, "compatibility with Rails"  do
 
   context "routes globbing" do
     it "should be supported as parameters" do
-      expect(evaljs("Routes.book_path('thrillers', 1)")).to eq(routes.book_path('thrillers', 1))
+      expect(evaljs("Routes.book_path('thrillers', 1)")).to eq(test_routes.book_path('thrillers', 1))
     end
 
     it "should support routes globbing as array" do
-      expect(evaljs("Routes.book_path(['thrillers'], 1)")).to eq(routes.book_path(['thrillers'], 1))
+      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
-      expect(evaljs("Routes.book_path([1, 2, 3], 1)")).to eq(routes.book_path([1, 2, 3], 1))
+      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
-      expect(evaljs("Routes.book_path('a_test/b_test/c_test', 1)")).to eq(routes.book_path('a_test/b_test/c_test', 1))
+      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 array with optional params" do
-      expect(evaljs("Routes.book_path([1, 2, 3, 5], 1, {c: '1'})")).to eq(routes.book_path([1, 2, 3, 5], 1, { :c => "1" }))
+      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
 
     it "should support routes globbing in book_title route as array" do
-      expect(evaljs("Routes.book_title_path('john', ['thrillers', 'comedian'])")).to eq(routes.book_title_path('john', ['thrillers', 'comedian']))
+      expect(evaljs("Routes.book_title_path('john', ['thrillers', 'comedian'])")).to eq(test_routes.book_title_path('john', ['thrillers', 'comedian']))
     end
 
     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(routes.book_title_path('john', ['thrillers', 'comedian'], {:some_key => 'some_value'}))
+      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(routes.search_path(:q => 'hello'))
+      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(routes.inboxes_path(:hello => {:world => nil}))
+      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
     context "including not optional parts" do
       it "should include everything that is not optional" do
-        expect(evaljs("Routes.foo_path()")).to eq(routes.foo_path)
+        expect(evaljs("Routes.foo_path()")).to eq(test_routes.foo_path)
       end
     end
 
     context "but not including them" do
       it "should not include the optional parts" do
-        expect(evaljs("Routes.things_path()")).to eq(routes.things_path)
-        expect(evaljs("Routes.things_path({ q: 'hello' })")).to eq(routes.things_path(q: 'hello'))
+        expect(evaljs("Routes.things_path()")).to eq(test_routes.things_path)
+        expect(evaljs("Routes.things_path({ q: 'hello' })")).to eq(test_routes.things_path(q: 'hello'))
       end
 
       it "should not require the optional parts as arguments" do
-        expect(evaljs("Routes.thing_path(null, 5)")).to eq(routes.thing_path(nil, 5))
+        expect(evaljs("Routes.thing_path(null, 5)")).to eq(test_routes.thing_path(nil, 5))
       end
 
       it "should treat undefined as non-given optional part" do
-        expect(evaljs("Routes.thing_path(5, {optional_id: undefined})")).to eq(routes.thing_path(5, :optional_id => nil))
+        expect(evaljs("Routes.thing_path(5, {optional_id: undefined})")).to eq(test_routes.thing_path(5, :optional_id => nil))
       end
 
       it "should raise error when passing non-full list of arguments and some query params" do
@@ -213,16 +213,16 @@ describe JsRoutes, "compatibility with Rails"  do
       end
 
       it "should treat null as non-given optional part" do
-        expect(evaljs("Routes.thing_path(5, {optional_id: null})")).to eq(routes.thing_path(5, :optional_id => nil))
+        expect(evaljs("Routes.thing_path(5, {optional_id: null})")).to eq(test_routes.thing_path(5, :optional_id => nil))
       end
 
       it "should work when passing required params in options" do
-        expect(evaljs("Routes.thing_deep_path({second_required: 1, third_required: 2})")).to eq(routes.thing_deep_path(second_required: 1, third_required: 2))
+        expect(evaljs("Routes.thing_deep_path({second_required: 1, third_required: 2})")).to eq(test_routes.thing_deep_path(second_required: 1, third_required: 2))
       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(routes.thing_deep_path(1, 2))
+        expect(evaljs("Routes.thing_deep_path(1, 2)")).to eq(test_routes.thing_deep_path(1, 2))
       end
     end
 
@@ -237,29 +237,29 @@ describe JsRoutes, "compatibility with Rails"  do
       end
 
       it "should include the optional parts" do
-        expect(evaljs("Routes.things_path({optional_id: 5})")).to eq(routes.things_path(:optional_id => 5))
-        expect(evaljs("Routes.things_path(5)")).to eq(routes.things_path(5))
-        expect(evaljs("Routes.thing_deep_path(1, { third_required: 3, second_required: 2 })")).to eq(routes.thing_deep_path(1, third_required: 3, second_required: 2))
-        expect(evaljs("Routes.thing_deep_path(1, { third_required: 3, second_required: 2, forth_optional: 4 })")).to eq(routes.thing_deep_path(1, third_required: 3, second_required: 2, forth_optional: 4))
-        expect(evaljs("Routes.thing_deep_path(2, { third_required: 3, first_optional: 1 })")).to eq(routes.thing_deep_path(2, third_required: 3, first_optional: 1))
-        expect(evaljs("Routes.thing_deep_path(3, { first_optional: 1, second_required: 2 })")).to eq(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(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(routes.thing_deep_path(4, first_optional: 1, second_required: 2, third_required: 3))
-        expect(evaljs("Routes.thing_deep_path(1, 2, { third_required: 3 })")).to eq(routes.thing_deep_path(1, 2, third_required: 3))
-        expect(evaljs("Routes.thing_deep_path(1,2, {third_required: 3, q: 'bogdan'})")).to eq(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(routes.thing_deep_path(1, 2, forth_optional: 4, third_required: 3))
-        expect(evaljs("Routes.thing_deep_path(1, 3, { second_required: 2 })")).to eq(routes.thing_deep_path(1, 3, second_required: 2))
-        expect(evaljs("Routes.thing_deep_path(1, 4, { second_required: 2, third_required: 3 })")).to eq(routes.thing_deep_path(1, 4, second_required: 2, third_required: 3))
-        expect(evaljs("Routes.thing_deep_path(2, 3, { first_optional: 1 })")).to eq(routes.thing_deep_path(2, 3, first_optional: 1))
-        expect(evaljs("Routes.thing_deep_path(2, 3, { first_optional: 1, forth_optional: 4 })")).to eq(routes.thing_deep_path(2, 3, first_optional: 1, forth_optional: 4))
-        expect(evaljs("Routes.thing_deep_path(2, 4, { first_optional: 1, third_required: 3 })")).to eq(routes.thing_deep_path(2, 4, first_optional: 1, third_required: 3))
-        expect(evaljs("Routes.thing_deep_path(3, 4, { first_optional: 1, second_required: 2 })")).to eq(routes.thing_deep_path(3, 4, first_optional: 1, second_required: 2))
-        expect(evaljs("Routes.thing_deep_path(1, 2, 3)")).to eq(routes.thing_deep_path(1, 2, 3))
-        expect(evaljs("Routes.thing_deep_path(1, 2, 3, { forth_optional: 4 })")).to eq(routes.thing_deep_path(1, 2, 3, forth_optional: 4))
-        expect(evaljs("Routes.thing_deep_path(1, 2, 4, { third_required: 3 })")).to eq(routes.thing_deep_path(1, 2, 4, third_required: 3))
-        expect(evaljs("Routes.thing_deep_path(1, 3, 4, { second_required: 2 })")).to eq(routes.thing_deep_path(1, 3, 4, second_required: 2))
-        expect(evaljs("Routes.thing_deep_path(2, 3, 4, { first_optional: 1 })")).to eq(routes.thing_deep_path(2, 3, 4, first_optional: 1))
-        expect(evaljs("Routes.thing_deep_path(1, 2, 3, 4)")).to eq(routes.thing_deep_path(1, 2, 3, 4))
+        expect(evaljs("Routes.things_path({optional_id: 5})")).to eq(test_routes.things_path(:optional_id => 5))
+        expect(evaljs("Routes.things_path(5)")).to eq(test_routes.things_path(5))
+        expect(evaljs("Routes.thing_deep_path(1, { third_required: 3, second_required: 2 })")).to eq(test_routes.thing_deep_path(1, third_required: 3, second_required: 2))
+        expect(evaljs("Routes.thing_deep_path(1, { third_required: 3, second_required: 2, forth_optional: 4 })")).to eq(test_routes.thing_deep_path(1, third_required: 3, second_required: 2, forth_optional: 4))
+        expect(evaljs("Routes.thing_deep_path(2, { third_required: 3, first_optional: 1 })")).to eq(test_routes.thing_deep_path(2, third_required: 3, first_optional: 1))
+        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(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))
+        expect(evaljs("Routes.thing_deep_path(1, 3, { second_required: 2 })")).to eq(test_routes.thing_deep_path(1, 3, second_required: 2))
+        expect(evaljs("Routes.thing_deep_path(1, 4, { second_required: 2, third_required: 3 })")).to eq(test_routes.thing_deep_path(1, 4, second_required: 2, third_required: 3))
+        expect(evaljs("Routes.thing_deep_path(2, 3, { first_optional: 1 })")).to eq(test_routes.thing_deep_path(2, 3, first_optional: 1))
+        expect(evaljs("Routes.thing_deep_path(2, 3, { first_optional: 1, forth_optional: 4 })")).to eq(test_routes.thing_deep_path(2, 3, first_optional: 1, forth_optional: 4))
+        expect(evaljs("Routes.thing_deep_path(2, 4, { first_optional: 1, third_required: 3 })")).to eq(test_routes.thing_deep_path(2, 4, first_optional: 1, third_required: 3))
+        expect(evaljs("Routes.thing_deep_path(3, 4, { first_optional: 1, second_required: 2 })")).to eq(test_routes.thing_deep_path(3, 4, first_optional: 1, second_required: 2))
+        expect(evaljs("Routes.thing_deep_path(1, 2, 3)")).to eq(test_routes.thing_deep_path(1, 2, 3))
+        expect(evaljs("Routes.thing_deep_path(1, 2, 3, { forth_optional: 4 })")).to eq(test_routes.thing_deep_path(1, 2, 3, forth_optional: 4))
+        expect(evaljs("Routes.thing_deep_path(1, 2, 4, { third_required: 3 })")).to eq(test_routes.thing_deep_path(1, 2, 4, third_required: 3))
+        expect(evaljs("Routes.thing_deep_path(1, 3, 4, { second_required: 2 })")).to eq(test_routes.thing_deep_path(1, 3, 4, second_required: 2))
+        expect(evaljs("Routes.thing_deep_path(2, 3, 4, { first_optional: 1 })")).to eq(test_routes.thing_deep_path(2, 3, 4, first_optional: 1))
+        expect(evaljs("Routes.thing_deep_path(1, 2, 3, 4)")).to eq(test_routes.thing_deep_path(1, 2, 3, 4))
 
       end
 
@@ -267,7 +267,7 @@ describe JsRoutes, "compatibility with Rails"  do
         if Rails.version <= "5.0.0"
           # this type of routing is deprecated
           it "should include everything that is not optional" do
-            expect(evaljs("Routes.classic_path({controller: 'classic', action: 'edit'})")).to eq(routes.classic_path(controller: :classic, action: :edit))
+            expect(evaljs("Routes.classic_path({controller: 'classic', action: 'edit'})")).to eq(test_routes.classic_path(controller: :classic, action: :edit))
           end
         end
       end
@@ -311,7 +311,7 @@ describe JsRoutes, "compatibility with Rails"  do
       evaljs("Array.prototype.indexOf = null")
     end
     it "should still work correctly" do
-      expect(evaljs("Routes.inboxes_path()")).to eq(routes.inboxes_path())
+      expect(evaljs("Routes.inboxes_path()")).to eq(test_routes.inboxes_path())
     end
   end
 
@@ -321,63 +321,63 @@ describe JsRoutes, "compatibility with Rails"  do
     let(:inbox) { klass.new(1,"my") }
 
     it "should support 0 as a to_param option" do
-      expect(evaljs("Routes.inbox_path({to_param: 0})")).to eq(routes.inbox_path(0))
+      expect(evaljs("Routes.inbox_path({to_param: 0})")).to eq(test_routes.inbox_path(0))
     end
 
     it "should check for options special key" do
-      expect(evaljs("Routes.inbox_path({id: 7, q: 'hello', _options: true})")).to eq(routes.inbox_path(id: 7, q: 'hello'))
+      expect(evaljs("Routes.inbox_path({id: 7, q: 'hello', _options: true})")).to eq(test_routes.inbox_path(id: 7, q: 'hello'))
       expect {
         evaljs("Routes.inbox_path({to_param: 7, _options: true})")
       }.to raise_error(js_error_class)
-      expect(evaljs("Routes.inbox_message_path(5, {id: 7, q: 'hello', _options: true})")).to eq(routes.inbox_message_path(5, id: 7, q: 'hello'))
+      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(routes.inbox_path(0))
+      expect(evaljs("Routes.inbox_path({id: 0})")).to eq(test_routes.inbox_path(0))
     end
 
     it "should use id property of the object in path" do
-      expect(evaljs("Routes.inbox_path({id: 1})")).to eq(routes.inbox_path(1))
+      expect(evaljs("Routes.inbox_path({id: 1})")).to eq(test_routes.inbox_path(1))
     end
 
     it "should prefer to_param property over id property" do
-      expect(evaljs("Routes.inbox_path({id: 1, to_param: 'my'})")).to eq(routes.inbox_path(inbox))
+      expect(evaljs("Routes.inbox_path({id: 1, to_param: 'my'})")).to eq(test_routes.inbox_path(inbox))
     end
 
     it "should call to_param if it is a function" do
-      expect(evaljs("Routes.inbox_path({id: 1, to_param: function(){ return 'my';}})")).to eq(routes.inbox_path(inbox))
+      expect(evaljs("Routes.inbox_path({id: 1, to_param: function(){ return 'my';}})")).to eq(test_routes.inbox_path(inbox))
     end
 
     it "should call id if it is a function" do
-      expect(evaljs("Routes.inbox_path({id: function() { return 1;}})")).to eq(routes.inbox_path(1))
+      expect(evaljs("Routes.inbox_path({id: function() { return 1;}})")).to eq(test_routes.inbox_path(1))
     end
 
     it "should support options argument" do
       expect(evaljs(
         "Routes.inbox_message_path({id:1, to_param: 'my'}, {id:2}, {custom: true, format: 'json'})"
-      )).to eq(routes.inbox_message_path(inbox, 2, :custom => true, :format => "json"))
+      )).to eq(test_routes.inbox_message_path(inbox, 2, :custom => true, :format => "json"))
     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(routes.book_path(inbox, 1))
+        expect(evaljs("Routes.book_path({id: 1, to_param: 'my'}, 1)")).to eq(test_routes.book_path(inbox, 1))
       end
 
       it "should call to_param if it is a function" do
-        expect(evaljs("Routes.book_path({id: 1, to_param: function(){ return 'my';}}, 1)")).to eq(routes.book_path(inbox, 1))
+        expect(evaljs("Routes.book_path({id: 1, to_param: function(){ return 'my';}}, 1)")).to eq(test_routes.book_path(inbox, 1))
       end
 
       it "should call id if it is a function" do
-        expect(evaljs("Routes.book_path({id: function() { return 'technical';}}, 1)")).to eq(routes.book_path('technical', 1))
+        expect(evaljs("Routes.book_path({id: function() { return 'technical';}}, 1)")).to eq(test_routes.book_path('technical', 1))
       end
 
       it "should support options argument" do
         expect(evaljs(
           "Routes.book_path({id:1, to_param: 'my'}, {id:2}, {custom: true, format: 'json'})"
-        )).to eq(routes.book_path(inbox, 2, :custom => true, :format => "json"))
+        )).to eq(test_routes.book_path(inbox, 2, :custom => true, :format => "json"))
       end
     end
   end

data/spec/js_routes/zzz_last_post_rails_init_spec.rb

@@ -78,7 +78,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(/root\.Routes/)
+              expect(evaluate(ctx, 'js-routes.js')).to match(/routes = /)
             end
           end
           context "and not initialize on precompile" do
@@ -89,7 +89,7 @@ describe "after Rails initialization" 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(/root\.Routes/)
+                expect(evaluate(ctx, 'js-routes.js')).to match(/routes = /)
               end
             end
           end

data/spec/spec_helper.rb

@@ -34,8 +34,8 @@ def evaljs(string, force = false)
   jscontext(force).eval(string)
 end
 
-def routes
-  App.routes.url_helpers
+def test_routes
+  ::App.routes.url_helpers
 end
 
 def blog_routes
@@ -55,7 +55,7 @@ module BlogEngine
 end
 
 
-class App < Rails::Application
+class ::App < Rails::Application
   # Enable the asset pipeline
   config.assets.enabled = true
   # initialize_on_precompile

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js-routes
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.4.0
 platform: ruby
 authors:
 - Bogdan Gusiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-28 00:00:00.000000000 Z
+date: 2017-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: 0.12.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: 0.12.3
 description: Generates javascript file that defines all Rails named routes as javascript
   helpers
 email: agresso@gmail.com
@@ -202,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Brings Rails named routes to javascript