mx-platform-ruby 0.3.0 → 0.3.1

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/system_command_handler.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module SystemCommandHandler
+    class << self
+      def default(output, command, _pry_instance)
+        return if Kernel.system(command)
+
+        output.puts(
+          "Error: there was a problem executing system command: #{command}"
+        )
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/testable.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# good idea ???
+# if you're testing pry plugin you should require pry by yourself, no?
+require 'pry' unless defined?(Pry)
+
+class Pry
+  module Testable
+    require_relative "testable/pry_tester"
+    require_relative "testable/evalable"
+    require_relative "testable/mockable"
+    require_relative "testable/variables"
+    require_relative "testable/utility"
+
+    #
+    # When {Pry::Testable} is included into another module or class,
+    # the following modules are also included: {Pry::Testable::Mockable},
+    # {Pry::Testable::Evalable}, {Pry::Testable::Variables}, and
+    # {Pry::Testable::Utility}.
+    #
+    # @note
+    #   Each of the included modules mentioned above may also be used
+    #   standalone or in a pick-and-mix fashion.
+    #
+    # @param [Module] mod
+    #   A class or module.
+    #
+    # @return [void]
+    #
+    def self.included(mod)
+      mod.module_eval do
+        include Pry::Testable::Mockable
+        include Pry::Testable::Evalable
+        include Pry::Testable::Variables
+        include Pry::Testable::Utility
+      end
+    end
+
+    #
+    # Sets various configuration options that make Pry optimal for a test
+    # environment, see source code for complete details.
+    #
+    # @return [void]
+    #
+    def self.set_testenv_variables
+      Pry.config = Pry::Config.new.merge(
+        color: false,
+        pager: false,
+        should_load_rc: false,
+        should_load_local_rc: false,
+        correct_indent: false,
+        collision_warning: false,
+        history_save: false,
+        history_load: false,
+        hooks: Pry::Hooks.new
+      )
+    end
+
+    #
+    # Reset the Pry configuration to their default values.
+    #
+    # @return [void]
+    #
+    def self.unset_testenv_variables
+      Pry.config = Pry::Config.new
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/testable/evalable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Pry
+  module Testable
+    module Evalable
+      def pry_tester(*args, &block)
+        args.unshift(Pry.toplevel_binding) if args.empty? || args[0].is_a?(Hash)
+        Pry::Testable::PryTester.new(*args).tap do |t|
+          t.singleton_class.class_eval(&block) if block
+        end
+      end
+
+      def pry_eval(*eval_strs)
+        b =
+          if eval_strs.first.is_a?(String)
+            Pry.toplevel_binding
+          else
+            Pry.binding_for(eval_strs.shift)
+          end
+        pry_tester(b).eval(*eval_strs)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/testable/mockable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+class Pry
+  module Testable
+    module Mockable
+      def mock_command(cmd, args = [], opts = {})
+        output = StringIO.new
+        pry = Pry.new(output: output)
+        ret = cmd.new(opts.merge(pry_instance: pry, output: output)).call_safely(*args)
+        Struct.new(:output, :return).new(output.string, ret)
+      end
+
+      def mock_exception(*mock_backtrace)
+        StandardError.new.tap do |e|
+          e.define_singleton_method(:backtrace) { mock_backtrace }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/testable/pry_tester.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+class Pry
+  module Testable
+    class PryTester
+      extend Pry::Forwardable
+      attr_reader :pry, :out
+      def_delegators :@pry, :eval_string, :eval_string=
+
+      def initialize(target = TOPLEVEL_BINDING, options = {})
+        @pry = Pry.new(options.merge(target: target))
+        @history = options[:history]
+        @pry.inject_sticky_locals!
+        reset_output
+      end
+
+      def eval(*strs)
+        reset_output
+        result = nil
+
+        strs.flatten.each do |str|
+          # Check for space prefix. See #1369.
+          str = "#{str.strip}\n" if str !~ /^\s\S/
+          @history.push str if @history
+
+          result =
+            if @pry.process_command(str)
+              last_command_result_or_output
+            else
+              # Check if this is a multiline paste.
+              begin
+                complete_expr = Pry::Code.complete_expression?(str)
+              rescue SyntaxError => exception
+                @pry.output.puts(
+                  "SyntaxError: #{exception.message.sub(/.*syntax error, */m, '')}"
+                )
+              end
+              @pry.evaluate_ruby(str) if complete_expr
+            end
+        end
+
+        result
+      end
+
+      def push(*lines)
+        Array(lines).flatten.each do |line|
+          @pry.eval(line)
+        end
+      end
+
+      def push_binding(context)
+        @pry.push_binding context
+      end
+
+      def last_output
+        @out.string if @out
+      end
+
+      def process_command(command_str)
+        @pry.process_command(command_str) || raise("Not a valid command")
+        last_command_result_or_output
+      end
+
+      def last_command_result
+        result = Pry.current[:pry_cmd_result]
+        result.retval if result
+      end
+
+      protected
+
+      def last_command_result_or_output
+        result = last_command_result
+        if result != Pry::Command::VOID_VALUE
+          result
+        else
+          last_output
+        end
+      end
+
+      def reset_output
+        @out = StringIO.new
+        @pry.output = @out
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/testable/utility.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+class Pry
+  module Testable
+    module Utility
+      #
+      # Creates a Tempfile then unlinks it after the block has yielded.
+      #
+      # @yieldparam [String] file
+      #   The path of the temp file
+      #
+      # @return [void]
+      #
+      def temp_file(ext = '.rb')
+        file = Tempfile.open(['pry', ext])
+        yield file
+      ensure
+        file.close(true) if file
+      end
+
+      def unindent(*args)
+        Pry::Helpers::CommandHelpers.unindent(*args)
+      end
+
+      def inner_scope
+        catch(:inner_scope) do
+          yield -> { throw(:inner_scope, self) }
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/testable/variables.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class Pry
+  module Testable
+    module Variables
+      #
+      # @example
+      #   temporary_constants(:Foo, :Bar) do
+      #     Foo = Class.new(RuntimeError)
+      #     Bar = Class.new(RuntimeError)
+      #   end
+      #   Foo # => NameError
+      #   Bar # => NameError
+      #
+      # @param [Array<Symbol>] names
+      #   An array of constant names that be defined by a block,
+      #   and removed by this method afterwards.
+      #
+      # @return [void]
+      #
+      def temporary_constants(*names)
+        names.each do |name|
+          Object.remove_const name if Object.const_defined?(name)
+        end
+        yield
+      ensure
+        names.each do |name|
+          Object.remove_const name if Object.const_defined?(name)
+        end
+      end
+
+      #
+      # @param [String] name
+      #   The name of a variable.
+      #
+      # @param [String] value
+      #   Its value.
+      #
+      # @param [Binding] binding
+      #   The binding object to insert a variable into.
+      #
+      # @return [void]
+      #
+      def insert_variable(name, value, binding)
+        Pry.current[:pry_local] = value
+        binding.eval("#{name} = ::Pry.current[:pry_local]")
+      ensure
+        Pry.current[:pry_local] = nil
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Pry
+  VERSION = '0.13.1'.freeze
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/warning.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Pry
+  # @api private
+  # @since v0.13.0
+  module Warning
+    # Prints a warning message with exact file and line location, similar to how
+    # Ruby's -W prints warnings.
+    #
+    # @param [String] message
+    # @return [void]
+    def self.warn(message)
+      if Kernel.respond_to?(:caller_locations)
+        location = caller_locations(2..2).first
+        path = location.path
+        lineno = location.lineno
+      else
+        # Ruby 1.9.3 support.
+        frame = caller[1].split(':') # rubocop:disable Performance/Caller
+        path = frame.first
+        lineno = frame[1]
+      end
+
+      Kernel.warn("#{path}:#{lineno}: warning: #{message}")
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/pry-0.13.1/lib/pry/wrapped_module.rb

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+class Pry
+  class << self
+    # If the given object is a `Pry::WrappedModule`, return it unaltered. If it's
+    # anything else, return it wrapped in a `Pry::WrappedModule` instance.
+    def WrappedModule(obj)
+      if obj.is_a? Pry::WrappedModule
+        obj
+      else
+        Pry::WrappedModule.new(obj)
+      end
+    end
+  end
+
+  class WrappedModule
+    include Helpers::BaseHelpers
+    include CodeObject::Helpers
+
+    attr_reader :wrapped
+
+    # Convert a string to a module.
+    #
+    # @param [String] mod_name
+    # @param [Binding] target The binding where the lookup takes place.
+    # @return [Module, nil] The module or `nil` (if conversion failed).
+    # @example
+    #   Pry::WrappedModule.from_str("Pry::Code")
+    def self.from_str(mod_name, target = TOPLEVEL_BINDING)
+      Pry::WrappedModule.new(target.eval(mod_name)) if safe_to_evaluate?(mod_name, target)
+    rescue RescuableException
+      nil
+    end
+
+    class << self
+      private
+
+      # We use this method to decide whether code is safe to eval. Method's are
+      # generally not, but everything else is.
+      # TODO: is just checking != "method" enough??
+      # TODO: see duplication of this method in Pry::CodeObject
+      # @param [String] str The string to lookup.
+      # @param [Binding] target Where the lookup takes place.
+      # @return [Boolean]
+      def safe_to_evaluate?(str, target)
+        return true if str.strip == "self"
+        return false if str =~ /%/
+
+        kind = target.eval("defined?(#{str})")
+        kind =~ /variable|constant/
+      end
+    end
+
+    # @raise [ArgumentError] if the argument is not a `Module`
+    # @param [Module] mod
+    def initialize(mod)
+      unless mod.is_a?(Module)
+        raise ArgumentError, "Tried to initialize a WrappedModule with a " \
+                             "non-module #{mod.inspect}"
+      end
+
+      @wrapped = mod
+      @memoized_candidates = []
+      @host_file_lines = nil
+      @source = nil
+      @source_location = nil
+      @doc = nil
+      @all_source_locations_by_popularity = nil
+    end
+
+    # Returns an array of the names of the constants accessible in the wrapped
+    # module. This avoids the problem of accidentally calling the singleton
+    # method `Module.constants`.
+    # @param [Boolean] inherit Include the names of constants from included
+    #   modules?
+    def constants(inherit = true)
+      Module.instance_method(:constants).bind(@wrapped).call(inherit)
+    end
+
+    # The prefix that would appear before methods defined on this class.
+    #
+    # i.e. the "String." or "String#" in String.new and String#initialize.
+    #
+    # @return String
+    def method_prefix
+      if singleton_class?
+        if Module === singleton_instance # rubocop:disable Style/CaseEquality
+          "#{WrappedModule.new(singleton_instance).nonblank_name}."
+        else
+          "self."
+        end
+      else
+        "#{nonblank_name}#"
+      end
+    end
+
+    # The name of the Module if it has one, otherwise #<Class:0xf00>.
+    #
+    # @return [String]
+    def nonblank_name
+      if name.to_s == ""
+        wrapped.inspect
+      else
+        name
+      end
+    end
+
+    # Is this a singleton class?
+    # @return [Boolean]
+    def singleton_class?
+      if Pry::Method.safe_send(wrapped, :respond_to?, :singleton_class?)
+        Pry::Method.safe_send(wrapped, :singleton_class?)
+      else
+        wrapped != Pry::Method.safe_send(wrapped, :ancestors).first
+      end
+    end
+
+    # Is this strictly a module? (does not match classes)
+    # @return [Boolean]
+    def module?
+      wrapped.instance_of?(Module)
+    end
+
+    # Is this strictly a class?
+    # @return [Boolean]
+    def class?
+      wrapped.instance_of?(Class)
+    end
+
+    # Get the instance associated with this singleton class.
+    #
+    # @raise ArgumentError: tried to get instance of non singleton class
+    #
+    # @return [Object]
+    def singleton_instance
+      unless singleton_class?
+        raise ArgumentError, "tried to get instance of non singleton class"
+      end
+
+      if Helpers::Platform.jruby?
+        wrapped.to_java.attached
+      else
+        @singleton_instance ||= ObjectSpace.each_object(wrapped).detect do |x|
+          (class << x; self; end) == wrapped
+        end
+      end
+    end
+
+    # Forward method invocations to the wrapped module
+    def method_missing(method_name, *args, &block)
+      if wrapped.respond_to?(method_name)
+        wrapped.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      wrapped.respond_to?(method_name, include_private) || super
+    end
+
+    # Retrieve the source location of a module. Return value is in same
+    # format as Method#source_location. If the source location
+    # cannot be found this method returns `nil`.
+    #
+    # @return [Array<String, Fixnum>, nil] The source location of the
+    #   module (or class), or `nil` if no source location found.
+    def source_location
+      @source_location ||= primary_candidate.source_location
+    rescue Pry::RescuableException
+      nil
+    end
+
+    # @return [String, nil] The associated file for the module (i.e
+    #   the primary candidate: highest ranked monkeypatch).
+    def file
+      Array(source_location).first
+    end
+    alias source_file file
+
+    # @return [Fixnum, nil] The associated line for the module (i.e
+    #   the primary candidate: highest ranked monkeypatch).
+    def line
+      Array(source_location).last
+    end
+    alias source_line line
+
+    # Returns documentation for the module.
+    # This documentation is for the primary candidate, if
+    # you would like documentation for other candidates use
+    # `WrappedModule#candidate` to select the candidate you're
+    # interested in.
+    # @raise [Pry::CommandError] If documentation cannot be found.
+    # @return [String] The documentation for the module.
+    def doc
+      @doc ||= primary_candidate.doc
+    end
+
+    # Returns the source for the module.
+    # This source is for the primary candidate, if
+    # you would like source for other candidates use
+    # `WrappedModule#candidate` to select the candidate you're
+    # interested in.
+    # @raise [Pry::CommandError] If source cannot be found.
+    # @return [String] The source for the module.
+    def source
+      @source ||= primary_candidate.source
+    end
+
+    # @return [String] Return the associated file for the
+    #   module from YARD, if one exists.
+    def yard_file
+      YARD::Registry.at(name).file if yard_docs?
+    end
+
+    # @return [Fixnum] Return the associated line for the
+    #   module from YARD, if one exists.
+    def yard_line
+      YARD::Registry.at(name).line if yard_docs?
+    end
+
+    # @return [String] Return the YARD docs for this module.
+    def yard_doc
+      YARD::Registry.at(name).docstring.to_s if yard_docs?
+    end
+
+    # Return a candidate for this module of specified rank. A `rank`
+    # of 0 is equivalent to the 'primary candidate', which is the
+    # module definition with the highest number of methods. A `rank`
+    # of 1 is the module definition with the second highest number of
+    # methods, and so on. Module candidates are necessary as modules
+    # can be reopened multiple times and in multiple places in Ruby,
+    # the candidate API gives you access to the module definition
+    # representing each of those reopenings.
+    # @raise [Pry::CommandError] If the `rank` is out of range. That
+    #   is greater than `number_of_candidates - 1`.
+    # @param [Fixnum] rank
+    # @return [Pry::WrappedModule::Candidate]
+    def candidate(rank)
+      @memoized_candidates[rank] ||= WrappedModule::Candidate.new(self, rank)
+    end
+
+    # @return [Fixnum] The number of candidate definitions for the
+    #   current module.
+    def number_of_candidates
+      method_candidates.count
+    end
+
+    # @note On JRuby 1.9 and higher, in certain conditions, this method chucks
+    #   away its ability to be quick (when there are lots of monkey patches,
+    #   like in Rails). However, it should be efficient enough on other rubies.
+    # @see https://github.com/jruby/jruby/issues/525
+    # @return [Enumerator, Array] on JRuby 1.9 and higher returns Array, on
+    #  other rubies returns Enumerator
+    def candidates
+      enum = Enumerator.new do |y|
+        (0...number_of_candidates).each do |num|
+          y.yield candidate(num)
+        end
+      end
+      Helpers::Platform.jruby_19? ? enum.to_a : enum
+    end
+
+    # @return [Boolean] Whether YARD docs are available for this module.
+    def yard_docs?
+      !!(defined?(YARD) && YARD::Registry.at(name))
+    end
+
+    # @param [Fixnum] times How far to travel up the ancestor chain.
+    # @return [Pry::WrappedModule, nil] The wrapped module that is the
+    #   superclass.
+    #   When `self` is a `Module` then return the
+    #   nth ancestor, otherwise (in the case of classes) return the
+    #   nth ancestor that is a class.
+    def super(times = 1)
+      return self if times.zero?
+
+      sup =
+        if wrapped.is_a?(Class)
+          ancestors.select { |v| v.is_a?(Class) }[times]
+        else
+          ancestors[times]
+        end
+
+      Pry::WrappedModule(sup) if sup
+    end
+
+    private
+
+    # @return [Pry::WrappedModule::Candidate] The candidate with the
+    #   highest rank, that is the 'monkey patch' of this module with the
+    #   highest number of methods, which contains a source code line that
+    #   defines the module. It is considered the 'canonical' definition
+    #   for the module. In the absense of a suitable candidate, the
+    #   candidate of rank 0 will be returned, or a CommandError raised if
+    #   there are no candidates at all.
+    def primary_candidate
+      @primary_candidate ||= candidates.find(&:file) || candidate(0)
+    end
+
+    # @return [Array<Array<Pry::Method>>] The array of `Pry::Method` objects,
+    #   there are two associated with each candidate. The first is the 'base
+    #   method' for a candidate and it serves as the start point for
+    #   the search in  uncovering the module definition. The second is
+    #   the last method defined for that candidate and it is used to
+    #   speed up source code extraction.
+    def method_candidates
+      @method_candidates ||= all_source_locations_by_popularity.map do |group|
+        methods_sorted_by_source_line = group.last.sort_by(&:source_line)
+        [methods_sorted_by_source_line.first, methods_sorted_by_source_line.last]
+      end
+    end
+
+    # A helper method.
+    def all_source_locations_by_popularity
+      return @all_source_locations_by_popularity if @all_source_locations_by_popularity
+
+      ims = all_relevant_methods_for(wrapped).group_by do |v|
+        Array(v.source_location).first
+      end
+
+      @all_source_locations_by_popularity = ims.sort_by do |path, methods|
+        expanded = File.expand_path(path)
+        load_order = $LOADED_FEATURES.index { |file| expanded.end_with?(file) }
+
+        [-methods.size, load_order || (1.0 / 0.0)]
+      end
+    end
+
+    # We only want methods that have a non-nil `source_location`. We also
+    # skip some spooky internal methods.
+    #
+    # @return [Array<Pry::Method>]
+    def all_relevant_methods_for(mod)
+      methods = all_methods_for(mod).select(&:source_location)
+        .reject { |x| method_defined_by_forwardable_module?(x) }
+
+      return methods unless methods.empty?
+
+      safe_send(mod, :constants).flat_map do |const_name|
+        if (const = nested_module?(mod, const_name))
+          all_relevant_methods_for(const)
+        else
+          []
+        end
+      end
+    end
+
+    # Return all methods (instance methods and class methods) for a
+    # given module.
+    # @return [Array<Pry::Method>]
+    def all_methods_for(mod)
+      Pry::Method.all_from_obj(mod, false) + Pry::Method.all_from_class(mod, false)
+    end
+
+    def nested_module?(parent, name)
+      return if safe_send(parent, :autoload?, name)
+
+      child = safe_send(parent, :const_get, name)
+      return unless child.is_a?(Module)
+      return unless safe_send(child, :name) == "#{safe_send(parent, :name)}::#{name}"
+
+      child
+    end
+
+    # Detect methods that are defined with `def_delegator` from the Forwardable
+    # module. We want to reject these methods as they screw up module
+    # extraction since the `source_location` for such methods points at forwardable.rb
+    # TODO: make this more robust as valid user-defined files called
+    # forwardable.rb are also skipped.
+    def method_defined_by_forwardable_module?(method)
+      method.source_location.first =~ /forwardable\.rb/
+    end
+
+    # memoized lines for file
+    def lines_for_file(file)
+      @lines_for_file ||= {}
+
+      @lines_for_file[file] ||=
+        if file == Pry.eval_path
+          Pry.line_buffer.drop(1)
+        else
+          File.readlines(file)
+        end
+    end
+  end
+end