rubocop 0.26.1 → 0.27.0

data/lib/rubocop/cop/style/string_literals_in_interpolation.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if uses of quotes match the configured preference.
+      class StringLiteralsInInterpolation < Cop
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+
+        private
+
+        def message(*)
+          # single_quotes -> single-quoted
+          kind = style.to_s.sub(/_(.*)s/, '-\1d')
+
+          "Prefer #{kind} strings inside interpolations."
+        end
+
+        def offense?(node)
+          # If it's not a string within a dynamic string, i.e. part of an
+          # expression in an interpolation, then it's not an offense for this
+          # cop.
+          return false unless node.each_ancestor.find do |a|
+            a.type == :dstr && within_node?(node, a)
+          end
+
+          wrong_quotes?(node, style)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            replacement = node.loc.begin.is?('"') ? "'" : '"'
+            corrector.replace(node.loc.begin, replacement)
+            corrector.replace(node.loc.end, replacement)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_comma.rb

@@ -78,8 +78,6 @@ module RuboCop
             unless should_have_comma
               extra_info = if style == :comma
                              ', unless each item is on its own line'
-                           else
-                             ''
                            end
               avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
                           extra_info)
@@ -123,7 +121,7 @@ module RuboCop
           article = kind =~ /array/ ? 'an' : 'a'
           add_offense(range, range,
                       format(MSG, 'Avoid', format(kind, article)) +
-                      extra_info + '.')
+                      "#{extra_info}.")
         end
 
         def put_comma(items, kind, sb)

data/lib/rubocop/cop/style/trivial_accessors.rb

@@ -6,13 +6,13 @@ module RuboCop
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
       class TrivialAccessors < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Use `attr_%s` to define trivial %s methods.'
 
         private
 
-        def on_method(node, method_name, args, body)
+        def on_method_def(node, method_name, args, body)
           kind = if trivial_reader?(method_name, args, body)
                    'reader'
                  elsif trivial_writer?(method_name, args, body)
@@ -91,7 +91,7 @@ module RuboCop
 
         def trivial_accessor_kind(method_name, args, body)
           if trivial_writer?(method_name, args, body) &&
-            !dsl_writer?(method_name)
+             !dsl_writer?(method_name)
             'writer'
           elsif trivial_reader?(method_name, args, body)
             'reader'

data/lib/rubocop/cop/style/unneeded_capital_w.rb

@@ -19,7 +19,7 @@ module RuboCop
         def on_percent_literal(node)
           node.children.each do |string|
             if string.type == :dstr ||
-              string.loc.expression.source =~ StringHelp::ESCAPED_CHAR_REGEXP
+               string.loc.expression.source =~ StringHelp::ESCAPED_CHAR_REGEXP
               return
             end
           end

data/lib/rubocop/cop/style/unneeded_percent_q.rb

@@ -33,11 +33,11 @@ module RuboCop
           end
           return if ignored_node?(node) || part_of_ignored_node?(node)
           src = node.loc.expression.source
-          return unless src =~ /^%q/i
+          return unless src.start_with?('%q') || src.start_with?('%Q')
           return if src =~ /'/ && src =~ /"/
           return if src =~ StringHelp::ESCAPED_CHAR_REGEXP
 
-          extra = if src =~ /^%Q/
+          extra = if src.start_with?('%Q')
                     ', or for dynamic strings that contain double quotes'
                   else
                     ''

data/lib/rubocop/cop/style/word_array.rb

@@ -17,8 +17,8 @@ module RuboCop
         def on_array(node)
           array_elems = node.children
           return unless array_of?(:str, node) &&
-            !complex_content?(array_elems) &&
-            array_elems.size > min_size && !comments_in_array?(node)
+                        !complex_content?(array_elems) &&
+                        array_elems.size > min_size && !comments_in_array?(node)
 
           add_offense(node, :expression) { self.max = array_elems.size }
         end
