fluid_cli 0.1.3 → 0.1.4

data/vendor/deps/debug/lib/debug/frame_info.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-module DEBUGGER__
-  FrameInfo = Struct.new(:location, :self, :binding, :iseq, :class, :frame_depth,
-                          :has_return_value,     :return_value,
-                          :has_raised_exception, :raised_exception,
-                          :show_line,
-                          :_local_variables, :_callee, # for recorder
-                          :dupped_binding,
-                        )
-
-  # extend FrameInfo with debug.so
-  begin
-    require_relative 'debug.so'
-  rescue LoadError
-    require 'debug/debug.so'
-  end
-
-  class FrameInfo
-    HOME = ENV['HOME'] ? (ENV['HOME'] + '/') : nil
-
-    def path
-      location.path
-    end
-
-    def realpath
-      location.absolute_path
-    end
-
-    def self.pretty_path path
-      return '#<none>' unless path
-      use_short_path = CONFIG[:use_short_path]
-
-      case
-      when use_short_path && path.start_with?(dir = RbConfig::CONFIG["rubylibdir"] + '/')
-        path.sub(dir, '$(rubylibdir)/')
-      when use_short_path && Gem.path.any? do |gp|
-          path.start_with?(dir = gp + '/gems/')
-        end
-        path.sub(dir, '$(Gem)/')
-      when HOME && path.start_with?(HOME)
-        path.sub(HOME, '~/')
-      else
-        path
-      end
-    end
-
-    def pretty_path
-      FrameInfo.pretty_path path
-    end
-
-    def name
-      # p frame_type: frame_type, self: self
-      case frame_type
-      when :block
-        level, block_loc = block_identifier
-        "block in #{block_loc}#{level}"
-      when :method
-        method_identifier
-      when :c
-        c_identifier
-      when :other
-        other_identifier
-      end
-    end
-
-    def file_lines
-      SESSION.source(self.iseq)
-    end
-
-    def frame_type
-      if self.local_variables && iseq
-        if iseq.type == :block
-          :block
-        elsif callee
-          :method
-        else
-          :other
-        end
-      else
-        :c
-      end
-    end
-
-    BLOCK_LABL_REGEXP = /\Ablock( \(\d+ levels\))* in (.+)\z/
-
-    def block_identifier
-      return unless frame_type == :block
-      re_match = location.label.match(BLOCK_LABL_REGEXP)
-      _, level, block_loc = re_match ? re_match.to_a : [nil, nil, location.label]
-
-      [level || "", block_loc]
-    end
-
-    def method_identifier
-      return unless frame_type == :method
-      "#{klass_sig}#{callee}"
-    end
-
-    def c_identifier
-      return unless frame_type == :c
-      "[C] #{klass_sig}#{location.base_label}"
-    end
-
-    def other_identifier
-      return unless frame_type == :other
-      location.label
-    end
-
-    def callee
-      self._callee ||= begin
-                         self.binding&.eval('__callee__')
-                       rescue NameError # BasicObject
-                         nil
-                       end
-    end
-
-    def return_str
-      if self.binding && iseq && has_return_value
-        DEBUGGER__.safe_inspect(return_value, short: true)
-      end
-    end
-
-    def matchable_location
-      # realpath can sometimes be nil so we can't use it here
-      "#{path}:#{location.lineno}"
-    end
-
-    def location_str
-      "#{pretty_path}:#{location.lineno}"
-    end
-
-    def eval_binding
-      if b = self.dupped_binding
-        b
-      else
-        b = self.binding || TOPLEVEL_BINDING
-        self.dupped_binding = b.dup
-      end
-    end
-
-    def local_variables
-      if lvars = self._local_variables
-        lvars
-      elsif b = self.binding
-        b.local_variables.map{|var|
-          [var, b.local_variable_get(var)]
-        }.to_h
-      end
-    end
-
-    def iseq_parameters_info
-      case frame_type
-      when :block, :method
-        parameters_info
-      else
-        nil
-      end
-    end
-
-    def parameters_info
-      vars = iseq.parameters_symbols
-      vars.map{|var|
-        begin
-          { name: var, value: DEBUGGER__.safe_inspect(local_variable_get(var), short: true) }
-        rescue NameError, TypeError
-          nil
-        end
-      }.compact
-    end
-
-    private def get_singleton_class obj
-      obj.singleton_class # TODO: don't use it
-    rescue TypeError
-      nil
-    end
-
-    private def local_variable_get var
-      local_variables[var]
-    end
-
-    private def klass_sig
-      if self.class == get_singleton_class(self.self)
-        "#{self.self}."
-      else
-        "#{self.class}#"
-      end
-    end
-  end
-end

data/vendor/deps/debug/lib/debug/irb_integration.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'irb'
-
-module DEBUGGER__
-  module IrbPatch
-    def evaluate(line, line_no)
-      SESSION.send(:restart_all_threads)
-      super
-      # This is to communicate with the test framework so it can feed the next input
-      puts "INTERNAL_INFO: {}" if ENV['RUBY_DEBUG_TEST_UI'] == 'terminal'
-    ensure
-      SESSION.send(:stop_all_threads)
-    end
-  end
-
-  class ThreadClient
-    def activate_irb_integration
-      IRB.setup(location, argv: [])
-      workspace = IRB::WorkSpace.new(current_frame&.binding || TOPLEVEL_BINDING)
-      irb = IRB::Irb.new(workspace)
-      IRB.conf[:MAIN_CONTEXT] = irb.context
-      IRB::Debug.setup(irb)
-      IRB::Context.prepend(IrbPatch)
-    end
-  end
-
-  class Session
-    def deactivate_irb_integration
-      Reline.completion_proc = nil
-      Reline.output_modifier_proc = nil
-      Reline.autocompletion = false
-      Reline.dig_perfect_match_proc = nil
-      reset_ui UI_LocalConsole.new
-    end
-  end
-end

