react_on_rails 11.0.0 → 11.1.0

data/lib/react_on_rails/prerender_error.rb

@@ -2,10 +2,50 @@
 
 # rubocop:disable: Layout/IndentHeredoc
 module ReactOnRails
-  class PrerenderError < StandardError
+  class PrerenderError < ::ReactOnRails::Error
+    MAX_ERROR_SNIPPET_TO_LOG = 1000
+    # TODO: Consider remove providing original `err` as already have access to `self.cause`
+    # http://blog.honeybadger.io/nested-errors-in-ruby-with-exception-cause/
+    attr_reader :component_name, :err, :props, :js_code, :console_messages
+
     # err might be nil if JS caught the error
     def initialize(component_name: nil, err: nil, props: nil,
                    js_code: nil, console_messages: nil)
+      @component_name = component_name
+      @err = err
+      @props = props
+      @js_code = js_code
+      @console_messages = console_messages
+
+      backtrace, message = calc_message(component_name, console_messages, err, js_code, props)
+
+      super([message, backtrace].compact.join("\n"))
+    end
+
+    def to_honeybadger_context
+      to_error_context
+    end
+
+    def raven_context
+      to_error_context
+    end
+
+    def to_error_context
+      result = {
+        component_name: component_name,
+        err: err,
+        props: props,
+        js_code: js_code,
+        console_messages: console_messages
+      }
+
+      result.merge!(err.to_error_context) if err.respond_to?(:to_error_context)
+      result
+    end
+
+    private
+
+    def calc_message(component_name, console_messages, err, js_code, props)
       message = "ERROR in SERVER PRERENDERING\n".dup
       if err
         # rubocop:disable Layout/IndentHeredoc
@@ -19,9 +59,12 @@ Encountered error: \"#{err}\"
       end
       # rubocop:disable Layout/IndentHeredoc
       message << <<-MSG
-when prerendering #{component_name} with props: #{props}
-js_code was:
-#{js_code}
+when prerendering #{component_name} with props: #{Utils.smart_trim(props, MAX_ERROR_SNIPPET_TO_LOG)}
+
+code:
+
+#{Utils.smart_trim(js_code, MAX_ERROR_SNIPPET_TO_LOG)}
+
       MSG
       # rubocop:enable Layout/IndentHeredoc
 
@@ -33,8 +76,7 @@ console messages:
         MSG
         # rubocop:enable Layout/IndentHeredoc
       end
-
-      super([message, backtrace].compact.join("\n"))
+      [backtrace, message]
     end
   end
 end

data/lib/react_on_rails/react_component/render_options.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "react_on_rails/utils"
+
+module ReactOnRails
+  module ReactComponent
+    class RenderOptions
+      include Utils::Required
+
+      attr_accessor :request_digest
+
+      NO_PROPS = {}.freeze
+
+      def initialize(react_component_name: required("react_component_name"), options: required("options"))
+        @react_component_name = react_component_name.camelize
+        @options = options
+      end
+
+      attr_reader :react_component_name
+
+      def props
+        options.fetch(:props) { NO_PROPS }
+      end
+
+      def random_dom_id
+        retrieve_key(:random_dom_id)
+      end
+
+      def dom_id
+        @dom_id ||= options.fetch(:id) do
+          if random_dom_id
+            generate_unique_dom_id
+          else
+            base_dom_id
+          end
+        end
+      end
+
+      def has_random_dom_id?
+        return false if options[:id]
+
+        return false unless random_dom_id
+
+        true
+      end
+
+      def html_options
+        options[:html_options].to_h
+      end
+
+      def prerender
+        retrieve_key(:prerender)
+      end
+
+      def trace
+        retrieve_key(:trace)
+      end
+
+      def replay_console
+        retrieve_key(:replay_console)
+      end
+
+      def raise_on_prerender_error
+        retrieve_key(:raise_on_prerender_error)
+      end
+
+      def logging_on_server
+        retrieve_key(:logging_on_server)
+      end
+
+      def to_s
+        "{ react_component_name = #{react_component_name}, options = #{options}, request_digest = #{request_digest}"
+      end
+
+      private
+
+      attr_reader :options
+
+      def base_dom_id
+       "#{react_component_name}-react-component"
+      end
+
+      def generate_unique_dom_id
+        "#{base_dom_id}-#{SecureRandom.uuid}"
+      end
+
+      def retrieve_key(key)
+        options.fetch(key) do
+          ReactOnRails.configuration.public_send(key)
+        end
+      end
+    end
+  end
+end

