js-routes 0.9.9 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11383682f9433b305670ebe17feb5ac27ccb7626
-  data.tar.gz: 422793010efafcc0e4a205c0e3d04f5bdcfdf533
+  metadata.gz: 82dc4e938c01969d6fa291afba76adbdc12106ce
+  data.tar.gz: ccab6107d6e2a86ab1529a2fa4ce06e4af50c820
 SHA512:
-  metadata.gz: e75c78237118f839aedad8697e13c4f4364eec313c9ab6c84993f12bdfd98a08e8aae1914aa17f0318cd0130c9a763c3d145795a74b15df4ea55fd9fe6875c65
-  data.tar.gz: badb9598727f1b815a5b3ca7b4e746b723c6321de85e0233ee647d13052d929cc3a7663615d89e77a2e75df22417545872ad1c30b68315170a901f219a7310e8
+  metadata.gz: 027362db5b8c3f3848cdea09fa9095364a3307e9f492ca5d871d9174e676e05492d5149818f76df989b53e15499465287c93644fa19b0b55117da8b1ed0db0b8
+  data.tar.gz: bbe7ac6a521322201322a01dcb847dcee803f8524dd1f190c17e5c99fe24fb5a6b57d27dd66644ff0b5be4c4fbc733dc69853d619cda8c975e7269f182daddcb

data/.travis.yml

@@ -1,22 +1,33 @@
 language: ruby
+cache: bundler
+
 rvm:
   - 1.9.3
-  - 2.0.0
-  - 2.1.2
+  - 2.0
+  - 2.1
+  - 2.2
   - jruby-19mode
   - ruby-head
   - jruby-head
+
 gemfile:
   - gemfiles/rails32.gemfile
   - gemfiles/rails40.gemfile
   - gemfiles/rails41.gemfile
+  - gemfiles/rails42.gemfile
+
+sudo: false
+
 notifications:
   email:
     - agresso@gmail.com
+
 branches:
   only:
     - master
+
 matrix:
   allow_failures:
+    - rvm: jruby-19mode
     - rvm: ruby-head
     - rvm: jruby-head

data/Appraisals

@@ -5,10 +5,12 @@ end
 
 appraise "rails40" do
   gem "railties", "~> 4.0.5"
-  gem "minitest", "~> 4.0"
 end
 
 appraise "rails41" do
   gem "railties", "~> 4.1.1"
-  gem "minitest", ">= 4.0"
+end
+
+appraise "rails42" do
+  gem "railties", "~> 4.2.0"
 end

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## master
 
