mx-platform-ruby 0.3.1 → 0.4.2

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

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-require 'method_source'
-
-class Pry
-  class CodeFile
-    DEFAULT_EXT = '.rb'.freeze
-
-    # List of all supported languages.
-    # @return [Hash]
-    EXTENSIONS = {
-      %w[.py] => :python,
-      %w[.js] => :javascript,
-      %w[.css] => :css,
-      %w[.xml] => :xml,
-      %w[.php] => :php,
-      %w[.html] => :html,
-      %w[.diff] => :diff,
-      %w[.java] => :java,
-      %w[.json] => :json,
-      %w[.c .h] => :c,
-      %w[.rhtml] => :rhtml,
-      %w[.yaml .yml] => :yaml,
-      %w[.cpp .hpp .cc .h .cxx] => :cpp,
-      %w[.rb .ru .irbrc .gemspec .pryrc .rake] => :ruby
-    }.freeze
-
-    FILES = {
-      %w[Gemfile Rakefile Guardfile Capfile] => :ruby
-    }.freeze
-
-    # Store the current working directory. This allows show-source etc. to work if
-    # your process has changed directory since boot. [Issue #675]
-    INITIAL_PWD = Dir.pwd
-
-    # @return [Symbol] The type of code stored in this wrapper.
-    attr_reader :code_type
-
-    # @param [String] filename The name of a file with code to be detected
-    # @param [Symbol] code_type The type of code the `filename` contains
-    def initialize(filename, code_type = type_from_filename(filename))
-      @filename = filename
-      @code_type = code_type
-    end
-
-    # @return [String] The code contained in the current `@filename`.
-    def code
-      if @filename == Pry.eval_path
-        Pry.line_buffer.drop(1)
-      elsif Pry::Method::Patcher.code_for(@filename)
-        Pry::Method::Patcher.code_for(@filename)
-      else
-        path = abs_path
-        @code_type = type_from_filename(path)
-        File.read(path)
-      end
-    end
-
-    private
-
-    # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
-    #   readable for some reason.
-    # @return [String] absolute path for the given `filename`.
-    def abs_path
-      code_path.detect { |path| readable?(path) } ||
-        raise(MethodSource::SourceNotFoundError,
-              "Cannot open #{@filename.inspect} for reading.")
-    end
-
-    # @param [String] path
-    # @return [Boolean] if the path, with or without the default ext,
-    #   is a readable file then `true`, otherwise `false`.
-    def readable?(path)
-      File.readable?(path) && !File.directory?(path) ||
-        File.readable?(path << DEFAULT_EXT)
-    end
-
-    # @return [Array] All the paths that contain code that Pry can use for its
-    #   API's. Skips directories.
-    def code_path
-      [from_pwd, from_pry_init_pwd, *from_load_path]
-    end
-
-    # @param [String] filename
-    # @param [Symbol] default (:unknown) the file type to assume if none could be
-    #   detected.
-    # @return [Symbol, nil] The SyntaxHighlighter type of a file from its
-    #   extension, or `nil` if `:unknown`.
-    def type_from_filename(filename, default = :unknown)
-      _, @code_type = EXTENSIONS.find do |k, _|
-        k.any? { |ext| ext == File.extname(filename) }
-      end || FILES.find do |k, _|
-        k.any? { |file_name| file_name == File.basename(filename) }
-      end
-
-      code_type || default
-    end
-
-    # @return [String]
-    def from_pwd
-      File.expand_path(@filename, Dir.pwd)
-    end
-
-    # @return [String]
-    def from_pry_init_pwd
-      File.expand_path(@filename, INITIAL_PWD)
-    end
-
-    # @return [String]
-    def from_load_path
-      $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Code
-    # Represents a range of lines in a code listing.
-    #
-    # @api private
-    class CodeRange
-      # @param [Integer] start_line
-      # @param [Integer?] end_line
-      def initialize(start_line, end_line = nil)
-        @start_line = start_line
-        @end_line   = end_line
-        force_set_end_line
-      end
-
-      # @param [Array<LOC>] lines
-      # @return [Range]
-      def indices_range(lines)
-        Range.new(*indices(lines))
-      end
-
-      private
-
-      attr_reader :start_line
-
-      attr_reader :end_line
-
-      # If `end_line` is equal to `nil`, then calculate it from the first
-      # parameter, `start_line`. Otherwise, leave it as it is.
-      # @return [void]
-      def force_set_end_line
-        if start_line.is_a?(Range)
-          set_end_line_from_range
-        else
-          @end_line ||= start_line
-        end
-      end
-
-      # Finds indices of `start_line` and `end_line` in the given Array of
-      # +lines+.
-      #
-      # @param [Array<LOC>] lines
-      # @return [Array<Integer>]
-      def indices(lines)
-        [find_start_index(lines), find_end_index(lines)]
-      end
-
-      # @return [Integer]
-      def find_start_index(lines)
-        return start_line if start_line < 0
-
-        lines.index { |loc| loc.lineno >= start_line } || lines.length
-      end
-
-      # @return [Integer]
-      def find_end_index(lines)
-        return end_line if end_line < 0
-
-        (lines.index { |loc| loc.lineno > end_line } || 0) - 1
-      end
-
-      # For example, if the range is 4..10, then `start_line` would be equal to
-      # 4 and `end_line` to 10.
-      # @return [void]
-      def set_end_line_from_range
-        @end_line = start_line.last
-        @end_line -= 1 if start_line.exclude_end?
-        @start_line = start_line.first
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Code
-    # Represents a line of code (which may, in fact, contain multiple lines if
-    # the entirety was eval'd as a single unit following the `edit` command).
-    #
-    # A line of code is a tuple, which consists of a line and a line number. A
-    # `LOC` object's state (namely, the line parameter) can be changed via
-    # instance methods.  `Pry::Code` heavily uses this class.
-    #
-    # @api private
-    # @example
-    #   loc = LOC.new("def example\n  :example\nend", 1)
-    #   puts loc.line
-    #   def example
-    #     :example
-    #   end
-    #   #=> nil
-    #
-    #   loc.indent(3)
-    #   loc.line #=> "   def example\n  :example\nend"
-    class LOC
-      # @return [Array<String, Integer>]
-      attr_reader :tuple
-
-      # @param [String] line The line of code.
-      # @param [Integer] lineno The position of the +line+.
-      def initialize(line, lineno)
-        @tuple = [line.chomp, lineno.to_i]
-      end
-
-      # @return [Boolean]
-      def ==(other)
-        other.tuple == tuple
-      end
-
-      def dup
-        self.class.new(line, lineno)
-      end
-
-      # @return [String]
-      def line
-        tuple.first
-      end
-
-      # @return [Integer]
-      def lineno
-        tuple.last
-      end
-
-      # Paints the `line` of code.
-      #
-      # @param [Symbol] code_type
-      # @return [void]
-      def colorize(code_type)
-        tuple[0] = SyntaxHighlighter.highlight(line, code_type)
-      end
-
-      # Prepends the line number `lineno` to the `line`.
-      #
-      # @param [Integer] max_width
-      # @return [void]
-      def add_line_number(max_width = 0, color = false)
-        padded = lineno.to_s.rjust(max_width)
-        colorized_lineno =
-          if color
-            Pry::Helpers::BaseHelpers.colorize_code(padded)
-          else
-            padded
-          end
-        properly_padded_line = handle_multiline_entries_from_edit_command(line, max_width)
-        tuple[0] = "#{colorized_lineno}: #{properly_padded_line}"
-      end
-
-      # Prepends a marker "=>" or an empty marker to the +line+.
-      #
-      # @param [Integer] marker_lineno If it is equal to the `lineno`, then
-      #   prepend a hashrocket. Otherwise, an empty marker.
-      # @return [void]
-      def add_marker(marker_lineno)
-        tuple[0] =
-          if lineno == marker_lineno
-            " => #{line}"
-          else
-            "    #{line}"
-          end
-      end
-
-      # Indents the `line` with +distance+ spaces.
-      #
-      # @param [Integer] distance
-      # @return [void]
-      def indent(distance)
-        tuple[0] = "#{' ' * distance}#{line}"
-      end
-
-      def handle_multiline_entries_from_edit_command(line, max_width)
-        line.split("\n").map.with_index do |inner_line, i|
-          i.zero? ? inner_line : "#{' ' * (max_width + 2)}#{inner_line}"
-        end.join("\n")
-      end
-    end
-  end
-end

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

