irb 1.0.0

data/lib/irb/frame.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: false
+#
+#   frame.rb -
+#   	$Release Version: 0.9$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(Nihon Rational Software Co.,Ltd)
+#
+# --
+#
+#
+#
+
+require "e2mmap"
+
+module IRB
+  class Frame
+    extend Exception2MessageMapper
+    def_exception :FrameOverflow, "frame overflow"
+    def_exception :FrameUnderflow, "frame underflow"
+
+    # Default number of stack frames
+    INIT_STACK_TIMES = 3
+    # Default number of frames offset
+    CALL_STACK_OFFSET = 3
+
+    # Creates a new stack frame
+    def initialize
+      @frames = [TOPLEVEL_BINDING] * INIT_STACK_TIMES
+    end
+
+    # Used by Kernel#set_trace_func to register each event in the call stack
+    def trace_func(event, file, line, id, binding)
+      case event
+      when 'call', 'class'
+        @frames.push binding
+      when 'return', 'end'
+        @frames.pop
+      end
+    end
+
+    # Returns the +n+ number of frames on the call stack from the last frame
+    # initialized.
+    #
+    # Raises FrameUnderflow if there are no frames in the given stack range.
+    def top(n = 0)
+      bind = @frames[-(n + CALL_STACK_OFFSET)]
+      Fail FrameUnderflow unless bind
+      bind
+    end
+
+    # Returns the +n+ number of frames on the call stack from the first frame
+    # initialized.
+    #
+    # Raises FrameOverflow if there are no frames in the given stack range.
+    def bottom(n = 0)
+      bind = @frames[n]
+      Fail FrameOverflow unless bind
+      bind
+    end
+
+    # Convenience method for Frame#bottom
+    def Frame.bottom(n = 0)
+      @backtrace.bottom(n)
+    end
+
+    # Convenience method for Frame#top
+    def Frame.top(n = 0)
+      @backtrace.top(n)
+    end
+
+    # Returns the binding context of the caller from the last frame initialized
+    def Frame.sender
+      eval "self", @backtrace.top
+    end
+
+    @backtrace = Frame.new
+    set_trace_func proc{|event, file, line, id, binding, klass|
+      @backtrace.trace_func(event, file, line, id, binding)
+    }
+  end
+end

