rubbycop 0.49.0

data/lib/rubbycop/cop/style/end_block.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for END blocks.
+      class EndBlock < Cop
+        MSG = 'Avoid the use of `END` blocks. ' \
+              'Use `Kernel#at_exit` instead.'.freeze
+
+        def on_postexe(node)
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/even_odd.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for places where Integer#even? or Integer#odd?
+      # should have been used.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x % 2 == 0
+      #
+      #   # good
+      #   if x.even?
+      class EvenOdd < Cop
+        MSG = 'Replace with `Integer#%s?`.'.freeze
+
+        def_node_matcher :even_odd_candidate?, <<-PATTERN
+          (send
+            {(send $_ :% (int 2))
+             (begin (send $_ :% (int 2)))}
+            ${:== :!=}
+            (int ${0 1 2}))
+        PATTERN
+
+        def on_send(node)
+          even_odd_candidate?(node) do |_base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+            add_offense(node, :expression, format(MSG, replacement_method))
+          end
+        end
+
+        def autocorrect(node)
+          even_odd_candidate?(node) do |base_number, method, arg|
+            replacement_method = replacement_method(arg, method)
+
+            correction = "#{base_number.source}.#{replacement_method}?"
+            ->(corrector) { corrector.replace(node.source_range, correction) }
+          end
+        end
+
+        private
+
+        def replacement_method(arg, method)
+          case arg
+          when 0
+            method == :== ? :even : :odd
+          when 1
+            method == :== ? :odd : :even
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/file_name.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop makes sure that Ruby source files have snake_case
+      # names. Ruby scripts (i.e. source files with a shebang in the
+      # first line) are ignored.
+      class FileName < Cop
+        MSG_SNAKE_CASE = 'The name of this source file (`%s`) ' \
+                         'should use snake_case.'.freeze
+        MSG_NO_DEFINITION = '%s should define a class or module ' \
+                            'called `%s`.'.freeze
+        MSG_REGEX = '`%s` should match `%s`.'.freeze
+
+        SNAKE_CASE = /^[\da-z_.?!]+$/
+
+        def investigate(processed_source)
+          file_path = processed_source.buffer.name
+          return if config.file_to_include?(file_path)
+
+          for_bad_filename(file_path) do |range, msg|
+            add_offense(nil, range, msg)
+          end
+        end
+
+        private
+
+        def for_bad_filename(file_path)
+          basename = File.basename(file_path)
+          msg = if filename_good?(basename)
+                  return unless expect_matching_definition?
+                  return if find_class_or_module(processed_source.ast,
+                                                 to_namespace(file_path))
+
+                  no_definition_message(basename, file_path)
+                else
+                  return if ignore_executable_scripts? && shebang?(first_line)
+                  other_message(basename)
+                end
+
+          yield source_range(processed_source.buffer, 1, 0), msg
+        end
+
+        def first_line
+          processed_source.lines.first
+        end
+
+        def no_definition_message(basename, file_path)
+          format(MSG_NO_DEFINITION,
+                 basename,
+                 to_namespace(file_path).join('::'))
+        end
+
+        def other_message(basename)
+          if regex
+            format(MSG_REGEX, basename, regex)
+          else
+            format(MSG_SNAKE_CASE, basename)
+          end
+        end
+
+        def shebang?(line)
+          line && line.start_with?('#!')
+        end
+
+        def ignore_executable_scripts?
+          cop_config['IgnoreExecutableScripts']
+        end
+
+        def expect_matching_definition?
+          cop_config['ExpectMatchingDefinition']
+        end
+
+        def regex
+          cop_config['Regex']
+        end
+
+        def allowed_acronyms
+          cop_config['AllowedAcronyms'] || []
+        end
+
+        def filename_good?(basename)
+          basename = basename.sub(/\.[^\.]+$/, '')
+          basename =~ (regex || SNAKE_CASE)
+        end
+
+        def find_class_or_module(node, namespace)
+          return nil if node.nil?
+          name = namespace.pop
+
+          on_node(%i[class module casgn], node) do |child|
+            next unless (const = child.defined_module)
+
+            const_namespace, const_name = *const
+            next if name != const_name && !match_acronym?(name, const_name)
+
+            return node if namespace.empty?
+            return node if match_namespace(child, const_namespace, namespace)
+          end
+
+          nil
+        end
+
+        def match_namespace(node, namespace, expected)
+          match_partial = partial_matcher!(expected)
+
+          match_partial.call(namespace)
+
+          node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
+            return false if ancestor.sclass_type?
+            match_partial.call(ancestor.defined_module)
+          end
+
+          match?(expected)
+        end
+
+        def partial_matcher!(expected)
+          lambda do |namespace|
+            while namespace
+              return match?(expected) if namespace.cbase_type?
+
+              namespace, name = *namespace
+
+              if name == expected.last || match_acronym?(expected.last, name)
+                expected.pop
+              end
+            end
+
+            false
+          end
+        end
+
+        def match?(expected)
+          expected.empty? || expected == [:Object]
+        end
+
+        def match_acronym?(expected, name)
+          expected = expected.to_s
+          name = name.to_s
+
+          allowed_acronyms.any? do |acronym|
+            expected.gsub(acronym.capitalize, acronym) == name
+          end
+        end
+
+        def to_namespace(path)
+          components = Pathname(path).each_filename.to_a
+          # To convert a pathname to a Ruby namespace, we need a starting point
+          # But RC can be run from any working directory, and can check any path
+          # We can't assume that the working directory, or any other, is the
+          # "starting point" to build a namespace
+          start = %w[lib spec test src]
+          start_index = nil
+
+          # To find the closest namespace root take the path components, and
+          # then work through them backwards until we find a candidate. This
+          # makes sure we work from the actual root in the case of a path like
+          # /home/user/src/project_name/lib.
+          components.reverse.each_with_index do |c, i|
+            if start.include?(c)
+              start_index = components.size - i
+              break
+            end
+          end
+
+          if start_index.nil?
+            [to_module_name(components.last)]
+          else
+            components[start_index..-1].map { |c| to_module_name(c) }
+          end
+        end
+
+        def to_module_name(basename)
+          words = basename.sub(/\..*/, '').split('_')
+          words.map(&:capitalize).join.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/flip_flop.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for uses of flip flop operator
+      class FlipFlop < Cop
+        MSG = 'Avoid the use of flip flop operators.'.freeze
+
+        def on_iflipflop(node)
+          add_offense(node, :expression)
+        end
+
+        def on_eflipflop(node)
+          add_offense(node, :expression)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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, however.
+      class For < Cop
+        include ConfigurableEnforcedStyle
+        EACH_LENGTH = 'each'.length
+
+        def on_for(node)
+          if style == :each
+            add_offense(node, :keyword, 'Prefer `each` over `for`.') do
+              opposite_style_detected
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        def on_block(node)
+          return if block_length(node).zero?
+
+          method, _args, _body = *node
+          return unless method.send_type? && method.method?(:each) &&
+                        !method.arguments?
+
+          if style == :for
+            incorrect_style_detected(method)
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def incorrect_style_detected(method)
+          end_pos = method.source_range.end_pos
+          range = range_between(end_pos - EACH_LENGTH, end_pos)
+          add_offense(range, range, 'Prefer `for` over `each`.') do
+            opposite_style_detected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.
+      class FormatString < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Favor `%s` over `%s`.'.freeze
+
+        def_node_matcher :formatter, <<-PATTERN
+        {
+          (send nil ${:sprintf :format} _ _ ...)
+          (send {str dstr} $:% ... )
+          (send !nil $:% {array hash})
+        }
+        PATTERN
+
+        def on_send(node)
+          formatter(node) do |selector|
+            detected_style = selector == :% ? :percent : selector
+
+            return if detected_style == style
+
+            add_offense(node, :selector, message(detected_style))
+          end
+        end
+
+        def message(detected_style)
+          format(MSG, method_name(style), method_name(detected_style))
+        end
+
+        def method_name(style_name)
+          style_name == :percent ? 'String#%' : style_name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Use a consistent style for named format string tokens.
+      #
+      # @example
+      #
+      #   EnforcedStyle: annotated
+      #
+      #   # 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')
+      class FormatStringToken < Cop
+        include ConfigurableEnforcedStyle
+
+        FIELD_CHARACTERS = Regexp.union(%w[A B E G X a b c d e f g i o p s u x])
+
+        STYLE_PATTERNS = {
+          annotated: /(?<token>%<[^>]+>#{FIELD_CHARACTERS})/,
+          template:  /(?<token>%\{[^\}]+\})/
+        }.freeze
+
+        TOKEN_PATTERN = Regexp.union(STYLE_PATTERNS.values)
+
+        def on_str(node)
+          return if node.each_ancestor(:xstr).any?
+
+          tokens(node) do |detected_style, token_range|
+            if detected_style == style
+              correct_style_detected
+            else
+              style_detected(detected_style)
+              add_offense(node, token_range, message(detected_style))
+            end
+          end
+        end
+
+        private
+
+        def message(detected_style)
+          "Prefer #{message_text(style)} over #{message_text(detected_style)}."
+        end
+
+        # rubbycop:disable FormatStringToken
+        def message_text(style)
+          case style
+          when :annotated then 'annotated tokens (like `%<foo>s`)'
+          when :template  then 'template tokens (like `%{foo}`)'
+          end
+        end
+        # rubbycop:enable 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
+            slice_source(
+              source_map.expression,
+              source_map.expression.begin_pos + 1,
+              source_map.expression.end_pos - 1
+            )
+          else
+            source_map.expression
+          end
+        end
+
+        def token_ranges(contents)
+          while (offending_match = match_token(contents))
+            detected_style, *range = *offending_match
+            token, contents = split_token(contents, *range)
+            yield(detected_style, token)
+          end
+        end
+
+        def match_token(source_range)
+          supported_styles.each do |style_name|
+            pattern = STYLE_PATTERNS.fetch(style_name)
+            match = source_range.source.match(pattern)
+            next unless match
+
+            return [style_name, match.begin(:token), match.end(:token)]
+          end
+
+          nil
+        end
+
+        def split_token(source_range, match_begin, match_end)
+          token =
+            slice_source(
+              source_range,
+              source_range.begin_pos + match_begin,
+              source_range.begin_pos + match_end
+            )
+
+          remainder =
+            slice_source(
+              source_range,
+              source_range.begin_pos + match_end,
+              source_range.end_pos
+            )
+
+          [token, remainder]
+        end
+
+        def slice_source(source_range, new_begin, new_end)
+          Parser::Source::Range.new(
+            source_range.source_buffer,
+            new_begin,
+            new_end
+          )
+        end
+      end
+    end
+  end
+end