jets 0.5.0 → 0.5.1

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Custom interface for easier assertions
+  #
+  class TestInterface < Interface
+    attr_accessor :test_block
+
+    def initialize
+      super()
+
+      clear
+    end
+
+    def errmsg(message)
+      error.concat(prepare(message))
+    end
+
+    def print(message)
+      output.concat(prepare(message))
+    end
+
+    def puts(message)
+      output.concat(prepare(message))
+    end
+
+    def read_command(prompt)
+      cmd = super(prompt)
+
+      return cmd unless cmd.nil? && test_block
+
+      test_block.call
+      self.test_block = nil
+    end
+
+    def clear
+      @input = []
+      @output = []
+      @error = []
+      history.clear
+    end
+
+    def inspect
+      [
+        "Input:", input.join("\n"),
+        "Output:", output.join("\n"),
+        "Error:", error.join("\n")
+      ].join("\n")
+    end
+
+    def readline(prompt)
+      puts(prompt)
+
+      cmd = input.shift
+      cmd.is_a?(Proc) ? cmd.call : cmd
+    end
+
+    private
+
+    def prepare(message)
+      return message.map(&:to_s) if message.respond_to?(:map)
+
+      message.to_s.split("\n")
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Byebug
+  #
+  # Handles byebug's command line options
+  #
+  class OptionSetter
+    def initialize(runner, opts)
+      @runner = runner
+      @opts = opts
+    end
+
+    def setup
+      debug
+      include_flag
+      post_mortem
+      quit
+      rc
+      stop
+      require_flag
+      remote
+      trace
+      version
+      help
+    end
+
+    private
+
+    def debug
+      @opts.on "-d", "--debug", "Set $DEBUG=true" do
+        $DEBUG = true
+      end
+    end
+
+    def include_flag
+      @opts.on "-I", "--include list", "Add to paths to $LOAD_PATH" do |list|
+        $LOAD_PATH.push(list.split(":")).flatten!
+      end
+    end
+
+    def post_mortem
+      @opts.on "-m", "--[no-]post-mortem", "Use post-mortem mode" do |v|
+        Setting[:post_mortem] = v
+      end
+    end
+
+    def quit
+      @opts.on "-q", "--[no-]quit", "Quit when script finishes" do |v|
+        @runner.quit = v
+      end
+    end
+
+    def rc
+      @opts.on "-x", "--[no-]rc", "Run byebug initialization file" do |v|
+        @runner.init_script = v
+      end
+    end
+
+    def stop
+      @opts.on "-s", "--[no-]stop", "Stop when script is loaded" do |v|
+        @runner.stop = v
+      end
+    end
+
+    def require_flag
+      @opts.on "-r", "--require file", "Require library before script" do |lib|
+        require lib
+      end
+    end
+
+    def remote
+      @opts.on "-R", "--remote [host:]port", "Remote debug [host:]port" do |p|
+        @runner.remote = p
+      end
+    end
+
+    def trace
+      @opts.on "-t", "--[no-]trace", "Turn on line tracing" do |v|
+        Setting[:linetrace] = v
+      end
+    end
+
+    def version
+      @opts.on "-v", "--version", "Print program version" do
+        @runner.version = Byebug::VERSION
+      end
+    end
+
+    def help
+      @opts.on "-h", "--help", "Display this message" do
+        @runner.help = @opts.help
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Byebug
+  module Printers
+    #
+    # Base printer
+    #
+    class Base
+      class MissedPath < StandardError; end
+      class MissedArgument < StandardError; end
+
+      SEPARATOR = ".".freeze
+
+      def type
+        self.class.name.split("::").last.downcase
+      end
+
+      private
+
+      def locate(path)
+        result = nil
+        contents.each_value do |contents|
+          result = parts(path).reduce(contents) do |r, part|
+            r && r.key?(part) ? r[part] : nil
+          end
+          break if result
+        end
+        raise MissedPath, "Can't find part path '#{path}'" unless result
+        result
+      end
+
+      def translate(string, args = {})
+        # they may contain #{} string interpolation
+        string.gsub(/\|\w+$/, "").gsub(/([^#]?){([^}]*)}/) do
+          key = Regexp.last_match[2].to_s
+          unless args.key?(key.to_sym)
+            raise MissedArgument, "Missed argument #{key} for '#{string}'"
+          end
+
+          "#{Regexp.last_match[1]}#{args[key.to_sym]}"
+        end
+      end
+
+      def parts(path)
+        path.split(SEPARATOR)
+      end
+
+      def contents
+        @contents ||= contents_files.each_with_object({}) do |filename, hash|
+          hash[filename] = YAML.load_file(filename) || {}
+        end
+      end
+
+      def array_of_args(collection, &_block)
+        collection_with_index = collection.each.with_index
+        collection_with_index.each_with_object([]) do |(item, index), array|
+          args = yield item, index
+          array << args if args
+        end
+      end
+
+      def contents_files
+        [File.join(__dir__, "texts", "base.yml")]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "byebug/printers/base"
+
+module Byebug
+  module Printers
+    #
+    # Plain text printer
+    #
+    class Plain < Base
+      def print(path, args = {})
+        message = translate(locate(path), args)
+        tail = parts(path).include?("confirmations") ? " (y/n) " : "\n"
+        message << tail
+      end
+
+      def print_collection(path, collection, &block)
+        lines = array_of_args(collection, &block).map do |args|
+          print(path, args)
+        end
+
+        lines.join
+      end
+
+      def print_variables(variables, *_)
+        print_collection("variable.variable", variables) do |(key, value), _|
+          value = value.nil? ? "nil" : value.to_s
+          if "#{key} = #{value}".size > Setting[:width]
+            key_size = "#{key} = ".size
+            value = value[0..Setting[:width] - key_size - 4] + "..."
+          end
+
+          { key: key, value: value }
+        end
+      end
+
+      private
+
+      def contents_files
+        [File.join(__dir__, "texts", "plain.yml")] + super
+      end
+    end
+  end
+end

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/printers/texts/base.yml

@@ -0,0 +1,115 @@
+base:
+  errors:
+    only_local: "Command is available only in local mode."
+
+break:
+  errors:
+    line: "Line {line} is not a valid breakpoint in file {file}.\n\nValid break points are:\n{valid_breakpoints}"
+    location: "Invalid breakpoint location"
+    state: "We are not in a state that has an associated file"
+    class: "Unknown class {klass}"
+    far_line: "There are only {lines} lines in file {file}"
+    source: "No file named {file}"
+    expression: "Incorrect expression \"{expr}\"; breakpoint disabled"
+    no_breakpoint: "Invalid breakpoint id. Use \"info breakpoint\" to find out the correct id"
+    no_breakpoint_delete: "No breakpoint number {pos}"
+    not_changed: "Incorrect expression \"{expr}\", breakpoint not changed"
+  confirmations:
+    delete_all: "Delete all breakpoints?"
+  messages:
+    breakpoint_deleted: "Deleted breakpoint {pos}"
+
+catch:
+  added: "Catching exception {exception}."
+  removed: "Catch for exception {exception} removed"
+  errors:
+    off: "Off expected. Got {off}"
+    not_class: "Warning {class} is not known to be a Class"
+    not_found: "Catch for exception {exception} not found"
+  confirmations:
+    delete_all: "Delete all catchpoints? (y or n) "
+
+condition:
+  errors:
+    no_breakpoints: "No breakpoints have been set"
+
+continue:
+  errors:
+    unstopped_line: "Line {line} is not a valid stopping point in file"
+
+display:
+  confirmations:
+    clear_all: "Clear all expressions?"
+  errors:
+    undefined: "Display expression {expr} is not defined"
+
+edit:
+  errors:
+    state: "We are not in a state that has an associated file"
+    file_line: "Invalid file[:line] number specification: {file_line}"
+    not_readable: "File {file} is not readable."
+    not_exist: "File {file} does not exist."
+
+frame:
+  errors:
+    too_low: "Can't navigate beyond the oldest frame"
+    too_high: "Can't navigate beyond the newest frame"
+    c_frame: "Can't navigate to c-frame"
+
+info:
+  errors:
+    undefined_file: "{file} is not a valid source file"
+
+pry:
+  errors:
+    not_installed: "You need to install pry in order to run this command"
+
+quit:
+  confirmations:
+    really: "Really quit?"
+
+save:
+  messages:
+    done: "Saved to '{path}'"
+
+set:
+  errors:
+    unknown_setting: "Unknown setting :{key}"
+    must_specify_value: "You must specify a value for setting :{key}"
+    on_off: "Expecting 'on', 1, true, 'off', 0, false. Got: {arg}."
+
+show:
+  errors:
+    unknown_setting: "Unknown setting :{key}"
+
+source:
+  errors:
+    not_found: "File \"{file}\" not found"
+
+thread:
+  errors:
+    no_thread: "No such thread"
+    current_thread: "It's the current thread"
+    wrong_action: "Can't {subcmd} thread {arg}"
+    already_running: "Already running"
+
+toggle:
+  errors:
+    no_breakpoints: "No breakpoints have been set"
+    no_display: "No display expressions have been set"
+    syntax: "\"{toggle}\" must be followed by \"display\", \"breakpoints\" or breakpoint ids"
+    expression: "Expression \"{expr}\" syntactically incorrect; breakpoint remains disabled."
+  messages:
+    toggled: "Breakpoint {bpnum} {endis}abled"
+
+parse:
+  errors:
+    int:
+      too_low: "\"{cmd}\" argument \"{str}\" needs to be at least {min}"
+      too_high: "\"{cmd}\" argument \"{str}\" needs to be at most {max}"
+      not_number: "\"{cmd}\" argument \"{str}\" needs to be a number"
+
+variable:
+  errors:
+    not_module: "Should be Class/Module: {object}"
+    cant_get_class_vars: "can't get class variables here.\n"

data/vendor/lambdagem/bundled/gems/ruby/2.5.0/gems/byebug-10.0.0/lib/byebug/printers/texts/plain.yml

@@ -0,0 +1,33 @@
+break:
+  created: "Created breakpoint {id} at {file}:{line}"
+
+display:
+  result: "{n}: {exp} = {result}"
+
+eval:
+  exception: "{text_message}"
+  result: "{result}"
+
+frame:
+  line: "{mark} #{pos} {call} at {file}:{line}"
+
+method:
+  methods: "{name}|c"
+
+restart:
+  success: "Re exec'ing:\n  {cmd}"
+
+thread:
+  context: "{status_flag}{debug_flag}{id} {thread} {file_line}"
+
+trace:
+  messages:
+    success: "Tracing global variable \"{var}\"."
+    on_change: "traced global variable '{name}' has value '{value}'"
+    undo: "Not tracing global variable \"{var}\" anymore."
+  errors:
+    var_is_not_global: "'{name}' is not a global variable."
+    needs_global_variable: "tracevar needs a global variable name"
+
+variable:
+  variable: "{key} = {value}"

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "byebug/helpers/eval"
+require "byebug/errors"
+
+module Byebug
+  #
+  # Processes commands in regular mode.
+  #
+  # You can override this class to create your own command processor that, for
+  # example, whitelists only certain commands to be executed.
+  #
+  # @see PostMortemProcessor for a example
+  #
+  class CommandProcessor
+    include Helpers::EvalHelper
+
+    attr_accessor :prev_line
+    attr_reader :context, :interface
+
+    def initialize(context, interface = LocalInterface.new)
+      @context = context
+      @interface = interface
+
+      @proceed = false
+      @prev_line = nil
+    end
+
+    def printer
+      @printer ||= Printers::Plain.new
+    end
+
+    extend Forwardable
+
+    def_delegators :@context, :frame
+
+    def_delegator :printer, :print, :pr
+    def_delegator :printer, :print_collection, :prc
+    def_delegator :printer, :print_variables, :prv
+
+    def_delegators :interface, :errmsg, :puts, :confirm
+
+    def_delegators :Byebug, :commands
+
+    #
+    # Available commands
+    #
+    def command_list
+      @command_list ||= CommandList.new(commands)
+    end
+
+    def at_line
+      process_commands
+    end
+
+    def at_tracing
+      puts "Tracing: #{context.full_location}"
+
+      run_auto_cmds(2)
+    end
+
+    def at_breakpoint(brkpt)
+      number = Byebug.breakpoints.index(brkpt) + 1
+
+      puts "Stopped by breakpoint #{number} at #{frame.file}:#{frame.line}"
+    end
+
+    def at_catchpoint(exception)
+      puts "Catchpoint at #{context.location}: `#{exception}'"
+    end
+
+    def at_return(return_value)
+      puts "Return value is: #{safe_inspect(return_value)}"
+
+      process_commands
+    end
+
+    def at_end
+      process_commands
+    end
+
+    #
+    # Let the execution continue
+    #
+    def proceed!
+      @proceed = true
+    end
+
+    #
+    # Handle byebug commands.
+    #
+    def process_commands
+      before_repl
+
+      repl
+    ensure
+      after_repl
+    end
+
+    protected
+
+    #
+    # Prompt shown before reading a command.
+    #
+    def prompt
+      "(byebug) "
+    end
+
+    def before_repl
+      @proceed = false
+      @prev_line = nil
+
+      run_auto_cmds(1)
+      interface.autorestore
+    end
+
+    def after_repl
+      interface.autosave
+    end
+
+    #
+    # Main byebug's REPL
+    #
+    def repl
+      until @proceed
+        cmd = interface.read_command(prompt)
+        return if cmd.nil?
+
+        next if cmd == ""
+
+        run_cmd(cmd)
+      end
+    end
+
+    private
+
+    def auto_cmds_for(run_level)
+      command_list.select { |cmd| cmd.always_run >= run_level }
+    end
+
+    #
+    # Run permanent commands.
+    #
+    def run_auto_cmds(run_level)
+      safely do
+        auto_cmds_for(run_level).each { |cmd| cmd.new(self).execute }
+      end
+    end
+
+    #
+    # Executes the received input
+    #
+    # Instantiates a command matching the input and runs it. If a matching
+    # command is not found, it evaluates the unknown input.
+    #
+    def run_cmd(input)
+      safely do
+        command = command_list.match(input)
+        return command.new(self, input).execute if command
+
+        puts safe_inspect(multiple_thread_eval(input))
+      end
+    end
+
+    def safely
+      yield
+    rescue StandardError => e
+      errmsg(e.message)
+    end
+  end
+end