rubocop 0.75.1

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of global variables.
+      # It does not report offenses for built-in global variables.
+      # Built-in global variables are allowed by default. Additionally
+      # users can allow additional variables via the AllowedVariables option.
+      #
+      # Note that backreferences like $1, $2, etc are not global variables.
+      #
+      # @example
+      #   # bad
+      #   $foo = 2
+      #   bar = $foo + 5
+      #
+      #   # good
+      #   FOO = 2
+      #   foo = 2
+      #   $stdin.read
+      class GlobalVars < Cop
+        MSG = 'Do not introduce global variables.'
+
+        # built-in global variables and their English aliases
+        # https://www.zenspider.com/ruby/quickref.html
+        BUILT_IN_VARS = %w[
+          $: $LOAD_PATH
+          $" $LOADED_FEATURES
+          $0 $PROGRAM_NAME
+          $! $ERROR_INFO
+          $@ $ERROR_POSITION
+          $; $FS $FIELD_SEPARATOR
+          $, $OFS $OUTPUT_FIELD_SEPARATOR
+          $/ $RS $INPUT_RECORD_SEPARATOR
+          $\\ $ORS $OUTPUT_RECORD_SEPARATOR
+          $. $NR $INPUT_LINE_NUMBER
+          $_ $LAST_READ_LINE
+          $> $DEFAULT_OUTPUT
+          $< $DEFAULT_INPUT
+          $$ $PID $PROCESS_ID
+          $? $CHILD_STATUS
+          $~ $LAST_MATCH_INFO
+          $= $IGNORECASE
+          $* $ARGV
+          $& $MATCH
+          $` $PREMATCH
+          $' $POSTMATCH
+          $+ $LAST_PAREN_MATCH
+          $stdin $stdout $stderr
+          $DEBUG $FILENAME $VERBOSE $SAFE
+          $-0 $-a $-d $-F $-i $-I $-l $-p $-v $-w
+          $CLASSPATH $JRUBY_VERSION $JRUBY_REVISION $ENV_JAVA
+        ].map(&:to_sym)
+
+        def user_vars
+          cop_config['AllowedVariables'].map(&:to_sym)
+        end
+
+        def allowed_var?(global_var)
+          BUILT_IN_VARS.include?(global_var) || user_vars.include?(global_var)
+        end
+
+        def on_gvar(node)
+          check(node)
+        end
+
+        def on_gvasgn(node)
+          check(node)
+        end
+
+        def check(node)
+          global_var, = *node
+
+          add_offense(node, location: :name) unless allowed_var?(global_var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a guard clause instead of wrapping the code inside a conditional
+      # expression
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     return unless something
+      #     work
+      #   end
+      #
+      #   # also good
+      #   def test
+      #     work if something
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     raise 'exception'
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   raise 'exception' if something
+      #   ok
+      class GuardClause < Cop
+        include MinBodyLength
+        include StatementModifier
+
+        MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
+              'code inside a conditional expression.'
+
+        def on_def(node)
+          body = node.body
+
+          return unless body
+
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type? && body.children.last.if_type?
+            check_ending_if(body.children.last)
+          end
+        end
+        alias on_defs on_def
+
+        def on_if(node)
+          return if accepted_form?(node)
+
+          guard_clause_in_if = node.if_branch&.guard_clause?
+          guard_clause_in_else = node.else_branch&.guard_clause?
+          guard_clause = guard_clause_in_if || guard_clause_in_else
+          return unless guard_clause
+
+          kw = if guard_clause_in_if
+                 node.loc.keyword.source
+               else
+                 opposite_keyword(node)
+               end
+          register_offense(node, guard_clause.source, kw)
+        end
+
+        private
+
+        def check_ending_if(node)
+          return if accepted_form?(node, true) || !min_body_length?(node)
+
+          register_offense(node, 'return', opposite_keyword(node))
+        end
+
+        def opposite_keyword(node)
+          node.if? ? 'unless' : 'if'
+        end
+
+        def register_offense(node, scope_exiting_keyword, conditional_keyword)
+          condition, = node.node_parts
+          example = [scope_exiting_keyword,
+                     conditional_keyword,
+                     condition.source].join(' ')
+          if too_long_for_single_line?(node, example)
+            example = "#{conditional_keyword} #{condition.source}; " \
+                      "#{scope_exiting_keyword}; end"
+          end
+          add_offense(node,
+                      location: :keyword,
+                      message: format(MSG, example: example))
+        end
+
+        def too_long_for_single_line?(node, example)
+          max = max_line_length
+          max && node.source_range.column + example.length > max
+        end
+
+        def accepted_form?(node, ending = false)
+          accepted_if?(node, ending) || node.condition.multiline?
+        end
+
+        def accepted_if?(node, ending)
+          return true if node.modifier_form? || node.ternary?
+
+          if ending
+            node.else?
+          else
+            !node.else? || node.elsif?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks hash literal syntax.
+      #
+      # It can enforce either the use of the class hash rocket syntax or
+      # the use of the newer Ruby 1.9 syntax (when applicable).
+      #
+      # A separate offense is registered for each problematic pair.
+      #
+      # The supported styles are:
+      #
+      # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
+      #   all symbols for keys
+      # * hash_rockets - forces use of hash rockets for all hashes
+      # * no_mixed_keys - simply checks for hashes with mixed syntaxes
+      # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
+      #   syntax hashes
+      #
+      # @example EnforcedStyle: ruby19 (default)
+      #   # bad
+      #   {:a => 2}
+      #   {b: 1, :c => 2}
+      #
+      #   # good
+      #   {a: 2, b: 1}
+      #   {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
+      #   {d: 1, 'e' => 2} # technically not forbidden
+      #
+      # @example EnforcedStyle: hash_rockets
+      #   # bad
+      #   {a: 1, b: 2}
+      #   {c: 1, 'd' => 5}
+      #
+      #   # good
+      #   {:a => 1, :b => 2}
+      #
+      # @example EnforcedStyle: no_mixed_keys
+      #   # bad
+      #   {:a => 1, b: 2}
+      #   {c: 1, 'd' => 2}
+      #
+      #   # good
+      #   {:a => 1, :b => 2}
+      #   {c: 1, d: 2}
+      #
+      # @example EnforcedStyle: ruby19_no_mixed_keys
+      #   # bad
+      #   {:a => 1, :b => 2}
+      #   {c: 2, 'd' => 3} # should just use hash rockets
+      #
+      #   # good
+      #   {a: 1, b: 2}
+      #   {:c => 3, 'd' => 4}
+      class HashSyntax < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
+        MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
+        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
+
+        def on_hash(node)
+          pairs = node.pairs
+
+          return if pairs.empty?
+
+          if style == :hash_rockets || force_hash_rockets?(pairs)
+            hash_rockets_check(pairs)
+          elsif style == :ruby19_no_mixed_keys
+            ruby19_no_mixed_keys_check(pairs)
+          elsif style == :no_mixed_keys
+            no_mixed_keys_check(pairs)
+          else
+            ruby19_check(pairs)
+          end
+        end
+
+        def ruby19_check(pairs)
+          check(pairs, '=>', MSG_19) if sym_indices?(pairs)
+        end
+
+        def hash_rockets_check(pairs)
+          check(pairs, ':', MSG_HASH_ROCKETS)
+        end
+
+        def ruby19_no_mixed_keys_check(pairs)
+          if force_hash_rockets?(pairs)
+            check(pairs, ':', MSG_HASH_ROCKETS)
+          elsif sym_indices?(pairs)
+            check(pairs, '=>', MSG_19)
+          else
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
+          end
+        end
+
+        def no_mixed_keys_check(pairs)
+          if !sym_indices?(pairs)
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
+          else
+            check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
+              autocorrect_hash_rockets(corrector, node)
+            elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+              autocorrect_no_mixed_keys(corrector, node)
+            else
+              autocorrect_ruby19(corrector, node)
+            end
+          end
+        end
+
+        def alternative_style
+          case style
+          when :hash_rockets
+            :ruby19
+          when :ruby19, :ruby19_no_mixed_keys
+            :hash_rockets
+          end
+        end
+
+        private
+
+        def sym_indices?(pairs)
+          pairs.all? { |p| word_symbol_pair?(p) }
+        end
+
+        def word_symbol_pair?(pair)
+          return false unless pair.key.sym_type? || pair.key.dsym_type?
+
+          acceptable_19_syntax_symbol?(pair.key.source)
+        end
+
+        def acceptable_19_syntax_symbol?(sym_name)
+          sym_name.sub!(/\A:/, '')
+
+          if cop_config['PreferHashRocketsForNonAlnumEndingSymbols']
+            # Prefer { :production? => false } over { production?: false } and
+            # similarly for other non-alnum final characters (except quotes,
+            # to prefer { "x y": 1 } over { :"x y" => 1 }).
+            return false unless sym_name =~ /[\p{Alnum}"']\z/
+          end
+
+          # Most hash keys can be matched against a simple regex.
+          return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
+
+          # For more complicated hash keys, let the parser validate the syntax.
+          parse("{ #{sym_name}: :foo }").valid_syntax?
+        end
+
+        def check(pairs, delim, msg)
+          pairs.each do |pair|
+            if pair.delimiter == delim
+              location = pair.source_range.begin.join(pair.loc.operator)
+              add_offense(pair, location: location, message: msg) do
+                opposite_style_detected
+              end
+            else
+              correct_style_detected
+            end
+          end
+        end
+
+        def autocorrect_ruby19(corrector, pair_node)
+          key = pair_node.key
+          op = pair_node.loc.operator
+
+          range = range_between(key.source_range.begin_pos, op.end_pos)
+          range = range_with_surrounding_space(range: range, side: :right)
+
+          space = argument_without_space?(pair_node.parent) ? ' ' : ''
+
+          corrector.replace(
+            range,
+            range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
+          )
+        end
+
+        def argument_without_space?(node)
+          node.argument? &&
+            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+        end
+
+        def autocorrect_hash_rockets(corrector, pair_node)
+          key = pair_node.key.source_range
+          op = pair_node.loc.operator
+
+          corrector.insert_after(key, pair_node.inverse_delimiter(true))
+          corrector.insert_before(key, ':')
+          corrector.remove(range_with_surrounding_space(range: op))
+        end
+
+        def autocorrect_no_mixed_keys(corrector, pair_node)
+          if pair_node.colon?
+            autocorrect_hash_rockets(corrector, pair_node)
+          else
+            autocorrect_ruby19(corrector, pair_node)
+          end
+        end
+
+        def force_hash_rockets?(pairs)
+          cop_config['UseHashRocketsWithSymbolValues'] &&
+            pairs.map(&:value).any?(&:sym_type?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for identical lines at the beginning or end of
+      # each branch of a conditional statement.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     do_x
+      #     do_z
+      #   else
+      #     do_y
+      #     do_z
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
+      #   do_z
+      #
+      #   # bad
+      #   if condition
+      #     do_z
+      #     do_x
+      #   else
+      #     do_z
+      #     do_y
+      #   end
+      #
+      #   # good
+      #   do_z
+      #   if condition
+      #     do_x
+      #   else
+      #     do_y
+      #   end
+      #
+      #   # bad
+      #   case foo
+      #   when 1
+      #     do_x
+      #   when 2
+      #     do_x
+      #   else
+      #     do_x
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1
+      #     do_x
+      #     do_y
+      #   when 2
+      #     # nothing
+      #   else
+      #     do_x
+      #     do_z
+      #   end
+      class IdenticalConditionalBranches < Cop
+        MSG = 'Move `%<source>s` out of the conditional.'
+
+        def on_if(node)
+          return if node.elsif?
+
+          branches = expand_elses(node.else_branch).unshift(node.if_branch)
+          check_branches(branches)
+        end
+
+        def on_case(node)
+          return unless node.else? && node.else_branch
+
+          branches = node.when_branches.map(&:body).push(node.else_branch)
+          check_branches(branches)
+        end
+
+        private
+
+        def check_branches(branches)
+          # return if any branch is empty. An empty branch can be an `if`
+          # without an `else` or a branch that contains only comments.
+          return if branches.any?(&:nil?)
+
+          tails = branches.map { |branch| tail(branch) }
+          check_expressions(tails) if tails.none?(&:nil?)
+          heads = branches.map { |branch| head(branch) }
+          check_expressions(heads) if tails.none?(&:nil?)
+        end
+
+        def check_expressions(expressions)
+          return unless expressions.size > 1 && expressions.uniq.one?
+
+          expressions.each do |expression|
+            add_offense(expression)
+          end
+        end
+
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
+        # `elsif` branches show up in the if node as nested `else` branches. We
+        # need to recursively iterate over all `else` branches.
+        def expand_elses(branch)
+          if branch.nil?
+            [nil]
+          elsif branch.if_type?
+            _condition, elsif_branch, else_branch = *branch
+            expand_elses(else_branch).unshift(elsif_branch)
+          else
+            [branch]
+          end
+        end
+
+        def tail(node)
+          node.begin_type? ? node.children.last : node
+        end
+
+        def head(node)
+          node.begin_type? ? node.children.first : node
+        end
+      end
+    end
+  end
+end