data/lib/irb/help.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: false
+#
+#   irb/help.rb - print usage module
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#
+# --
+#
+#
+#
+
+require_relative 'magic-file'
+
+module IRB
+  # Outputs the irb help message, see IRB@Command+line+options.
+  def IRB.print_usage
+    lc = IRB.conf[:LC_MESSAGES]
+    path = lc.find("irb/help-message")
+    space_line = false
+    IRB::MagicFile.open(path){|f|
+      f.each_line do |l|
+        if /^\s*$/ =~ l
+          lc.puts l unless space_line
+          space_line = true
+          next
+        end
+        space_line = false
+
+        l.sub!(/#.*$/, "")
+        next if /^\s*$/ =~ l
+        lc.puts l
+      end
+    }
+  end
+end
+

data/lib/irb/init.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: false
+#
+#   irb/init.rb - irb initialize module
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+
+module IRB # :nodoc:
+
+  # initialize config
+  def IRB.setup(ap_path, argv: ::ARGV)
+    IRB.init_config(ap_path)
+    IRB.init_error
+    IRB.parse_opts(argv: argv)
+    IRB.run_config
+    IRB.load_modules
+
+    unless @CONF[:PROMPT][@CONF[:PROMPT_MODE]]
+      IRB.fail(UndefinedPromptMode, @CONF[:PROMPT_MODE])
+    end
+  end
+
+  # @CONF default setting
+  def IRB.init_config(ap_path)
+    # class instance variables
+    @TRACER_INITIALIZED = false
+
+    # default configurations
+    unless ap_path and @CONF[:AP_NAME]
+      ap_path = File.join(File.dirname(File.dirname(__FILE__)), "irb.rb")
+    end
+    @CONF[:AP_NAME] = File::basename(ap_path, ".rb")
+
+    @CONF[:IRB_NAME] = "irb"
+    @CONF[:IRB_LIB_PATH] = File.dirname(__FILE__)
+
+    @CONF[:RC] = true
+    @CONF[:LOAD_MODULES] = []
+    @CONF[:IRB_RC] = nil
+
+    @CONF[:USE_READLINE] = false unless defined?(ReadlineInputMethod)
+    @CONF[:INSPECT_MODE] = true
+    @CONF[:USE_TRACER] = false
+    @CONF[:USE_LOADER] = false
+    @CONF[:IGNORE_SIGINT] = true
+    @CONF[:IGNORE_EOF] = false
+    @CONF[:ECHO] = nil
+    @CONF[:VERBOSE] = nil
+
+    @CONF[:EVAL_HISTORY] = nil
+    @CONF[:SAVE_HISTORY] = nil
+
+    @CONF[:BACK_TRACE_LIMIT] = 16
+
+    @CONF[:PROMPT] = {
+      :NULL => {
+        :PROMPT_I => nil,
+        :PROMPT_N => nil,
+        :PROMPT_S => nil,
+        :PROMPT_C => nil,
+        :RETURN => "%s\n"
+      },
+      :DEFAULT => {
+        :PROMPT_I => "%N(%m):%03n:%i> ",
+        :PROMPT_N => "%N(%m):%03n:%i> ",
+        :PROMPT_S => "%N(%m):%03n:%i%l ",
+        :PROMPT_C => "%N(%m):%03n:%i* ",
+        :RETURN => "=> %s\n"
+      },
+      :CLASSIC => {
+        :PROMPT_I => "%N(%m):%03n:%i> ",
+        :PROMPT_N => "%N(%m):%03n:%i> ",
+        :PROMPT_S => "%N(%m):%03n:%i%l ",
+        :PROMPT_C => "%N(%m):%03n:%i* ",
+        :RETURN => "%s\n"
+      },
+      :SIMPLE => {
+        :PROMPT_I => ">> ",
+        :PROMPT_N => ">> ",
+        :PROMPT_S => nil,
+        :PROMPT_C => "?> ",
+        :RETURN => "=> %s\n"
+      },
+      :INF_RUBY => {
+        :PROMPT_I => "%N(%m):%03n:%i> ",
+        :PROMPT_N => nil,
+        :PROMPT_S => nil,
+        :PROMPT_C => nil,
+        :RETURN => "%s\n",
+        :AUTO_INDENT => true
+      },
+      :XMP => {
+        :PROMPT_I => nil,
+        :PROMPT_N => nil,
+        :PROMPT_S => nil,
+        :PROMPT_C => nil,
+        :RETURN => "    ==>%s\n"
+      }
+    }
+
+    @CONF[:PROMPT_MODE] = (STDIN.tty? ? :DEFAULT : :NULL)
+    @CONF[:AUTO_INDENT] = false
+
+    @CONF[:CONTEXT_MODE] = 3 # use binding in function on TOPLEVEL_BINDING
+    @CONF[:SINGLE_IRB] = false
+
+    @CONF[:LC_MESSAGES] = Locale.new
+
+    @CONF[:AT_EXIT] = []
+
+    @CONF[:DEBUG_LEVEL] = 0
+  end
+
+  def IRB.init_error
+    @CONF[:LC_MESSAGES].load("irb/error.rb")
+  end
+
+  # option analyzing
+  def IRB.parse_opts(argv: ::ARGV)
+    load_path = []
+    while opt = argv.shift
+      case opt
+      when "-f"
+        @CONF[:RC] = false
+      when "-d"
+        $DEBUG = true
+        $VERBOSE = true
+      when "-w"
+        $VERBOSE = true
+      when /^-W(.+)?/
+        opt = $1 || argv.shift
+        case opt
+        when "0"
+          $VERBOSE = nil
+        when "1"
+          $VERBOSE = false
+        else
+          $VERBOSE = true
+        end
+      when /^-r(.+)?/
+        opt = $1 || argv.shift
+        @CONF[:LOAD_MODULES].push opt if opt
+      when /^-I(.+)?/
+        opt = $1 || argv.shift
+        load_path.concat(opt.split(File::PATH_SEPARATOR)) if opt
+      when '-U'
+        set_encoding("UTF-8", "UTF-8")
+      when /^-E(.+)?/, /^--encoding(?:=(.+))?/
+        opt = $1 || argv.shift
+        set_encoding(*opt.split(':', 2))
+      when "--inspect"
+        if /^-/ !~ argv.first
+          @CONF[:INSPECT_MODE] = argv.shift
+        else
+          @CONF[:INSPECT_MODE] = true
+        end
+      when "--noinspect"
+        @CONF[:INSPECT_MODE] = false
+      when "--readline"
+        @CONF[:USE_READLINE] = true
+      when "--noreadline"
+        @CONF[:USE_READLINE] = false
+      when "--echo"
+        @CONF[:ECHO] = true
+      when "--noecho"
+        @CONF[:ECHO] = false
+      when "--verbose"
+        @CONF[:VERBOSE] = true
+      when "--noverbose"
+        @CONF[:VERBOSE] = false
+      when /^--prompt-mode(?:=(.+))?/, /^--prompt(?:=(.+))?/
+        opt = $1 || argv.shift
+        prompt_mode = opt.upcase.tr("-", "_").intern
+        @CONF[:PROMPT_MODE] = prompt_mode
+      when "--noprompt"
+        @CONF[:PROMPT_MODE] = :NULL
+      when "--inf-ruby-mode"
+        @CONF[:PROMPT_MODE] = :INF_RUBY
+      when "--sample-book-mode", "--simple-prompt"
+        @CONF[:PROMPT_MODE] = :SIMPLE
+      when "--tracer"
+        @CONF[:USE_TRACER] = true
+      when /^--back-trace-limit(?:=(.+))?/
+        @CONF[:BACK_TRACE_LIMIT] = ($1 || argv.shift).to_i
+      when /^--context-mode(?:=(.+))?/
+        @CONF[:CONTEXT_MODE] = ($1 || argv.shift).to_i
+      when "--single-irb"
+        @CONF[:SINGLE_IRB] = true
+      when /^--irb_debug(?:=(.+))?/
+        @CONF[:DEBUG_LEVEL] = ($1 || argv.shift).to_i
+      when "-v", "--version"
+        print IRB.version, "\n"
+        exit 0
+      when "-h", "--help"
+        require_relative "help"
+        IRB.print_usage
+        exit 0
+      when "--"
+        if opt = argv.shift
+          @CONF[:SCRIPT] = opt
+          $0 = opt
+        end
+        break
+      when /^-/
+        IRB.fail UnrecognizedSwitch, opt
+      else
+        @CONF[:SCRIPT] = opt
+        $0 = opt
+        break
+      end
+    end
+    load_path.collect! do |path|
+      /\A\.\// =~ path ? path : File.expand_path(path)
+    end
+    $LOAD_PATH.unshift(*load_path)
+
+  end
+
+  # running config
+  def IRB.run_config
+    if @CONF[:RC]
+      begin
+        load rc_file
+      rescue LoadError, Errno::ENOENT
+      rescue # StandardError, ScriptError
+        print "load error: #{rc_file}\n"
+        print $!.class, ": ", $!, "\n"
+        for err in $@[0, $@.size - 2]
+          print "\t", err, "\n"
+        end
+      end
+    end
+  end
+
+  IRBRC_EXT = "rc"
+  def IRB.rc_file(ext = IRBRC_EXT)
+    if !@CONF[:RC_NAME_GENERATOR]
+      rc_file_generators do |rcgen|
+        @CONF[:RC_NAME_GENERATOR] ||= rcgen
+        if File.exist?(rcgen.call(IRBRC_EXT))
+          @CONF[:RC_NAME_GENERATOR] = rcgen
+          break
+        end
+      end
+    end
+    case rc_file = @CONF[:RC_NAME_GENERATOR].call(ext)
+    when String
+      return rc_file
+    else
+      IRB.fail IllegalRCNameGenerator
+    end
+  end
+
+  # enumerate possible rc-file base name generators
+  def IRB.rc_file_generators
+    if irbrc = ENV["IRBRC"]
+      yield proc{|rc| rc == "rc" ? irbrc : irbrc+rc}
+    end
+    if home = ENV["HOME"]
+      yield proc{|rc| home+"/.irb#{rc}"}
+    end
+    home = Dir.pwd
+    yield proc{|rc| home+"/.irb#{rc}"}
+    yield proc{|rc| home+"/irb#{rc.sub(/\A_?/, '.')}"}
+    yield proc{|rc| home+"/_irb#{rc}"}
+    yield proc{|rc| home+"/$irb#{rc}"}
+  end
+
+  # loading modules
+  def IRB.load_modules
+    for m in @CONF[:LOAD_MODULES]
+      begin
+        require m
+      rescue LoadError => err
+        warn "#{err.class}: #{err}", uplevel: 0
+      end
+    end
+  end
+
+
+  DefaultEncodings = Struct.new(:external, :internal)
+  class << IRB
+    private
+    def set_encoding(extern, intern = nil)
+      verbose, $VERBOSE = $VERBOSE, nil
+      Encoding.default_external = extern unless extern.nil? || extern.empty?
+      Encoding.default_internal = intern unless intern.nil? || intern.empty?
+      @CONF[:ENCODINGS] = IRB::DefaultEncodings.new(extern, intern)
+      [$stdin, $stdout, $stderr].each do |io|
+        io.set_encoding(extern, intern)
+      end
+      @CONF[:LC_MESSAGES].instance_variable_set(:@encoding, extern)
+    ensure
+      $VERBOSE = verbose
+    end
+  end
+end

data/lib/irb/input-method.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: false
+#
+#   irb/input-method.rb - input methods used irb
+#   	$Release Version: 0.9.6$
+#   	$Revision$
+#   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+# --
+#
+#
+#
+require_relative 'src_encoding'
+require_relative 'magic-file'
+
+module IRB
+  STDIN_FILE_NAME = "(line)" # :nodoc:
+  class InputMethod
+
+    # Creates a new input method object
+    def initialize(file = STDIN_FILE_NAME)
+      @file_name = file
+    end
+    # The file name of this input method, usually given during initialization.
+    attr_reader :file_name
+
+    # The irb prompt associated with this input method
+    attr_accessor :prompt
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      IRB.fail NotImplementedError, "gets"
+    end
+    public :gets
+
+    # Whether this input method is still readable when there is no more data to
+    # read.
+    #
+    # See IO#eof for more information.
+    def readable_after_eof?
+      false
+    end
+  end
+
+  class StdioInputMethod < InputMethod
+    # Creates a new input method object
+    def initialize
+      super
+      @line_no = 0
+      @line = []
+      @stdin = IO.open(STDIN.to_i, :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+      @stdout = IO.open(STDOUT.to_i, 'w', :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+    end
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      print @prompt
+      line = @stdin.gets
+      @line[@line_no += 1] = line
+    end
+
+    # Whether the end of this input method has been reached, returns +true+ if
+    # there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      @stdin.eof?
+    end
+
+    # Whether this input method is still readable when there is no more data to
+    # read.
+    #
+    # See IO#eof for more information.
+    def readable_after_eof?
+      true
+    end
+
+    # Returns the current line number for #io.
+    #
+    # #line counts the number of times #gets is called.
+    #
+    # See IO#lineno for more information.
+    def line(line_no)
+      @line[line_no]
+    end
+
+    # The external encoding for standard input.
+    def encoding
+      @stdin.external_encoding
+    end
+  end
+
+  # Use a File for IO with irb, see InputMethod
+  class FileInputMethod < InputMethod
+    # Creates a new input method object
+    def initialize(file)
+      super
+      @io = IRB::MagicFile.open(file)
+    end
+    # The file name of this input method, usually given during initialization.
+    attr_reader :file_name
+
+    # Whether the end of this input method has been reached, returns +true+ if
+    # there is no more data to read.
+    #
+    # See IO#eof? for more information.
+    def eof?
+      @io.eof?
+    end
+
+    # Reads the next line from this input method.
+    #
+    # See IO#gets for more information.
+    def gets
+      print @prompt
+      l = @io.gets
+      l
+    end
+
+    # The external encoding for standard input.
+    def encoding
+      @io.external_encoding
+    end
+  end
+
+  begin
+    require "readline"
+    class ReadlineInputMethod < InputMethod
+      include Readline
+      # Creates a new input method object using Readline
+      def initialize
+        super
+
+        @line_no = 0
+        @line = []
+        @eof = false
+
+        @stdin = IO.open(STDIN.to_i, :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+        @stdout = IO.open(STDOUT.to_i, 'w', :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+      end
+
+      # Reads the next line from this input method.
+      #
+      # See IO#gets for more information.
+      def gets
+        Readline.input = @stdin
+        Readline.output = @stdout
+        if l = readline(@prompt, false)
+          HISTORY.push(l) if !l.empty?
+          @line[@line_no += 1] = l + "\n"
+        else
+          @eof = true
+          l
+        end
+      end
+
+      # Whether the end of this input method has been reached, returns +true+
+      # if there is no more data to read.
+      #
+      # See IO#eof? for more information.
+      def eof?
+        @eof
+      end
+
+      # Whether this input method is still readable when there is no more data to
+      # read.
+      #
+      # See IO#eof for more information.
+      def readable_after_eof?
+        true
+      end
+
+      # Returns the current line number for #io.
+      #
+      # #line counts the number of times #gets is called.
+      #
+      # See IO#lineno for more information.
+      def line(line_no)
+        @line[line_no]
+      end
+
+      # The external encoding for standard input.
+      def encoding
+        @stdin.external_encoding
+      end
+    end
+  rescue LoadError
+  end
+end