rubbycop 0.49.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop is designed to help upgrade to Ruby 3.0. It will add the
+      # comment `# frozen_string_literal: true` to the top of files to
+      # enable frozen string literals. Frozen string literals will be default
+      # in Ruby 3.0. The comment will be added below a shebang and encoding
+      # comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      class FrozenStringLiteralComment < Cop
+        include ConfigurableEnforcedStyle
+        include FrozenStringLiteral
+
+        MSG = 'Missing magic comment `# frozen_string_literal: true`.'.freeze
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'.freeze
+        SHEBANG = '#!'.freeze
+
+        def investigate(processed_source)
+          return if style == :when_needed && target_ruby_version < 2.3
+          return if processed_source.tokens.empty?
+
+          if frozen_string_literal_comment_exists?
+            check_for_no_comment(processed_source)
+          else
+            check_for_comment(processed_source)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if style == :never
+              corrector.remove(range_with_surrounding_space(node.pos, :right))
+            else
+              last_special_comment = last_special_comment(processed_source)
+              if last_special_comment.nil?
+                corrector.insert_before(processed_source.tokens[0].pos,
+                                        "#{FROZEN_STRING_LITERAL_ENABLED}\n")
+              else
+                corrector.insert_after(last_special_comment.pos,
+                                       "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+              end
+            end
+          end
+        end
+
+        private
+
+        def check_for_no_comment(processed_source)
+          unnecessary_comment_offense(processed_source) if style == :never
+        end
+
+        def check_for_comment(processed_source)
+          offense(processed_source) unless style == :never
+        end
+
+        def last_special_comment(processed_source)
+          token_number = 0
+          if processed_source.tokens[token_number].text.start_with?(SHEBANG)
+            token = processed_source.tokens[token_number]
+            token_number += 1
+          end
+
+          if processed_source.tokens[token_number].text =~
+             Encoding::ENCODING_PATTERN
+            token = processed_source.tokens[token_number]
+          end
+
+          token
+        end
+
+        def frozen_string_literal_comment(processed_source)
+          processed_source.tokens.find do |token|
+            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+          end
+        end
+
+        def offense(processed_source)
+          last_special_comment = last_special_comment(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(last_special_comment, range, MSG)
+        end
+
+        def unnecessary_comment_offense(processed_source)
+          frozen_string_literal_comment =
+            frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment,
+                      frozen_string_literal_comment.pos,
+                      MSG_UNNECESSARY)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cops 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.
+      class GlobalVars < Cop
+        MSG = 'Do not introduce global variables.'.freeze
+
+        # predefined global variables their English aliases
+        # http://www.zenspider.com/Languages/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, :name) unless allowed_var?(global_var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 OnMethodDef
+
+        MSG = 'Use a guard clause instead of wrapping the code inside a ' \
+              'conditional expression.'.freeze
+
+        def on_method_def(_node, _method_name, _args, 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
+
+        def on_if(node)
+          return if accepted_form?(node) || !contains_guard_clause?(node)
+
+          add_offense(node, :keyword)
+        end
+
+        private
+
+        def check_ending_if(node)
+          return if accepted_form?(node, true) || !min_body_length?(node)
+
+          add_offense(node, :keyword)
+        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
+
+        def contains_guard_clause?(node)
+          node.if_branch && node.if_branch.guard_clause? ||
+            node.else_branch && node.else_branch.guard_clause?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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'"
+      #
+      #   @good
+      #   {a: 2, b: 1}
+      #   {:c => 2, 'd' => 2} # acceptable since 'd' isn't a symbol
+      #   {d: 1, 'e' => 2} # technically not forbidden
+      #
+      #   @bad
+      #   {:a => 2}
+      #   {b: 1, :c => 2}
+      #
+      # @example
+      #   "EnforcedStyle => 'hash_rockets'"
+      #
+      #   @good
+      #   {:a => 1, :b => 2}
+      #
+      #   @bad
+      #   {a: 1, b: 2}
+      #   {c: 1, 'd' => 5}
+      #
+      # @example
+      #   "EnforcedStyle => 'no_mixed_keys'"
+      #
+      #   @good
+      #   {:a => 1, :b => 2}
+      #   {c: 1, d: 2}
+      #
+      #   @bad
+      #   {:a => 1, b: 2}
+      #   {c: 1, 'd' => 2}
+      #
+      # @example
+      #   "EnforcedStyle => 'ruby19_no_mixed_keys'"
+      #
+      #   @good
+      #   {a: 1, b: 2}
+      #   {:c => 3, 'd' => 4}
+      #
+      #   @bad
+      #   {:a => 1, :b => 2}
+      #   {c: 2, 'd' => 3} # should just use hash rockets
+      class HashSyntax < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_19 = 'Use the new Ruby 1.9 hash syntax.'.freeze
+        MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash.".freeze
+        MSG_HASH_ROCKETS = 'Use hash rockets syntax.'.freeze
+
+        def on_hash(node)
+          return if node.pairs.empty?
+
+          @force_hash_rockets = force_hash_rockets?(node.pairs)
+
+          if style == :hash_rockets || @force_hash_rockets
+            hash_rockets_check(node.pairs)
+          elsif style == :ruby19_no_mixed_keys
+            ruby19_no_mixed_keys_check(node.pairs)
+          elsif style == :no_mixed_keys
+            no_mixed_keys_check(node.pairs)
+          else
+            ruby19_check(node.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
+            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
+              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 then
+            :ruby19
+          when :ruby19, :ruby19_no_mixed_keys then
+            :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?
+
+          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
+              add_offense(pair,
+                          pair.source_range.begin.join(pair.loc.operator),
+                          msg) do
+                opposite_style_detected
+              end
+            else
+              correct_style_detected
+            end
+          end
+        end
+
+        def autocorrect_ruby19(corrector, node)
+          key = node.children.first.source_range
+          op = node.loc.operator
+
+          range = range_between(key.begin_pos, op.end_pos)
+          range = range_with_surrounding_space(range, :right)
+          corrector.replace(range,
+                            range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
+        end
+
+        def autocorrect_hash_rockets(corrector, node)
+          key = node.children.first.source_range
+          op = node.loc.operator
+
+          corrector.insert_after(key, node.inverse_delimiter(true))
+          corrector.insert_before(key, ':')
+          corrector.remove(range_with_surrounding_space(op))
+        end
+
+        def autocorrect_no_mixed_keys(corrector, node)
+          if node.colon?
+            autocorrect_hash_rockets(corrector, node)
+          else
+            autocorrect_ruby19(corrector, node)
+          end
+        end
+
+        def force_hash_rockets?(pairs)
+          @force_hash_rockets ||= begin
+            cop_config['UseHashRocketsWithSymbolValues'] &&
+              pairs.map(&:value).any?(&:sym_type?)
+          end
+        end
+      end
+    end
+  end
+end