@@ -45,7 +45,7 @@ module RuboCop
             next if source.start_with?('?') # %W(\r \n) can replace [?\r, ?\n]
 
             str_content = Util.strip_quotes(source)
-            return true unless str_content =~ /\A[\p{Word}]+\z/
+            return true unless str_content =~ word_regex
           end
 
           false
@@ -55,29 +55,33 @@ module RuboCop
           cop_config['MinSize']
         end
 
+        def word_regex
+          cop_config['WordRegex']
+        end
+
         def autocorrect(node)
-          sb = node.loc.expression.source_buffer
-          interpolated = false
-
-          contents = node.children.map do |n|
-            if character_literal?(n)
-              interpolated = true
-              begin_pos = n.loc.expression.begin_pos + '?'.length
-              end_pos = n.loc.expression.end_pos
-            else
-              begin_pos = n.loc.begin.end_pos
-              end_pos = n.loc.end.begin_pos
-            end
-            Parser::Source::Range.new(sb, begin_pos, end_pos).source
-          end.join(' ')
-
-          char = interpolated ? 'W' : 'w'
+          @interpolated = false
+          contents = node.children.map { |n| source_for(n) }.join(' ')
+          char = @interpolated ? 'W' : 'w'
 
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.expression, "%#{char}(#{contents})")
           end
         end
 
+        def source_for(str_node)
+          if character_literal?(str_node)
+            @interpolated = true
+            begin_pos = str_node.loc.expression.begin_pos + '?'.length
+            end_pos = str_node.loc.expression.end_pos
+          else
+            begin_pos = str_node.loc.begin.end_pos
+            end_pos = str_node.loc.end.begin_pos
+          end
+          Parser::Source::Range.new(str_node.loc.expression.source_buffer,
+                                    begin_pos, end_pos).source
+        end
+
         def character_literal?(node)
           node.loc.end.nil?
         end

data/lib/rubocop/cop/team.rb

@@ -62,26 +62,7 @@ module RuboCop
         @updated_source_file = false
         return unless autocorrect?
 
-        corrections = cops.each_with_object([]) do |cop, array|
-          array.concat(cop.corrections) if cop.relevant_file?(buffer.name)
-        end
-
-        corrector = Corrector.new(buffer, corrections)
-        new_source = begin
-                       # Corrector#rewrite can raise RangeError or RuntimeError
-                       # for various error conditions including clobbering.
-                       s = corrector.rewrite
-                       # We raise RuntimeError ourselves if the rewritten code
-                       # is not parsable ruby. We don't want to write that code
-                       # to file.
-                       fail unless ProcessedSource.new(s).valid_syntax?
-                       s
-                     rescue RangeError, RuntimeError
-                       # Handle all errors by limiting the changes to one
-                       # cop. The caller will parse the source again when the
-                       # file has been updated.
-                       autocorrect_one_cop(buffer, cops)
-                     end
+        new_source = autocorrect_one_cop(buffer, cops)
 
         return if new_source == buffer.source
 
@@ -90,13 +71,19 @@ module RuboCop
         @updated_source_file = true
       end
 
-      # Does a slower but safer auto-correction run by correcting for just one
-      # cop. The re-running of auto-corrections will make sure that the full
-      # set of auto-corrections is tried again after this method has finished.
+      # Does an auto-correction run by correcting for just one cop. The
+      # re-running of auto-corrections will make sure that the full set of
+      # auto-corrections is tried again after this method has finished.
       def autocorrect_one_cop(buffer, cops)
-        cop_with_corrections = cops.find { |cop| cop.corrections.any? }
-        corrector = Corrector.new(buffer, cop_with_corrections.corrections)
-        corrector.rewrite
+        cop_with_corrections = cops.find do |cop|
+          cop.relevant_file?(buffer.name) && cop.corrections.any?
+        end
+        if cop_with_corrections
+          corrector = Corrector.new(buffer, cop_with_corrections.corrections)
+          corrector.rewrite
+        else
+          buffer.source
+        end
       end
 
       def process_commissioner_errors(file, file_errors)

