tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/debug-1.5.0/lib/debug/console.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-module DEBUGGER__
-  class Console
-    begin
-      raise LoadError if CONFIG[:no_reline]
-      require 'reline'
-
-      # reline 0.2.7 or later is required.
-      raise LoadError if Reline::VERSION < '0.2.7'
-
-      require_relative 'color'
-      include Color
-
-      begin
-        prev = trap(:SIGWINCH, nil)
-        trap(:SIGWINCH, prev)
-        SIGWINCH_SUPPORTED = true
-      rescue ArgumentError
-        SIGWINCH_SUPPORTED = false
-      end
-
-      # 0.2.7 has SIGWINCH issue on non-main thread
-      class ::Reline::LineEditor
-        m = Module.new do
-          def reset(prompt = '', encoding:)
-            super
-            Signal.trap(:SIGWINCH, nil)
-          end
-        end
-        prepend m
-      end if SIGWINCH_SUPPORTED
-
-      def parse_input buff, commands
-        c, rest = get_command buff
-        case
-        when commands.keys.include?(c)
-          :command
-        when !rest && /\A\s*[a-z]*\z/ =~ c
-          nil
-        else
-          :ruby
-        end
-      end
-
-      def readline_setup prompt
-        load_history_if_not_loaded
-        commands = DEBUGGER__.commands
-
-        prev_completion_proc = Reline.completion_proc
-        prev_output_modifier_proc = Reline.output_modifier_proc
-        prev_prompt_proc = Reline.prompt_proc
-
-        # prompt state
-        state = nil # :command, :ruby, nil (unknown)
-
-        Reline.prompt_proc = -> args, *kw do
-          case state = parse_input(args.first, commands)
-          when nil, :command
-            [prompt, prompt]
-          when :ruby
-            [prompt.sub('rdbg'){colorize('ruby', [:RED])}] * 2
-          end
-        end
-
-        Reline.completion_proc = -> given do
-          buff = Reline.line_buffer
-          Reline.completion_append_character= ' '
-
-          if /\s/ =~ buff # second parameters
-            given = File.expand_path(given + 'a').sub(/a\z/, '')
-            files = Dir.glob(given + '*')
-            if files.size == 1 && File.directory?(files.first)
-              Reline.completion_append_character= '/'
-            end
-            files
-          else
-            commands.keys.grep(/\A#{Regexp.escape(given)}/)
-          end
-        end
-
-        Reline.output_modifier_proc = -> buff, **kw do
-          c, rest = get_command buff
-
-          case state
-          when :command
-            cmd = colorize(c, [:CYAN, :UNDERLINE])
-
-            if commands[c] == c
-              rprompt = colorize("    # command", [:DIM])
-            else
-              rprompt = colorize("    # #{commands[c]} command", [:DIM])
-            end
-
-            rest = rest ? colorize_code(rest) : ''
-            cmd + rest + rprompt
-          when nil
-            buff
-          when :ruby
-            colorize_code(buff.chomp)
-          end
-        end
-
-        yield
-
-      ensure
-        Reline.completion_proc = prev_completion_proc
-        Reline.output_modifier_proc = prev_output_modifier_proc
-        Reline.prompt_proc = prev_prompt_proc
-      end
-
-      private def get_command line
-        case line.chomp
-        when /\A(\s*[a-z]+)(\s.*)?\z$/
-          return $1.strip, $2
-        else
-          line.strip
-        end
-      end
-
-      def readline prompt
-        readline_setup prompt do
-          Reline.readmultiline(prompt, true){ true }
-        end
-      end
-
-      def history
-        Reline::HISTORY
-      end
-
-    rescue LoadError
-      begin
-        require 'readline.so'
-
-        def readline_setup
-          load_history_if_not_loaded
-          commands = DEBUGGER__.commands
-
-          Readline.completion_proc = proc{|given|
-            buff = Readline.line_buffer
-            Readline.completion_append_character= ' '
-
-            if /\s/ =~ buff # second parameters
-              given = File.expand_path(given + 'a').sub(/a\z/, '')
-              files = Dir.glob(given + '*')
-              if files.size == 1 && File.directory?(files.first)
-                Readline.completion_append_character= '/'
-              end
-              files
-            else
-              commands.keys.grep(/\A#{given}/)
-            end
-          }
-        end
-
-        def readline prompt
-          readline_setup
-          Readline.readline(prompt, true)
-        end
-
-        def history
-          Readline::HISTORY
-        end
-
-      rescue LoadError
-        def readline prompt
-          print prompt
-          gets
-        end
-
-        def history
-          nil
-        end
-      end
-    end
-
-    def history_file
-      CONFIG[:history_file] || File.expand_path("~/.rdbg_history")
-    end
-
-    FH = "# Today's OMIKUJI: "
-
-    def read_history_file
-      if history && File.exist?(path = history_file)
-        f = (['', 'DAI-', 'CHU-', 'SHO-'].map{|e| e+'KICHI'}+['KYO']).sample
-        ["#{FH}#{f}".dup] + File.readlines(path)
-      else
-        []
-      end
-    end
-
-    def initialize
-      @init_history_lines = nil
-    end
-
-    def load_history_if_not_loaded
-      return if @init_history_lines
-
-      @init_history_lines = load_history
-    end
-
-    def deactivate
-      if history && @init_history_lines
-        added_records = history.to_a[@init_history_lines .. -1]
-        path = history_file
-        max = CONFIG[:save_history] || 10_000
-
-        if !added_records.empty? && !path.empty?
-          orig_records = read_history_file
-          open(history_file, 'w'){|f|
-            (orig_records + added_records).last(max).each{|line|
-              if !line.start_with?(FH) && !line.strip.empty?
-                f.puts line.strip
-              end
-            }
-          }
-        end
-      end
-    end
-
-    def load_history
-      read_history_file.count{|line|
-        line.strip!
-        history << line unless line.empty?
-      }
-    end
-  end # class Console
-end
-

data/vendor/bundle/ruby/3.1.0/gems/debug-1.5.0/lib/debug/frame_info.rb

@@ -1,172 +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 pretty_path
-      return '#<none>' unless path = self.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 name
-      # p frame_type: frame_type, self: self
-      case frame_type
-      when :block
-        level, block_loc, _args = block_identifier
-        "block in #{block_loc}#{level}"
-      when :method
-        ci, _args = method_identifier
-        "#{ci}"
-      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
-      args = parameters_info
-      _, level, block_loc = location.label.match(BLOCK_LABL_REGEXP).to_a
-      [level || "", block_loc, args]
-    end
-
-    def method_identifier
-      return unless frame_type == :method
-      args = parameters_info
-      ci = "#{klass_sig}#{callee}"
-      [ci, args]
-    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 ||= self.binding&.eval('__callee__')
-    end
-
-    def return_str
-      if self.binding && iseq && has_return_value
-        DEBUGGER__.safe_inspect(return_value, short: true)
-      end
-    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
-
-    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
-
-    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
-
-    def klass_sig
-      if self.class == get_singleton_class(self.self)
-        "#{self.self}."
-      else
-        "#{self.class}#"
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/debug-1.5.0/lib/debug/prelude.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-return if defined?(::DEBUGGER__)
-
-# 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