js-routes 0.8.8 → 0.9.0

data/Readme.md

@@ -61,6 +61,8 @@ Available options:
   * Default: blank
 * `camel_case` (version >= 0.8.8) - Generate camel case route names.
   * Default: false
+* `url_links` (version >= 0.8.9) - Generate additional url links, where url_links value is beginning of url routes (ex: http[s]://example.com).
+  * Default: false
 
 You can generate routes files on the application side like this:
 

data/lib/js_routes/version.rb

@@ -1,3 +1,3 @@
 class JsRoutes
-  VERSION = "0.8.8"
+  VERSION = "0.9.0"
 end

data/lib/js_routes.rb

@@ -1,4 +1,6 @@
+require 'uri'
 require 'js_routes/version'
+
 class JsRoutes
 
   #
@@ -12,7 +14,8 @@ class JsRoutes
     :exclude => [],
     :include => //,
     :file => DEFAULT_PATH,
-    :prefix => "",
+    :prefix => nil,
+    :url_links => nil,
     :camel_case => false,
     :default_url_options => {}
   }
@@ -29,6 +32,8 @@ class JsRoutes
     :DOT => 8
   }
 
+  LAST_OPTIONS_KEY = "options".freeze
+
   class Options < Struct.new(*DEFAULTS.keys)
     def to_hash
       Hash[*members.zip(values).flatten(1)].symbolize_keys
@@ -89,7 +94,7 @@ class JsRoutes
     js = File.read(File.dirname(__FILE__) + "/routes.js")
     js.gsub!("NAMESPACE", @options[:namespace])
     js.gsub!("DEFAULT_URL_OPTIONS", json(@options[:default_url_options].merge(deprecated_default_format)))
-    js.gsub!("PREFIX", @options[:prefix])
+    js.gsub!("PREFIX", @options[:prefix] || "")
     js.gsub!("NODE_TYPES", json(NODE_TYPES))
     js.gsub!("ROUTES", js_routes)
   end
@@ -148,19 +153,34 @@ class JsRoutes
   def build_js(route, parent_route)
     name = [parent_route.try(:name), route.name].compact
     parent_spec = parent_route.try(:path).try(:spec)
-    required_parts = route.required_parts.clone
-    optional_parts = route.optional_parts.clone
+    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 = "#{name.join('_')}_path"
-    route_name = route_name.camelize(:lower) if true == @options[:camel_case]
+    route_name = generate_route_name(name)
+    url_link = generate_url_link(name, route_name, required_parts)
     _ = <<-JS.strip!
   // #{name.join('.')} => #{parent_spec}#{route.path.spec}
   #{route_name}: function(#{build_params(required_parts)}) {
+  if (!#{LAST_OPTIONS_KEY}){ #{LAST_OPTIONS_KEY} = {}; }
   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}
   JS
   end
 
+  def generate_url_link(name, route_name, required_parts)
+    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)});
+    }
+    JS
+  end
+
+  def generate_route_name(name, is_url = false)
+    route_name = "#{name.join('_')}_#{is_url ? "url" : "path"}"
+    @options[:camel_case] ? route_name.camelize(:lower) : route_name
+  end
+
   def json(string)
     self.class.json(string)
   end
@@ -169,8 +189,8 @@ class JsRoutes
     params = required_parts.map do |name|
       # prepending each parameter name with underscore
       # to prevent conflict with JS reserved words
-      "_" + name.to_s
-    end << "options"
+      "_#{name}"
+    end << LAST_OPTIONS_KEY
     params.join(", ")
   end
 

data/lib/routes.js

