js-routes 1.4.14 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a952ba9e2f582074e459b770227628ee2cecf37cd50d03978ba9690bac5a94
-  data.tar.gz: 151da0e08b1b47fd6caa3bfbb1a5311ac0a528a9c88bb53b05dea181438823fb
+  metadata.gz: 86ed2a6e4f90ea3c7bbc91836148b23121acbb21c59e4b26e55f0925a2d37fce
+  data.tar.gz: 485241d5aa3e009545a78113c49e2781be677cb4ddfe91286329f325f8a6b9dc
 SHA512:
-  metadata.gz: 586fc3bcbef2fc96c12b0d53b5f9fd58eb19b8f5987ca7a6dac068ecc6865c363a4207e69afd4d0fe0c6d252d7b0c507428c7257a99cabf6fc34ba0c5afe29ea
-  data.tar.gz: 10276a454e7f07fe6166957c18516214c34853859f4e8645e06105984e80fb18b77016cbc398a1cdd5351eba6f4d38ce78555f34498be04f35e353c341500c75
+  metadata.gz: 75844cdc35fc7cbf506fdd40eb00bc002c8bdc35397607943d28519572ae63f3f374cd249c4f50c218a979ffbbafe3938d5d2de0d1f03505e00549b9483a7ae6
+  data.tar.gz: ffb6920c23e81c18cc4c6e1476ae61f60801973e93583cd481ef6cd9f45171005de01124cc62aefc7862c2451cdbde31787efeeb8d2fb2e9dab223b1f5964230

data/.eslintrc.js

@@ -0,0 +1,15 @@
+ module.exports = {
+  root: true,
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/eslint-recommended',
+    'plugin:@typescript-eslint/recommended',
+    'prettier/@typescript-eslint',
+  ],
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  rules: {
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off'
+  },
+};

data/.gitignore