data/lib/rubocop/cop/util.rb

@@ -158,6 +158,11 @@ module RuboCop
         source_before_end =~ /\n\s*\Z/
       end
 
+      def within_node?(inner, outer)
+        o, i = outer.loc.expression, inner.loc.expression
+        i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
+      end
+
       # Returns, for example, a bare `if` node if the given node is an `if`
       # with calls chained to the end of it.
       def first_part_of_call_chain(node)

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -39,7 +39,7 @@ module RuboCop
           #     # resbody
           #   end
           if branch_point_node.type == :rescue &&
-            (branch_body_name == 'main' || other.branch_body_name == 'main')
+             (branch_body_name == 'main' || other.branch_body_name == 'main')
             return false
           end
 
@@ -78,18 +78,12 @@ module RuboCop
 
         def branch_body_name
           case branch_point_node.type
-          when :if
-            if_body_name
-          when :case
-            case_body_name
-          when *LOGICAL_OPERATOR_TYPES
-            logical_operator_body_name
-          when RESCUE_TYPE
-            rescue_body_name
-          when ENSURE_TYPE
-            ensure_body_name
-          else
-            fail InvalidBranchBodyError
+          when :if                     then if_body_name
+          when :case                   then case_body_name
+          when *LOGICAL_OPERATOR_TYPES then logical_operator_body_name
+          when RESCUE_TYPE             then rescue_body_name
+          when ENSURE_TYPE             then ensure_body_name
+          else fail InvalidBranchBodyError
           end
         rescue InvalidBranchBodyError
           raise InvalidBranchBodyError,

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -56,7 +56,7 @@ module RuboCop
         return unless default_cfg
 
         params = default_cfg.keys - %w(Description StyleGuide Enabled) -
-          cfg.keys
+                 cfg.keys
         return if params.empty?
 
         output.puts "# Configuration parameters: #{params.join(', ')}."

data/lib/rubocop/formatter/formatter_set.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'fileutils'
+
 module RuboCop
   module Formatter
     # This is a collection of formatters. A FormatterSet can hold multiple
@@ -37,7 +39,13 @@ module RuboCop
                             builtin_formatter_class(formatter_type)
                           end
 
-        output = output_path ? File.open(output_path, 'w') : $stdout
+        if output_path
+          dir_path = File.dirname(output_path)
+          FileUtils.mkdir_p(dir_path) unless File.exist?(dir_path)
+          output = File.open(output_path, 'w')
+        else
+          output = $stdout
+        end
 
         self << formatter_class.new(output)
       end

data/lib/rubocop/formatter/html_formatter.rb

@@ -1,89 +1,117 @@
 # encoding: utf-8
 
 require 'erb'
-require 'pathname'
+require 'ostruct'
+require 'base64'
+require 'rubocop/formatter/text_util'
 
 module RuboCop
   module Formatter
     # This formatter saves the output as a html file.
     class HTMLFormatter < BaseFormatter
-      include PathUtil
+      TEMPLATE_PATH =
+        File.expand_path('../../../../assets/output.html.erb', __FILE__)
 
-      attr_reader :output_hash
+      attr_reader :files, :summary
 
       def initialize(output)
         super
-        @output_hash = {
-          metadata: metadata_hash,
-          files:    [],
-          summary:  { offense_count: 0 }
-        }
+        @files = []
+        @summary = OpenStruct.new(offense_count: 0)
       end
 
       def started(target_files)
-        output_hash[:summary][:target_file_count] = target_files.count
+        summary.target_files = target_files
       end
 
       def file_finished(file, offenses)
-        output_hash[:files] << hash_for_file(file, offenses)
-        output_hash[:summary][:offense_count] += offenses.count
+        files << OpenStruct.new(path: file, offenses: offenses)
+        summary.offense_count += offenses.count
       end
 
       def finished(inspected_files)
