rubocop 0.75.1

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for division with integers coerced to floats.
+      # It is recommended to either always use `fdiv` or coerce one side only.
+      # This cop also provides other options for code consistency.
+      #
+      # @example EnforcedStyle: single_coerce (default)
+      #   # bad
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: left_coerce
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.to_f / b
+      #
+      # @example EnforcedStyle: right_coerce
+      #   # bad
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a / b.to_f
+      #
+      # @example EnforcedStyle: fdiv
+      #   # bad
+      #   a / b.to_f
+      #   a.to_f / b
+      #   a.to_f / b.to_f
+      #
+      #   # good
+      #   a.fdiv(b)
+      class FloatDivision < Cop
+        include ConfigurableEnforcedStyle
+
+        def_node_matcher :right_coerce?, <<~PATTERN
+          (send _ :/ (send _ :to_f))
+        PATTERN
+        def_node_matcher :left_coerce?, <<~PATTERN
+          (send (send _ :to_f) :/ _)
+        PATTERN
+        def_node_matcher :both_coerce?, <<~PATTERN
+          (send (send _ :to_f) :/ (send _ :to_f))
+        PATTERN
+        def_node_matcher :any_coerce?, <<~PATTERN
+          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if offense_condition?(node)
+        end
+
+        private
+
+        def offense_condition?(node)
+          case style
+          when :left_coerce
+            right_coerce?(node)
+          when :right_coerce
+            left_coerce?(node)
+          when :single_coerce
+            both_coerce?(node)
+          when :fdiv
+            any_coerce?(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          case style
+          when :left_coerce
+            'Prefer using `.to_f` on the left side.'
+          when :right_coerce
+            'Prefer using `.to_f` on the right side.'
+          when :single_coerce
+            'Prefer using `.to_f` on one side only.'
+          when :fdiv
+            'Prefer using `fdiv` for float divisions.'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of the `for` keyword or `each` method. The
+      # preferred alternative is set in the EnforcedStyle configuration
+      # parameter. An `each` call with a block on a single line is always
+      # allowed.
+      #
+      # @example EnforcedStyle: each (default)
+      #   # bad
+      #   def foo
+      #     for n in [1, 2, 3] do
+      #       puts n
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     [1, 2, 3].each do |n|
+      #       puts n
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: for
+      #   # bad
+      #   def foo
+      #     [1, 2, 3].each do |n|
+      #       puts n
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     for n in [1, 2, 3] do
+      #       puts n
+      #     end
+      #   end
+      #
+      class For < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        EACH_LENGTH = 'each'.length
+        PREFER_EACH = 'Prefer `each` over `for`.'
+        PREFER_FOR = 'Prefer `for` over `each`.'
+
+        def on_for(node)
+          if style == :each
+            add_offense(node, message: PREFER_EACH) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def on_block(node)
+          return unless suspect_enumerable?(node)
+
+          if style == :for
+            add_offense(node, message: PREFER_FOR) do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def autocorrect(node)
+          if style == :each
+            ForToEachCorrector.new(node)
+          else
+            EachToForCorrector.new(node)
+          end
+        end
+
+        private
+
+        def suspect_enumerable?(node)
+          node.multiline? &&
+            node.send_node.method?(:each) && !node.send_node.arguments?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of a single string formatting utility.
+      # Valid options include Kernel#format, Kernel#sprintf and String#%.
+      #
+      # The detection of String#% cannot be implemented in a reliable
+      # manner for all cases, so only two scenarios are considered -
+      # if the first argument is a string literal and if the second
+      # argument is an array literal.
+      #
+      # @example EnforcedStyle: format (default)
+      #   # bad
+      #   puts sprintf('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts format('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: sprintf
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts '%10s' % 'hoge'
+      #
+      #   # good
+      #   puts sprintf('%10s', 'hoge')
+      #
+      # @example EnforcedStyle: percent
+      #   # bad
+      #   puts format('%10s', 'hoge')
+      #   puts sprintf('%10s', 'hoge')
+      #
+      #   # good
+      #   puts '%10s' % 'hoge'
+      #
+      class FormatString < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Favor `%<prefer>s` over `%<current>s`.'
+
+        def_node_matcher :formatter, <<~PATTERN
+          {
+            (send nil? ${:sprintf :format} _ _ ...)
+            (send {str dstr} $:% ... )
+            (send !nil? $:% {array hash})
+          }
+        PATTERN
+
+        def_node_matcher :variable_argument?, <<~PATTERN
+          (send {str dstr} :% {send_type? lvar_type?})
+        PATTERN
+
+        def on_send(node)
+          formatter(node) do |selector|
+            detected_style = selector == :% ? :percent : selector
+
+            return if detected_style == style
+
+            add_offense(node, location: :selector,
+                              message: message(detected_style))
+          end
+        end
+
+        def message(detected_style)
+          format(MSG,
+                 prefer: method_name(style),
+                 current: method_name(detected_style))
+        end
+
+        def method_name(style_name)
+          style_name == :percent ? 'String#%' : style_name
+        end
+
+        def autocorrect(node)
+          return if variable_argument?(node)
+
+          lambda do |corrector|
+            case node.method_name
+            when :%
+              autocorrect_from_percent(corrector, node)
+            when :format, :sprintf
+              case style
+              when :percent
+                autocorrect_to_percent(corrector, node)
+              when :format, :sprintf
+                corrector.replace(node.loc.selector, style.to_s)
+              end
+            end
+          end
+        end
+
+        private
+
+        def autocorrect_from_percent(corrector, node)
+          args = if %i[array hash].include?(node.first_argument.type)
+                   node.first_argument.children.map(&:source).join(', ')
+                 else
+                   node.first_argument.source
+                 end
+
+          corrected = "#{style}(#{node.receiver.source}, #{args})"
+
+          corrector.replace(node.loc.expression, corrected)
+        end
+
+        def autocorrect_to_percent(corrector, node)
+          format = node.first_argument.source
+
+          args = if node.arguments.size == 2
+                   arg = node.arguments.last
+
+                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                 else
+                   "[#{node.arguments[1..-1].map(&:source).join(', ')}]"
+                 end
+
+          corrector.replace(node.loc.expression, "#{format} % #{args}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a consistent style for named format string tokens.
+      #
+      # **Note:**
+      # `unannotated` style cop only works for strings
+      # which are passed as arguments to those methods:
+      # `printf`, `sprintf`, `format`, `%`.
+      # The reason is that *unannotated* format is very similar
+      # to encoded URLs or Date/Time formatting strings.
+      #
+      # @example EnforcedStyle: annotated (default)
+      #
+      #   # bad
+      #   format('%{greeting}', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #   format('%<greeting>s', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: template
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%s', 'Hello')
+      #
+      #   # good
+      #   format('%{greeting}', greeting: 'Hello')
+      #
+      # @example EnforcedStyle: unannotated
+      #
+      #   # bad
+      #   format('%<greeting>s', greeting: 'Hello')
+      #   format('%{greeting}', 'Hello')
+      #
+      #   # good
+      #   format('%s', 'Hello')
+      class FormatStringToken < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_str(node)
+          return if node.each_ancestor(:xstr, :regexp).any?
+
+          tokens(node) do |detected_style, token_range|
+            if detected_style == style ||
+               unannotated_format?(node, detected_style)
+              correct_style_detected
+            else
+              style_detected(detected_style)
+              add_offense(node, location: token_range,
+                                message: message(detected_style))
+            end
+          end
+        end
+
+        private
+
+        def_node_matcher :format_string_in_typical_context?, <<~PATTERN
+          {
+            ^(send _ {:format :sprintf :printf} %0 ...)
+            ^(send %0 :% _)
+          }
+        PATTERN
+
+        def unannotated_format?(node, detected_style)
+          detected_style == :unannotated &&
+            !format_string_in_typical_context?(node)
+        end
+
+        def message(detected_style)
+          "Prefer #{message_text(style)} over #{message_text(detected_style)}."
+        end
+
+        # rubocop:disable Style/FormatStringToken
+        def message_text(style)
+          case style
+          when :annotated then 'annotated tokens (like `%<foo>s`)'
+          when :template then 'template tokens (like `%{foo}`)'
+          when :unannotated then 'unannotated tokens (like `%s`)'
+          end
+        end
+        # rubocop:enable Style/FormatStringToken
+
+        def tokens(str_node, &block)
+          return if str_node.source == '__FILE__'
+
+          token_ranges(str_contents(str_node.loc), &block)
+        end
+
+        def str_contents(source_map)
+          if source_map.is_a?(Parser::Source::Map::Heredoc)
+            source_map.heredoc_body
+          elsif source_map.begin
+            source_map.expression.adjust(begin_pos: +1, end_pos: -1)
+          else
+            source_map.expression
+          end
+        end
+
+        def token_ranges(contents)
+          format_string = RuboCop::Cop::Utils::FormatString.new(contents.source)
+
+          format_string.format_sequences.each do |seq|
+            detected_style = seq.style
+            token = contents.begin.adjust(
+              begin_pos: seq.begin_pos,
+              end_pos:   seq.end_pos
+            )
+
+            yield(detected_style, token)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop is designed to help you transition from mutable string literals
+      # to frozen string literals.
+      # It will add the comment `# frozen_string_literal: true` to the top of
+      # files to enable frozen string literals. Frozen string literals may be
+      # default in future Ruby. The comment will be added below a shebang and
+      # encoding comment. The frozen string literal comment is only valid in
+      # Ruby 2.3+.
+      #
+      # @example EnforcedStyle: always (default)
+      #   # The `always` style will always add the frozen string literal comment
+      #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
+      #   # called on a string literal.
+      #   # bad
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: never
+      #   # The `never` will enforce that the frozen string literal comment does
+      #   # not exist in a file.
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Baz
+      #     # ...
+      #   end
+      class FrozenStringLiteralComment < Cop
+        include ConfigurableEnforcedStyle
+        include FrozenStringLiteral
+        include RangeHelp
+
+        MSG = 'Missing magic comment `# frozen_string_literal: true`.'
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
+        SHEBANG = '#!'
+
+        def investigate(processed_source)
+          return if processed_source.tokens.empty?
+
+          if frozen_string_literal_comment_exists?
+            check_for_no_comment(processed_source)
+          else
+            check_for_comment(processed_source)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if style == :never
+              remove_comment(corrector, node)
+            else
+              insert_comment(corrector)
+            end
+          end
+        end
+
+        private
+
+        def check_for_no_comment(processed_source)
+          unnecessary_comment_offense(processed_source) if style == :never
+        end
+
+        def check_for_comment(processed_source)
+          offense(processed_source) unless style == :never
+        end
+
+        def last_special_comment(processed_source)
+          token_number = 0
+          if processed_source.tokens[token_number].text.start_with?(SHEBANG)
+            token = processed_source.tokens[token_number]
+            token_number += 1
+          end
+
+          next_token = processed_source.tokens[token_number]
+          if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
+            token = next_token
+          end
+
+          token
+        end
+
+        def frozen_string_literal_comment(processed_source)
+          processed_source.find_token do |token|
+            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+          end
+        end
+
+        def offense(processed_source)
+          last_special_comment = last_special_comment(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(last_special_comment, location: range)
+        end
+
+        def unnecessary_comment_offense(processed_source)
+          frozen_string_literal_comment =
+            frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment,
+                      location: frozen_string_literal_comment.pos,
+                      message: MSG_UNNECESSARY)
+        end
+
+        def remove_comment(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.pos,
+                                                        side: :right))
+        end
+
+        def insert_comment(corrector)
+          comment = last_special_comment(processed_source)
+
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
+          else
+            corrector.insert_before(line_range(1), preceding_comment)
+          end
+        end
+
+        def line_range(line)
+          processed_source.buffer.line_range(line)
+        end
+
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
+
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
+        end
+      end
+    end
+  end
+end