rubbycop 0.49.0

data/lib/rubbycop/cop/severity.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # Severity class is simple value object about severity
+    class Severity
+      include Comparable
+
+      # @api private
+      NAMES = %i[refactor convention warning error fatal].freeze
+
+      # @api private
+      CODE_TABLE = { R: :refactor, C: :convention,
+                     W: :warning, E: :error, F: :fatal }.freeze
+
+      # @api public
+      #
+      # @!attribute [r] name
+      #
+      # @return [Symbol]
+      #   severity.
+      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      attr_reader :name
+
+      # @api private
+      def self.name_from_code(code)
+        name = code.to_sym
+        CODE_TABLE[name] || name
+      end
+
+      # @api private
+      def initialize(name_or_code)
+        name = Severity.name_from_code(name_or_code)
+        unless NAMES.include?(name)
+          raise ArgumentError, "Unknown severity: #{name}"
+        end
+        @name = name.freeze
+        freeze
+      end
+
+      # @api private
+      def to_s
+        @name.to_s
+      end
+
+      # @api private
+      def code
+        @name.to_s[0].upcase
+      end
+
+      # @api private
+      def level
+        NAMES.index(name) + 1
+      end
+
+      # @api private
+      def ==(other)
+        @name == if other.is_a?(Symbol)
+                   other
+                 else
+                   other.name
+                 end
+      end
+
+      # @api private
+      def hash
+        @name.hash
+      end
+
+      # @api private
+      def <=>(other)
+        level <=> other.level
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop makes sure that accessor methods are named properly.
+      #
+      # @example
+      #   # bad
+      #   def set_attribute(value) ...
+      #
+      #   # good
+      #   def attribute=(value)
+      #
+      #   # bad
+      #   def get_attribute ...
+      #
+      #   # good
+      #   def attribute ...
+      class AccessorMethodName < Cop
+        include OnMethodDef
+
+        private
+
+        def on_method_def(node, method_name, args, _body)
+          if bad_reader_name?(method_name.to_s, args)
+            add_offense(node, :name,
+                        'Do not prefix reader method names with `get_`.')
+          elsif bad_writer_name?(method_name.to_s, args)
+            add_offense(node, :name,
+                        'Do not prefix writer method names with `set_`.')
+          end
+        end
+
+        def bad_reader_name?(method_name, args)
+          method_name.start_with?('get_') && args.to_a.empty?
+        end
+
+        def bad_writer_name?(method_name, args)
+          method_name.start_with?('set_') && args.to_a.one?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop finds uses of `alias` where `alias_method` would be more
+      # appropriate (or is simply preferred due to configuration), and vice
+      # versa.
+      # It also finds uses of `alias :symbol` rather than `alias bareword`.
+      class Alias < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %s.'.freeze
+        MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %s`.'.freeze
+
+        def on_send(node)
+          return unless node.command?(:alias_method)
+          return if style == :prefer_alias_method
+          return if scope_type(node) == :dynamic
+
+          msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
+          add_offense(node, :selector, msg)
+        end
+
+        def on_alias(node)
+          # alias_method can't be used with global variables
+          return if node.each_child_node(:gvar).any?
+          # alias_method can't be used in instance_eval blocks
+          scope_type = scope_type(node)
+          return if scope_type == :instance_eval
+
+          if scope_type == :dynamic || style == :prefer_alias_method
+            add_offense(node, :keyword, MSG_ALIAS)
+          elsif node.children.none? { |arg| bareword?(arg) }
+            add_offense_for_args(node)
+          end
+        end
+
+        def add_offense_for_args(node)
+          existing_args  = node.children.map(&:source).join(' ')
+          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          arg_ranges     = node.children.map(&:source_range)
+          msg            = format(MSG_SYMBOL_ARGS, preferred_args,
+                                  existing_args)
+          add_offense(node, arg_ranges.reduce(&:join), msg)
+        end
+
+        def autocorrect(node)
+          if node.send_type?
+            correct_alias_method_to_alias(node)
+          elsif scope_type(node) == :dynamic || style == :prefer_alias_method
+            correct_alias_to_alias_method(node)
+          else
+            correct_alias_with_symbol_args(node)
+          end
+        end
+
+        private
+
+        # In this expression, will `self` be the same as the innermost enclosing
+        # class or module block (:lexical)? Or will it be something else
+        # (:dynamic)? If we're in an instance_eval block, return that.
+        def scope_type(node)
+          while (parent = node.parent)
+            case parent.type
+            when :class, :module
+              return :lexical
+            when :def, :defs
+              return :dynamic
+            when :block
+              return :instance_eval if parent.method_name == :instance_eval
+
+              return :dynamic
+            end
+            node = parent
+          end
+          :lexical
+        end
+
+        def lexical_scope_type(node)
+          node.each_ancestor(:class, :module) do |ancestor|
+            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          end
+          'at the top level'
+        end
+
+        def bareword?(sym_node)
+          !sym_node.source.start_with?(':')
+        end
+
+        def correct_alias_method_to_alias(send_node)
+          lambda do |corrector|
+            new, old = *send_node.arguments
+            replacement = "alias #{new.children.first} #{old.children.first}"
+            corrector.replace(send_node.source_range, replacement)
+          end
+        end
+
+        def correct_alias_to_alias_method(node)
+          lambda do |corrector|
+            new, old = *node
+            replacement = "alias_method :#{new.children.first}, " \
+                          ":#{old.children.first}"
+            corrector.replace(node.source_range, replacement)
+          end
+        end
+
+        def correct_alias_with_symbol_args(node)
+          lambda do |corrector|
+            new, old = *node
+            corrector.replace(new.source_range, new.children.first.to_s)
+            corrector.replace(old.source_range, old.children.first.to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of *and* and *or*.
+      class AndOr < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%s` instead of `%s`.'.freeze
+
+        OPS = { 'and' => '&&', 'or' => '||' }.freeze
+
+        def on_and(node)
+          process_logical_op(node) if style == :always
+        end
+
+        def on_or(node)
+          process_logical_op(node) if style == :always
+        end
+
+        def on_if(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        def on_while(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        def on_while_post(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        def on_until(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        def on_until_post(node)
+          on_conditionals(node) if style == :conditionals
+        end
+
+        private
+
+        def on_conditionals(node)
+          node.condition.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
+            process_logical_op(logical_node)
+          end
+        end
+
+        def process_logical_op(node)
+          return if node.logical_operator?
+
+          add_offense(node, :operator,
+                      format(MSG, node.alternate_operator, node.operator))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            [*node].each do |expr|
+              if expr.send_type?
+                correct_send(expr, corrector)
+              elsif expr.return_type?
+                correct_other(expr, corrector)
+              elsif expr.assignment?
+                correct_other(expr, corrector)
+              end
+            end
+
+            corrector.replace(node.loc.operator, node.alternate_operator)
+          end
+        end
+
+        def correct_send(node, corrector)
+          return correct_not(node, node.receiver, corrector) if node.method?(:!)
+          return correct_setter(node, corrector) if node.setter_method?
+          return unless correctable_send?(node)
+
+          corrector.replace(whitespace_before_arg(node), '('.freeze)
+          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+        end
+
+        def correct_setter(node, corrector)
+          corrector.insert_before(node.receiver.source_range, '('.freeze)
+          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+        end
+
+        # ! is a special case:
+        # 'x and !obj.method arg' can be auto-corrected if we
+        # recurse down a level and add parens to 'obj.method arg'
+        # however, 'not x' also parses as (send x :!)
+        def correct_not(node, receiver, corrector)
+          if node.keyword_bang?
+            return unless receiver.send_type?
+
+            correct_send(receiver, corrector)
+          elsif node.keyword_not?
+            correct_other(node, corrector)
+          else
+            raise 'unrecognized unary negation operator'
+          end
+        end
+
+        def correct_other(node, corrector)
+          return if node.source_range.begin.is?('(')
+
+          corrector.insert_before(node.source_range, '(')
+          corrector.insert_after(node.source_range, ')')
+        end
+
+        def correctable_send?(node)
+          !node.parenthesized? && node.arguments?
+        end
+
+        def whitespace_before_arg(node)
+          begin_paren = node.loc.selector.end_pos
+          end_paren = begin_paren
+          # Increment position of parenthesis, unless message is a predicate
+          # method followed by a non-whitespace char (e.g. is_a?String).
+          end_paren += 1 unless node.source =~ /\?\S/
+          range_between(begin_paren, end_paren)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of "*" as a substitute for *join*.
+      #
+      # Not all cases can reliably checked, due to Ruby's dynamic
+      # types, so we consider only cases when the first argument is an
+      # array literal or the second is a string literal.
+      class ArrayJoin < Cop
+        MSG = 'Favor `Array#join` over `Array#*`.'.freeze
+
+        def_node_matcher :join_candidate?, '(send $array :* $str)'
+
+        def on_send(node)
+          join_candidate?(node) { add_offense(node, :selector) }
+        end
+
+        def autocorrect(node)
+          array, join_arg = join_candidate?(node).map(&:source)
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "#{array}.join(#{join_arg})")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for non-ascii (non-English) characters
+      # in comments.
+      class AsciiComments < Cop
+        MSG = 'Use only ascii symbols in comments.'.freeze
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            unless comment.text.ascii_only?
+              add_offense(comment, first_offense_range(comment))
+            end
+          end
+        end
+
+        private
+
+        def first_offense_range(comment)
+          expression    = comment.loc.expression
+          first_offense = first_non_ascii_chars(comment.text)
+
+          start_position = expression.begin_pos +
+                           comment.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          range_between(start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for non-ascii characters in identifier names.
+      class AsciiIdentifiers < Cop
+        MSG = 'Use only ascii symbols in identifiers.'.freeze
+
+        def investigate(processed_source)
+          processed_source.tokens.each do |token|
+            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
+            add_offense(token, first_offense_range(token))
+          end
+        end
+
+        private
+
+        def first_offense_range(identifier)
+          expression    = identifier.pos
+          first_offense = first_non_ascii_chars(identifier.text)
+
+          start_position = expression.begin_pos +
+                           identifier.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          range_between(start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
+      end
+    end
+  end
+end