-        output_hash[:summary][:inspected_file_count] = inspected_files.count
-        template = File.read(File
-          .expand_path('../../../../assets/output.html.erb', __FILE__))
-        erb = ERB.new(template)
-        html_content = erb.result(binding)
-        output.write html_content
-      end
+        summary.inspected_files = inspected_files
 
-      def metadata_hash
-        {
-          rubocop_version: RuboCop::Version::STRING,
-          ruby_engine:     RUBY_ENGINE,
-          ruby_version:    RUBY_VERSION,
-          ruby_patchlevel: RUBY_PATCHLEVEL.to_s,
-          ruby_platform:   RUBY_PLATFORM
-        }
+        render_html
       end
 
-      def hash_for_file(file, offenses)
-        {
-          path:     relative_path(file),
-          offenses: offenses.map { |o| hash_for_offense(o) }
-        }
+      def render_html
+        context = ERBContext.new(files, summary)
+
+        template = File.read(TEMPLATE_PATH)
+        erb = ERB.new(template, nil, '-')
+        html = erb.result(context.binding)
+
+        output.write html
       end
 
-      def hash_for_offense(offense)
-        {
-          severity: offense.severity.name,
-          message:  offense.message,
-          cop_name: offense.cop_name,
-          corrected: offense.corrected?,
-          location: hash_for_location(offense)
-        }
+      Color = Struct.new(:red, :green, :blue, :alpha) do
+        def to_s
+          "rgba(#{values.join(', ')})"
+        end
+
+        def fade_out(amount)
+          dup.tap do |color|
+            color.alpha -= amount
+          end
+        end
       end
 
-      # TODO: Consider better solution for Offense#real_column.
-      def hash_for_location(offense)
-        {
-          line:   offense.line,
-          column: offense.real_column,
-          length: offense.location.length,
-          source_line: offense.location.source_line,
-          highlight: highlight_line(offense.location)
+      # This class privides helper methods used in the ERB template.
+      class ERBContext
+        include PathUtil, TextUtil
+
+        SEVERITY_COLORS = {
+          refactor:   Color.new(0xED, 0x9C, 0x28, 1.0),
+          convention: Color.new(0xED, 0x9C, 0x28, 1.0),
+          warning:    Color.new(0x96, 0x28, 0xEF, 1.0),
+          error:      Color.new(0xD2, 0x32, 0x2D, 1.0),
+          fatal:      Color.new(0xD2, 0x32, 0x2D, 1.0)
         }
-      end
 
-      def highlight_line(location)
-        column_length = if location.begin.line == location.end.line
-                          location.column_range.count
-                        else
-                          location.source_line.length - location.column
-                        end
+        LOGO_IMAGE_PATH =
+          File.expand_path('../../../../assets/logo.png', __FILE__)
+
+        attr_reader :files, :summary
+
+        def initialize(files, summary)
+          @files = files.sort_by(&:path)
+          @summary = summary
+        end
+
+        # Make Kernel#binding public.
+        def binding
+          super
+        end
+
+        def decorated_message(offense)
+          offense.message.gsub(/`(.+?)`/) do
+            "<code>#{Regexp.last_match(1)}</code>"
+          end
+        end
+
+        def highlighted_source_line(offense)
+          location = offense.location
+
+          column_range = if location.begin.line == location.end.line
+                           location.column_range
+                         else
+                           location.column...location.source_line.length
+                         end
+
+          source_line = location.source_line
+
+          source_line[0...column_range.begin] +
+            "<span class=\"highlight #{offense.severity}\">" +
+            source_line[column_range] +
+            '</span>' +
+            source_line[column_range.end..-1]
+        end
 
-        ' ' * location.column + '^' * column_length
+        def base64_encoded_logo_image
+          image = File.read(LOGO_IMAGE_PATH, binmode: true)
+          Base64.encode64(image)
+        end
       end
     end
   end