@@ -60,3 +60,5 @@ gemfiles/*.lock
 /spec/dummy/app/assets/javascripts/routes.js
 /spec/dummy/logs
 /spec/dummy/tmp
+node_modules
+

data/.nvmrc

@@ -0,0 +1 @@
+14

data/.travis.yml

@@ -5,7 +5,6 @@ before_install:
   - gem install bundler # need for jruby and ruby-head
 
 rvm:
-  - 2.3.1
   - 2.4.1
   - 2.5.3
   - 2.6.0
@@ -22,6 +21,8 @@ gemfile:
   - gemfiles/rails50_sprockets_3.gemfile
   - gemfiles/rails51_sprockets_3.gemfile
   - gemfiles/rails52_sprockets_3.gemfile
+env:
+  TRAVIS_CI: true
 
 sudo: false
 dist: xenial

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## master
 
+## v2.0.0
+
+Version 2.0 has some breaking changes.
+See [UPGRADE TO 2.0](./VERSION_2_UPGRADE.md) for guidance.
+
+* `module_type` option support
+* `documentation` option spport
+* Migrated implementation to typescript
+* ESM tree shaking support
+* Support camel case `toParam` version of `to_param` property
+
 ## v1.4.14
 
 * Fix compatibility with UMD modules #237 [Comment](https://github.com/railsware/js-routes/issues/237#issuecomment-752754679)

data/Readme.md

@@ -4,6 +4,8 @@
 
 Generates javascript file that defines all Rails named routes as javascript helpers
 
+[UPGRADE TO 2.0](./VERSION_2_UPGRADE.md)
+
 ## Intallation
 
 Your Rails Gemfile:
@@ -14,6 +16,8 @@ gem "js-routes"
 
 ## Setup
 
+### Quick Start 
+
 Run:
 
 ```
@@ -23,19 +27,24 @@ rake js:routes
 Make routes available globally in `app/javascript/packs/application.js`: 
 
 ``` javascript
-window.Routes = require('routes');
+import * as Routes from 'routes';
+window.Routes = Routes;
 ```
 
 Individual routes can be imported using:
 
 ``` javascript
-import {edit_post_path, new_post_path} from 'routes';
+import {edit_post_path} from 'routes';
+console.log(edit_post_path(1))
 ```
 
 **Note**: that this setup requires `rake js:routes` to be run each time routes file is updated.
 
+<div id='webpacker'></div>
+
 #### Webpacker + automatic updates
 
+
 This setup can automatically update your routes without `rake js:routes` being called manually.
 It requires [rails-erb-loader](https://github.com/usabilityhub/rails-erb-loader) npm package to work.
 
@@ -64,7 +73,7 @@ module.exports = {
 
 Enable `erb` extension in `config/webpacker/environment.js`:
 
-```
+``` javascript
 const erb = require('./loaders/erb')
 environment.loaders.append('erb', erb)
 ```
@@ -78,13 +87,23 @@ Create routes file `app/javascript/routes.js.erb`:
 Use routes wherever you need them `app/javascript/packs/application.js`: 
 
 ``` javascript
-window.Routes = require('routes.js.erb');
+import * as Routes from 'routes.js.erb';
+window.Routes = Routes;
 ```
 
 #### Sprockets (Deprecated)
 
 If you are using [Sprockets](https://github.com/rails/sprockets-rails) you may configure js-routes in the following way.
 
+Setup the initializer (e.g. `config/initializers/js_routes.rb`):
+
+``` ruby
+JsRoutes.setup do |config|
+  config.module_type = nil
+  config.namespace = 'Routes'
+end
+```
+
 Require JsRoutes in `app/assets/javascripts/application.js` or other bundle
 
 ``` js
@@ -114,6 +133,7 @@ end
 Or dynamically in JavaScript, although only [Formatter Options](#formatter-options) are supported (see below)
 
 ``` js
+import * as Routes from 'routes'
 Routes.configure({
   option: value
 });
@@ -126,6 +146,12 @@ Routes.config(); // current config
 
 Options to configure JavaScript file generator. These options are only available in Ruby context but not JavaScript.
 
+* `module_type` - JavaScript module type for generated code. [Article](https://dev.to/iggredible/what-the-heck-are-cjs-amd-umd-and-esm-ikm)
+  * Options: `ESM`, `UMD`, `CJS`, `AMD`, `nil`.
+  * Default: `ESM`
+  * `nil` option can be used in case you don't want generated code to export anything.
+* `documentation` - specifies if each route should be annotated with [JSDoc](https://jsdoc.app/) comment
+  * Default: `true`
 * `exclude` - Array of regexps to exclude from routes.
   * Default: `[]`
   * The regexp applies only to the name before the `_path` suffix, eg: you want to match exactly `settings_path`, the regexp should be `/^settings$/`
@@ -134,11 +160,10 @@ Options to configure JavaScript file generator. These options are only available
   * The regexp applies only to the name before the `_path` suffix, eg: you want to match exactly `settings_path`, the regexp should be `/^settings$/`
 * `namespace` - global object used to access routes.
   * Supports nested namespace like `MyProject.routes`
-  * Default: `Routes`
-* `camel_case` - Generate camel case route names.
+  * Default: `nil`
+* `camel_case` - specifies if route helpers should be generated in camel case instead of underscore case.
   * Default: `false`
-* `url_links` - Generate `*_url` helpers (in addition to the default `*_path` helpers).
-  * Example: `true`
+* `url_links` - specifies if `*_url` helpers should be generated (in addition to the default `*_path` helpers).
   * Default: `false`
   * Note: generated URLs will first use the protocol, host, and port options specified in the route definition. Otherwise, the URL will be based on the option specified in the `default_url_options` config. If no default option has been set, then the URL will fallback to the current URL based on `window.location`.
 * `compact` - Remove `_path` suffix in path routes(`*_url` routes stay untouched if they were enabled)
@@ -175,27 +200,28 @@ If your application has an `admin` and an `application` namespace for example:
 
 ```
 # app/javascript/admin/routes.js.erb
-<%= JsRoutes.generate(namespace: "AdminRoutes", include: /admin/) %>
+<%= JsRoutes.generate(include: /admin/) %>
 ```
 
 ```
 # app/javascript/customer/routes.js.erb
-<%= JsRoutes.generate(namespace: "CustomerRoutes", exclude: /admin/) %>
+<%= JsRoutes.generate(exclude: /admin/) %>
 ```
 
-In order to generate the routes JS code to a string:
+You can manipulate the generated helper manually by injecting ruby into javascript:
 
-``` ruby
-routes_js = JsRoutes.generate(options)
+``` erb
+export const routes = <%= JsRoutes.generate(module_type: nil, namespace: nil) %>
 ```
 
 If you want to generate the routes files outside of the asset pipeline, you can use `JsRoutes.generate!`:
 
 ``` ruby
-path = "app/javascript"
-JsRoutes.generate!("#{path}/app_routes.js", namespace: "AppRoutes", exclude: [/^admin_/, /^api_/])
-JsRoutes.generate!("#{path}/adm_routes.js", namespace: "AdmRoutes", include: /^admin_/)
-JsRoutes.generate!("#{path}/api_routes.js", namespace: "ApiRoutes", include: /^api_/, default_url_options: {format: "json"})
+path = Rails.root.join("app/javascript")
+
+JsRoutes.generate!("#{path}/app_routes.js", exclude: [/^admin_/, /^api_/])
+JsRoutes.generate!("#{path}/adm_routes.js", include: /^admin_/)
+JsRoutes.generate!("#{path}/api_routes.js", include: /^api_/, default_url_options: {format: "json"})
 ```
 
 ## Usage
@@ -203,6 +229,8 @@ JsRoutes.generate!("#{path}/api_routes.js", namespace: "ApiRoutes", include: /^a
 Configuration above will create a nice javascript file with `Routes` object that has all the rails routes available:
 
 ``` js
+import * as Routes from 'routes';
+
 Routes.users_path() // => "/users"
 Routes.user_path(1) // => "/users/1"
 Routes.user_path(1, {format: 'json'}) // => "/users/1.json"
@@ -243,11 +271,11 @@ This function allow to get the same `spec` for route, if you will get string rep
 '' + Routes.user_path // => "/users/:id(.:format)"
 ```
 
-Route function also contain inside attribute `required_params` required param names as array:
+Route function also contain method `requiredParams` inside which returns required param names array:
 
 ```js
-Routes.users_path.required_params // => []
-Routes.user_path.required_params // => ['id']
+Routes.users_path.requiredParams() // => []
+Routes.user_path.requiredParams() // => ['id']
 ```
 
 
@@ -268,9 +296,34 @@ Routes.company_project_path({company_id: 1, id: 2, _options: true}) // => "/comp
 
 ## What about security?
 
-JsRoutes itself does not have security holes. It makes URLs
-without access protection more reachable by potential attacker.
-In order to prevent this use `:exclude` option for sensitive urls like `/admin_/`
+JsRoutes itself does not have security holes. 
+It makes URLs without access protection more reachable by potential attacker.
+If that is an issue for you, you may use one of the following solutions:
+
+### Explicit Import + ESM Tree shaking
+
+Make sure `module_type` is set to `ESM` (the default) and JS files import only required routes into the file like:
+
+``` javascript
+import {
+  inbox_path,
+  inboxes_path,
+  inbox_message_path,
+  inbox_attachment_path,
+  user_path,
+} from 'routes.js.erb'
+```
+
+### Exclude option
+
+Split your routes into multiple files related to each section of your website like:
+
+``` javascript
+// admin-routes.js.erb
+<%= JsRoutes.generate(include: /^admin_/)
+// app-routes.js.erb
+<%= JsRoutes.generate(exclude: /^admin_/)
+```
 
 ## JsRoutes and Heroku
 
@@ -290,11 +343,20 @@ There are some alternatives available. Most of them has only basic feature and d
 Advantages of this one are:
 
 * Rails 4,5,6 support
+* [ESM Tree shaking](https://webpack.js.org/guides/tree-shaking/) support
 * Rich options set
 * Full rails compatibility
 * Support Rails `#to_param` convention for seo optimized paths
 * Well tested
 
+## Version 2 TODO
+
+* Add routes generation .d.ts file
+* Add config option on the output format: js, ts, d.ts
+* Add prettier
+* Add eslint
+* Add development guide
+
 #### Thanks to [contributors](https://github.com/railsware/js-routes/contributors)
 
 #### Have fun

data/VERSION_2_UPGRADE.md

@@ -0,0 +1,61 @@
+## Version 2.0 upgrade notes
+
+### Using ESM module by default
+
+The default setting are now changed:
+
+Setting | Old | New 
+--- | --- | ---
+module\_type | nil | ESM 
+namespace | Routes | nil
+
+This is more optimized setup for WebPacker. You can restore the old configuration like this:
+
+``` ruby
+JsRoutes.setup do |config|
+  config.module_type = nil
+  config.namespace = 'Routes'
+end
+```
+
+However, [ESM+Webpacker](/Readme.md#webpacker) upgrade is recommended. 
+
+### `required_params` renamed
+
+In case you are using `required_params` property, it is now renamed and converted to a method:
+
+``` javascript
+// Old style
+Routes.post_path.required_params  // => ['id']
+// New style
+Routes.post_path.requiredParams() // => ['id']
+```
+
+### ParameterMissing error rework
+
+`ParameterMissing` is renamed to `ParametersMissing` error and now list all missing parameters instead of just first encountered in its message. Missing parameters are now available via `ParametersMissing#keys` property.
+
+``` javascript
+try {
+  return Routes.inbox_path();
+} catch(error) {
+  if (error.name === 'ParametersMissing') {
+    console.warn(`Missing route keys ${error.keys.join(', ')}. Ignoring.`);
+    return "#";
+  } else {
+    throw error;
+  }
+}
+```
+
+### JSDoc comment format
+
+New version of js-routes generates function comment in the [JSDoc](https://jsdoc.app) format.
+If you have any problems with that disable the annotation:
+
+``` ruby
+JsRoutes.setup do |config|
+  config.documentation = false
+end
+```
+

data/js-routes.gemspec

@@ -7,13 +7,16 @@ Gem::Specification.new do |s|
   s.name = %q{js-routes}
   s.version = JsRoutes::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  if s.respond_to? :required_rubygems_version=
+    s.required_rubygems_version = Gem::Requirement.new(">= 0")
+  end
   s.authors = ["Bogdan Gusiev"]
   s.description = %q{Generates javascript file that defines all Rails named routes as javascript helpers}
   s.email = %q{agresso@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE.txt"
   ]
+  s.required_ruby_version = '>= 2.4.0'
   s.files = `git ls-files`.split("\n")
   s.homepage = %q{http://github.com/railsware/js-routes}
   s.licenses = ["MIT"]
@@ -24,13 +27,13 @@ Gem::Specification.new do |s|
   s.add_development_dependency(%q<sprockets-rails>)
   s.add_development_dependency(%q<rspec>, [">= 3.0.0"])
   s.add_development_dependency(%q<bundler>, [">= 1.1.0"])
-  s.add_development_dependency(%q<coffee-script>, [">= 0"])
   s.add_development_dependency(%q<appraisal>, [">= 0.5.2"])
+  s.add_development_dependency(%q<bump>, [">= 0.10.0"])
   if defined?(JRUBY_VERSION)
     s.add_development_dependency(%q<therubyrhino>, [">= 2.0.4"])
   else
     s.add_development_dependency(%q<byebug>)
     s.add_development_dependency(%q<pry-byebug>)
-    s.add_development_dependency(%q<mini_racer>, [">= 0.2.4"])
+    s.add_development_dependency(%q<mini_racer>, [">= 0.4.0"])
   end
 end

data/lib/js_routes.rb

@@ -3,6 +3,7 @@ if defined?(::Rails) && defined?(::Sprockets::Railtie)
   require 'js_routes/engine'
 end
 require 'js_routes/version'
+require 'active_support/core_ext/string/indent'
 
 class JsRoutes
 
@@ -19,7 +20,7 @@ class JsRoutes
       sprockets_dir = Rails.root.join('app','assets','javascripts')
       sprockets_file = sprockets_dir.join('routes.js')
       webpacker_file = webpacker_dir.join('routes.js')
-      !Dir.exists?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
+      !Dir.exist?(webpacker_dir) && defined?(::Sprockets) ? sprockets_file : webpacker_file
     end,
     prefix: -> { Rails.application.config.relative_url_root || "" },
     url_links: false,
@@ -28,7 +29,9 @@ class JsRoutes
     compact: false,
     serializer: nil,
     special_options_key: "_options",
-    application: -> { Rails.application }
+    application: -> { Rails.application },
+    module_type: 'ESM',
+    documentation: true,
   } #:nodoc:
 
   NODE_TYPES = {
@@ -72,6 +75,10 @@ class JsRoutes
     def to_hash
       Hash[*members.zip(values).flatten(1)].symbolize_keys
     end
+
+    def esm?
+      self.module_type === 'ESM'
+    end
   end
 
   #
@@ -83,11 +90,6 @@ class JsRoutes
       configuration.tap(&block) if block
     end
 
-    def options
-      ActiveSupport::Deprecation.warn('JsRoutes.options method is deprecated use JsRoutes.configuration instead')
-      configuration
-    end
-
     def configuration
       @configuration ||= Configuration.new
     end
@@ -125,8 +127,7 @@ class JsRoutes
 
     {
       'GEM_VERSION'         => JsRoutes::VERSION,
-      'ROUTES'              => js_routes,
-      'NODE_TYPES'          => json(NODE_TYPES),
+      'ROUTES_OBJECT'              => routes_object,
       'RAILS_VERSION'       => ActionPack.version,
       'DEPRECATED_GLOBBING_BEHAVIOR' => ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR == 0,
 
@@ -136,9 +137,12 @@ class JsRoutes
       'PREFIX'              => json(@configuration.prefix),
       'SPECIAL_OPTIONS_KEY' => json(@configuration.special_options_key),
       'SERIALIZER'          => @configuration.serializer || json(nil),
+      'MODULE_TYPE'         => json(@configuration.module_type),
+      'WRAPPER'             => @configuration.esm? ? 'const __jsr = ' : '',
     }.inject(File.read(File.dirname(__FILE__) + "/routes.js")) do |js, (key, value)|
-      js.gsub!(key, value.to_s)
-    end
+      js.gsub!("RubyVariables.#{key}", value.to_s) ||
+        raise("Missing key #{key} in JS template")
+    end + routes_export
   end
 
   def generate!(file_name = nil)
@@ -170,19 +174,37 @@ class JsRoutes
     application.routes.named_routes.to_a
   end
 
-  def js_routes
-    js_routes = named_routes.sort_by(&:first).flat_map do |_, route|
-      [build_route_if_match(route)] + mounted_app_routes(route)
+  def routes_object
+    return json({}) if @configuration.esm?
+    properties = routes_list.map do |comment, name, body|
+      "#{comment}#{name}: #{body}".indent(2)
+    end
+    "{\n" + properties.join(",\n\n") + "}\n"
+  end
+
+  STATIC_EXPORTS = [:configure, :config, :serialize].map do |name|
+    ["", name, "__jsr.#{name}"]
+  end
+
+  def routes_export
+    return "" unless @configuration.esm?
+    [*STATIC_EXPORTS, *routes_list].map do |comment, name, body|
+      "#{comment}export const #{name} = #{body};"
+    end.join("\n\n")
+  end
+
+  def routes_list
+    named_routes.sort_by(&:first).flat_map do |_, route|
+      build_routes_if_match(route) + mounted_app_routes(route)
     end.compact
-    "{\n" + js_routes.join(",\n") + "}\n"
   end
 
   def mounted_app_routes(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)
+      rails_engine_app.routes.named_routes.flat_map do |_, engine_route|
+        build_routes_if_match(engine_route, route)
       end
     else
       []
@@ -199,12 +221,17 @@ class JsRoutes
     end
   end
 
-  def build_route_if_match(route, parent_route = nil)
+  def build_routes_if_match(route, parent_route = nil)
     if any_match?(route, parent_route, @configuration[:exclude]) ||
        !any_match?(route, parent_route, @configuration[:include])
-      nil
+      []
     else
-      build_js(route, parent_route)
+      name = [parent_route.try(:name), route.name].compact
+      parent_spec = parent_route.try(:path).try(:spec)
+      route_arguments = route_js_arguments(route, parent_spec)
+      return [false, true].map do |absolute|
+        route_js(name, parent_spec, route, route_arguments, absolute)
+      end
     end
   end
 
@@ -215,59 +242,72 @@ class JsRoutes
     matchers.any? { |regex| full_route =~ regex }
   end
 
-  def build_js(route, parent_route)
-    name = [parent_route.try(:name), route.name].compact
-    route_name = generate_route_name(name, (:path unless @configuration[:compact]))
-    parent_spec = parent_route.try(:path).try(:spec)
-    route_arguments = route_js_arguments(route, parent_spec)
-    url_link = generate_url_link(name, route_arguments)
-    <<-JS.strip!
-  // #{name.join('.')} => #{parent_spec}#{route.path.spec}
-  // function(#{build_params(route.required_parts)})
-  #{route_name}: Utils.route(#{route_arguments})#{",\n" + url_link if url_link.length > 0}
-  JS
+  def route_js(name_parts, parent_spec, route, route_arguments, absolute)
+    if absolute
+      return nil unless @configuration[:url_links]
+      route_arguments = route_arguments + [json(true)]
+    end
+    name_suffix = absolute ? :url : @configuration[:compact] ? nil : :path
+    name = generate_route_name(name_parts, name_suffix)
+    body = "__jsr.r(#{route_arguments.join(', ')})"
+    comment = documentation(route, parent_spec)
+    [ comment, name, body ]
+  end
+
+  def documentation(route, parent_spec)
+    return nil unless @configuration[:documentation]
+    <<-JS
+/**
+ * Generates rails route to
+ * #{parent_spec}#{route.path.spec}#{build_params(route.required_parts)}
+ * @param {object | undefined} options
+ * @returns {string} route path
+ */
+JS
   end
 
   def route_js_arguments(route, parent_spec)
     required_parts = route.required_parts