+ * Add the compact mode [#125](https://github.com/railsware/js-routes/pull/125)
+ * Add support for host, protocol, and port configuration [#137](https://github.com/railsware/js-routes/pull/137)
+ * Routes path specs [#135](https://github.com/railsware/js-routes/pull/135)
+ * Support Rails 4.2 and Ruby 2.2 [#140](https://github.com/railsware/js-routes/pull/140)
+
+## v0.9.9
+
+* Bugfix Rails Engine subapplication route generation when they are nested [#120](https://github.com/railsware/js-routes/pull/120)
+
 ## v0.9.8
 
 * Support AMD/Require.js [#111](https://github.com/railsware/js-routes/pull/111)
@@ -11,4 +20,4 @@
 * Fix typeof error for IE [#95](https://github.com/railsware/js-routes/pull/95)
 * Fix testing on ruby-head [#92](https://github.com/railsware/js-routes/pull/92)
 * Correct thread safety issue in js-routes generation [#90](https://github.com/railsware/js-routes/pull/90)
-* Use the `of` operator to detect for `to_param` and `id` in objects [#87](https://github.com/railsware/js-routes/pull/87)
+* Use the `of` operator to detect for `to_param` and `id` in objects [#87](https://github.com/railsware/js-routes/pull/87)

data/Readme.md

@@ -1,5 +1,5 @@
 # JsRoutes
-[![Build Status](https://travis-ci.org/railsware/js-routes.png)](https://travis-ci.org/railsware/js-routes)
+[![Build Status](https://travis-ci.org/railsware/js-routes.svg?branch=master)](https://travis-ci.org/railsware/js-routes)
 
 Generates javascript file that defines all Rails named routes as javascript helpers
 
@@ -43,9 +43,10 @@ end
 
 Available options:
 
-* `default_url_options` - default parameters to be used to generate url
-  * Note that currently only optional parameters (like `:format` or `:trailing_slash`) can be defaulted.
-  * Example: {:format => "json", :trailing_slash => true}
+* `default_url_options` - default parameters used when generating URLs
+  * Note that only specific options are supported at this time.
+  * Supported options: `:format`, `:trailing_slash`, `:protocol`, `:host`, `:port`
+  * Example: {:format => "json", :trailing_slash => true, :protocol => "https", :host => "example.com", :port => 3000}
   * Default: {}
 * `exclude` - Array of regexps to exclude from js routes.
   * Default: []
@@ -61,9 +62,13 @@ Available options:
   * Default: blank
 * `camel_case` (version >= 0.8.8) - Generate camel case route names.
   * Default: false
-* `url_links` (version >= 0.8.9) - Generate `*_url` links (in addition to default `*_path`), where url_links value is beginning of url routes
-  * Example: http[s]://example.com
+* `url_links` (version >= 0.8.9) - Generate `*_url` helpers (in addition to the default `*_path` helpers).
+  * Example: true
   * Default: false
+  * Be sure to specify a default host in `default_url_options`. Routes which specify a specific host, protocol, or port will be used instead of their corresponding default.
+* `compact` (version > 0.9.9) - Remove `_path` suffix in path routes(`*_url` routes stay untouched if they were enabled)
+  * Default: false
+  * Sample route call when option is set to true: Routes.users() => `/users`
 
 ### Very Advanced Setup
 
@@ -129,6 +134,29 @@ In order to make routes helpers available globally:
 jQuery.extend(window, Routes)
 ```
 
+## Get spec of routes and required params
+
+Possible to get `spec` of route by function `toString`:
+
+```js
+Routes.users_path.toString() // => "/users(.:format)"
+Routes.user_path.toString() // => "/users/:id(.:format)"
+```
+
+This function allow to get the same `spec` for route, if you will get string representation of the route function:
+
+```js
+'' + Routes.users_path // => "/users(.:format)", a string representation of the object
+'' + Routes.user_path // => "/users/:id(.:format)"
+```
+
+Route function also contain inside attribute `required_params` required param names as array:
+
+```js
+Routes.users_path.required_params // => []
+Routes.user_path.required_params // => ['id']
+```
+
 ## What about security?
 
 js-routes itself do not have security holes. It makes URLs
@@ -145,7 +173,7 @@ Spork.trap_method(JsRoutes, :generate!)
 
 ## JS-Routes and heroku
 
-Heroku environment has a specific problems with setup. It is impossible to use asset pipeline in this environtment. You should use "Very Advanced Setup" schema in this case. 
+Heroku environment has a specific problems with setup. It is impossible to use asset pipeline in this environment. You should use "Very Advanced Setup" schema in this case.
 
 For example create routes.js.erb in assets folder with needed content:
 

data/gemfiles/rails32.gemfile

@@ -5,4 +5,4 @@ source "http://rubygems.org"
 gem "railties", "~> 3.2.18"
 gem "tzinfo"
 
-gemspec :path=>"../"
+gemspec :path => "../"

data/gemfiles/rails40.gemfile

@@ -3,6 +3,5 @@
 source "http://rubygems.org"
 
 gem "railties", "~> 4.0.5"
-gem "minitest", "~> 4.0"
 
-gemspec :path=>"../"
+gemspec :path => "../"

data/gemfiles/rails41.gemfile

@@ -3,6 +3,5 @@
 source "http://rubygems.org"
 
 gem "railties", "~> 4.1.1"
-gem "minitest", ">= 4.0"
 
-gemspec :path=>"../"
+gemspec :path => "../"

data/gemfiles/rails42.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "railties", "~> 4.2.0"
+
+gemspec :path => "../"

data/js-routes.gemspec

@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/railsware/js-routes}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.0}
   s.summary = %q{Brings Rails named routes to javascript}
 
   s.add_runtime_dependency(%q<railties>, [">= 3.2"])
@@ -29,10 +28,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<guard-coffeescript>, [">= 0"])
   s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
   if defined?(JRUBY_VERSION)
-    s.add_development_dependency(%q<therubyrhino>, [">= 0"])
+    s.add_development_dependency(%q<therubyrhino>, [">= 2.0.4"])
   else
-    s.add_development_dependency(%q<debugger>, [">= 0"]) if RUBY_VERSION =~ /\A2\.0/
-    s.add_development_dependency(%q<therubyracer>, [">= 0"])
+    s.add_development_dependency(%q<therubyracer>, [">= 0.12.1"])
   end
 end
 

data/lib/js_routes.rb

@@ -18,7 +18,8 @@ class JsRoutes
     prefix: nil,
     url_links: nil,
     camel_case: false,
-    default_url_options: {}
+    default_url_options: {},
+    compact: false
   }
 
   NODE_TYPES = {
@@ -124,8 +125,9 @@ class JsRoutes
 
   def js_routes
     js_routes = Rails.application.routes.named_routes.routes.sort_by(&:to_s).map do |_, route|
-      if route.app.respond_to?(:superclass) && route.app.superclass == Rails::Engine && !route.path.anchored
-        route.app.routes.named_routes.map do |_, engine_route|
+      rails_engine_app = get_app_from_route(route)
+      if rails_engine_app.respond_to?(:superclass) && rails_engine_app.superclass == Rails::Engine && !route.path.anchored
+        rails_engine_app.routes.named_routes.map do |_, engine_route|
           build_route_if_match(engine_route, route)
         end
       else
@@ -136,6 +138,15 @@ class JsRoutes
     "{\n" + js_routes.join(",\n") + "}\n"
   end
 
+  def get_app_from_route(route)
+    # rails engine in Rails 4.2 use additional ActionDispatch::Routing::Mapper::Constraints, which contain app
+    if route.app.respond_to?(:app) && route.app.respond_to?(:constraints)
+      route.app.app
+    else
+      route.app
+    end
+  end
+
   def build_route_if_match(route, parent_route=nil)
     if any_match?(route, parent_route, @options[:exclude]) || !any_match?(route, parent_route, @options[:include])
       nil
@@ -154,28 +165,47 @@ class JsRoutes
     parent_spec = parent_route.try(:path).try(:spec)
     required_parts, optional_parts = route.required_parts.clone, route.optional_parts.clone
     optional_parts.push(required_parts.delete :format) if required_parts.include?(:format)
-    route_name = generate_route_name(name)
-    url_link = generate_url_link(name, route_name, required_parts)
+    route_name = generate_route_name(name, (:path unless @options[:compact]))
+    url_link = generate_url_link(name, route_name, required_parts, route)
     _ = <<-JS.strip!
   // #{name.join('.')} => #{parent_spec}#{route.path.spec}
-  #{route_name}: function(#{build_params(required_parts)}) {
-  return Utils.build_path(#{json(required_parts)}, #{json(optional_parts)}, #{json(serialize(route.path.spec, parent_spec))}, arguments);
-  }#{",\n" + url_link if url_link.length > 0}
+  // function(#{[required_parts, LAST_OPTIONS_KEY].flatten.join(', ')})
+  #{route_name}: Utils.route(#{json(required_parts)}, #{json(optional_parts)}, #{json(serialize(route.path.spec, parent_spec))}, arguments)#{",\n" + url_link if url_link.length > 0}
   JS
   end
 
-  def generate_url_link(name, route_name, required_parts)
+  def generate_url_link(name, route_name, required_parts, route)
     return "" unless @options[:url_links]
-    raise "invalid URL format in url_links (ex: http[s]://example.com)" if @options[:url_links].match(URI::regexp(%w(http https))).nil?
     _ = <<-JS.strip!
-    #{generate_route_name(name, true)}: function(#{build_params(required_parts)}) {
-    return "" + #{@options[:url_links].inspect} + this.#{route_name}(#{build_params(required_parts)});
+    #{generate_route_name(name, :url)}: function(#{build_params(required_parts)}) {
+    return #{generate_base_url_js(route)} + this.#{route_name}(#{build_params(required_parts)});
     }
     JS
   end
 
-  def generate_route_name(name, is_url = false)
-    route_name = "#{name.join('_')}_#{is_url ? "url" : "path"}"
+  def generate_base_url_js(route)
+    # preserve and deprecate previous behavior
+    unless @options[:url_links] == true
+      ActiveSupport::Deprecation.warn('js-routes url_links config value must be a boolean. Use default_url_options for specifying a default host.')
+      raise "invalid URL format in url_links (ex: http[s]://example.com)" if @options[:url_links].match(URI::Parser.new.make_regexp(%w(http https))).nil?
+      return "#{@options[:url_links].inspect}"
+    else
+      protocol = route.defaults[:protocol] || @options[:default_url_options][:protocol] || 'http'
+      hostname = route.defaults[:host] || @options[:default_url_options][:host]
+      port = route.defaults[:port] || (@options[:default_url_options][:port] unless route.defaults[:host])
+      port = ":#{port}" if port
+
+      unless hostname
+        raise "A :default_url_options[:host] must be configured in order to generate *_url helpers"
+      end
+
+      return %Q|'#{protocol}://#{hostname}#{port}'|
+    end
+  end
+
+  def generate_route_name(name, suffix)
+    route_name = name.join('_')
+    route_name << "_#{ suffix }" if suffix
     @options[:camel_case] ? route_name.camelize(:lower) : route_name
   end
 
@@ -183,7 +213,7 @@ class JsRoutes
     self.class.json(string)
   end
 
-  def build_params required_parts
+  def build_params(required_parts)
     params = required_parts.map do |name|
       # prepending each parameter name with underscore
       # to prevent conflict with JS reserved words

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "0.9.9"
+  VERSION = "1.0.0"
 end

data/lib/routes.js

@@ -233,6 +233,35 @@
           throw new Error("Unknown Rails node type");
       }
     },
+    build_path_spec: function(route, wildcard) {
+      var left, right, type;
+
+      if (wildcard == null) {
+        wildcard = false;
+      }
+      type = route[0], left = route[1], right = route[2];
+      switch (type) {
+        case NodeTypes.GROUP:
+          return "(" + (this.build_path_spec(left)) + ")";
+        case NodeTypes.CAT:
+          return "" + (this.build_path_spec(left)) + (this.build_path_spec(right));
+        case NodeTypes.STAR:
+          return this.build_path_spec(left, true);
+        case NodeTypes.SYMBOL:
+          if (wildcard === true) {
+            return "" + (left[0] === '*' ? '' : '*') + left;
+          } else {
+            return ":" + left;
+          }
+          break;
+        case NodeTypes.SLASH:
+        case NodeTypes.DOT:
+        case NodeTypes.LITERAL:
+          return left;
+        default:
+          throw new Error("Unknown Rails node type");
+      }
+    },
     visit_globbing: function(route, parameters, optional) {
       var left, right, type, value;
 
@@ -263,6 +292,18 @@
       }
       return prefix;
     },
+    route: function(required_parts, optional_parts, route_spec) {
+      var path_fn;
+
+      path_fn = function() {
+        return Utils.build_path(required_parts, optional_parts, route_spec, arguments);
+      };
+      path_fn.required_params = required_parts;
+      path_fn.toString = function() {
+        return Utils.build_path_spec(route_spec);
+      };
+      return path_fn;
+    },
     _classToTypeCache: null,
     _classToType: function() {
       var name, _i, _len, _ref;

data/lib/routes.js.coffee

@@ -167,6 +167,29 @@ Utils =
       else
         throw new Error("Unknown Rails node type")
 
+  #
+  # This method build spec for route
+  #
+  build_path_spec: (route, wildcard=false) ->
+    [type, left, right] = route
+    switch type
+      when NodeTypes.GROUP
+        "(#{@build_path_spec(left)})"
+      when NodeTypes.CAT
+        "#{@build_path_spec(left)}#{@build_path_spec(right)}"
+      when NodeTypes.STAR
+        @build_path_spec(left, true)
+      when NodeTypes.SYMBOL
+        if wildcard is true
+          "#{if left[0] is '*' then '' else '*'}#{left}"
+        else
+          ":#{left}"
+      when NodeTypes.SLASH, NodeTypes.DOT, NodeTypes.LITERAL
+        left
+      # Not sure about this one
+      # when NodeTypes.OR
+      else throw new Error("Unknown Rails node type")
+
   #
   # This method convert value for globbing in right value for rails route
   #
@@ -191,6 +214,15 @@ Utils =
     prefix = (if prefix.match("/$") then prefix else "#{prefix}/") if prefix isnt ""
     prefix
 
+  #
+  # route function: create route path function and add spec to it
+  #
+  route: (required_parts, optional_parts, route_spec) ->
+    path_fn = -> Utils.build_path(required_parts, optional_parts, route_spec, arguments)
+    path_fn.required_params = required_parts
+    path_fn.toString = -> Utils.build_path_spec(route_spec)
+    path_fn
+
   #
   # This is helper method to define object type.
   # The typeof operator is probably the biggest design flaw of JavaScript, simply because it's basically completely broken.

data/spec/js_routes/generated_javascript_spec.rb

@@ -9,14 +9,24 @@ describe JsRoutes do
 
   describe "generated js" do
     subject { JsRoutes.generate }
+    it "should call route function for each route" do
+      is_expected.to include("inboxes_path: Utils.route(")
+    end
     it "should have correct function without arguments signature" do
-      is_expected.to include("inboxes_path: function(options)")
+      is_expected.to include("inboxes_path: Utils.route([]")
     end
     it "should have correct function with arguments signature" do
-      is_expected.to include("inbox_message_path: function(_inbox_id, _id, options)")
+      is_expected.to include("inbox_message_path: Utils.route([\"inbox_id\",\"id\"]")
     end
     it "should have correct function signature with unordered hash" do
-      is_expected.to include("inbox_message_attachment_path: function(_inbox_id, _message_id, _id, options)")
+      is_expected.to include("inbox_message_attachment_path: Utils.route([\"inbox_id\",\"message_id\",\"id\"]")
+    end
+
+    it "should have correct function comment with options argument" do
+      is_expected.to include("// function(options)\n  inboxes_path: Utils.route")
+    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")
     end
 
     it "routes should be sorted in alphabetical order" do
@@ -51,7 +61,7 @@ describe JsRoutes do
   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: function(_inbox_id, _id, options)")
+      is_expected.to include("inbox_message_path: Utils.route([\"inbox_id\",\"id\"]")
     end
   end
 end

data/spec/js_routes/options_spec.rb

@@ -238,40 +238,171 @@ describe JsRoutes, "options" do
       end
     end
 
-    context "with host" do
-      let(:_options) { { :url_links => "http://localhost" } }
-      it "should generate path and url links" do
-        expect(evaljs("Routes.inbox_path")).not_to be_nil
-        expect(evaljs("Routes.inbox_url")).not_to be_nil
-        expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1))
-        expect(evaljs("Routes.inbox_url(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
-        expect(evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })")).to eq("http://localhost#{routes.inbox_path(1, :test_key => "test_val")}")
+    context 'with deprecated, non-boolean config value' do
+      around(:each) do |example|
+        ActiveSupport::Deprecation.silence do
+          example.run
+        end
+      end
+
+      context "with host" do
+        let(:_options) { { :url_links => "http://localhost" } }
+        it "should generate path and url links" do
+          expect(evaljs("Routes.inbox_path")).not_to be_nil
+          expect(evaljs("Routes.inbox_url")).not_to be_nil
+          expect(evaljs("Routes.inbox_path(1)")).to eq(routes.inbox_path(1))
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })")).to eq("http://localhost#{routes.inbox_path(1, :test_key => "test_val")}")
+        end
       end
-    end
 
-    context "with invalid host" do
-      it "should raise error" do
-        expect { JsRoutes.generate({ :url_links => "localhost" }) }.to raise_error RuntimeError
+      context "with invalid host" do
+        it "should raise error" do
+          expect { JsRoutes.generate({ :url_links => "localhost" }) }.to raise_error RuntimeError
+        end
+      end
+
+      context "with host and camel_case" do
+        let(:_options) { { :camel_case => true, :url_links => "http://localhost" } }
+        it "should generate path and url links" do
+          expect(evaljs("Routes.inboxPath")).not_to be_nil
+          expect(evaljs("Routes.inboxUrl")).not_to be_nil
+          expect(evaljs("Routes.inboxPath(1)")).to eq(routes.inbox_path(1))
+          expect(evaljs("Routes.inboxUrl(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
+        end
+      end
+
+      context "with host and prefix" do
+        let(:_options) { { :prefix => "/api", :url_links => "https://example.com" } }
+        it "should generate path and url links" do
+          expect(evaljs("Routes.inbox_path")).not_to be_nil
+          expect(evaljs("Routes.inbox_url")).not_to be_nil
+          expect(evaljs("Routes.inbox_path(1)")).to eq("/api#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.inbox_url(1)")).to eq("https://example.com/api#{routes.inbox_path(1)}")
+        end
       end
     end
 
-    context "with host and camel_case" do
-      let(:_options) { { :camel_case => true, :url_links => "http://localhost" } }
-      it "should generate path and url links" do
-        expect(evaljs("Routes.inboxPath")).not_to be_nil
-        expect(evaljs("Routes.inboxUrl")).not_to be_nil
-        expect(evaljs("Routes.inboxPath(1)")).to eq(routes.inbox_path(1))
-        expect(evaljs("Routes.inboxUrl(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
+    context "when configuring with default_url_options" do
+      context "when default host is not specified" do
+        it "raises an error" do
+          expect { JsRoutes.generate({ :url_links => true }) }.to raise_error RuntimeError
+        end
+      end
+
+      context "when only host option is specified" do
+        let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com"} } }
+        
+        it "uses the specified host, defaults protocol to http, defaults port to 80 (leaving it blank)" do
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com#{routes.inbox_path(1)}")
+        end
+        
+        it "does not override protocol when specified in route" do
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{routes.new_session_path}")
+        end
+
+        it "does not override host when specified in route" do
+          expect(evaljs("Routes.sso_url()")).to eq(routes.sso_url)
+        end
+
+        it "does not override port when specified in route" do
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{routes.portals_path}")
+        end
+      end
+
+      context "when default host and protocol are specified" do
+        let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com", :protocol => "ftp"} } }
+
+        it "uses the specified protocol and host, defaults port to 80 (leaving it blank)" do
+          expect(evaljs("Routes.inbox_url(1)")).to eq("ftp://example.com#{routes.inbox_path(1)}")
+        end
+        
+        it "does not override protocol when specified in route" do
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{routes.new_session_path}")
+        end
+
+        it "does not override host when host is specified in route" do
+          expect(evaljs("Routes.sso_url()")).to eq("ftp://sso.example.com#{routes.sso_path}")
+        end
+
+        it "does not override port when specified in route" do
+          expect(evaljs("Routes.portals_url()")).to eq("ftp://example.com:8080#{routes.portals_path}")
+        end
+      end
+
+      context "when default host and port are specified" do
+        let(:_options) { { :url_links => true, :default_url_options => {:host => "example.com", :port => 3000} } }
+
+        it "uses the specified host and port, defaults protocol to http" do
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://example.com:3000#{routes.inbox_path(1)}")
+        end
+
+        it "does not override protocol when specified in route" do
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com:3000#{routes.new_session_path}")
+        end
+        
+        it "does not override host, protocol, or port when host is specified in route" do
+          expect(evaljs("Routes.sso_url()")).to eq(routes.sso_url)
+        end
+        
+        it "does not override port when specified in route" do
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{routes.portals_path}")
+        end
+      end
+
+      context "with camel_case option" 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#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.newSessionUrl()")).to eq("https://example.com#{routes.new_session_path}")
+          expect(evaljs("Routes.ssoUrl()")).to eq(routes.sso_url)
+          expect(evaljs("Routes.portalsUrl()")).to eq("http://example.com:8080#{routes.portals_path}")
+        end
+      end
+
+      context "with prefix option" 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#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com/api#{routes.new_session_path}")
+          expect(evaljs("Routes.sso_url()")).to eq("http://sso.example.com/api#{routes.sso_path}")
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080/api#{routes.portals_path}")
+        end
+      end
+
+      context "with compact option" 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#{routes.inbox_path(1)}")
+          expect(evaljs("Routes.new_session_url()")).to eq("https://example.com#{routes.new_session_path}")
+          expect(evaljs("Routes.sso_url()")).to eq(routes.sso_url)
+          expect(evaljs("Routes.portals_url()")).to eq("http://example.com:8080#{routes.portals_path}")
+        end
       end
     end
+  end
 
-    context "with host and prefix" do
-      let(:_options) { { :prefix => "/api", :url_links => "https://example.com" } }
-      it "should generate path and url links" do
-        expect(evaljs("Routes.inbox_path")).not_to be_nil
-        expect(evaljs("Routes.inbox_url")).not_to be_nil
-        expect(evaljs("Routes.inbox_path(1)")).to eq("/api#{routes.inbox_path(1)}")
-        expect(evaljs("Routes.inbox_url(1)")).to eq("https://example.com/api#{routes.inbox_path(1)}")
+  describe "when the compact mode is enabled" do
+    let(:_options) { { :compact => true } }
+    it "removes _path suffix from path helpers" do
+      expect(evaljs("Routes.inbox_path")).to be_nil
+      expect(evaljs("Routes.inboxes()")).to eq(routes.inboxes_path())
+      expect(evaljs("Routes.inbox(2)")).to eq(routes.inbox_path(2))
+    end
+
+    context "with url_links option" do
+      context "with deprecated url_links config value" do
+        around(:each) do |example|
+          ActiveSupport::Deprecation.silence do
+            example.run
+          end
+        end
+        
+        let(:_options) { { :compact => true, :url_links => "http://localhost" } }
+        it "should not strip urls" do
+          expect(evaljs("Routes.inbox(1)")).to eq(routes.inbox_path(1))
+          expect(evaljs("Routes.inbox_url(1)")).to eq("http://localhost#{routes.inbox_path(1)}")
+        end
       end
     end
   end

data/spec/js_routes/rails_routes_compatibility_spec.rb

@@ -150,8 +150,8 @@ describe JsRoutes, "compatibility with Rails"  do
   context "when jQuery is present" do
     before do
       evaljs("window.jQuery = {};")
-      jscontext[:parameterize] = lambda {|object| _value.to_param}
-      evaljs("window.jQuery.param = parameterize")
+      jscontext[:parameterizeFunc] = lambda {|object| _value.to_param}
+      evaljs("window.jQuery.param = parameterizeFunc")
     end
 
     shared_examples_for "serialization" do
@@ -177,6 +177,11 @@ describe JsRoutes, "compatibility with Rails"  do
       let(:_value) do
         nil
       end
+
+      before do
+        pending("This test is invalid for nil/null and jruby #{JRUBY_VERSION}") if defined?(JRUBY_VERSION) && '1.7.13' == JRUBY_VERSION
+      end
+
       it_should_behave_like 'serialization'
     end
   end
@@ -199,11 +204,17 @@ describe JsRoutes, "compatibility with Rails"  do
         expect(evaljs("Routes.thing_path(null, 5)")).to eq(routes.thing_path(nil, 5))
       end
 
+      # Fail for rails 4.2. Reason: https://github.com/rails/rails/issues/12178
       it "should treat undefined as non-given optional part" do
+        # TODO: remove me after release of rails 4.2.1 (change Appraisals to "~> 4.2.1")
+        pending("This test is invalid for rails 4.2. Reason: https://github.com/rails/rails/issues/12178") if [4, 2, 0] == [Rails::VERSION::MAJOR, Rails::VERSION::MINOR, Rails::VERSION::TINY]
         expect(evaljs("Routes.thing_path(5, {optional_id: undefined})")).to eq(routes.thing_path(5, :optional_id => nil))
       end
 
+      # Fail for rails 4.2. Reason: https://github.com/rails/rails/issues/12178
       it "should treat null as non-given optional part" do
+        # TODO: remove me after release of rails 4.2.1 (change Appraisals to "~> 4.2.1")
+        pending("This test is invalid for rails 4.2. Reason: https://github.com/rails/rails/issues/12178") if [4, 2, 0] == [Rails::VERSION::MAJOR, Rails::VERSION::MINOR, Rails::VERSION::TINY]
         expect(evaljs("Routes.thing_path(5, {optional_id: null})")).to eq(routes.thing_path(5, :optional_id => nil))
       end
     end
@@ -291,4 +302,32 @@ describe JsRoutes, "compatibility with Rails"  do
       end
     end
   end
+
+  context "when specs" do
+    it "should show inbox spec" do
+      expect(evaljs("Routes.inbox_path.toString()")).to eq('/inboxes/:id(.:format)')
+    end
+
+    it "should show inbox spec convert to string" do
+      expect(evaljs("'' + Routes.inbox_path")).to eq('/inboxes/:id(.:format)')
+    end
+
+    it "should show inbox message spec" do
+      expect(evaljs("Routes.inbox_message_path.toString()")).to eq('/inboxes/:inbox_id/messages/:id(.:format)')
+    end
+
+    it "should show inbox message spec convert to string" do
+      expect(evaljs("'' + Routes.inbox_message_path")).to eq('/inboxes/:inbox_id/messages/:id(.:format)')
+    end
+  end
+
+  context "when params" do
+    it "should show inbox spec" do
+      expect(evaljs("Routes.inbox_path.required_params").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"])
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -108,6 +108,12 @@ def draw_routes
 
     get '/привет' => "foo#foo", :as => :hello
     get '(/o/:organization)/search/:q' => "foo#foo", as: :search
+
+    resources :sessions, :only => [:new, :create, :destroy], :protocol => 'https'
+
+    get '/' => 'sso#login', host: 'sso.example.com', as: :sso
+
+    resources :portals, :port => 8080
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js-routes
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 1.0.0
 platform: ruby
 authors:
 - Bogdan Gusiev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-15 00:00:00.000000000 Z
+date: 2014-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.12.1
 description: Generates javascript file that defines all Rails named routes as javascript
   helpers
 email: agresso@gmail.com
@@ -145,6 +145,7 @@ files:
 - gemfiles/rails32.gemfile
 - gemfiles/rails40.gemfile
 - gemfiles/rails41.gemfile
+- gemfiles/rails42.gemfile
 - js-routes.gemspec
 - lib/js-routes.rb
 - lib/js_routes.rb