rubbycop 0.49.0

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for case statements with an empty condition.
+      #
+      # @example
+      #
+      #   # bad:
+      #   case
+      #   when x == 0
+      #     puts 'x is 0'
+      #   when y == 0
+      #     puts 'y is 0'
+      #   else
+      #     puts 'neither is 0'
+      #   end
+      #
+      #   # good:
+      #   if x == 0
+      #     puts 'x is 0'
+      #   elsif y == 0
+      #     puts 'y is 0'
+      #   else
+      #     puts 'neither is 0'
+      #   end
+      #
+      #   # good: (the case condition node is not empty)
+      #   case n
+      #   when 0
+      #     puts 'zero'
+      #   when 1
+      #     puts 'one'
+      #   else
+      #     puts 'more'
+      #   end
+      class EmptyCaseCondition < Cop
+        MSG = 'Do not use empty `case` condition, instead use an `if` '\
+              'expression.'.freeze
+
+        def on_case(case_node)
+          return if case_node.condition
+
+          add_offense(case_node, :keyword, MSG)
+        end
+
+        private
+
+        def autocorrect(case_node)
+          when_branches = case_node.when_branches
+
+          lambda do |corrector|
+            correct_case_when(corrector, case_node, when_branches)
+            correct_when_conditions(corrector, when_branches)
+          end
+        end
+
+        def correct_case_when(corrector, case_node, when_nodes)
+          case_range = case_node.loc.keyword.join(when_nodes.first.loc.keyword)
+
+          corrector.replace(case_range, 'if')
+
+          when_nodes[1..-1].each do |when_node|
+            corrector.replace(when_node.loc.keyword, 'elsif')
+          end
+        end
+
+        def correct_when_conditions(corrector, when_nodes)
+          when_nodes.each do |when_node|
+            conditions = when_node.conditions
+
+            next unless conditions.size > 1
+
+            range = range_between(conditions.first.loc.expression.begin_pos,
+                                  conditions.last.loc.expression.end_pos)
+
+            corrector.replace(range, conditions.map(&:source).join(' || '))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for empty else-clauses, possibly including comments and/or an
+      # explicit `nil` depending on the EnforcedStyle.
+      #
+      # SupportedStyles:
+      #
+      # @example
+      #   # good for all styles
+      #
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good for all styles
+      #   if condition
+      #     statement
+      #   end
+      #
+      # @example
+      #   # empty - warn only on empty else
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      # @example
+      #   # nil - warn on else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      # @example
+      #   # both - warn on empty else and else with nil in it
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      class EmptyElse < Cop
+        include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Redundant `else`-clause.'.freeze
+
+        def on_normal_if_unless(node)
+          check(node)
+        end
+
+        def on_case(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          empty_check(node) if empty_style?
+          nil_check(node) if nil_style?
+        end
+
+        def nil_style?
+          style == :nil || style == :both
+        end
+
+        def empty_style?
+          style == :empty || style == :both
+        end
+
+        def empty_check(node)
+          return unless node.else? && !node.else_branch
+
+          add_offense(node, :else, MSG)
+        end
+
+        def nil_check(node)
+          return unless node.else_branch && node.else_branch.nil_type?
+
+          add_offense(node, :else, MSG)
+        end
+
+        def autocorrect(node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+
+          lambda do |corrector|
+            end_pos = base_if_node(node).loc.end.begin_pos
+
+            corrector.remove(range_between(node.loc.else.begin_pos, end_pos))
+          end
+        end
+
+        def base_if_node(node)
+          node.each_ancestor(:if).find { |parent| parent.loc.end } || node
+        end
+
+        def autocorrect_forbidden?(type)
+          [type, 'both'].include?(missing_else_style)
+        end
+
+        def missing_else_style
+          missing_cfg = config.for_cop('Style/MissingElse')
+          missing_cfg.fetch('Enabled') ? missing_cfg['EnforcedStyle'] : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for the use of a method, the result of which
+      # would be a literal, like an empty array, hash or string.
+      class EmptyLiteral < Cop
+        include FrozenStringLiteral
+
+        ARR_MSG = 'Use array literal `[]` instead of `Array.new`.'.freeze
+        HASH_MSG = 'Use hash literal `{}` instead of `Hash.new`.'.freeze
+        STR_MSG = 'Use string literal `%s` instead of `String.new`.'.freeze
+
+        def_node_matcher :array_node, '(send (const nil :Array) :new)'
+        def_node_matcher :hash_node, '(send (const nil :Hash) :new)'
+        def_node_matcher :str_node, '(send (const nil :String) :new)'
+        def_node_matcher :array_with_block,
+                         '(block (send (const nil :Array) :new) args _)'
+        def_node_matcher :hash_with_block,
+                         '(block (send (const nil :Hash) :new) args _)'
+
+        def on_send(node)
+          add_offense(node, :expression, ARR_MSG) if offense_array_node?(node)
+
+          add_offense(node, :expression, HASH_MSG) if offense_hash_node?(node)
+
+          str_node(node) do
+            return if frozen_string_literals_enabled?
+
+            add_offense(node, :expression,
+                        format(STR_MSG, preferred_string_literal))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(replacement_range(node), correction(node))
+          end
+        end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+
+        def first_argument_unparenthesized?(node)
+          return false unless node.parent && node.parent.send_type?
+
+          _receiver, _method_name, *args = *node.parent
+          node.object_id == args.first.object_id && !parentheses?(node.parent)
+        end
+
+        def replacement_range(node)
+          if hash_node(node) &&
+             first_argument_unparenthesized?(node)
+            # `some_method {}` is not same as `some_method Hash.new`
+            # because the braces are interpreted as a block. We will have
+            # to rewrite the arguments to wrap them in parenthesis.
+            _receiver, _method_name, *args = *node.parent
+
+            Parser::Source::Range.new(node.parent.loc.expression,
+                                      args[0].loc.expression.begin_pos - 1,
+                                      args[-1].loc.expression.end_pos)
+          else
+            node.source_range
+          end
+        end
+
+        def offense_array_node?(node)
+          array_node(node) && !array_with_block(node.parent)
+        end
+
+        def offense_hash_node?(node)
+          # If Hash.new takes a block, it can't be changed to {}.
+          hash_node(node) && !hash_with_block(node.parent)
+        end
+
+        def correction(node)
+          if offense_array_node?(node)
+            '[]'
+          elsif str_node(node)
+            preferred_string_literal
+          elsif offense_hash_node?(node)
+            if first_argument_unparenthesized?(node)
+              # `some_method {}` is not same as `some_method Hash.new`
+              # because the braces are interpreted as a block. We will have
+              # to rewrite the arguments to wrap them in parenthesis.
+              _receiver, _method_name, *args = *node.parent
+              "(#{args[1..-1].map(&:source).unshift('{}').join(', ')})"
+            else
+              '{}'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for the formatting of empty method definitions.
+      # By default it enforces empty method definitions to go on a single
+      # line (compact style), but it can be configured to enforce the `end`
+      # to go on its own line (expanded style.)
+      #
+      # Note: A method definition is not considered empty if it contains
+      #       comments.
+      #
+      # @example
+      #
+      #   EnforcedStyle: compact (default)
+      #
+      #   @bad
+      #   def foo(bar)
+      #   end
+      #   def self.foo(bar)
+      #   end
+      #
+      #   @good
+      #   def foo(bar); end
+      #   def foo(bar)
+      #     # baz
+      #   end
+      #   def self.foo(bar); end
+      #
+      #   EnforcedStyle: expanded
+      #
+      #   @bad
+      #   def foo(bar); end
+      #   def self.foo(bar); end
+      #
+      #   @good
+      #   def foo(bar)
+      #   end
+      #   def self.foo(bar)
+      #   end
+      class EmptyMethod < Cop
+        include OnMethodDef
+        include ConfigurableEnforcedStyle
+
+        MSG_COMPACT = 'Put empty method definitions on a single line.'.freeze
+        MSG_EXPANDED = 'Put the `end` of empty method definitions on the ' \
+                       'next line.'.freeze
+
+        def on_method_def(node, _method_name, _args, body)
+          return if body || comment_lines?(node)
+          return if compact_style? && compact?(node)
+          return if expanded_style? && expanded?(node)
+
+          add_offense(node, node.source_range, message)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node))
+          end
+        end
+
+        def message
+          compact_style? ? MSG_COMPACT : MSG_EXPANDED
+        end
+
+        def corrected(node)
+          method_name, args, _body, scope = method_def_node_parts(node)
+
+          arguments = args.source unless args.children.empty?
+          joint = compact_style? ? '; ' : "\n"
+          scope = scope ? 'self.' : ''
+
+          ["def #{scope}#{method_name}#{arguments}", 'end'].join(joint)
+        end
+
+        def comment_lines?(node)
+          processed_source[line_range(node)].any? { |line| comment_line?(line) }
+        end
+
+        def compact?(node)
+          node.single_line?
+        end
+
+        def expanded?(node)
+          node.multiline?
+        end
+
+        def compact_style?
+          style == :compact
+        end
+
+        def expanded_style?
+          style == :expanded
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks whether the source file has a utf-8 encoding
+      # comment or not.
+      # Setting this check to "always" and "when_needed" makes sense only
+      # for code that should support Ruby 1.9, since in 2.0+ utf-8 is the
+      # default source file encoding. There are three styles:
+      #
+      # when_needed - only enforce an encoding comment if there are non ASCII
+      #               characters, otherwise report an offense
+      # always - enforce encoding comment in all files
+      # never - enforce no encoding comment in all files
+      class Encoding < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_MISSING = 'Missing utf-8 encoding comment.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'.freeze
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+        AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
+        SHEBANG = '#!'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.buffer.source.empty?
+
+          line_number = encoding_line_number(processed_source)
+          return unless (@message = offense(processed_source, line_number))
+
+          range = processed_source.buffer.line_range(line_number + 1)
+          add_offense(range, range, @message)
+        end
+
+        def autocorrect(range)
+          if @message == MSG_MISSING
+            raise encoding_mismatch_message unless matching_encoding?
+
+            lambda do |corrector|
+              corrector.insert_before(range, "#{encoding}\n")
+            end
+          else
+            # Need to remove unnecessary encoding comment
+            lambda do |corrector|
+              corrector.remove(range_with_surrounding_space(range, :right))
+            end
+          end
+        end
+
+        private
+
+        def encoding
+          cop_config[AUTO_CORRECT_ENCODING_COMMENT]
+        end
+
+        def matching_encoding?
+          encoding =~ ENCODING_PATTERN
+        end
+
+        def encoding_mismatch_message
+          "#{encoding} does not match #{ENCODING_PATTERN}"
+        end
+
+        def offense(processed_source, line_number)
+          line = processed_source[line_number]
+
+          if !encoding_present?(line) && !encoding_omitable?
+            MSG_MISSING
+          elsif encoding_present?(line) && encoding_omitable?
+            MSG_UNNECESSARY
+          end
+        end
+
+        def encoding_present?(line)
+          MagicComment.parse(line).encoding
+        end
+
+        def encoding_omitable?
+          return true if style == :never
+
+          style != :always && processed_source.buffer.source.ascii_only?
+        end
+
+        def encoding_line_number(processed_source)
+          line_number = 0
+          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
+          line_number
+        end
+      end
+    end
+  end
+end