mx-platform-ruby 0.4.0 → 0.4.1

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/mixin/uncommunicative_name.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality shared by Uncommunicative cops
-    module UncommunicativeName
-      CASE_MSG = 'Only use lowercase characters for %<name_type>s.'.freeze
-      NUM_MSG = 'Do not end %<name_type>s with a number.'.freeze
-      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
-                   'characters long.'.freeze
-      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
-                      '%<name_type>s.'.freeze
-
-      def check(node, args)
-        args.each do |arg|
-          name = arg.children.first.to_s
-          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
-          next if allowed_names.include?(name)
-
-          range = arg_range(arg, name.size)
-          issue_offenses(node, range, name)
-        end
-      end
-
-      private
-
-      def issue_offenses(node, range, name)
-        forbidden_offense(node, range, name) if forbidden_names.include?(name)
-        case_offense(node, range) if uppercase?(name)
-        length_offense(node, range) unless long_enough?(name)
-        return if allow_nums
-
-        num_offense(node, range) if ends_with_num?(name)
-      end
-
-      def case_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(CASE_MSG, name_type: name_type(node)))
-      end
-
-      def uppercase?(name)
-        name =~ /[[:upper:]]/
-      end
-
-      def name_type(node)
-        @name_type ||= begin
-          case node.type
-          when :block then 'block parameter'
-          when :def, :defs then 'method parameter'
-          end
-        end
-      end
-
-      def num_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(NUM_MSG, name_type: name_type(node)))
-      end
-
-      def ends_with_num?(name)
-        name[-1] =~ /\d/
-      end
-
-      def length_offense(node, range)
-        add_offense(node, location: range,
-                          message: format(LENGTH_MSG,
-                                          name_type: name_type(node).capitalize,
-                                          min: min_length))
-      end
-
-      def long_enough?(name)
-        name.size >= min_length
-      end
-
-      def arg_range(arg, length)
-        begin_pos = arg.source_range.begin_pos
-        Parser::Source::Range.new(processed_source.buffer,
-                                  begin_pos,
-                                  begin_pos + length)
-      end
-
-      def forbidden_offense(node, range, name)
-        add_offense(
-          node,
-          location: range,
-          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
-        )
-      end
-
-      def allowed_names
-        cop_config['AllowedNames']
-      end
-
-      def forbidden_names
-        cop_config['ForbiddenNames']
-      end
-
-      def allow_nums
-        cop_config['AllowNamesEndingInNumbers']
-      end
-
-      def min_length
-        cop_config['MinNameLength']
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/mixin/unused_argument.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # Common functionality for cops handling unused arguments.
-      module UnusedArgument
-        extend NodePattern::Macros
-
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
-        end
-
-        private
-
-        def check_argument(variable)
-          return if variable.should_be_unused?
-          return if variable.referenced?
-
-          message = message(variable)
-          add_offense(variable.declaration_node, location: :name,
-                                                 message: message)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # This cop makes sure that accessor methods are named properly.
-      #
-      # @example
-      #   # bad
-      #   def set_attribute(value)
-      #   end
-      #
-      #   # good
-      #   def attribute=(value)
-      #   end
-      #
-      #   # bad
-      #   def get_attribute
-      #   end
-      #
-      #   # good
-      #   def attribute
-      #   end
-      class AccessorMethodName < Cop
-        MSG_READER = 'Do not prefix reader method names with `get_`.'.freeze
-        MSG_WRITER = 'Do not prefix writer method names with `set_`.'.freeze
-
-        def on_def(node)
-          return unless bad_reader_name?(node) || bad_writer_name?(node)
-
-          add_offense(node, location: :name)
-        end
-        alias on_defs on_def
-
-        private
-
-        def message(node)
-          if bad_reader_name?(node)
-            MSG_READER
-          elsif bad_writer_name?(node)
-            MSG_WRITER
-          end
-        end
-
-        def bad_reader_name?(node)
-          node.method_name.to_s.start_with?('get_') && !node.arguments?
-        end
-
-        def bad_writer_name?(node)
-          node.method_name.to_s.start_with?('set_') && node.arguments.one?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/naming/ascii_identifiers.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Style/AsciiComments
-
-module RuboCop
-  module Cop
-    module Naming
-      # This cop checks for non-ascii characters in identifier names.
-      #
-      # @example
-      #   # bad
-      #   def καλημερα # Greek alphabet (non-ascii)
-      #   end
-      #
-      #   # bad
-      #   def こんにちはと言う # Japanese character (non-ascii)
-      #   end
-      #
-      #   # bad
-      #   def hello_🍣 # Emoji (non-ascii)
-      #   end
-      #
-      #   # good
-      #   def say_hello
-      #   end
-      #
-      #   # bad
-      #   신장 = 10 # Hangul character (non-ascii)
-      #
-      #   # good
-      #   height = 10
-      #
-      #   # bad
-      #   params[:عرض_gteq] # Arabic character (non-ascii)
-      #
-      #   # good
-      #   params[:width_gteq]
-      #
-      class AsciiIdentifiers < Cop
-        include RangeHelp
-
-        MSG = 'Use only ascii symbols in identifiers.'.freeze
-
-        def investigate(processed_source)
-          processed_source.each_token do |token|
-            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
-
-            add_offense(token, location: first_offense_range(token))
-          end
-        end
-
-        private
-
-        def first_offense_range(identifier)
-          expression    = identifier.pos
-          first_offense = first_non_ascii_chars(identifier.text)
-
-          start_position = expression.begin_pos +
-                           identifier.text.index(first_offense)
-          end_position   = start_position + first_offense.length
-
-          range_between(start_position, end_position)
-        end
-
-        def first_non_ascii_chars(string)
-          string.match(/[^[:ascii:]]+/).to_s
-        end
-      end
-    end
-  end
-end
-# rubocop:enable Style/AsciiComments

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # This cop makes sure that certain binary operator methods have their
-      # sole  parameter named `other`.
-      #
-      # @example
-      #
-      #   # bad
-      #   def +(amount); end
-      #
-      #   # good
-      #   def +(other); end
-      class BinaryOperatorParameterName < Cop
-        MSG = 'When defining the `%<opr>s` operator, ' \
-              'name its argument `other`.'.freeze
-
-        OP_LIKE_METHODS = %i[eql? equal?].freeze
-        BLACKLISTED = %i[+@ -@ [] []= << === `].freeze
-
-        def_node_matcher :op_method_candidate?, <<-PATTERN
-          (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
-        PATTERN
-
-        def on_def(node)
-          op_method_candidate?(node) do |name, arg|
-            add_offense(arg, message: format(MSG, opr: name))
-          end
-        end
-
-        private
-
-        def op_method?(name)
-          return false if BLACKLISTED.include?(name)
-
-          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # This cop checks for class and module names with
-      # an underscore in them.
-      #
-      # @example
-      #   # bad
-      #   class My_Class
-      #   end
-      #   module My_Module
-      #   end
-      #
-      #   # good
-      #   class MyClass
-      #   end
-      #   module MyModule
-      #   end
-      class ClassAndModuleCamelCase < Cop
-        MSG = 'Use CamelCase for classes and modules.'.freeze
-
-        def on_class(node)
-          return unless node.loc.name.source =~ /_/
-
-          add_offense(node, location: :name)
-        end
-        alias on_module on_class
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/naming/constant_name.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # This cop checks whether constant names are written using
-      # SCREAMING_SNAKE_CASE.
-      #
-      # To avoid false positives, it ignores cases in which we cannot know
-      # for certain the type of value that would be assigned to a constant.
-      #
-      # @example
-      #   # bad
-      #   InchInCm = 2.54
-      #   INCHinCM = 2.54
-      #   Inch_In_Cm = 2.54
-      #
-      #   # good
-      #   INCH_IN_CM = 2.54
-      class ConstantName < Cop
-        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'.freeze
-        # Use POSIX character classes, so we allow accented characters rather
-        # than just standard ASCII characters
-        SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
-
-        def_node_matcher :class_or_struct_return_method?, <<-PATTERN
-          (send
-            (const _ {:Class :Struct}) :new
-            ...)
-        PATTERN
-
-        def on_casgn(node)
-          if node.parent && node.parent.or_asgn_type?
-            lhs, value = *node.parent
-            _scope, const_name = *lhs
-          else
-            _scope, const_name, value = *node
-          end
-
-          # We cannot know the result of method calls like
-          # NewClass = something_that_returns_a_class
-          # It's also ok to assign a class constant another class constant,
-          # `Class.new(...)` or `Struct.new(...)`
-          # SomeClass = SomeOtherClass
-          # SomeClass = Class.new(...)
-          # SomeClass = Struct.new(...)
-          return if allowed_assignment?(value)
-
-          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
-        end
-
-        private
-
-        def allowed_assignment?(value)
-          value && %i[block const casgn].include?(value.type) ||
-            allowed_method_call_on_rhs?(value) ||
-            class_or_struct_return_method?(value) ||
-            allowed_conditional_expression_on_rhs?(value)
-        end
-
-        def allowed_method_call_on_rhs?(node)
-          node && node.send_type? &&
-            (node.receiver.nil? || !literal_receiver?(node))
-        end
-
-        def_node_matcher :literal_receiver?, <<-PATTERN
-          {(send literal? ...)
-           (send (begin literal?) ...)}
-        PATTERN
-
-        def allowed_conditional_expression_on_rhs?(node)
-          node && node.if_type? && contains_contant?(node)
-        end
-
-        def contains_contant?(node)
-          node.branches.any?(&:const_type?)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/naming/file_name.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-
-module RuboCop
-  module Cop
-    module Naming
-      # This cop makes sure that Ruby source files have snake_case
-      # names. Ruby scripts (i.e. source files with a shebang in the
-      # first line) are ignored.
-      #
-      # The cop also ignores `.gemspec` files, because Bundler
-      # recommends using dashes to separate namespaces in nested gems
-      # (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
-      # gemspec is supposed to be named `bundler-console.gemspec`.
-      #
-      # @example
-      #   # bad
-      #   lib/layoutManager.rb
-      #
-      #   anything/usingCamelCase
-      #
-      #   # good
-      #   lib/layout_manager.rb
-      #
-      #   anything/using_snake_case.rake
-      class FileName < Cop
-        include RangeHelp
-
-        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
-                         'should use snake_case.'.freeze
-        MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
-                            'called `%<namespace>s`.'.freeze
-        MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'.freeze
-
-        SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
-
-        def investigate(processed_source)
-          file_path = processed_source.file_path
-          return if config.file_to_exclude?(file_path) ||
-                    config.allowed_camel_case_file?(file_path)
-
-          for_bad_filename(file_path) do |range, msg|
-            add_offense(nil, location: range, message: msg)
-          end
-        end
-
-        private
-
-        def for_bad_filename(file_path)
-          basename = File.basename(file_path)
-          msg = if filename_good?(basename)
-                  return unless expect_matching_definition?
-                  return if find_class_or_module(processed_source.ast,
-                                                 to_namespace(file_path))
-
-                  no_definition_message(basename, file_path)
-                else
-                  return if ignore_executable_scripts? &&
-                            processed_source.start_with?('#!')
-
-                  other_message(basename)
-                end
-
-          yield source_range(processed_source.buffer, 1, 0), msg
-        end
-
-        def no_definition_message(basename, file_path)
-          format(MSG_NO_DEFINITION,
-                 basename: basename,
-                 namespace: to_namespace(file_path).join('::'))
-        end
-
-        def other_message(basename)
-          if regex
-            format(MSG_REGEX, basename: basename, regex: regex)
-          else
-            format(MSG_SNAKE_CASE, basename: basename)
-          end
-        end
-
-        def ignore_executable_scripts?
-          cop_config['IgnoreExecutableScripts']
-        end
-
-        def expect_matching_definition?
-          cop_config['ExpectMatchingDefinition']
-        end
-
-        def regex
-          cop_config['Regex']
-        end
-
-        def allowed_acronyms
-          cop_config['AllowedAcronyms'] || []
-        end
-
-        def filename_good?(basename)
-          basename = basename.sub(/^\./, '')
-          basename = basename.sub(/\.[^\.]+$/, '')
-          # special handling for Action Pack Variants file names like
-          # some_file.xlsx+mobile.axlsx
-          basename = basename.sub('+', '_')
-          basename =~ (regex || SNAKE_CASE)
-        end
-
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def find_class_or_module(node, namespace)
-          return nil unless node
-
-          name = namespace.pop
-
-          on_node(%i[class module casgn], node) do |child|
-            next unless (const = child.defined_module)
-
-            const_namespace, const_name = *const
-            next if name != const_name && !match_acronym?(name, const_name)
-            next unless namespace.empty? ||
-                        match_namespace(child, const_namespace, namespace)
-
-            return node
-          end
-
-          nil
-        end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def match_namespace(node, namespace, expected)
-          match_partial = partial_matcher!(expected)
-
-          match_partial.call(namespace)
-
-          node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
-            return false if ancestor.sclass_type?
-
-            match_partial.call(ancestor.defined_module)
-          end
-
-          match?(expected)
-        end
-
-        def partial_matcher!(expected)
-          lambda do |namespace|
-            while namespace
-              return match?(expected) if namespace.cbase_type?
-
-              namespace, name = *namespace
-
-              if name == expected.last || match_acronym?(expected.last, name)
-                expected.pop
-              end
-            end
-
-            false
-          end
-        end
-
-        def match?(expected)
-          expected.empty? || expected == [:Object]
-        end
-
-        def match_acronym?(expected, name)
-          expected = expected.to_s
-          name = name.to_s
-
-          allowed_acronyms.any? do |acronym|
-            expected.gsub(acronym.capitalize, acronym) == name
-          end
-        end
-
-        def to_namespace(path)
-          components = Pathname(path).each_filename.to_a
-          # To convert a pathname to a Ruby namespace, we need a starting point
-          # But RC can be run from any working directory, and can check any path
-          # We can't assume that the working directory, or any other, is the
-          # "starting point" to build a namespace.
-          start = %w[lib spec test src]
-          start_index = nil
-
-          # To find the closest namespace root take the path components, and
-          # then work through them backwards until we find a candidate. This
-          # makes sure we work from the actual root in the case of a path like
-          # /home/user/src/project_name/lib.
-          components.reverse.each_with_index do |c, i|
-            if start.include?(c)
-              start_index = components.size - i
-              break
-            end
-          end
-
-          if start_index.nil?
-            [to_module_name(components.last)]
-          else
-            components[start_index..-1].map { |c| to_module_name(c) }
-          end
-        end
-
-        def to_module_name(basename)
-          words = basename.sub(/\..*/, '').split('_')
-          words.map(&:capitalize).join.to_sym
-        end
-      end
-    end
-  end
-end