docspring 3.0.0 → 3.1.0

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/lc/help-message

@@ -0,0 +1,55 @@
+Usage:  irb.rb [options] [programfile] [arguments]
+  -f                Don't initialize from configuration file.
+  -d                Set $DEBUG and $VERBOSE to true (same as 'ruby -d').
+  -r load-module    Require load-module (same as 'ruby -r').
+  -I path           Specify $LOAD_PATH directory (same as 'ruby -I').
+  -U                Set external and internal encodings to UTF-8.
+  -E ex[:in]        Set default external (ex) and internal (in) encodings
+                    (same as 'ruby -E').
+  -w                Suppress warnings (same as 'ruby -w').
+  -W[level=2]       Set warning level: 0=silence, 1=medium, 2=verbose
+                    (same as 'ruby -W').
+  --context-mode n  Set n[0-4] to method to create Binding Object,
+                    when new workspace was created.
+  --extra-doc-dir   Add an extra doc dir for the doc dialog.
+  --echo            Show result (default).
+  --noecho          Don't show result.
+  --echo-on-assignment
+                    Show result on assignment.
+  --noecho-on-assignment
+                    Don't show result on assignment.
+  --truncate-echo-on-assignment
+                    Show truncated result on assignment (default).
+  --inspect         Use 'inspect' for output.
+  --noinspect       Don't use 'inspect' for output.
+  --no-pager        Don't use pager.
+  --multiline       Use multiline editor module (default).
+  --nomultiline     Don't use multiline editor module.
+  --singleline      Use single line editor module.
+  --nosingleline    Don't use single line editor module (default).
+  --colorize        Use color-highlighting (default).
+  --nocolorize      Don't use color-highlighting.
+  --autocomplete    Use auto-completion (default).
+  --noautocomplete  Don't use auto-completion.
+  --regexp-completor
+                    Use regexp based completion (default).
+  --type-completor  Use type based completion.
+  --prompt prompt-mode, --prompt-mode prompt-mode
+                    Set prompt mode. Pre-defined prompt modes are:
+                    'default', 'classic', 'simple', 'inf-ruby', 'xmp', 'null'.
+  --inf-ruby-mode   Use prompt appropriate for inf-ruby-mode on emacs.
+                    Suppresses --multiline and --singleline.
+  --sample-book-mode, --simple-prompt
+                    Set prompt mode to 'simple'.
+  --noprompt        Don't output prompt.
+  --script          Script mode (default, treat first argument as script)
+  --noscript        No script mode (leave arguments in argv)
+  --single-irb      Share self with sub-irb.
+  --tracer          Show stack trace for each command.
+  --back-trace-limit n[=16]
+                    Display backtrace top n and bottom n.
+  --verbose         Show details.
+  --noverbose       Don't show details.
+  -v, --version     Print the version of irb.
+  -h, --help        Print help.
+  --                Separate options of irb from the list of command-line args.

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/lc/ja/error.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+#
+#   irb/lc/ja/error.rb -
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+module IRB
+  # :stopdoc:
+
+  class UnrecognizedSwitch < StandardError
+    def initialize(val)
+      super("スイッチ(#{val})が分りません")
+    end
+  end
+  class CantReturnToNormalMode < StandardError
+    def initialize
+      super("Normalモードに戻れません.")
+    end
+  end
+  class IllegalParameter < StandardError
+    def initialize(val)
+      super("パラメータ(#{val})が間違っています.")
+    end
+  end
+  class IrbAlreadyDead < StandardError
+    def initialize
+      super("Irbは既に死んでいます.")
+    end
+  end
+  class IrbSwitchedToCurrentThread < StandardError
+    def initialize
+      super("カレントスレッドに切り替わりました.")
+    end
+  end
+  class NoSuchJob < StandardError
+    def initialize(val)
+      super("そのようなジョブ(#{val})はありません.")
+    end
+  end
+  class CantChangeBinding < StandardError
+    def initialize(val)
+      super("バインディング(#{val})に変更できません.")
+    end
+  end
+  class UndefinedPromptMode < StandardError
+    def initialize(val)
+      super("プロンプトモード(#{val})は定義されていません.")
+    end
+  end
+
+  # :startdoc:
+end
+# vim:fileencoding=utf-8

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/lc/ja/help-message