data/lib/react_on_rails/server_rendering_pool/ruby_embedded_java_script.rb

@@ -5,61 +5,70 @@ require "open-uri"
 module ReactOnRails
   module ServerRenderingPool
     class RubyEmbeddedJavaScript
-      def self.reset_pool
-        options = {
-          size: ReactOnRails.configuration.server_renderer_pool_size,
-          timeout: ReactOnRails.configuration.server_renderer_timeout
-        }
-        @js_context_pool = ConnectionPool.new(options) { create_js_context }
-      end
+      class << self
+        def reset_pool
+          options = {
+            size: ReactOnRails.configuration.server_renderer_pool_size,
+            timeout: ReactOnRails.configuration.server_renderer_timeout
+          }
+          @js_context_pool = ConnectionPool.new(options) { create_js_context }
+        end
 
-      def self.reset_pool_if_server_bundle_was_modified
-        return unless ReactOnRails.configuration.development_mode
+        def reset_pool_if_server_bundle_was_modified
+          return unless ReactOnRails.configuration.development_mode
 
-        file_mtime = File.mtime(ReactOnRails::Utils.server_bundle_js_file_path)
-        @server_bundle_timestamp ||= file_mtime
-        return if @server_bundle_timestamp == file_mtime
+          file_mtime = File.mtime(ReactOnRails::Utils.server_bundle_js_file_path)
+          @server_bundle_timestamp ||= file_mtime
+          return if @server_bundle_timestamp == file_mtime
 
-        @server_bundle_timestamp = file_mtime
+          @server_bundle_timestamp = file_mtime
 
-        ReactOnRails::ServerRenderingPool.reset_pool
-      end
-
-      # js_code: JavaScript expression that returns a string.
-      # Returns a Hash:
-      #   html: string of HTML for direct insertion on the page by evaluating js_code
-      #   consoleReplayScript: script for replaying console
-      #   hasErrors: true if server rendering errors
-      # Note, js_code does not have to be based on React.
-      # js_code MUST RETURN json stringify Object
-      # Calling code will probably call 'html_safe' on return value before rendering to the view.
-      def self.server_render_js_with_console_logging(js_code)
-        if ReactOnRails.configuration.trace
-          @file_index ||= 1
-          trace_js_code_used("Evaluating code to server render.", js_code,
-                             "tmp/server-generated-#{@file_index % 10}.js")
-          @file_index += 1
+          ReactOnRails::ServerRenderingPool.reset_pool
         end
-        json_string = eval_js(js_code)
-        result = JSON.parse(json_string)
-
-        if ReactOnRails.configuration.logging_on_server
-          console_script = result["consoleReplayScript"]
-          console_script_lines = console_script.split("\n")
-          console_script_lines = console_script_lines[2..-2]
-          re = /console\.(log|error)\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
-          if console_script_lines
-            console_script_lines.each do |line|
-              match = re.match(line)
-              Rails.logger.info { "[react_on_rails] #{match[:msg]}" } if match
+
+        # js_code: JavaScript expression that returns a string.
+        # render_options: lib/react_on_rails/react_component/render_options.rb
+        # Using these options:
+        #    trace: saves the executed JS to a file, used in development
+        #    logging_on_server: put on server logs, not just in browser console
+        #
+        # Returns a Hash:
+        #   html: string of HTML for direct insertion on the page by evaluating js_code
+        #   consoleReplayScript: script for replaying console
+        #   hasErrors: true if server rendering errors
+        # Note, js_code does not have to be based on React.
+        # js_code MUST RETURN json stringify Object
+        # Calling code will probably call 'html_safe' on return value before rendering to the view.
+        def exec_server_render_js(js_code, render_options, js_evaluator = nil)
+          js_evaluator ||= self
+          if render_options.trace
+            @file_index ||= 1
+            trace_js_code_used("Evaluating code to server render.", js_code,
+                               "tmp/server-generated-#{@file_index % 10}.js")
+            @file_index += 1
+          end
+          json_string = js_evaluator.eval_js(js_code, render_options)
+          result = nil
+          begin
+            result = JSON.parse(json_string)
+          rescue JSON::ParserError => e
+            raise ReactOnRails::JsonParseError.new(e, json_string)
+          end
+
+          if render_options.logging_on_server
+            console_script = result["consoleReplayScript"]
+            console_script_lines = console_script.split("\n")
+            console_script_lines = console_script_lines[2..-2]
+            re = /console\.(log|error)\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
+            if console_script_lines
+              console_script_lines.each do |line|
+                match = re.match(line)
+                Rails.logger.info { "[react_on_rails] #{match[:msg]}" } if match
+              end
             end
           end