-    parts_table = route.parts.each_with_object({}) do |part, hash|
-      hash[part] = required_parts.include?(part)
+    parts_table = {}
+    route.parts.each do |part, hash|
+      parts_table[part] ||= {}
+      if required_parts.include?(part)
+        # Using shortened keys to reduce js file size
+        parts_table[part][:r] = true
+      end
     end
-    default_options = route.defaults.select do |part, _|
-      FILTERED_DEFAULT_PARTS.exclude?(part) &&
+    route.defaults.each do |part, value|
+      if FILTERED_DEFAULT_PARTS.exclude?(part) &&
         URL_OPTIONS.include?(part) || parts_table[part]
+        parts_table[part] ||= {}
+        # Using shortened keys to reduce js file size
+        parts_table[part][:d] = value
+      end
     end
     [
-      # JS objects don't preserve the order of properties which is crucial,
-      # so array is a better choice.
-      parts_table.to_a,
-      default_options,
+      parts_table,
       serialize(route.path.spec, parent_spec)
     ].map do |argument|
       json(argument)
-    end.join(', ')
-  end
-
-  def generate_url_link(name, route_arguments)
-    return '' unless @configuration[:url_links]
-
-    <<-JS.strip!
-    #{generate_route_name(name, :url)}: Utils.route(#{route_arguments}, true)
-    JS
+    end
   end
 
   def generate_route_name(*parts)
-    route_name = parts.compact.join('_')
-    @configuration[:camel_case] ? route_name.camelize(:lower) : route_name
+    apply_case(parts.compact.join('_'))
   end
 
   def json(string)
     self.class.json(string)
   end
 
+  def apply_case(value)
+    @configuration[:camel_case] ? value.to_s.camelize(:lower) : value
+  end
+
   def build_params(required_parts)
-    params = required_parts + [LAST_OPTIONS_KEY]
-    params.join(', ')
+    required_parts.map do |param|
+      "\n * @param {any} #{apply_case(param)}"
+    end.join
   end
 
   # This function serializes Journey route into JSON structure
@@ -296,7 +336,7 @@ class JsRoutes
     [
       NODE_TYPES[spec.type],
       serialize(spec.left, parent_spec),
-      spec.respond_to?(:right) && serialize(spec.right)
-    ]
+      spec.respond_to?(:right) ? serialize(spec.right) : nil
+    ].compact
   end
 end