@@ -0,0 +1,58 @@
+Usage:  irb.rb [options] [programfile] [arguments]
+  -f		    ~/.irbrc を読み込まない.
+  -d                $DEBUG をtrueにする(ruby -d と同じ)
+  -r load-module    ruby -r と同じ.
+  -I path           $LOAD_PATH に path を追加する.
+  -U                ruby -U と同じ.
+  -E enc            ruby -E と同じ.
+  -w                ruby -w と同じ.
+  -W[level=2]       ruby -W と同じ.
+  --context-mode n  新しいワークスペースを作成した時に関連する Binding
+		    オブジェクトの作成方法を 0 から 4 のいずれかに設定する.
+  --extra-doc-dir   指定したディレクトリのドキュメントを追加で読み込む.
+  --echo	    実行結果を表示する(デフォルト).
+  --noecho	    実行結果を表示しない.
+  --echo-on-assignment
+                    代入結果を表示する.
+  --noecho-on-assignment
+                    代入結果を表示しない.
+  --truncate-echo-on-assignment
+                    truncateされた代入結果を表示する(デフォルト).
+  --inspect	    結果出力にinspectを用いる.
+  --noinspect	    結果出力にinspectを用いない.
+  --no-pager        ページャを使用しない.
+  --multiline       マルチラインエディタを利用する.
+  --nomultiline     マルチラインエディタを利用しない.
+  --singleline      シングルラインエディタを利用する.
+  --nosingleline    シングルラインエディタを利用しない.
+  --colorize	    色付けを利用する.
+  --nocolorize	    色付けを利用しない.
+  --autocomplete    オートコンプリートを利用する.
+  --noautocomplete  オートコンプリートを利用しない.
+  --regexp-completor
+                    補完に正規表現を利用する.
+  --type-completor  補完に型情報を利用する.
+  --prompt prompt-mode/--prompt-mode prompt-mode
+                    プロンプトモードを切り替える.
+                    現在定義されているプロンプトモードは,
+                    default, classic, simple, inf-ruby, xmp, null.
+  --inf-ruby-mode   emacsのinf-ruby-mode用のプロンプト表示を行なう. 特
+                    に指定がない限り, シングルラインエディタとマルチラ
+                    インエディタは使わなくなる.
+  --sample-book-mode/--simple-prompt
+		    非常にシンプルなプロンプトを用いるモードです.
+  --noprompt	    プロンプト表示を行なわない.
+  --script          スクリプトモード(最初の引数をスクリプトファイルとして扱う、デフォルト)
+  --noscript        引数をargvとして扱う.
+  --single-irb	    irb 中で self を実行して得られるオブジェクトをサ
+		    ブ irb と共有する.
+  --tracer	    コマンド実行時にトレースを行なう.
+  --back-trace-limit n
+		    バックトレース表示をバックトレースの頭から n, 後ろ
+		    からnだけ行なう. デフォルトは16
+
+  --verbose	    詳細なメッセージを出力する.
+  --noverbose	    詳細なメッセージを出力しない(デフォルト).
+  -v, --version	    irbのバージョンを表示する.
+  -h, --help	    irb のヘルプを表示する.
+  --		    以降のコマンドライン引数をオプションとして扱わない.

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/locale.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+#
+#   irb/locale.rb - internationalization module
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+
+module IRB # :nodoc:
+  class Locale
+
+    LOCALE_NAME_RE = %r[
+      (?<language>[[:alpha:]]{2,3})
+      (?:_  (?<territory>[[:alpha:]]{2,3}) )?
+      (?:\. (?<codeset>[^@]+) )?
+      (?:@  (?<modifier>.*) )?
+    ]x
+    LOCALE_DIR = "/lc/"
+
+    LEGACY_ENCODING_ALIAS_MAP = {
+      'ujis' => Encoding::EUC_JP,
+      'euc' => Encoding::EUC_JP
+    }
+
+    @@loaded = []
+
+    def initialize(locale = nil)
+      @override_encoding = nil
+      @lang = @territory = @encoding_name = @modifier = nil
+      @locale = locale || ENV["IRB_LANG"] || ENV["LC_MESSAGES"] || ENV["LC_ALL"] || ENV["LANG"] || "C"
+      if m = LOCALE_NAME_RE.match(@locale)
+        @lang, @territory, @encoding_name, @modifier = m[:language], m[:territory], m[:codeset], m[:modifier]
+
+        if @encoding_name
+          if @encoding = LEGACY_ENCODING_ALIAS_MAP[@encoding_name]
+            warn(("%s is obsolete. use %s" % ["#{@lang}_#{@territory}.#{@encoding_name}", "#{@lang}_#{@territory}.#{@encoding.name}"]), uplevel: 1)
+          else
+            @encoding = Encoding.find(@encoding_name) rescue nil
+          end
+        end
+      end
+      @encoding ||= (Encoding.find('locale') rescue Encoding::ASCII_8BIT)
+    end
+
+    attr_reader :lang, :territory, :modifier
+
+    def encoding
+      @override_encoding || @encoding
+    end
+
+    def String(mes)
+      mes = super(mes)
+      if encoding
+        mes.encode(encoding, undef: :replace)
+      else
+        mes
+      end
+    end
+
+    def format(*opts)
+      String(super(*opts))
+    end
+
+    def gets(*rs)
+      String(super(*rs))
+    end
+
+    def readline(*rs)
+      String(super(*rs))
+    end
+
+    def print(*opts)
+      ary = opts.collect{|opt| String(opt)}
+      super(*ary)
+    end
+
+    def printf(*opts)
+      s = format(*opts)
+      print s
+    end
+
+    def puts(*opts)
+      ary = opts.collect{|opt| String(opt)}
+      super(*ary)
+    end
+
+    def load(file)
+      found = find(file)
+      if found
+        unless @@loaded.include?(found)
+          @@loaded << found # cache
+          Kernel.load(found)
+        end
+      else
+        raise LoadError, "No such file to load -- #{file}"
+      end
+    end
+
+    def find(file, paths = $:)
+      dir = File.dirname(file)
+      dir = "" if dir == "."
+      base = File.basename(file)
+
+      if dir.start_with?('/')
+        return each_localized_path(dir, base).find{|full_path| File.readable? full_path}
+      else
+        return search_file(paths, dir, base)
+      end
+    end
+
+    # @param paths load paths in which IRB find a localized file.
+    # @param dir directory
+    # @param file basename to be localized
+    #
+    # typically, for the parameters and a <path> in paths, it searches
+    #   <path>/<dir>/<locale>/<file>
+    def search_file(lib_paths, dir, file)
+      each_localized_path(dir, file) do |lc_path|
+        lib_paths.each do |libpath|
+          full_path = File.join(libpath, lc_path)
+          return full_path if File.readable?(full_path)
+        end
+        redo if defined?(Gem) and Gem.try_activate(lc_path)
+      end
+      nil
+    end
+
+    def each_localized_path(dir, file)
+      return enum_for(:each_localized_path) unless block_given?
+      each_sublocale do |lc|
+        yield lc.nil? ? File.join(dir, LOCALE_DIR, file) : File.join(dir, LOCALE_DIR, lc, file)
+      end
+    end
+
+    def each_sublocale
+      if @lang
+        if @territory
+          if @encoding_name
+            yield "#{@lang}_#{@territory}.#{@encoding_name}@#{@modifier}" if @modifier
+            yield "#{@lang}_#{@territory}.#{@encoding_name}"
+          end
+          yield "#{@lang}_#{@territory}@#{@modifier}" if @modifier
+          yield "#{@lang}_#{@territory}"
+        end
+        if @encoding_name
+          yield "#{@lang}.#{@encoding_name}@#{@modifier}" if @modifier
+          yield "#{@lang}.#{@encoding_name}"
+        end
+        yield "#{@lang}@#{@modifier}" if @modifier
+        yield "#{@lang}"
+      end
+      yield nil
+    end
+  end
+end