@@ -24,14 +24,14 @@
       }
       if (window.jQuery) {
         result = window.jQuery.param(obj);
-        return (!result ? "" : "?" + result);
+        return (!result ? "" : result);
       }
       s = [];
       for (key in obj) {
         if (!__hasProp.call(obj, key)) continue;
         prop = obj[key];
         if (prop != null) {
-          if (prop instanceof Array) {
+          if (this.getObjectType(prop) === "array") {
             for (i = _i = 0, _len = prop.length; _i < _len; i = ++_i) {
               val = prop[i];
               s.push("" + key + (encodeURIComponent("[]")) + "=" + (encodeURIComponent(val.toString())));
@@ -44,7 +44,7 @@
       if (!s.length) {
         return "";
       }
-      return "?" + (s.join("&"));
+      return s.join("&");
     },
     clean_path: function(path) {
       var last_index;
@@ -74,7 +74,7 @@
       anchor = "";
       if (options.hasOwnProperty("anchor")) {
         anchor = "#" + options.anchor;
-        options.anchor = null;
+        delete options.anchor;
       }
       return anchor;
     },
@@ -82,7 +82,7 @@
       var ret_value;
 
       ret_value = {};
-      if (args.length > number_of_params && typeof args[args.length - 1] === "object") {
+      if (args.length > number_of_params && this.getObjectType(args[args.length - 1]) === "object") {
         ret_value = args.pop();
       }
       return ret_value;
@@ -97,9 +97,9 @@
         return "";
       }
       property = object;
-      if (typeof object === "object") {
+      if (this.getObjectType(object) === "object") {
         property = object.to_param || object.id || object;
-        if (typeof property === "function") {
+        if (this.getObjectType(property) === "function") {
           property = property.call(object);
         }
       }
@@ -108,7 +108,7 @@
     clone: function(obj) {
       var attr, copy, key;
 
-      if (null === obj || "object" !== typeof obj) {
+      if ((obj == null) || "object" !== this.getObjectType(obj)) {
         return obj;
       }
       copy = obj.constructor();
@@ -130,7 +130,7 @@
       return result;
     },
     build_path: function(required_parameters, optional_parts, route, args) {
-      var opts, parameters, result;
+      var opts, parameters, result, url, url_params;
 
       args = Array.prototype.slice.call(args);
       opts = this.extract_options(required_parameters.length, args);
@@ -139,17 +139,25 @@
       }
       parameters = this.prepare_parameters(required_parameters, args, opts);
       this.set_default_url_options(optional_parts, parameters);
-      result = "" + (Utils.get_prefix()) + (this.visit(route, parameters));
-      return Utils.clean_path("" + result + (Utils.extract_anchor(parameters))) + Utils.serialize(parameters);
+      result = "" + (this.get_prefix()) + (this.visit(route, parameters));
+      url = Utils.clean_path("" + result + (this.extract_anchor(parameters)));
+      if ((url_params = this.serialize(parameters)).length) {
+        url += "?" + url_params;
+      }
+      return url;
     },
     visit: function(route, parameters, optional) {
       var left, left_part, right, right_part, type, value;
 
+      if (optional == null) {
+        optional = false;
+      }
       type = route[0], left = route[1], right = route[2];
       switch (type) {
         case NodeTypes.GROUP:
-        case NodeTypes.STAR:
           return this.visit(left, parameters, true);
+        case NodeTypes.STAR:
+          return this.visit_globbing(left, parameters, true);
         case NodeTypes.LITERAL:
         case NodeTypes.SLASH:
         case NodeTypes.DOT:
@@ -164,7 +172,7 @@
         case NodeTypes.SYMBOL:
           value = parameters[left];
           if (value != null) {
-            parameters[left] = null;
+            delete parameters[left];
             return this.path_identifier(value);
           }
           if (optional) {
@@ -177,6 +185,24 @@
           throw new Error("Unknown Rails node type");
       }
     },
+    visit_globbing: function(route, parameters, optional) {
+      var left, right, type, value;
+
+      type = route[0], left = route[1], right = route[2];
+      value = parameters[left];
+      if (value == null) {
+        return this.visit(route, parameters, optional);
+      }
+      parameters[left] = (function() {
+        switch (this.getObjectType(value)) {
+          case "array":
+            return value.join("/");
+          default:
+            return value;
+        }
+      }).call(this);
+      return this.visit(route, parameters, optional);
+    },
     get_prefix: function() {
       var prefix;
 
@@ -186,6 +212,30 @@
       }
       return prefix;
     },
+    _classToTypeCache: null,
+    _classToType: function() {
+      var name, _i, _len, _ref;
+
+      if (this._classToTypeCache != null) {
+        return this._classToTypeCache;
+      }
+      this._classToTypeCache = {};
+      _ref = "Boolean Number String Function Array Date RegExp Undefined Null".split(" ");
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        name = _ref[_i];
+        this._classToTypeCache["[object " + name + "]"] = name.toLowerCase();
+      }
+      return this._classToTypeCache;
+    },
+    getObjectType: function(obj) {
+      var strType;
+
+      if (window.jQuery && (window.jQuery.type != null)) {
+        return window.jQuery.type(obj);
+      }
+      strType = Object.prototype.toString.call(obj);
+      return this._classToType()[strType] || "object";
+    },
     namespace: function(root, namespaceString) {
       var current, parts;
 

data/lib/routes.js.coffee

@@ -6,21 +6,21 @@ defaults =
 
 NodeTypes = NODE_TYPES
 Utils =
+
   serialize: (obj) ->
     return ""  unless obj
     if window.jQuery
       result = window.jQuery.param(obj)
-      return (if not result then "" else "?#{result}")
+      return (if not result then "" else result)
     s = []
-    for own key, prop of obj
-      if prop?
-        if prop instanceof Array
-          for val, i in prop
-            s.push "#{key}#{encodeURIComponent("[]")}=#{encodeURIComponent(val.toString())}"
-        else
-          s.push "#{key}=#{encodeURIComponent(prop.toString())}"
+    for own key, prop of obj when prop?
+      if @getObjectType(prop) is "array"
+        for val, i in prop
+          s.push "#{key}#{encodeURIComponent("[]")}=#{encodeURIComponent(val.toString())}"
+      else
+        s.push "#{key}=#{encodeURIComponent(prop.toString())}"
     return "" unless s.length
-    "?#{s.join("&")}"
+    s.join("&")
 
   clean_path: (path) ->
     path = path.split("://")
@@ -37,12 +37,12 @@ Utils =
     anchor = ""
     if options.hasOwnProperty("anchor")
       anchor = "##{options.anchor}"
-      options.anchor = null
+      delete options.anchor
     anchor
 
   extract_options: (number_of_params, args) ->
     ret_value = {}
-    if args.length > number_of_params and typeof (args[args.length - 1]) is "object"
+    if args.length > number_of_params and @getObjectType(args[args.length - 1]) is "object"
       ret_value = args.pop()
     ret_value
 
@@ -51,13 +51,13 @@ Utils =
     # null, undefined, false or ''
     return ""  unless object
     property = object
-    if typeof (object) is "object"
+    if @getObjectType(object) is "object"
       property = object.to_param or object.id or object
-      property = property.call(object) if typeof (property) is "function"
+      property = property.call(object) if @getObjectType(property) is "function"
     property.toString()
 
   clone: (obj) ->
-    return obj if null is obj or "object" isnt typeof obj
+    return obj if !obj? or "object" isnt @getObjectType(obj)
     copy = obj.constructor()
     copy[key] = attr for own key, attr of obj
     copy
@@ -73,8 +73,10 @@ Utils =
     throw new Error("Too many parameters provided for path") if args.length > required_parameters.length
     parameters = @prepare_parameters(required_parameters, args, opts)
     @set_default_url_options optional_parts, parameters
-    result = "#{Utils.get_prefix()}#{@visit(route, parameters)}"
-    Utils.clean_path("#{result}#{Utils.extract_anchor(parameters)}") + Utils.serialize(parameters)
+    result = "#{@get_prefix()}#{@visit(route, parameters)}"
+    url = Utils.clean_path("#{result}#{@extract_anchor(parameters)}")
+    url += "?#{url_params}" if (url_params = @serialize(parameters)).length
+    url
   #
   # This function is JavaScript impelementation of the
   # Journey::Visitors::Formatter that builds route by given parameters
@@ -86,11 +88,13 @@ Utils =
   # If set to `true`, this method will not throw when encountering
   # a missing parameter (used in recursive calls).
   #
-  visit: (route, parameters, optional) ->
+  visit: (route, parameters, optional = false) ->
     [type, left, right] = route
     switch type
-      when NodeTypes.GROUP, NodeTypes.STAR
+      when NodeTypes.GROUP
         @visit left, parameters, true
+      when NodeTypes.STAR
+        @visit_globbing left, parameters, true
       when NodeTypes.LITERAL, NodeTypes.SLASH, NodeTypes.DOT
         left
       when NodeTypes.CAT
@@ -101,7 +105,7 @@ Utils =
       when NodeTypes.SYMBOL
         value = parameters[left]
         if value?
-          parameters[left] = null
+          delete parameters[left]
           return @path_identifier(value)
         if optional
           "" # missing parameter
@@ -115,11 +119,65 @@ Utils =
       else
         throw new Error("Unknown Rails node type")
 
+  #
+  # This method convert value for globbing in right value for rails route
+  #
+  visit_globbing: (route, parameters, optional) ->
+    [type, left, right] = route
+    value = parameters[left]
+    return @visit(route, parameters, optional) unless value?
+    parameters[left] = switch @getObjectType(value)
+      when "array"
+        value.join("/")
+      else
+        value
+    @visit route, parameters, optional
+
+  #
+  # This method check and return prefix from options
+  #
   get_prefix: ->
     prefix = defaults.prefix
     prefix = (if prefix.match("/$") then prefix else "#{prefix}/") if prefix isnt ""
     prefix
 
+  #
+  # 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.
+  #
+  # Value               Class      Type
+  # -------------------------------------
+  # "foo"               String     string
+  # new String("foo")   String     object
+  # 1.2                 Number     number
+  # new Number(1.2)     Number     object
+  # true                Boolean    boolean
+  # new Boolean(true)   Boolean    object
+  # new Date()          Date       object
+  # new Error()         Error      object
+  # [1,2,3]             Array      object
+  # new Array(1, 2, 3)  Array      object
+  # new Function("")    Function   function
+  # /abc/g              RegExp     object
+  # new RegExp("meow")  RegExp     object
+  # {}                  Object     object
+  # new Object()        Object     object
+  #
+  # What is why I use Object.prototype.toString() to know better type of variable. Or use jQuery.type, if it available.
+  # _classToTypeCache used for perfomance cache of types map (underscore at the beginning mean private method - of course it doesn't realy private).
+  #
+  _classToTypeCache: null
+  _classToType: ->
+    return @_classToTypeCache if @_classToTypeCache?
+    @_classToTypeCache = {}
+    for name in "Boolean Number String Function Array Date RegExp Undefined Null".split(" ")
+      @_classToTypeCache["[object " + name + "]"] = name.toLowerCase()
+    @_classToTypeCache
+  getObjectType: (obj) ->
+    return window.jQuery.type(obj) if window.jQuery and window.jQuery.type?
+    strType = Object::toString.call(obj)
+    @_classToType()[strType] or "object"
+
   namespace: (root, namespaceString) ->
     parts = (if namespaceString then namespaceString.split(".") else [])
     return unless parts.length
@@ -129,4 +187,4 @@ Utils =
 
 Utils.namespace window, "NAMESPACE"
 window.NAMESPACE = ROUTES
-window.NAMESPACE.options = defaults
+window.NAMESPACE.options = defaults

data/spec/js_routes/options_spec.rb

@@ -172,4 +172,51 @@ describe JsRoutes, "options" do
       end
     end
   end
+
+  describe "url_links" do
+    context "with default option" do
+      let(:_options) { Hash.new }
+      it "should generate only path links" do
+        evaljs("Routes.inbox_path(1)").should == routes.inbox_path(1)
+        evaljs("Routes.inbox_url").should be_nil
+      end
+    end
+
+    context "with host" do
+      let(:_options) { { :url_links => "http://localhost" } }
+      it "should generate path and url links" do
+        evaljs("Routes.inbox_path").should_not be_nil
+        evaljs("Routes.inbox_url").should_not be_nil
+        evaljs("Routes.inbox_path(1)").should == routes.inbox_path(1)
+        evaljs("Routes.inbox_url(1)").should == "http://localhost#{routes.inbox_path(1)}"
+        evaljs("Routes.inbox_url(1, { test_key: \"test_val\" })").should == "http://localhost#{routes.inbox_path(1, :test_key => "test_val")}"
+      end
+    end
+
+    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
+        evaljs("Routes.inboxPath").should_not be_nil
+        evaljs("Routes.inboxUrl").should_not be_nil
+        evaljs("Routes.inboxPath(1)").should == routes.inbox_path(1)
+        evaljs("Routes.inboxUrl(1)").should == "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
+        evaljs("Routes.inbox_path").should_not be_nil
+        evaljs("Routes.inbox_url").should_not be_nil
+        evaljs("Routes.inbox_path(1)").should == "/api#{routes.inbox_path(1)}"
+        evaljs("Routes.inbox_url(1)").should == "https://example.com/api#{routes.inbox_path(1)}"
+      end
+    end
+  end
 end

data/spec/js_routes/rails_routes_compatibility_spec.rb

@@ -76,14 +76,28 @@ describe JsRoutes, "compatibility with Rails"  do
       evaljs("Routes.book_path('thrillers', 1)").should == routes.book_path('thrillers', 1)
     end
 
-    it "should support routes globbing as hash" do
-      pending
-      evaljs("Routes.book_path(1, {section: 'thrillers'})").should == routes.book_path(1, :section => 'thrillers')
+    it "should support routes globbing as array" do
+      evaljs("Routes.book_path(['thrillers'], 1)").should == routes.book_path(['thrillers'], 1)
+    end
+
+    it "should bee support routes globbing as array" do
+      evaljs("Routes.book_path([1, 2, 3], 1)").should == routes.book_path([1, 2, 3], 1)
     end
 
     it "should bee support routes globbing as hash" do
-      pending
-      evaljs("Routes.book_path(1)").should == routes.book_path(1)
+      evaljs("Routes.book_path('a_test/b_test/c_test', 1)").should == routes.book_path('a_test/b_test/c_test', 1)
+    end
+
+    it "should support routes globbing as array with optional params" do
+      evaljs("Routes.book_path([1, 2, 3, 5], 1, {c: '1'})").should == routes.book_path([1, 2, 3, 5], 1, { :c => "1" })
+    end
+
+    it "should support routes globbing in book_title route as array" do
+      evaljs("Routes.book_title_path('john', ['thrillers', 'comedian'])").should == routes.book_title_path('john', ['thrillers', 'comedian'])
+    end
+
+    it "should support routes globbing in book_title route as array with optional params" do
+      evaljs("Routes.book_title_path('john', ['thrillers', 'comedian'], {some_key: 'some_value'})").should == routes.book_title_path('john', ['thrillers', 'comedian'], {:some_key => 'some_value'})
     end
   end
 
@@ -98,6 +112,7 @@ describe JsRoutes, "compatibility with Rails"  do
       it "should support serialization of objects" do
         evaljs("window.jQuery.param(#{_value.to_json})").should == _value.to_param
         evaljs("Routes.inboxes_path(#{_value.to_json})").should == routes.inboxes_path(_value)
+        evaljs("Routes.inbox_path(1, #{_value.to_json})").should == routes.inbox_path(1, _value)
       end
     end
     context "when parameters is a hash" do
@@ -202,5 +217,25 @@ describe JsRoutes, "compatibility with Rails"  do
         "Routes.inbox_message_path({id:1, to_param: 'my'}, {id:2}, {custom: true, format: 'json'})"
       ).should == 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
+        evaljs("Routes.book_path({id: 1, to_param: 'my'}, 1)").should == routes.book_path(inbox, 1)
+      end
+
+      it "should call to_param if it is a function" do
+        evaljs("Routes.book_path({id: 1, to_param: function(){ return 'my';}}, 1)").should == routes.book_path(inbox, 1)
+      end
+
+      it "should call id if it is a function" do
+        evaljs("Routes.book_path({id: function() { return 'technical';}}, 1)").should == routes.book_path('technical', 1)
+      end
+
+      it "should support options argument" do
+        evaljs(
+          "Routes.book_path({id:1, to_param: 'my'}, {id:2}, {custom: true, format: 'json'})"
+        ).should == routes.book_path(inbox, 2, :custom => true, :format => "json")
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -68,6 +68,7 @@ def draw_routes
     match "/other_optional/(:optional_id)" => "foo#foo", :as => :foo
 
     match 'books/*section/:title' => 'books#show', :as => :book
+    match 'books/:title/*section' => 'books#show', :as => :book_title
 
     mount BlogEngine::Engine => "/blog", :as => :blog_app
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: js-routes
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -169,7 +169,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1021076515432540813
+      hash: 1949067975122087130
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: