config_gems_initialization_aim 0.1.3

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/multiline_if_then.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of the `then` keyword in multi-line if statements.
+      #
+      # @example
+      #   # bad
+      #   # This is considered bad practice.
+      #   if cond then
+      #   end
+      #
+      #   # good
+      #   # If statements can contain `then` on the same line.
+      #   if cond then a
+      #   elsif cond then b
+      #   end
+      class MultilineIfThen < Cop
+        include OnNormalIfUnless
+        include RangeHelp
+
+        NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
+
+        MSG = 'Do not use `then` for multi-line `%<keyword>s`.'.freeze
+
+        def on_normal_if_unless(node)
+          return unless non_modifier_then?(node)
+
+          add_offense(node, location: :begin,
+                            message: format(MSG, keyword: node.keyword))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(range: node.loc.begin, side: :left)
+            )
+          end
+        end
+
+        private
+
+        def non_modifier_then?(node)
+          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/multiline_memoization.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks expressions wrapping styles for multiline memoization.
+      #
+      # @example EnforcedStyle: keyword (default)
+      #   # bad
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      #
+      #   # good
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      # @example EnforcedStyle: braces
+      #   # bad
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      #   # good
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      class MultilineMemoization < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'.freeze
+
+        def on_or_asgn(node)
+          _lhs, rhs = *node
+
+          return unless bad_rhs?(rhs)
+
+          add_offense(rhs, location: node.source_range)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if style == :keyword
+              keyword_autocorrect(node, corrector)
+            else
+              corrector.replace(node.loc.begin, '(')
+              corrector.replace(node.loc.end, ')')
+            end
+          end
+        end
+
+        private
+
+        def bad_rhs?(rhs)
+          return false unless rhs.multiline?
+
+          if style == :keyword
+            rhs.begin_type?
+          else
+            rhs.kwbegin_type?
+          end
+        end
+
+        def keyword_autocorrect(node, corrector)
+          node_buf = node.source_range.source_buffer
+          corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))
+          corrector.replace(node.loc.end, keyword_end_str(node, node_buf))
+        end
+
+        def keyword_begin_str(node, node_buf)
+          indent = config.for_cop('IndentationWidth')['Width'] || 2
+          if node_buf.source[node.loc.begin.end_pos] == "\n"
+            'begin'
+          else
+            "begin\n" + (' ' * (node.loc.column + indent))
+          end
+        end
+
+        def keyword_end_str(node, node_buf)
+          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
+            "\n" + (' ' * node.loc.column) + 'end'
+          else
+            'end'
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/multiline_method_signature.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for method signatures that span multiple lines.
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo(bar, baz)
+      #   end
+      #
+      #   # bad
+      #
+      #   def foo(bar,
+      #           baz)
+      #   end
+      #
+      class MultilineMethodSignature < Cop
+        MSG = 'Avoid multi-line method signatures.'.freeze
+
+        def on_def(node)
+          return unless node.arguments?
+          return if opening_line(node) == closing_line(node)
+          return if correction_exceeds_max_line_length?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def opening_line(node)
+          node.first_line
+        end
+
+        def closing_line(node)
+          node.arguments.last_line
+        end
+
+        def correction_exceeds_max_line_length?(node)
+          indentation_width(node) + definition_width(node) > max_line_length
+        end
+
+        def indentation_width(node)
+          processed_source.line_indentation(node.loc.expression.line)
+        end
+
+        def definition_width(node)
+          node.source_range.begin.join(node.arguments.source_range.end).length
+        end
+
+        def max_line_length
+          config.for_cop('Metrics/LineLength')['Max'] || 80
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/multiline_ternary_operator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for multi-line ternary op expressions.
+      #
+      # @example
+      #   # bad
+      #   a = cond ?
+      #     b : c
+      #   a = cond ? b :
+      #       c
+      #   a = cond ?
+      #       b :
+      #       c
+      #
+      #   # good
+      #   a = cond ? b : c
+      #   a =
+      #     if cond
+      #       b
+      #     else
+      #       c
+      #     end
+      class MultilineTernaryOperator < Cop
+        MSG = 'Avoid multi-line ternary operators, ' \
+              'use `if` or `unless` instead.'.freeze
+
+        def on_if(node)
+          return unless node.ternary? && node.multiline?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/multiple_comparison.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks against comparing a variable with multiple items, where
+      # `Array#include?` could be used instead to avoid code repetition.
+      #
+      # @example
+      #   # bad
+      #   a = 'a'
+      #   foo if a == 'a' || a == 'b' || a == 'c'
+      #
+      #   # good
+      #   a = 'a'
+      #   foo if ['a', 'b', 'c'].include?(a)
+      class MultipleComparison < Cop
+        MSG = 'Avoid comparing a variable with multiple items ' \
+          'in a conditional, use `Array#include?` instead.'.freeze
+
+        def on_or(node)
+          root_of_or_node = root_of_or_node(node)
+
+          return unless node == root_of_or_node
+          return unless nested_variable_comparison?(root_of_or_node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
+        def_node_matcher :simple_comparison?, <<-PATTERN
+          {(send $lvar :== _)
+           (send _ :== $lvar)}
+        PATTERN
+
+        def nested_variable_comparison?(node)
+          return false unless nested_comparison?(node)
+
+          variables_in_node(node).count == 1
+        end
+
+        def variables_in_node(node)
+          if node.or_type?
+            node.node_parts
+                .flat_map { |node_part| variables_in_node(node_part) }
+                .uniq
+          else
+            variables_in_simple_node(node)
+          end
+        end
+
+        def variables_in_simple_node(node)
+          simple_double_comparison?(node) do |var1, var2|
+            return [variable_name(var1), variable_name(var2)]
+          end
+          simple_comparison?(node) do |var|
+            return [variable_name(var)]
+          end
+          []
+        end
+
+        def variable_name(node)
+          node.children[0]
+        end
+
+        def nested_comparison?(node)
+          if node.or_type?
+            node.node_parts.all? { |node_part| comparison? node_part }
+          else
+            false
+          end
+        end
+
+        def comparison?(node)
+          simple_comparison?(node) || nested_comparison?(node)
+        end
+
+        def root_of_or_node(or_node)
+          return or_node unless or_node.parent
+
+          if or_node.parent.or_type?
+            root_of_or_node(or_node.parent)
+          else
+            or_node
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/mutable_constant.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether some constant value isn't a
+      # mutable literal (e.g. array or hash).
+      #
+      # @example
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   CONST = [1, 2, 3].freeze
+      #
+      #   # good
+      #   CONST = <<~TESTING.freeze
+      #   This is a heredoc
+      #   TESTING
+      class MutableConstant < Cop
+        include FrozenStringLiteral
+
+        MSG = 'Freeze mutable objects assigned to constants.'.freeze
+
+        def on_casgn(node)
+          _scope, _const_name, value = *node
+          on_assignment(value)
+        end
+
+        def on_or_asgn(node)
+          lhs, value = *node
+
+          return unless lhs && lhs.casgn_type?
+
+          on_assignment(value)
+        end
+
+        def autocorrect(node)
+          expr = node.source_range
+
+          lambda do |corrector|
+            if node.array_type? && !node.bracketed?
+              corrector.insert_before(expr, '[')
+              corrector.insert_after(expr, '].freeze')
+            elsif node.irange_type? || node.erange_type?
+              corrector.insert_before(expr, '(')
+              corrector.insert_after(expr, ').freeze')
+            else
+              corrector.insert_after(expr, '.freeze')
+            end
+          end
+        end
+
+        private
+
+        def on_assignment(value)
+          range_enclosed_in_parentheses = range_enclosed_in_parentheses?(value)
+
+          value = splat_value(value) if splat_value(value)
+
+          return unless mutable_literal?(value) ||
+                        range_enclosed_in_parentheses
+          return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
+                    frozen_string_literals_enabled?
+
+          add_offense(value)
+        end
+
+        def mutable_literal?(value)
+          value && value.mutable_literal?
+        end
+
+        def_node_matcher :splat_value, <<-PATTERN
+          (array (splat $_))
+        PATTERN
+
+        def_node_matcher :range_enclosed_in_parentheses?, <<-PATTERN
+          (begin ({irange erange} _ _))
+        PATTERN
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/rubocop-0.60.0/lib/rubocop/cop/style/negated_if.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered. There are three different styles:
+      #
+      #   - both
+      #   - prefix
+      #   - postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `unless` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `unless` for just `prefix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar if !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `unless` for just `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # good
+      #
+      #   if !foo
+      #     bar
+      #   end
+      class NegatedIf < Cop
+        include ConfigurableEnforcedStyle
+        include NegativeConditional
+
+        def on_if(node)
+          return if node.elsif? || node.ternary?
+          return if correct_style?(node)
+
+          check_negative_conditional(node)
+        end
+
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          style == :prefix && node.modifier_form? ||
+            style == :postfix && !node.modifier_form?
+        end
+      end
+    end
+  end
+end