rubocop 0.87.1

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistency when using exponential notation
+      # for numbers in the code (eg 1.2e4). Different styles are supported:
+      # * `scientific` which enforces a mantissa between 1 (inclusive)
+      #                and 10 (exclusive).
+      # * `engineering` which enforces the exponent to be a multiple of 3
+      #                 and the mantissa to be between 0.1 (inclusive)
+      #                 and 10 (exclusive).
+      # * `integral` which enforces the mantissa to always be a whole number
+      #              without trailing zeroes.
+      #
+      # @example EnforcedStyle: scientific (default)
+      #   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      #
+      #   # bad
+      #   10e6
+      #   0.3e4
+      #   11.7e5
+      #   3.14e0
+      #
+      #   # good
+      #   1e7
+      #   3e3
+      #   1.17e6
+      #   3.14
+      #
+      # @example EnforcedStyle: engineering
+      #   # Enforces using multiple of 3 exponents,
+      #   # mantissa should be between 0.1 (inclusive) and 1000 (exclusive)
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   12e5
+      #   1232e6
+      #
+      #   # good
+      #   32e6
+      #   10e3
+      #   1.2e6
+      #   1.232e9
+      #
+      # @example EnforcedStyle: integral
+      #   # Enforces the mantissa to have no decimal part and no
+      #   # trailing zeroes.
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   120e4
+      #
+      #   # good
+      #   32e6
+      #   1e4
+      #   12e5
+      #
+      class ExponentialNotation < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_float(node)
+          add_offense(node) if offense?(node)
+        end
+
+        private
+
+        def scientific?(node)
+          mantissa, = node.source.split('e')
+          /^-?[1-9](\.\d*[0-9])?$/.match?(mantissa)
+        end
+
+        def engineering?(node)
+          mantissa, exponent = node.source.split('e')
+          return false unless /^-?\d+$/.match?(exponent)
+          return false unless (exponent.to_i % 3).zero?
+          return false if /^-?\d{4}/.match?(mantissa)
+          return false if /^-?0\d/.match?(mantissa)
+          return false if /^-?0.0/.match?(mantissa)
+
+          true
+        end
+
+        def integral(node)
+          mantissa, = node.source.split('e')
+          /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
+        end
+
+        def offense?(node)
+          return false unless node.source['e']
+
+          case style
+          when :scientific
+            !scientific?(node)
+          when :engineering
+            !engineering?(node)
+          when :integral
+            !integral(node)
+          else
+            false
+          end
+        end
+
+        def message(_node)
+          case style
+          when :scientific
+            'Use a mantissa in [1, 10[.'
+          when :engineering
+            'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.'
+          when :integral
+            'Use an integer as mantissa, without trailing zero.'
+          end
+        end
+      end
+    end
+  end
+end

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,127 @@
+# 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)
+          percent_rhs = node.first_argument
+          args = case percent_rhs.type
+                 when :array, :hash
+                   percent_rhs.children.map(&:source).join(', ')
+                 else
+                   percent_rhs.source
+                 end
+
+          corrected = "#{style}(#{node.receiver.source}, #{args})"
+
+          corrector.replace(node, corrected)
+        end
+
+        def autocorrect_to_percent(corrector, node)
+          format_arg, *param_args = node.arguments
+          format = format_arg.source
+
+          args = if param_args.one?
+                   arg = param_args.last
+
+                   arg.hash_type? ? "{ #{arg.source} }" : arg.source
+                 else
+                   "[#{param_args.map(&:source).join(', ')}]"
+                 end
+
+          corrector.replace(node, "#{format} % #{args}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# 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|
+            next if seq.percent?
+
+            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