data/vendor/deps/debug/lib/debug/local.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'io/console/size'
-require_relative 'console'
-
-module DEBUGGER__
-  class UI_LocalConsole < UI_Base
-    def initialize
-      @console = Console.new
-    end
-
-    def remote?
-      false
-    end
-
-    def activate_sigint
-      prev_handler = trap(:SIGINT){
-        if SESSION.active?
-          ThreadClient.current.on_trap :SIGINT
-        end
-      }
-      SESSION.intercept_trap_sigint_start prev_handler
-    end
-
-    def deactivate_sigint
-      if SESSION.intercept_trap_sigint?
-        prev = SESSION.intercept_trap_sigint_end
-        trap(:SIGINT, prev)
-      end
-    end
-
-    def activate session, on_fork: false
-      activate_sigint unless CONFIG[:no_sigint_hook]
-    end
-
-    def deactivate
-      deactivate_sigint
-      @console.deactivate
-    end
-
-    def width
-      if (w = IO.console_size[1]) == 0 # for tests PTY
-        80
-      else
-        w
-      end
-    end
-
-    def quit n
-      yield
-      exit n
-    end
-
-    def ask prompt
-      setup_interrupt do
-        print prompt
-        ($stdin.gets || '').strip
-      end
-    end
-
-    def puts str = nil
-      case str
-      when Array
-        str.each{|line|
-          $stdout.puts line.chomp
-        }
-      when String
-        str.each_line{|line|
-          $stdout.puts line.chomp
-        }
-      when nil
-        $stdout.puts
-      end
-    end
-
-    def readline prompt = '(rdbg)'
-      setup_interrupt do
-        (@console.readline(prompt) || 'quit').strip
-      end
-    end
-
-    def setup_interrupt
-      SESSION.intercept_trap_sigint false do
-        current_thread = Thread.current # should be session_server thread
-
-        prev_handler = trap(:INT){
-          current_thread.raise Interrupt
-        }
-
-        yield
-      ensure
-        trap(:INT, prev_handler)
-      end
-    end
-
-    def after_fork_parent
-      parent_pid = Process.pid
-
-      at_exit{
-        SESSION.intercept_trap_sigint_end
-        trap(:SIGINT, :IGNORE)
-
-        if Process.pid == parent_pid
-          # only check child process from its parent
-          begin
-            # wait for all child processes to keep terminal
-            Process.waitpid
-          rescue Errno::ESRCH, Errno::ECHILD
-          end
-        end
-      }
-    end
-  end
-end
-

data/vendor/deps/debug/lib/debug/open.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-#
-# Open the door for the debugger to connect.
-# Users can connect to debuggee program with "rdbg --attach" option.
-#
-# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
-# Otherwise, UNIX domain socket is used.
-#
-
-require_relative 'session'
-return unless defined?(DEBUGGER__)
-
-DEBUGGER__.open

data/vendor/deps/debug/lib/debug/open_nonstop.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-#
-# Open the door for the debugger to connect.
-# Unlike debug/open, it does not stop at the beginning of the program.
-# Users can connect to debuggee program with "rdbg --attach" option or
-# VSCode attach type.
-#
-# If RUBY_DEBUG_PORT envval is provided (digits), open TCP/IP port.
-# Otherwise, UNIX domain socket is used.
-#
-
-require_relative 'session'
-return unless defined?(DEBUGGER__)
-
-DEBUGGER__.open(nonstop: true)

data/vendor/deps/debug/lib/debug/prelude.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-return if ENV['RUBY_DEBUG_ENABLE'] == '0'
-return if defined?(::DEBUGGER__::Session)
-
-# Put the following line in your login script (e.g. ~/.bash_profile) with modified path:
-#
-#   export RUBYOPT="-r /path/to/debug/prelude ${RUBYOPT}"
-#
-module Kernel
-  def debugger(*a, up_level: 0, **kw)
-    begin
-      require_relative 'version'
-      cur_version = ::DEBUGGER__::VERSION
-      require_relative 'frame_info'
-
-      if !defined?(::DEBUGGER__::SO_VERSION) || ::DEBUGGER__::VERSION != ::DEBUGGER__::SO_VERSION
-        ::Object.send(:remove_const, :DEBUGGER__)
-        raise LoadError
-      end
-      require_relative 'session'
-      up_level += 1
-    rescue LoadError
-      $LOADED_FEATURES.delete_if{|e|
-        e.start_with?(__dir__) || e.end_with?('debug/debug.so')
-      }
-      require 'debug/session'
-      require 'debug/version'
-      ::DEBUGGER__.info "Can not activate debug #{cur_version} specified by debug/prelude.rb. Activate debug #{DEBUGGER__::VERSION} instead."
-      up_level += 1
-    end
-
-    ::DEBUGGER__::start no_sigint_hook: true, nonstop: true
-
-    begin
-      debugger(*a, up_level: up_level, **kw)
-      self
-    rescue ArgumentError # for 1.2.4 and earlier
-      debugger(*a, **kw)
-      self
-    end
-  end
-
-  alias bb debugger if ENV['RUBY_DEBUG_BB']
-end
-
-class Binding
-  alias break debugger
-  alias b debugger
-end