@@ -1,365 +0,0 @@
-# frozen_string_literal: true
-
-require 'method_source'
-
-class Pry
-  class << self
-    # Convert the given object into an instance of `Pry::Code`, if it isn't
-    # already one.
-    #
-    # @param [Code, Method, UnboundMethod, Proc, Pry::Method, String, Array,
-    #   IO] obj
-    def Code(obj)
-      case obj
-      when Code
-        obj
-      when ::Method, UnboundMethod, Proc, Pry::Method
-        Code.from_method(obj)
-      else
-        Code.new(obj)
-      end
-    end
-  end
-
-  # `Pry::Code` is a class that encapsulates lines of source code and their
-  # line numbers and formats them for terminal output. It can read from a file
-  # or method definition or be instantiated with a `String` or an `Array`.
-  #
-  # In general, the formatting methods in `Code` return a new `Code` object
-  # which will format the text as specified when `#to_s` is called. This allows
-  # arbitrary chaining of formatting methods without mutating the original
-  # object.
-  class Code
-    class << self
-      include MethodSource::CodeHelpers
-
-      # Instantiate a `Code` object containing code loaded from a file or
-      # Pry's line buffer.
-      #
-      # @param [String] filename The name of a file, or "(pry)".
-      # @param [Symbol] code_type The type of code the file contains.
-      # @return [Code]
-      def from_file(filename, code_type = nil)
-        code_file = CodeFile.new(filename, code_type)
-        new(code_file.code, 1, code_file.code_type)
-      end
-
-      # Instantiate a `Code` object containing code extracted from a
-      # `::Method`, `UnboundMethod`, `Proc`, or `Pry::Method` object.
-      #
-      # @param [::Method, UnboundMethod, Proc, Pry::Method] meth The method
-      #   object.
-      # @param [Integer, nil] start_line The line number to start on, or nil to
-      #   use the method's original line numbers.
-      # @return [Code]
-      def from_method(meth, start_line = nil)
-        meth = Pry::Method(meth)
-        start_line ||= meth.source_line || 1
-        new(meth.source, start_line, meth.source_type)
-      end
-
-      # Attempt to extract the source code for module (or class) `mod`.
-      #
-      # @param [Module, Class] mod The module (or class) of interest.
-      # @param [Integer] candidate_rank The module candidate (by rank)
-      #   to use (see `Pry::WrappedModule::Candidate` for more information).
-      # @param [Integer, nil] start_line The line number to start on, or nil to
-      #   use the method's original line numbers.
-      # @return [Code]
-      def from_module(mod, candidate_rank = 0, start_line = nil)
-        candidate = Pry::WrappedModule(mod).candidate(candidate_rank)
-        start_line ||= candidate.line
-        new(candidate.source, start_line, :ruby)
-      end
-    end
-
-    # @return [Symbol] The type of code stored in this wrapper.
-    attr_accessor :code_type
-
-    # Instantiate a `Code` object containing code from the given `Array`,
-    # `String`, or `IO`. The first line will be line 1 unless specified
-    # otherwise. If you need non-contiguous line numbers, you can create an
-    # empty `Code` object and then use `#push` to insert the lines.
-    #
-    # @param [Array<String>, String, IO] lines
-    # @param [Integer?] start_line
-    # @param [Symbol?] code_type
-    def initialize(lines = [], start_line = 1, code_type = :ruby)
-      lines = lines.lines if lines.is_a? String
-      @lines = lines.each_with_index.map do |line, lineno|
-        LOC.new(line, lineno + start_line.to_i)
-      end
-      @code_type = code_type
-
-      @with_marker = @with_indentation = @with_line_numbers = nil
-    end
-
-    # Append the given line. +lineno+ is one more than the last existing
-    # line, unless specified otherwise.
-    #
-    # @param [String] line
-    # @return [void]
-    def push(line)
-      line_number = @lines.any? ? @lines.last.lineno + 1 : 1
-      @lines.push(LOC.new(line, line_number))
-    end
-    alias << push
-
-    # Filter the lines using the given block.
-    #
-    # @yield [LOC]
-    # @return [Code]
-    def select(&block)
-      alter do
-        @lines = @lines.select(&block)
-      end
-    end
-
-    # Filter the lines using the given block.
-    #
-    # @yield [LOC]
-    # @return [Code]
-    def reject(&block)
-      alter do
-        @lines = @lines.reject(&block)
-      end
-    end
-
-    # Remove all lines that aren't in the given range, expressed either as a
-    # `Range` object or a first and last line number (inclusive). Negative
-    # indices count from the end of the array of lines.
-    #
-    # @param [Range, Integer] start_line
-    # @param [Integer?] end_line
-    # @return [Code]
-    def between(start_line, end_line = nil)
-      return self unless start_line
-
-      code_range = CodeRange.new(start_line, end_line)
-
-      alter do
-        @lines = @lines[code_range.indices_range(@lines)] || []
-      end
-    end
-
-    # Take `num_lines` from `start_line`, forward or backwards.
-    #
-    # @param [Integer] start_line
-    # @param [Integer] num_lines
-    # @return [Code]
-    def take_lines(start_line, num_lines)
-      start_idx =
-        if start_line >= 0
-          @lines.index { |loc| loc.lineno >= start_line } || @lines.length
-        else
-          [@lines.length + start_line, 0].max
-        end
-
-      alter do
-        @lines = @lines.slice(start_idx, num_lines)
-      end
-    end
-
-    # Remove all lines except for the +lines+ up to and excluding +lineno+.
-    #
-    # @param [Integer] lineno
-    # @param [Integer] lines
-    # @return [Code]
-    def before(lineno, lines = 1)
-      return self unless lineno
-
-      select do |loc|
-        loc.lineno >= lineno - lines && loc.lineno < lineno
-      end
-    end
-
-    # Remove all lines except for the +lines+ on either side of and including
-    # +lineno+.
-    #
-    # @param [Integer] lineno
-    # @param [Integer] lines
-    # @return [Code]
-    def around(lineno, lines = 1)
-      return self unless lineno
-
-      select do |loc|
-        loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
-      end
-    end
-
-    # Remove all lines except for the +lines+ after and excluding +lineno+.
-    #
-    # @param [Integer] lineno
-    # @param [Integer] lines
-    # @return [Code]
-    def after(lineno, lines = 1)
-      return self unless lineno
-
-      select do |loc|
-        loc.lineno > lineno && loc.lineno <= lineno + lines
-      end
-    end
-
-    # Remove all lines that don't match the given `pattern`.
-    #
-    # @param [Regexp] pattern
-    # @return [Code]
-    def grep(pattern)
-      return self unless pattern
-
-      pattern = Regexp.new(pattern)
-
-      select do |loc|
-        loc.line =~ pattern
-      end
-    end
-
-    # Format output with line numbers next to it, unless `y_n` is falsy.
-    #
-    # @param [Boolean?] y_n
-    # @return [Code]
-    def with_line_numbers(y_n = true)
-      alter do
-        @with_line_numbers = y_n
-      end
-    end
-
-    # Format output with a marker next to the given +lineno+, unless +lineno+ is
-    # falsy.
-    #
-    # @param [Integer?] lineno
-    # @return [Code]
-    def with_marker(lineno = 1)
-      alter do
-        @with_marker   = !!lineno
-        @marker_lineno = lineno
-      end
-    end
-
-    # Format output with the specified number of spaces in front of every line,
-    # unless `spaces` is falsy.
-    #
-    # @param [Integer?] spaces
-    # @return [Code]
-    def with_indentation(spaces = 0)
-      alter do
-        @with_indentation = !!spaces
-        @indentation_num  = spaces
-      end
-    end
-
-    # @return [Integer] the number of digits in the last line.
-    def max_lineno_width
-      !@lines.empty? ? @lines.last.lineno.to_s.length : 0
-    end
-
-    # @return [String] a formatted representation (based on the configuration of
-    #   the object).
-    def to_s
-      print_to_output(''.dup, false)
-    end
-
-    # @return [String] a (possibly highlighted) copy of the source code.
-    def highlighted
-      print_to_output(''.dup, true)
-    end
-
-    # Writes a formatted representation (based on the configuration of the
-    # object) to the given output, which must respond to `#<<`.
-    def print_to_output(output, color = false)
-      @lines.each do |loc|
-        loc = loc.dup
-        loc.colorize(@code_type)              if color
-        loc.add_line_number(max_lineno_width, color) if @with_line_numbers
-        loc.add_marker(@marker_lineno)        if @with_marker
-        loc.indent(@indentation_num)          if @with_indentation
-        output << loc.line
-        output << "\n"
-      end
-      output
-    end
-
-    # Get the comment that describes the expression on the given line number.
-    #
-    # @param [Integer] line_number (1-based)
-    # @return [String] the code.
-    def comment_describing(line_number)
-      self.class.comment_describing(raw, line_number)
-    end
-
-    # Get the multiline expression that starts on the given line number.
-    #
-    # @param [Integer] line_number (1-based)
-    # @return [String] the code.
-    def expression_at(line_number, consume = 0)
-      self.class.expression_at(raw, line_number, consume: consume)
-    end
-
-    # Get the (approximate) Module.nesting at the give line number.
-    #
-    # @param [Integer] line_number line number starting from 1
-    # @return [Array<Module>] a list of open modules.
-    def nesting_at(line_number)
-      Pry::Indent.nesting_at(raw, line_number)
-    end
-
-    # Return an unformatted String of the code.
-    #
-    # @return [String]
-    def raw
-      @lines.map(&:line).join("\n") << "\n"
-    end
-
-    # Return the number of lines stored.
-    #
-    # @return [Integer]
-    def length
-      @lines ? @lines.length : 0
-    end
-
-    # Two `Code` objects are equal if they contain the same lines with the same
-    # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.
-    #
-    # @param [Code, Object] other
-    # @return [Boolean]
-    def ==(other)
-      if other.is_a?(Code)
-        other_lines = other.instance_variable_get(:@lines)
-        @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
-      else
-        to_s.chomp == other.to_s.chomp
-      end
-    end
-
-    # Forward any missing methods to the output of `#to_s`.
-    def method_missing(method_name, *args, &block)
-      if (string = to_s).respond_to?(method_name)
-        string.__send__(method_name, *args, &block)
-      else
-        super
-      end
-    end
-    undef =~
-
-    # Check whether String responds to missing methods.
-    def respond_to_missing?(method_name, include_private = false)
-      ''.respond_to?(method_name, include_private) || super
-    end
-
-    if RUBY_VERSION.start_with?('1.9')
-      # @todo This is needed for Ruby 1.9 support where `lines` return an
-      #   Enumerator. Newer Rubies return an Array
-      def lines
-        super.to_a
-      end
-    end
-
-    protected
-
-    # An abstraction of the `dup.instance_eval` pattern used throughout this
-    # class.
-    def alter(&block)
-      dup.tap { |o| o.instance_eval(&block) }
-    end
-  end
-end