mx-platform-ruby 0.4.0 → 0.6.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/block_delimiters.rb

@@ -1,315 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Check for uses of braces or do/end around single line or
-      # multi-line blocks.
-      #
-      # @example EnforcedStyle: line_count_based (default)
-      #   # bad - single line block
-      #   items.each do |item| item / 5 end
-      #
-      #   # good - single line block
-      #   items.each { |item| item / 5 }
-      #
-      #   # bad - multi-line block
-      #   things.map { |thing|
-      #     something = thing.some_method
-      #     process(something)
-      #   }
-      #
-      #   # good - multi-line block
-      #   things.map do |thing|
-      #     something = thing.some_method
-      #     process(something)
-      #   end
-      #
-      # @example EnforcedStyle: semantic
-      #   # Prefer `do...end` over `{...}` for procedural blocks.
-      #
-      #   # return value is used/assigned
-      #   # bad
-      #   foo = map do |x|
-      #     x
-      #   end
-      #   puts (map do |x|
-      #     x
-      #   end)
-      #
-      #   # return value is not used out of scope
-      #   # good
-      #   map do |x|
-      #     x
-      #   end
-      #
-      #   # Prefer `{...}` over `do...end` for functional blocks.
-      #
-      #   # return value is not used out of scope
-      #   # bad
-      #   each { |x|
-      #     x
-      #   }
-      #
-      #   # return value is used/assigned
-      #   # good
-      #   foo = map { |x|
-      #     x
-      #   }
-      #   map { |x|
-      #     x
-      #   }.inspect
-      #
-      #   # The AllowBracesOnProceduralOneLiners option is ignored unless the
-      #   # EnforcedStyle is set to `semantic`. If so:
-      #
-      #   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
-      #   # set to `false` or any other falsey value, then semantic purity is
-      #   # maintained, so one-line procedural blocks must use do-end, not
-      #   # braces.
-      #
-      #   # bad
-      #   collection.each { |element| puts element }
-      #
-      #   # good
-      #   collection.each do |element| puts element end
-      #
-      #   # If the AllowBracesOnProceduralOneLiners option is set to `true`, or
-      #   # any other truthy value, then one-line procedural blocks may use
-      #   # either style. (There is no setting for requiring braces on them.)
-      #
-      #   # good
-      #   collection.each { |element| puts element }
-      #
-      #   # also good
-      #   collection.each do |element| puts element end
-      #
-      # @example EnforcedStyle: braces_for_chaining
-      #   # bad
-      #   words.each do |word|
-      #     word.flip.flop
-      #   end.join("-")
-      #
-      #   # good
-      #   words.each { |word|
-      #     word.flip.flop
-      #   }.join("-")
-      #
-      class BlockDelimiters < Cop
-        include ConfigurableEnforcedStyle
-        include IgnoredMethods
-
-        def on_send(node)
-          return unless node.arguments?
-          return if node.parenthesized? || node.operator_method?
-
-          node.arguments.each do |arg|
-            get_blocks(arg) do |block|
-              # If there are no parentheses around the arguments, then braces
-              # and do-end have different meaning due to how they bind, so we
-              # allow either.
-              ignore_node(block)
-            end
-          end
-        end
-
-        def on_block(node)
-          return if ignored_node?(node)
-
-          add_offense(node, location: :begin) unless proper_block_style?(node)
-        end
-
-        def autocorrect(node)
-          return if correction_would_break_code?(node)
-
-          if node.braces?
-            replace_braces_with_do_end(node.loc)
-          else
-            replace_do_end_with_braces(node.loc)
-          end
-        end
-
-        private
-
-        def line_count_based_message(node)
-          if node.multiline?
-            'Avoid using `{...}` for multi-line blocks.'
-          else
-            'Prefer `{...}` over `do...end` for single-line blocks.'
-          end
-        end
-
-        def semantic_message(node)
-          block_begin = node.loc.begin.source
-
-          if block_begin == '{'
-            'Prefer `do...end` over `{...}` for procedural blocks.'
-          else
-            'Prefer `{...}` over `do...end` for functional blocks.'
-          end
-        end
-
-        def braces_for_chaining_message(node)
-          if node.multiline?
-            if return_value_chaining?(node)
-              'Prefer `{...}` over `do...end` for multi-line chained blocks.'
-            else
-              'Prefer `do...end` for multi-line blocks without chaining.'
-            end
-          else
-            'Prefer `{...}` over `do...end` for single-line blocks.'
-          end
-        end
-
-        def message(node)
-          case style
-          when :line_count_based    then line_count_based_message(node)
-          when :semantic            then semantic_message(node)
-          when :braces_for_chaining then braces_for_chaining_message(node)
-          end
-        end
-
-        def replace_braces_with_do_end(loc)
-          b = loc.begin
-          e = loc.end
-
-          lambda do |corrector|
-            corrector.insert_before(b, ' ') unless whitespace_before?(b)
-            corrector.insert_before(e, ' ') unless whitespace_before?(e)
-            corrector.insert_after(b, ' ') unless whitespace_after?(b)
-            corrector.replace(b, 'do')
-            corrector.replace(e, 'end')
-          end
-        end
-
-        def replace_do_end_with_braces(loc)
-          b = loc.begin
-          e = loc.end
-
-          lambda do |corrector|
-            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
-
-            corrector.replace(b, '{')
-            corrector.replace(e, '}')
-          end
-        end
-
-        def whitespace_before?(range)
-          range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
-        end
-
-        def whitespace_after?(range, length = 1)
-          range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
-        end
-
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def get_blocks(node, &block)
-          case node.type
-          when :block
-            yield node
-          when :send
-            get_blocks(node.receiver, &block) if node.receiver
-          when :hash
-            # A hash which is passed as method argument may have no braces
-            # In that case, one of the K/V pairs could contain a block node
-            # which could change in meaning if do...end replaced {...}
-            return if node.braces?
-
-            node.each_child_node { |child| get_blocks(child, &block) }
-          when :pair
-            node.each_child_node { |child| get_blocks(child, &block) }
-          end
-        end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def proper_block_style?(node)
-          return true if ignored_method?(node.method_name)
-
-          case style
-          when :line_count_based    then line_count_based_block_style?(node)
-          when :semantic            then semantic_block_style?(node)
-          when :braces_for_chaining then braces_for_chaining_style?(node)
-          end
-        end
-
-        def line_count_based_block_style?(node)
-          node.multiline? ^ node.braces?
-        end
-
-        def semantic_block_style?(node)
-          method_name = node.method_name
-
-          if node.braces?
-            functional_method?(method_name) || functional_block?(node) ||
-              (procedural_oneliners_may_have_braces? && !node.multiline?)
-          else
-            procedural_method?(method_name) || !return_value_used?(node)
-          end
-        end
-
-        def braces_for_chaining_style?(node)
-          block_begin = node.loc.begin.source
-
-          block_begin == if node.multiline?
-                           (return_value_chaining?(node) ? '{' : 'do')
-                         else
-                           '{'
-                         end
-        end
-
-        def return_value_chaining?(node)
-          node.parent && node.parent.send_type? && node.parent.dot?
-        end
-
-        def correction_would_break_code?(node)
-          return unless node.keywords?
-
-          node.send_node.arguments? && !node.send_node.parenthesized?
-        end
-
-        def functional_method?(method_name)
-          cop_config['FunctionalMethods'].map(&:to_sym).include?(method_name)
-        end
-
-        def functional_block?(node)
-          return_value_used?(node) || return_value_of_scope?(node)
-        end
-
-        def procedural_oneliners_may_have_braces?
-          cop_config['AllowBracesOnProceduralOneLiners']
-        end
-
-        def procedural_method?(method_name)
-          cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
-        end
-
-        def return_value_used?(node)
-          return unless node.parent
-
-          # If there are parentheses around the block, check if that
-          # is being used.
-          if node.parent.begin_type?
-            return_value_used?(node.parent)
-          else
-            node.parent.assignment? || node.parent.send_type?
-          end
-        end
-
-        def return_value_of_scope?(node)
-          return unless node.parent
-
-          conditional?(node.parent) || array_or_range?(node.parent) ||
-            node.parent.children.last == node
-        end
-
-        def conditional?(node)
-          node.if_type? || node.or_type? || node.and_type?
-        end
-
-        def array_or_range?(node)
-          node.array_type? || node.range_type?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/braces_around_hash_parameters.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for braces around the last parameter in a method call
-      # if the last parameter is a hash.
-      # It supports `braces`, `no_braces` and `context_dependent` styles.
-      #
-      # @example EnforcedStyle: braces
-      #   # The `braces` style enforces braces around all method
-      #   # parameters that are hashes.
-      #
-      #   # bad
-      #   some_method(x, y, a: 1, b: 2)
-      #
-      #   # good
-      #   some_method(x, y, {a: 1, b: 2})
-      #
-      # @example EnforcedStyle: no_braces (default)
-      #   # The `no_braces` style checks that the last parameter doesn't
-      #   # have braces around it.
-      #
-      #   # bad
-      #   some_method(x, y, {a: 1, b: 2})
-      #
-      #   # good
-      #   some_method(x, y, a: 1, b: 2)
-      #
-      # @example EnforcedStyle: context_dependent
-      #   # The `context_dependent` style checks that the last parameter
-      #   # doesn't have braces around it, but requires braces if the
-      #   # second to last parameter is also a hash literal.
-      #
-      #   # bad
-      #   some_method(x, y, {a: 1, b: 2})
-      #   some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
-      #
-      #   # good
-      #   some_method(x, y, a: 1, b: 2)
-      #   some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
-      class BracesAroundHashParameters < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        MSG = '%<type>s curly braces around a hash parameter.'.freeze
-
-        def on_send(node)
-          return if node.assignment_method? || node.operator_method?
-
-          return unless node.arguments? && node.last_argument.hash_type? &&
-                        !node.last_argument.empty?
-
-          check(node.last_argument, node.arguments)
-        end
-        alias on_csend on_send
-
-        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
-        # node, because that context is needed. When parsing the code to see if
-        # the AST has changed, a braceless hash would not be parsed as a hash
-        # otherwise.
-        def autocorrect(send_node)
-          hash_node = send_node.last_argument
-
-          lambda do |corrector|
-            if hash_node.braces?
-              remove_braces_with_whitespace(corrector,
-                                            hash_node,
-                                            extra_space(hash_node))
-            else
-              add_braces(corrector, hash_node)
-            end
-          end
-        end
-
-        private
-
-        def check(arg, args)
-          if style == :braces && !arg.braces?
-            add_arg_offense(arg, :missing)
-          elsif style == :no_braces && arg.braces?
-            add_arg_offense(arg, :redundant)
-          elsif style == :context_dependent
-            check_context_dependent(arg, args)
-          end
-        end
-
-        def check_context_dependent(arg, args)
-          braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
-
-          if arg.braces?
-            unless braces_around_second_from_end
-              add_arg_offense(arg, :redundant)
-            end
-          elsif braces_around_second_from_end
-            add_arg_offense(arg, :missing)
-          end
-        end
-
-        def add_arg_offense(arg, type)
-          add_offense(arg.parent, location: arg.source_range,
-                                  message: format(MSG,
-                                                  type: type.to_s.capitalize))
-        end
-
-        def extra_space(hash_node)
-          {
-            newlines: extra_left_space?(hash_node) &&
-              extra_right_space?(hash_node),
-            left: extra_left_space?(hash_node),
-            right: extra_right_space?(hash_node)
-          }
-        end
-
-        def extra_left_space?(hash_node)
-          @extra_left_space ||= begin
-            top_line = hash_node.source_range.source_line
-            top_line.delete(' ') == '{'
-          end
-        end
-
-        def extra_right_space?(hash_node)
-          @extra_right_space ||= begin
-            bottom_line_number = hash_node.source_range.last_line
-            bottom_line = processed_source.lines[bottom_line_number - 1]
-            bottom_line.delete(' ') == '}'
-          end
-        end
-
-        def remove_braces_with_whitespace(corrector, node, space)
-          if node.multiline?
-            remove_braces_with_range(corrector,
-                                     left_whole_line_range(node.loc.begin),
-                                     right_whole_line_range(node.loc.end))
-          else
-            right_brace_and_space = right_brace_and_space(node.loc.end, space)
-            left_brace_and_space = left_brace_and_space(node.loc.begin, space)
-            remove_braces_with_range(corrector,
-                                     left_brace_and_space,
-                                     right_brace_and_space)
-          end
-        end
-
-        def remove_braces_with_range(corrector, left_range, right_range)
-          corrector.remove(left_range)
-          corrector.remove(right_range)
-        end
-
-        def left_whole_line_range(loc_begin)
-          if range_by_whole_lines(loc_begin).source.strip == '{'
-            range_by_whole_lines(loc_begin, include_final_newline: true)
-          else
-            loc_begin
-          end
-        end
-
-        def right_whole_line_range(loc_end)
-          if range_by_whole_lines(loc_end).source.strip =~ /\A}\s*,?\z/
-            range_by_whole_lines(loc_end, include_final_newline: true)
-          else
-            loc_end
-          end
-        end
-
-        def left_brace_and_space(loc_begin, space)
-          range_with_surrounding_space(range: loc_begin,
-                                       side: :right,
-                                       newlines: space[:newlines],
-                                       whitespace: space[:left])
-        end
-
-        def right_brace_and_space(loc_end, space)
-          brace_and_space =
-            range_with_surrounding_space(
-              range: loc_end,
-              side: :left,
-              newlines: space[:newlines],
-              whitespace: space[:right]
-            )
-          range_with_surrounding_comma(brace_and_space, :left)
-        end
-
-        def add_braces(corrector, node)
-          corrector.insert_before(node.source_range, '{')
-          corrector.insert_after(node.source_range, '}')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/case_equality.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of the case equality operator(===).
-      #
-      # @example
-      #   # bad
-      #   Array === something
-      #   (1..100) === 7
-      #   /something/ === some_string
-      #
-      #   # good
-      #   something.is_a?(Array)
-      #   (1..100).include?(7)
-      #   some_string =~ /something/
-      #
-      class CaseEquality < Cop
-        MSG = 'Avoid the use of the case equality operator `===`.'.freeze
-
-        def_node_matcher :case_equality?, '(send _ :=== _)'
-
-        def on_send(node)
-          case_equality?(node) { add_offense(node, location: :selector) }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/character_literal.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for uses of the character literal ?x.
-      #
-      # @example
-      #   # bad
-      #   ?x
-      #
-      #   # good
-      #   'x'
-      #
-      #   # good
-      #   ?\C-\M-d
-      class CharacterLiteral < Cop
-        include StringHelp
-
-        MSG = 'Do not use the character literal - ' \
-              'use string literal instead.'.freeze
-
-        def offense?(node)
-          # we don't register an offense for things like ?\C-\M-d
-          node.loc.begin.is?('?') &&
-            node.source.size.between?(2, 3)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            string = node.source[1..-1]
-
-            # special character like \n
-            # or ' which needs to use "" or be escaped.
-            if string.length == 2 || string == "'"
-              corrector.replace(node.source_range, %("#{string}"))
-            elsif string.length == 1 # normal character
-              corrector.replace(node.source_range, "'#{string}'")
-            end
-          end
-        end
-
-        # Dummy implementation of method in ConfigurableEnforcedStyle that is
-        # called from StringHelp.
-        def opposite_style_detected; end
-
-        # Dummy implementation of method in ConfigurableEnforcedStyle that is
-        # called from StringHelp.
-        def correct_style_detected; end
-      end
-    end
-  end
-end