rbhint 0.8.5.rc1

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop is designed to help you transition from mutable string literals
+      # to frozen string literals.
+      # It will add the comment `# frozen_string_literal: true` to the top of
+      # files to enable frozen string literals. Frozen string literals may be
+      # default in future Ruby. The comment will be added below a shebang and
+      # encoding comment.
+      #
+      # Note that the cop will ignore files where the comment exists but is set
+      # to `false` instead of `true`.
+      #
+      # @example EnforcedStyle: always (default)
+      #   # The `always` style will always add the frozen string literal comment
+      #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are
+      #   # called on a string literal.
+      #   # bad
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: false
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: never
+      #   # The `never` will enforce that the frozen string literal comment does
+      #   # not exist in a file.
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: always_true
+      #   # The `always_true` style enforces that the frozen string literal
+      #   # comment is set to `true`. This is a stricter option than `always`
+      #   # and forces projects to use frozen string literals.
+      #   # bad
+      #   # frozen_string_literal: false
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      class FrozenStringLiteralComment < Cop
+        include ConfigurableEnforcedStyle
+        include FrozenStringLiteral
+        include RangeHelp
+
+        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
+                           'true`.'
+        MSG_MISSING = 'Missing frozen string literal comment.'
+        MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
+        MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
+        SHEBANG = '#!'
+
+        def investigate(processed_source)
+          return if processed_source.tokens.empty?
+
+          case style
+          when :never
+            ensure_no_comment(processed_source)
+          when :always_true
+            ensure_enabled_comment(processed_source)
+          else
+            ensure_comment(processed_source)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            case style
+            when :never
+              remove_comment(corrector, node)
+            when :always_true
+              if frozen_string_literal_specified?
+                enable_comment(corrector)
+              else
+                insert_comment(corrector)
+              end
+            else
+              insert_comment(corrector)
+            end
+          end
+        end
+
+        private
+
+        def ensure_no_comment(processed_source)
+          return unless frozen_string_literal_comment_exists?
+
+          unnecessary_comment_offense(processed_source)
+        end
+
+        def ensure_comment(processed_source)
+          return if frozen_string_literal_comment_exists?
+
+          missing_offense(processed_source)
+        end
+
+        def ensure_enabled_comment(processed_source)
+          if frozen_string_literal_specified?
+            return if frozen_string_literals_enabled?
+
+            # The comment exists, but is not enabled.
+            disabled_offense(processed_source)
+          else # The comment doesn't exist at all.
+            missing_true_offense(processed_source)
+          end
+        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
+
+          next_token = processed_source.tokens[token_number]
+          token = next_token if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
+
+          token
+        end
+
+        def frozen_string_literal_comment(processed_source)
+          processed_source.find_token do |token|
+            token.text.start_with?(FrozenStringLiteral::FROZEN_STRING_LITERAL)
+          end
+        end
+
+        def missing_offense(processed_source)
+          last_special_comment = last_special_comment(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(last_special_comment,
+                      location: range,
+                      message: MSG_MISSING)
+        end
+
+        def missing_true_offense(processed_source)
+          last_special_comment = last_special_comment(processed_source)
+          range = source_range(processed_source.buffer, 0, 0)
+
+          add_offense(last_special_comment,
+                      location: range,
+                      message: MSG_MISSING_TRUE)
+        end
+
+        def unnecessary_comment_offense(processed_source)
+          frozen_string_literal_comment =
+            frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment,
+                      location: frozen_string_literal_comment.pos,
+                      message: MSG_UNNECESSARY)
+        end
+
+        def disabled_offense(processed_source)
+          frozen_string_literal_comment =
+            frozen_string_literal_comment(processed_source)
+
+          add_offense(frozen_string_literal_comment,
+                      location: frozen_string_literal_comment.pos,
+                      message: MSG_DISABLED)
+        end
+
+        def remove_comment(corrector, node)
+          corrector.remove(range_with_surrounding_space(range: node.pos,
+                                                        side: :right))
+        end
+
+        def enable_comment(corrector)
+          comment = frozen_string_literal_comment(processed_source)
+
+          corrector.replace(line_range(comment.line),
+                            FROZEN_STRING_LITERAL_ENABLED)
+        end
+
+        def insert_comment(corrector)
+          comment = last_special_comment(processed_source)
+
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
+          else
+            corrector.insert_before(processed_source.buffer.source_range, preceding_comment)
+          end
+        end
+
+        def line_range(line)
+          processed_source.buffer.line_range(line)
+        end
+
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
+
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
+        end
+      end
+    end
+  end
+end

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,145 @@
+# 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
+      #
+      #   # bad
+      #   if something
+      #     foo || raise('exception')
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   foo || 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?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
+          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(guard_clause), 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 guard_clause_source(guard_clause)
+          parent = guard_clause.parent
+
+          if parent.and_type? || parent.or_type?
+            guard_clause.parent.source
+          else
+            guard_clause.source
+          end
+        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? ||
+            node.parent&.assignment?
+        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