data/vendor/bundle/ruby/3.3.0/gems/irb-1.15.1/lib/irb/nesting_parser.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+module IRB
+  module NestingParser
+    IGNORE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
+
+    class << self
+      # Scan each token and call the given block with array of token and other information for parsing
+      def scan_opens(tokens)
+        opens = []
+        pending_heredocs = []
+        first_token_on_line = true
+        tokens.each do |t|
+          skip = false
+          last_tok, state, args = opens.last
+          case state
+          when :in_alias_undef
+            skip = t.event == :on_kw
+          when :in_unquoted_symbol
+            unless IGNORE_TOKENS.include?(t.event)
+              opens.pop
+              skip = true
+            end
+          when :in_lambda_head
+            opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
+          when :in_method_head
+            unless IGNORE_TOKENS.include?(t.event)
+              next_args = []
+              body = nil
+              if args.include?(:receiver)
+                case t.event
+                when :on_lparen, :on_ivar, :on_gvar, :on_cvar
+                  # def (receiver). | def @ivar. | def $gvar. | def @@cvar.
+                  next_args << :dot
+                when :on_kw
+                  case t.tok
+                  when 'self', 'true', 'false', 'nil'
+                    # def self(arg) | def self.
+                    next_args.push(:arg, :dot)
+                  else
+                    # def if(arg)
+                    skip = true
+                    next_args << :arg
+                  end
+                when :on_op, :on_backtick
+                  # def +(arg)
+                  skip = true
+                  next_args << :arg
+                when :on_ident, :on_const
+                  # def a(arg) | def a.
+                  next_args.push(:arg, :dot)
+                end
+              end
+              if args.include?(:dot)
+                # def receiver.name
+                next_args << :name if t.event == :on_period || (t.event == :on_op && t.tok == '::')
+              end
+              if args.include?(:name)
+                if %i[on_ident on_const on_op on_kw on_backtick].include?(t.event)
+                  # def name(arg) | def receiver.name(arg)
+                  next_args << :arg
+                  skip = true
+                end
+              end
+              if args.include?(:arg)
+                case t.event
+                when :on_nl, :on_semicolon
+                  # def receiver.f;
+                  body = :normal
+                when :on_lparen
+                  # def receiver.f()
+                  next_args << :eq
+                else
+                  if t.event == :on_op && t.tok == '='
+                    # def receiver.f =
+                    body = :oneliner
+                  else
+                    # def receiver.f arg
+                    next_args << :arg_without_paren
+                  end
+                end
+              end
+              if args.include?(:eq)
+                if t.event == :on_op && t.tok == '='
+                  body = :oneliner
+                else
+                  body = :normal
+                end
+              end
+              if args.include?(:arg_without_paren)
+                if %i[on_semicolon on_nl].include?(t.event)
+                  # def f a;
+                  body = :normal
+                else
+                  # def f a, b
+                  next_args << :arg_without_paren
+                end
+              end
+              if body == :oneliner
+                opens.pop
+              elsif body
+                opens[-1] = [last_tok, nil]
+              else
+                opens[-1] = [last_tok, :in_method_head, next_args]
+              end
+            end
+          when :in_for_while_until_condition
+            if t.event == :on_semicolon || t.event == :on_nl || (t.event == :on_kw && t.tok == 'do')
+              skip = true if t.event == :on_kw && t.tok == 'do'
+              opens[-1] = [last_tok, nil]
+            end
+          end
+
+          unless skip
+            case t.event
+            when :on_kw
+              case t.tok
+              when 'begin', 'class', 'module', 'do', 'case'
+                opens << [t, nil]
+              when 'end'
+                opens.pop
+              when 'def'
+                opens << [t, :in_method_head, [:receiver, :name]]
+              when 'if', 'unless'
+                unless t.state.allbits?(Ripper::EXPR_LABEL)
+                  opens << [t, nil]
+                end
+              when 'while', 'until'
+                unless t.state.allbits?(Ripper::EXPR_LABEL)
+                  opens << [t, :in_for_while_until_condition]
+                end
+              when 'ensure', 'rescue'
+                unless t.state.allbits?(Ripper::EXPR_LABEL)
+                  opens.pop
+                  opens << [t, nil]
+                end
+              when 'alias'
+                opens << [t, :in_alias_undef, 2]
+              when 'undef'
+                opens << [t, :in_alias_undef, 1]
+              when 'elsif', 'else', 'when'
+                opens.pop
+                opens << [t, nil]
+              when 'for'
+                opens << [t, :in_for_while_until_condition]
+              when 'in'
+                if last_tok&.event == :on_kw && %w[case in].include?(last_tok.tok) && first_token_on_line
+                  opens.pop
+                  opens << [t, nil]
+                end
+              end
+            when :on_tlambda
+              opens << [t, :in_lambda_head]
+            when :on_lparen, :on_lbracket, :on_lbrace, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
+              opens << [t, nil]
+            when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
+              opens.pop
+            when :on_heredoc_beg
+              pending_heredocs << t
+            when :on_heredoc_end
+              opens.pop
+            when :on_backtick
+              opens << [t, nil] unless t.state == Ripper::EXPR_ARG
+            when :on_tstring_beg, :on_words_beg, :on_qwords_beg, :on_symbols_beg, :on_qsymbols_beg, :on_regexp_beg
+              opens << [t, nil]
+            when :on_tstring_end, :on_regexp_end, :on_label_end
+              opens.pop
+            when :on_symbeg
+              if t.tok == ':'
+                opens << [t, :in_unquoted_symbol]
+              else
+                opens << [t, nil]
+              end
+            end
+          end
+          if t.event == :on_nl || t.event == :on_semicolon
+            first_token_on_line = true
+          elsif t.event != :on_sp
+            first_token_on_line = false
+          end
+          if pending_heredocs.any? && t.tok.include?("\n")
+            pending_heredocs.reverse_each { |t| opens << [t, nil] }
+            pending_heredocs = []
+          end
+          if opens.last && opens.last[1] == :in_alias_undef && !IGNORE_TOKENS.include?(t.event) && t.event != :on_heredoc_end
+            tok, state, arg = opens.pop
+            opens << [tok, state, arg - 1] if arg >= 1
+          end
+          yield t, opens if block_given?
+        end
+        opens.map(&:first) + pending_heredocs.reverse
+      end
+
+      def open_tokens(tokens)
+        # scan_opens without block will return a list of open tokens at last token position
+        scan_opens(tokens)
+      end
+
+      # Calculates token information [line_tokens, prev_opens, next_opens, min_depth] for each line.
+      # Example code
+      #   ["hello
+      #   world"+(
+      # First line
+      #   line_tokens: [[lbracket, '['], [tstring_beg, '"'], [tstring_content("hello\nworld"), "hello\n"]]
+      #   prev_opens:  []
+      #   next_tokens: [lbracket, tstring_beg]
+      #   min_depth:   0 (minimum at beginning of line)
+      # Second line
+      #   line_tokens: [[tstring_content("hello\nworld"), "world"], [tstring_end, '"'], [op, '+'], [lparen, '(']]
+      #   prev_opens:  [lbracket, tstring_beg]
+      #   next_tokens: [lbracket, lparen]
+      #   min_depth:   1 (minimum just after tstring_end)
+      def parse_by_line(tokens)
+        line_tokens = []
+        prev_opens = []
+        min_depth = 0
+        output = []
+        last_opens = scan_opens(tokens) do |t, opens|
+          depth = t == opens.last&.first ? opens.size - 1 : opens.size
+          min_depth = depth if depth < min_depth
+          if t.tok.include?("\n")
+            t.tok.each_line do |line|
+              line_tokens << [t, line]
+              next if line[-1] != "\n"
+              next_opens = opens.map(&:first)
+              output << [line_tokens, prev_opens, next_opens, min_depth]
+              prev_opens = next_opens
+              min_depth = prev_opens.size
+              line_tokens = []
+            end
+          else
+            line_tokens << [t, t.tok]
+          end
+        end
+        output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
+        output
+      end
+    end
+  end
+end