jets 0.5.0 → 0.5.1

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/core.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "byebug/helpers/reflection"
+require "byebug/byebug"
+require "byebug/context"
+require "byebug/breakpoint"
+require "byebug/interface"
+require "byebug/processors/script_processor"
+require "byebug/processors/post_mortem_processor"
+require "byebug/commands"
+require "byebug/remote"
+require "byebug/printers/plain"
+
+#
+# Main debugger's container module. Everything is defined under this module
+#
+module Byebug
+  include Helpers::ReflectionHelper
+
+  extend self
+
+  #
+  # Configuration file used for startup commands. Default value is .byebugrc
+  #
+  attr_accessor :init_file
+  self.init_file = ".byebugrc"
+
+  #
+  # Debugger's display expressions
+  #
+  attr_accessor :displays
+  self.displays = []
+
+  #
+  # Running mode of the debugger. Can be either:
+  #
+  # * :attached => Attached to a running program through the `byebug` method.
+  # * :standalone => Started through `byebug` script.
+  #
+  attr_accessor :mode
+
+  #
+  # Runs normal byebug initialization scripts.
+  #
+  # Reads and executes the commands from init file (if any) in the current
+  # working directory. This is only done if the current directory is different
+  # from your home directory. Thus, you can have more than one init file, one
+  # generic in your home directory, and another, specific to the program you
+  # are debugging, in the directory where you invoke byebug.
+  #
+  def run_init_script
+    rc_dirs.each do |dir|
+      rc_file = File.expand_path(File.join(dir, init_file))
+      next unless File.exist?(rc_file)
+
+      run_rc_file(rc_file)
+    end
+  end
+
+  def self.load_settings
+    Dir.glob(File.join(__dir__, "settings", "*.rb")).each do |file|
+      require file
+    end
+
+    constants.grep(/[a-z]Setting/).map do |name|
+      setting = const_get(name).new
+      Byebug::Setting.settings[setting.to_sym] = setting
+    end
+  end
+
+  #
+  # Saves information about the unhandled exception and gives a byebug
+  # prompt back to the user before program termination.
+  #
+  def self.handle_post_mortem
+    return unless raised_exception
+
+    context = raised_exception.__bb_context
+
+    PostMortemProcessor.new(context).at_line
+  end
+
+  at_exit { Byebug.handle_post_mortem if Byebug.post_mortem? }
+
+  private
+
+  #
+  # Runs a initialization script file
+  #
+  def run_rc_file(rc_file)
+    interface = ScriptInterface.new(rc_file)
+
+    ScriptProcessor.new(nil, interface).process_commands
+  end
+
+  #
+  # List of folders to load rc files from
+  #
+  # @note Files will be loaded in the order specified here.
+  #
+  def rc_dirs
+    [ENV["HOME"], Dir.pwd].compact.uniq
+  end
+end
+
+Byebug.load_settings
+
+#
+# Extends the extension class to be able to pass information about the
+# debugging environment from the c-extension to the user.
+#
+class Exception
+  attr_reader :__bb_context
+end

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Custom exception exception to signal "command not found" errors
+  #
+  class CommandNotFound < NoMethodError
+    def initialize(input, parent = nil)
+      @input = input
+      @parent = parent
+
+      super("Unknown command '#{name}'. Try '#{help}'")
+    end
+
+    private
+
+    def name
+      build_cmd(@parent, @input)
+    end
+
+    def help
+      build_cmd("help", @parent)
+    end
+
+    def build_cmd(*args)
+      args.compact.join(" ")
+    end
+  end
+end

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/frame.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "byebug/helpers/file"
+
+module Byebug
+  #
+  # Represents a frame in the stack trace
+  #
+  class Frame
+    include Helpers::FileHelper
+
+    attr_reader :pos
+
+    def initialize(context, pos)
+      @context = context
+      @pos = pos
+    end
+
+    def file
+      @context.frame_file(pos)
+    end
+
+    def line
+      @context.frame_line(pos)
+    end
+
+    def _self
+      @context.frame_self(pos)
+    end
+
+    def _binding
+      @context.frame_binding(pos)
+    end
+
+    def _class
+      @context.frame_class(pos)
+    end
+
+    def _method
+      @context.frame_method(pos)
+    end
+
+    def current?
+      @context.frame.pos == pos
+    end
+
+    #
+    # Gets local variables for the frame.
+    #
+    def locals
+      return [] unless _binding
+
+      _binding.local_variables.each_with_object({}) do |e, a|
+        a[e] = _binding.local_variable_get(e)
+        a
+      end
+    end
+
+    #
+    # Gets current method arguments for the frame.
+    #
+    def args
+      return c_args unless _binding
+
+      ruby_args
+    end
+
+    #
+    # Returns the current class in the frame or an empty string if the current
+    # +callstyle+ setting is 'short'
+    #
+    def deco_class
+      Setting[:callstyle] == "short" || _class.to_s.empty? ? "" : "#{_class}."
+    end
+
+    def deco_block
+      _method[/(?:block(?: \(\d+ levels\))?|rescue) in /] || ""
+    end
+
+    def deco_method
+      _method[/((?:block(?: \(\d+ levels\))?|rescue) in )?(.*)/]
+    end
+
+    #
+    # Builds a string containing all available args in the frame number, in a
+    # verbose or non verbose way according to the value of the +callstyle+
+    # setting
+    #
+    def deco_args
+      return "" if args.empty?
+
+      my_args = args.map do |arg|
+        prefix, default = prefix_and_default(arg[0])
+
+        kls = use_short_style?(arg) ? "" : "##{locals[arg[1]].class}"
+
+        "#{prefix}#{arg[1] || default}#{kls}"
+      end
+
+      "(#{my_args.join(', ')})"
+    end
+
+    #
+    # Builds a formatted string containing information about current method call
+    #
+    def deco_call
+      deco_block + deco_class + deco_method + deco_args
+    end
+
+    #
+    # Formatted filename in frame
+    #
+    def deco_file
+      Setting[:fullpath] ? File.expand_path(file) : shortpath(file)
+    end
+
+    #
+    # Properly formatted frame number of frame
+    #
+    def deco_pos
+      format("%-2d", pos)
+    end
+
+    #
+    # Formatted mark for the frame.
+    #
+    # --> marks the current frame
+    # ͱ-- marks c-frames
+    #     marks regular frames
+    #
+    def mark
+      return "-->" if current?
+      return "    ͱ--" if c_frame?
+
+      "   "
+    end
+
+    #
+    # Checks whether the frame is a c-frame
+    #
+    def c_frame?
+      _binding.nil?
+    end
+
+    def to_hash
+      {
+        mark: mark,
+        pos: deco_pos,
+        call: deco_call,
+        file: deco_file,
+        line: line,
+        full_path: File.expand_path(deco_file)
+      }
+    end
+
+    private
+
+    def c_args
+      return [] unless _self.to_s != "main"
+
+      _class.instance_method(_method).parameters
+    end
+
+    def ruby_args
+      meth_name = _binding.eval("__method__")
+      return [] unless meth_name
+
+      meth_obj = _class.instance_method(meth_name)
+      return [] unless meth_obj
+
+      meth_obj.parameters
+    end
+
+    def use_short_style?(arg)
+      Setting[:callstyle] == "short" || arg[1].nil? || locals.empty?
+    end
+
+    def prefix_and_default(arg_type)
+      return ["&", "block"] if arg_type == :block
+      return ["*", "args"] if arg_type == :rest
+
+      ["", nil]
+    end
+  end
+end

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/helpers/bin.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities for interaction with executables
+    #
+    module BinHelper
+      #
+      # Cross-platform way of finding an executable in the $PATH.
+      # Adapted from: https://gist.github.com/steakknife/88b6c3837a5e90a08296
+      #
+      def which(cmd)
+        return File.expand_path(cmd) if File.exist?(cmd)
+
+        [nil, *search_paths].each do |path|
+          exe = find_executable(path, cmd)
+          return exe if exe
+        end
+
+        nil
+      end
+
+      def find_executable(path, cmd)
+        executable_file_extensions.each do |ext|
+          exe = File.expand_path(cmd + ext, path)
+
+          return exe if real_executable?(exe)
+        end
+
+        nil
+      end
+
+      def search_paths
+        ENV["PATH"].split(File::PATH_SEPARATOR)
+      end
+
+      def executable_file_extensions
+        ENV["PATHEXT"] ? ENV["PATHEXT"].split(";") : [""]
+      end
+
+      def real_executable?(f)
+        File.executable?(f) && !File.directory?(f)
+      end
+    end
+  end
+end

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/helpers/eval.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Byebug
+  module Helpers
+    #
+    # Utilities to assist evaluation of code strings
+    #
+    module EvalHelper
+      #
+      # Evaluates an +expression+ in a separate thread.
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def separate_thread_eval(expression)
+        allowing_other_threads do
+          in_new_thread { warning_eval(expression) }
+        end
+      end
+
+      #
+      # Evaluates an +expression+ that might use or defer execution to threads
+      # other than the current one.
+      #
+      # @note This is necessary because when in byebug's prompt, every thread is
+      # "frozen" so that nothing gets run. So we need to unlock threads prior
+      # to evaluation or we will run into a deadlock.
+      #
+      # @param expression [String] Expression to evaluate
+      #
+      def multiple_thread_eval(expression)
+        allowing_other_threads { warning_eval(expression) }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # returning nil in an error happens.
+      #
+      def silent_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |_e| nil }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at an error level.
+      #
+      def error_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| raise(e, msg(e)) }
+      end
+
+      #
+      # Evaluates a string containing Ruby code in a specific binding,
+      # handling the errors at a warning level.
+      #
+      def warning_eval(str, binding = frame._binding)
+        safe_eval(str, binding) { |e| errmsg(msg(e)) }
+      end
+
+      private
+
+      def safe_eval(str, binding)
+        binding.eval(str.gsub(/\Aeval /, ""), "(byebug)", 1)
+      rescue StandardError, ScriptError => e
+        yield(e)
+      end
+
+      def msg(e)
+        msg = Setting[:stack_on_error] ? error_msg(e) : warning_msg(e)
+
+        pr("eval.exception", text_message: msg)
+      end
+
+      def error_msg(e)
+        at = e.backtrace
+
+        locations = ["#{at.shift}: #{warning_msg(e)}"]
+        locations += at.map { |path| "  from #{path}" }
+        locations.join("\n")
+      end
+
+      def warning_msg(e)
+        "#{e.class} Exception: #{e.message}"
+      end
+
+      #
+      # Run block temporarily ignoring all TracePoint events.
+      #
+      # Used to evaluate stuff within Byebug's prompt. Otherwise, any code
+      # creating new threads won't be properly evaluated because new threads
+      # will get blocked by byebug's main thread.
+      #
+      def allowing_other_threads
+        Byebug.unlock
+
+        res = yield
+
+        Byebug.lock
+
+        res
+      end
+
+      #
+      # Runs the given block in a new thread, waits for it to finish and
+      # returns the new thread's result.
+      #
+      def in_new_thread
+        res = nil
+
+        Thread.new { res = yield }.join
+
+        res
+      end
+
+      def safe_inspect(var)
+        var.inspect
+      rescue StandardError
+        safe_to_s(var)
+      end
+
+      def safe_to_s(var)
+        var.to_s
+      rescue StandardError
+        "*Error in evaluation*"
+      end
+    end
+  end
+end