+          result
         end
-        result
-      end
-
-      class << self
-        private
 
         def trace_js_code_used(msg, js_code, file_name = "tmp/server-generated.js", force: false)
           return unless ReactOnRails.configuration.trace || force
@@ -78,7 +87,7 @@ module ReactOnRails
           end
         end
 
-        def eval_js(js_code)
+        def eval_js(js_code, _render_options)
           @js_context_pool.with do |js_context|
             result = js_context.eval(js_code)
             js_context.eval("console.history = []")
@@ -156,8 +165,7 @@ function clearTimeout() {
 
         def undefined_for_exec_js_logging(function_name)
           if ReactOnRails.configuration.trace
-            "console.error('[React on Rails Rendering] #{function_name} is not defined for execJS. See "\
-            "https://github.com/sstephenson/execjs#faq. Note babel-polyfill may call this.');\n"\
+            "console.error('[React on Rails Rendering] #{function_name} is not defined for server rendering.');\n"\
             "  console.error(getStackTrace().join('\\n'));"
           else
             ""

data/lib/react_on_rails/server_rendering_pool.rb

@@ -5,33 +5,21 @@ require_relative "server_rendering_pool/ruby_embedded_java_script"
 
 # Based on the react-rails gem.
 # None of these methods should be called directly.
-# See app/helpers/react_on_rails_helper.rb
 module ReactOnRails
   module ServerRenderingPool
     class << self
-      def react_on_rails_pro?
-        @react_on_rails_pro ||= gem_available?("react_on_rails_pro")
-      end
-
       def pool
-        @pool ||= if react_on_rails_pro?
+        @pool ||= if ReactOnRails::Utils.react_on_rails_pro?
                     ReactOnRailsPro::ServerRenderingPool::ProRendering
                   else
                     ReactOnRails::ServerRenderingPool::RubyEmbeddedJavaScript
                   end
       end
 
-      delegate :server_render_js_with_console_logging, :reset_pool_if_server_bundle_was_modified,
-               :reset_pool, to: :pool
-
-      private
+      delegate :reset_pool_if_server_bundle_was_modified, :reset_pool, to: :pool
 
-      def gem_available?(name)
-        Gem::Specification.find_by_name(name)
-      rescue Gem::LoadError
-        false
-      rescue StandardError
-        Gem.available?(name)
+      def server_render_js_with_console_logging(js_code, render_options)
+        pool.exec_server_render_js(js_code, render_options)
       end
     end
   end

data/lib/react_on_rails/test_helper/webpack_assets_status_checker.rb

@@ -13,14 +13,14 @@ module ReactOnRails
       # source_path is typically configured in the webpacker.yml file
       # for `source_path`
       # or for legacy React on Rails, it's /client, where all client files go
-      attr_reader :source_path, :generated_assets_dir
+      attr_reader :source_path, :generated_assets_full_path
 
       def initialize(
-        generated_assets_dir: required("generated_assets_dir"),
+        generated_assets_full_path: required("generated_assets_full_path"),
         source_path: required("source_path"),
         webpack_generated_files: required("webpack_generated_files")
       )
-        @generated_assets_dir = generated_assets_dir
+        @generated_assets_full_path = generated_assets_full_path
         @source_path = source_path
         @webpack_generated_files = webpack_generated_files
       end
@@ -53,19 +53,23 @@ module ReactOnRails
       def all_compiled_assets
         @all_compiled_assets ||= begin
           webpack_generated_files = @webpack_generated_files.map do |bundle_name|
-            ReactOnRails::Utils.bundle_js_file_path(bundle_name)
+            if bundle_name == ReactOnRails.configuration.server_bundle_js_file
+              ReactOnRails::Utils.server_bundle_js_file_path
+            else
+              ReactOnRails::Utils.bundle_js_file_path(bundle_name)
+            end
           end
 
           if webpack_generated_files.present?
             webpack_generated_files
           else
-            file_list = make_file_list(make_globs(generated_assets_dir)).to_ary
+            file_list = make_file_list(make_globs(generated_assets_full_path)).to_ary
             puts "V" * 80
             puts "Please define config.webpack_generated_files (array) so the test helper knows "\
             "which files are required. If you are using webpacker, you typically need to only "\
             "include 'manifest.json'."
             puts "Detected the possible following files to check for webpack compilation in "\
-              "#{generated_assets_dir}"
+              "#{generated_assets_full_path}"
             puts file_list.join("\n")
             puts "^" * 80
             file_list

data/lib/react_on_rails/test_helper.rb

@@ -31,7 +31,7 @@ module ReactOnRails
     # Params:
     # config - config for rspec
     # metatags - metatags to add the ensure_assets_compiled check.
-    #            Default is :js, :server_rendering
+    #            Default is :js, :server_rendering, :controller
     def self.configure_rspec_to_compile_assets(config, *metatags)
       metatags = %i[js server_rendering controller] if metatags.empty?
 
@@ -48,30 +48,31 @@ module ReactOnRails
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsStatusChecker
     # webpack_assets_compiler: provide one method: `def compile`
     #                         defaults to ReactOnRails::TestHelper::WebpackAssetsCompiler
-    # source_path and generated_assets_dir are passed into the default webpack_assets_status_checker if you
+    # source_path and generated_assets_full_path are passed into the default webpack_assets_status_checker if you
     #                        don't provide one.
     # webpack_generated_files List of files to check for up-to-date-status, defaulting to
     #                        webpack_generated_files in your configuration
     def self.ensure_assets_compiled(webpack_assets_status_checker: nil,
                                     webpack_assets_compiler: nil,
                                     source_path: nil,
-                                    generated_assets_dir: nil,
+                                    generated_assets_full_path: nil,
                                     webpack_generated_files: nil)
       ReactOnRails::WebpackerUtils.check_manifest_not_cached
       if webpack_assets_status_checker.nil?
         source_path ||= ReactOnRails::Utils.source_path
-        generated_assets_dir ||= ReactOnRails::Utils.generated_assets_dir
+        generated_assets_full_path ||= ReactOnRails::Utils.generated_assets_full_path
         webpack_generated_files ||= ReactOnRails.configuration.webpack_generated_files
 
         webpack_assets_status_checker ||=
           WebpackAssetsStatusChecker.new(source_path: source_path,
-                                         generated_assets_dir: generated_assets_dir,
+                                         generated_assets_full_path: generated_assets_full_path,
                                          webpack_generated_files: webpack_generated_files)
 
         unless @printed_once
           puts
-          puts "====> React On Rails: Checking #{webpack_assets_status_checker.generated_assets_dir} for "\
-          "outdated/missing bundles"
+          puts "====> React On Rails: Checking files in "\
+            "#{webpack_assets_status_checker.generated_assets_full_path} for "\
+            "outdated/missing bundles based on source_path #{source_path}"
           puts
           @printed_once = true
         end

data/lib/react_on_rails/utils.rb

@@ -8,6 +8,8 @@ require "active_support/core_ext/string"
 
 module ReactOnRails
   module Utils
+    TRUNCATION_FILLER = "\n... TRUNCATED ...\n"
+
     # https://forum.shakacode.com/t/yak-of-the-week-ruby-2-4-pathname-empty-changed-to-look-at-file-size/901
     # return object if truthy, else return nil
     def self.truthy_presence(obj)
@@ -76,8 +78,10 @@ exitstatus: #{status.exitstatus}#{stdout_msg}#{stderr_msg}
                               begin
                                 bundle_js_file_path(bundle_name)
                               rescue Webpacker::Manifest::MissingEntryError
-                                Rails.root.join(File.join(Webpacker.config.public_output_path,
-                                                          bundle_name)).to_s
+                                File.expand_path(
+                                  File.join(ReactOnRails::WebpackerUtils.webpacker_public_output_path,
+                                            bundle_name)
+                                )
                               end
                             else
                               bundle_js_file_path(bundle_name)
@@ -90,7 +94,8 @@ exitstatus: #{status.exitstatus}#{stdout_msg}#{stderr_msg}
       else
         # Default to the non-hashed name in the specified output directory, which, for legacy
         # React on Rails, this is the output directory picked up by the asset pipeline.
-        File.join(ReactOnRails.configuration.generated_assets_dir, bundle_name)
+        # For Webpacker, this is the public output path defined in the webpacker.yml file.
+        File.join(generated_assets_full_path, bundle_name)
       end
     end
 
@@ -114,7 +119,7 @@ exitstatus: #{status.exitstatus}#{stdout_msg}#{stderr_msg}
 
     module Required
       def required(arg_name)
-        raise ReactOnRailsPro::Error, "#{arg_name} is required"
+        raise ReactOnRails::Error, "#{arg_name} is required"
       end
     end
 
@@ -130,12 +135,39 @@ exitstatus: #{status.exitstatus}#{stdout_msg}#{stderr_msg}
       end
     end
 
-    def self.generated_assets_dir
+    def self.generated_assets_full_path
       if ReactOnRails::WebpackerUtils.using_webpacker?
         ReactOnRails::WebpackerUtils.webpacker_public_output_path
       else
-        ReactOnRails.configuration.generated_assets_dir
+        File.expand_path(ReactOnRails.configuration.generated_assets_dir)
       end
     end
+
+    def self.gem_available?(name)
+      Gem::Specification.find_by_name(name).present?
+    rescue Gem::LoadError
+      false
+    rescue StandardError
+      Gem.available?(name).present?
+    end
+
+    def self.react_on_rails_pro?
+      @react_on_rails_pro ||= gem_available?("react_on_rails_pro")
+    end
+
+    def self.smart_trim(str, max_length = 1000)
+      # From https://stackoverflow.com/a/831583/1009332
+      str = str.to_s
+      return str unless str.present? && max_length >= 1
+      return str if str.length <= max_length
+
+      return str[0, 1] + TRUNCATION_FILLER if max_length == 1
+
+      midpoint = (str.length / 2.0).ceil;
+      to_remove = str.length - max_length;
+      lstrip = (to_remove / 2.0).ceil;
+      rstrip = to_remove - lstrip;
+      str[0..(midpoint - lstrip - 1)] + TRUNCATION_FILLER + str[(midpoint + rstrip)..-1]
+    end
   end
 end

data/lib/react_on_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReactOnRails
-  VERSION = "11.0.0".freeze
+  VERSION = "11.1.0".freeze
 end

data/lib/react_on_rails/version_syntax_converter.rb

@@ -2,19 +2,21 @@
 
 require_relative "version"
 
-class VersionSyntaxConverter
-  def rubygem_to_npm(rubygem_version = ReactOnRails::VERSION)
-    regex_match = rubygem_version.match(/(\d+\.\d+\.\d+)[.\-]?(.+)?/)
-    return "#{regex_match[1]}-#{regex_match[2]}" if regex_match[2]
+module ReactOnRails
+  class VersionSyntaxConverter
+    def rubygem_to_npm(rubygem_version = ReactOnRails::VERSION)
+      regex_match = rubygem_version.match(/(\d+\.\d+\.\d+)[.\-]?(.+)?/)
+      return "#{regex_match[1]}-#{regex_match[2]}" if regex_match[2]
 
-    regex_match[1].to_s
-  end
+      regex_match[1].to_s
+    end
 
-  def npm_to_rubygem(npm_version)
-    match = npm_version
-            .tr("-", ".")
-            .strip
-            .match(/(\d.*)/)
-    match.present? ? match[0] : nil
+    def npm_to_rubygem(npm_version)
+      match = npm_version
+              .tr("-", ".")
+              .strip
+              .match(/(\d.*)/)
+      match.present? ? match[0] : nil
+    end
   end
 end

data/lib/react_on_rails/webpacker_utils.rb

@@ -1,18 +1,20 @@
 module ReactOnRails
   module WebpackerUtils
     def self.using_webpacker?
-      ActionController::Base.helpers.respond_to?(:asset_pack_path)
+      ReactOnRails::Utils.gem_available?("webpacker")
     end
 
     def self.bundle_js_file_path_from_webpacker(bundle_name)
-      possible_result = Webpacker.manifest.lookup(bundle_name)
-      hashed_bundle_name = possible_result.nil? ? Webpacker.manifest.lookup!(bundle_name) : possible_result
+      # Note Webpacker 3.4.3 manifest lookup is inside of the public_output_path
+      # [2] (pry) ReactOnRails::WebpackerUtils: 0> Webpacker.manifest.lookup("app-bundle.js")
+      # "/webpack/development/app-bundle-c1d2b6ab73dffa7d9c0e.js"
+      # Next line will throw if the file or manifest does not exist
+      hashed_bundle_name = Webpacker.manifest.lookup!(bundle_name)
+
       if Webpacker.dev_server.running?
-        result = "#{Webpacker.dev_server.protocol}://#{Webpacker.dev_server.host_with_port}#{hashed_bundle_name}"
-        result
+        "#{Webpacker.dev_server.protocol}://#{Webpacker.dev_server.host_with_port}#{hashed_bundle_name}"
       else
-        # Next line will throw if the file or manifest does not exist
-        Rails.root.join(File.join("public", hashed_bundle_name)).to_s
+        File.expand_path(File.join("public", hashed_bundle_name)).to_s
       end
     end
 
@@ -21,7 +23,8 @@ module ReactOnRails
     end
 
     def self.webpacker_public_output_path
-      Webpacker.config.public_output_path
+      # Webpacker has the full absolute path of webpacker output files in a Pathname
+      Webpacker.config.public_output_path.to_s
     end
 
     def self.manifest_exists?

data/lib/react_on_rails.rb

@@ -3,14 +3,16 @@
 require "rails"
 
 require "react_on_rails/error"
-require "react_on_rails/react_on_rails_helper"
+require "react_on_rails/prerender_error"
+require "react_on_rails/json_parse_error"
+require "react_on_rails/helper"
 require "react_on_rails/controller"
 require "react_on_rails/version"
 require "react_on_rails/version_checker"
 require "react_on_rails/configuration"
 require "react_on_rails/server_rendering_pool"
 require "react_on_rails/engine"
-require "react_on_rails/react_component/options"
+require "react_on_rails/react_component/render_options"
 require "react_on_rails/version_syntax_converter"
 require "react_on_rails/test_helper"
 require "react_on_rails/git_utils"

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-on-rails",
-  "version": "11.0.0",
+  "version": "11.1.0",
   "description": "react-on-rails JavaScript for react_on_rails Ruby gem",
   "main": "node_package/lib/ReactOnRails.js",
   "directories": {
@@ -53,7 +53,8 @@
   "scripts": {
     "test": "babel-tape-runner -r node_package/tests/helpers/test_helper.js node_package/tests/*.js | tap-spec",
     "clean": "rm -rf node_package/lib",
-    "prepublish": "yarn run build",
+    "prepare": "yarn run build",
+    "prepublish": "npm run prepare",
     "babel": "babel --out-dir node_package/lib node_package/src",
     "build": "yarn run clean && yarn run babel",
     "build-watch": "babel --watch --out-dir node_package/lib node_package/src",

data/rakelib/release.rake

@@ -41,7 +41,7 @@ task :release, %i[gem_version dry_run tools_install] do |_t, args|
   npm_version = if gem_version.strip.empty?
                   ""
                 else
-                  VersionSyntaxConverter.new.rubygem_to_npm(gem_version)
+                  ReactOnRails::VersionSyntaxConverter.new.rubygem_to_npm(gem_version)
                 end
 
   # Having the examples prevents publishing

data/react_on_rails.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |s|
   s.add_dependency "connection_pool"
   s.add_dependency "execjs", "~> 2.5"
   s.add_dependency "rails", ">= 3.2"
-  s.add_dependency "rainbow", "~> 2.2"
+  s.add_dependency "rainbow", "~> 3.0"
 
   s.add_development_dependency "awesome_print"
   s.add_development_dependency "bundler", "~> 1"
@@ -48,7 +48,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rake", "~> 10.0"
   s.add_development_dependency "rspec"
-  s.add_development_dependency "rubocop", "0.55.0"
+  s.add_development_dependency "rubocop", "~> 0.58.1"
 
   s.post_install_message = '
 --------------------------------------------------------------------------------