irb 1.15.2 → 1.17.0

data/lib/irb/ruby-lex.rb

@@ -4,6 +4,7 @@
 #   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
 #
 
+require "prism"
 require "ripper"
 require "jruby" if RUBY_ENGINE == "jruby"
 require_relative "nesting_parser"
@@ -52,6 +53,27 @@ module IRB
       on_words_beg on_qwords_beg
     ]
 
+    RESERVED_WORDS = %i[
+      __ENCODING__ __LINE__ __FILE__
+      BEGIN END
+      alias and
+      begin break
+      case class
+      def defined? do
+      else elsif end ensure
+      false for
+      if in
+      module
+      next nil not
+      or
+      redo rescue retry return
+      self super
+      then true
+      undef unless until
+      when while
+      yield
+    ]
+
     class TerminateLineInput < StandardError
       def initialize
         super("Terminate Line Input")
@@ -77,6 +99,10 @@ module IRB
       end
 
       def generate_local_variables_assign_code(local_variables)
+        # Some reserved words could be a local variable
+        # Example: def f(if: 1); binding.irb; end
+        # These reserved words should be removed from assignment code
+        local_variables -= RESERVED_WORDS
         "#{local_variables.join('=')}=nil;" unless local_variables.empty?
       end
 
@@ -145,7 +171,7 @@ module IRB
 
     def check_code_state(code, local_variables:)
       tokens = self.class.ripper_lex_without_warning(code, local_variables: local_variables)
-      opens = NestingParser.open_tokens(tokens)
+      opens = NestingParser.open_nestings(Prism.parse_lex(code, scopes: [local_variables]))
       [tokens, opens, code_terminated?(code, tokens, opens, local_variables: local_variables)]
     end
 
@@ -282,11 +308,11 @@ module IRB
 
     def calc_indent_level(opens)
       indent_level = 0
-      opens.each_with_index do |t, index|
-        case t.event
+      opens.each_with_index do |elem, index|
+        case elem.event
         when :on_heredoc_beg
           if opens[index + 1]&.event != :on_heredoc_beg
-            if t.tok.match?(/^<<[~-]/)
+            if elem.tok.match?(/^<<[~-]/)
               indent_level += 1
             else
               indent_level = 0
@@ -295,50 +321,50 @@ module IRB
         when :on_tstring_beg, :on_regexp_beg, :on_symbeg, :on_backtick
           # No indent: "", //, :"", ``
           # Indent: %(), %r(), %i(), %x()
-          indent_level += 1 if t.tok.start_with? '%'
+          indent_level += 1 if elem.tok.start_with? '%'
         when :on_embdoc_beg
           indent_level = 0
         else
-          indent_level += 1 unless t.tok == 'alias' || t.tok == 'undef'
+          indent_level += 1 unless elem.tok == 'alias' || elem.tok == 'undef'
         end
       end
       indent_level
     end
 
-    FREE_INDENT_TOKENS = %i[on_tstring_beg on_backtick on_regexp_beg on_symbeg]
+    FREE_INDENT_NESTINGS = %i[on_tstring_beg on_backtick on_regexp_beg on_symbeg]
 
-    def free_indent_token?(token)
-      FREE_INDENT_TOKENS.include?(token&.event)
+    def free_indent_nesting_element?(elem)
+      FREE_INDENT_NESTINGS.include?(elem&.event)
     end
 
     # Calculates the difference of pasted code's indent and indent calculated from tokens
     def indent_difference(lines, line_results, line_index)
       loop do
-        _tokens, prev_opens, _next_opens, min_depth = line_results[line_index]
-        open_token = prev_opens.last
-        if !open_token || (open_token.event != :on_heredoc_beg && !free_indent_token?(open_token))
+        prev_opens, _next_opens, min_depth = line_results[line_index]
+        open_elem = prev_opens.last
+        if !open_elem || (open_elem.event != :on_heredoc_beg && !free_indent_nesting_element?(open_elem))
           # If the leading whitespace is an indent, return the difference
           indent_level = calc_indent_level(prev_opens.take(min_depth))
           calculated_indent = 2 * indent_level
           actual_indent = lines[line_index][/^ */].size
           return actual_indent - calculated_indent
-        elsif open_token.event == :on_heredoc_beg && open_token.tok.match?(/^<<[^-~]/)
+        elsif open_elem.event == :on_heredoc_beg && open_elem.tok.match?(/^<<[^-~]/)
           return 0
         end
         # If the leading whitespace is not an indent but part of a multiline token
         # Calculate base_indent of the multiline token's beginning line
-        line_index = open_token.pos[0] - 1
+        line_index = open_elem.pos[0] - 1
       end
     end
 
-    def process_indent_level(tokens, lines, line_index, is_newline)
-      line_results = NestingParser.parse_by_line(tokens)
+    def process_indent_level(parse_lex_result, lines, line_index, is_newline)
+      line_results = NestingParser.parse_by_line(parse_lex_result)
       result = line_results[line_index]
       if result
-        _tokens, prev_opens, next_opens, min_depth = result
+        prev_opens, next_opens, min_depth = result
       else
         # When last line is empty
-        prev_opens = next_opens = line_results.last[2]
+        prev_opens = next_opens = line_results.last[1]
         min_depth = next_opens.size
       end
 
@@ -348,39 +374,39 @@ module IRB
 
       preserve_indent = lines[line_index - (is_newline ? 1 : 0)][/^ */].size
 
-      prev_open_token = prev_opens.last
-      next_open_token = next_opens.last
+      prev_open_elem = prev_opens.last
+      next_open_elem = next_opens.last
 
-      # Calculates base indent for pasted code on the line where prev_open_token is located
-      # irb(main):001:1*   if a # base_indent is 2, indent calculated from tokens is 0
-      # irb(main):002:1*         if b # base_indent is 6, indent calculated from tokens is 2
-      # irb(main):003:0>           c # base_indent is 6, indent calculated from tokens is 4
-      if prev_open_token
-        base_indent = [0, indent_difference(lines, line_results, prev_open_token.pos[0] - 1)].max
+      # Calculates base indent for pasted code on the line where prev_open_elem is located
+      # irb(main):001:1*   if a # base_indent is 2, indent calculated from nestings is 0
+      # irb(main):002:1*         if b # base_indent is 6, indent calculated from nestings is 2
+      # irb(main):003:0>           c # base_indent is 6, indent calculated from nestings is 4
+      if prev_open_elem
+        base_indent = [0, indent_difference(lines, line_results, prev_open_elem.pos[0] - 1)].max
       else
         base_indent = 0
       end
 
-      if free_indent_token?(prev_open_token)
-        if is_newline && prev_open_token.pos[0] == line_index
+      if free_indent_nesting_element?(prev_open_elem)
+        if is_newline && prev_open_elem.pos[0] == line_index
           # First newline inside free-indent token
           base_indent + indent
         else
           # Accept any number of indent inside free-indent token
           preserve_indent
         end
-      elsif prev_open_token&.event == :on_embdoc_beg || next_open_token&.event == :on_embdoc_beg
-        if prev_open_token&.event == next_open_token&.event
+      elsif prev_open_elem&.event == :on_embdoc_beg || next_open_elem&.event == :on_embdoc_beg
+        if prev_open_elem&.event == next_open_elem&.event
           # Accept any number of indent inside embdoc content
           preserve_indent
         else
           # =begin or =end
           0
         end
-      elsif prev_open_token&.event == :on_heredoc_beg
-        tok = prev_open_token.tok
+      elsif prev_open_elem&.event == :on_heredoc_beg
+        tok = prev_open_elem.tok
         if prev_opens.size <= next_opens.size
-          if is_newline && lines[line_index].empty? && line_results[line_index - 1][1].last != next_open_token
+          if is_newline && lines[line_index].empty? && line_results[line_index - 1][0].last != next_open_elem
             # First line in heredoc
             tok.match?(/^<<[-~]/) ? base_indent + indent : indent
           elsif tok.match?(/^<<~/)
@@ -400,15 +426,15 @@ module IRB
       end
     end
 
-    def ltype_from_open_tokens(opens)
-      start_token = opens.reverse_each.find do |tok|
-        LTYPE_TOKENS.include?(tok.event)
+    def ltype_from_open_nestings(opens)
+      start_nesting = opens.reverse_each.find do |elem|
+        LTYPE_TOKENS.include?(elem.event)
       end
-      return nil unless start_token
+      return nil unless start_nesting
 
-      case start_token&.event
+      case start_nesting&.event
       when :on_tstring_beg
-        case start_token&.tok
+        case start_nesting&.tok
         when ?"      then ?"
         when /^%.$/  then ?"
         when /^%Q.$/ then ?"
@@ -423,7 +449,7 @@ module IRB
       when :on_qsymbols_beg then ?]
       when :on_symbols_beg  then ?]
       when :on_heredoc_beg
-        start_token&.tok =~ /<<[-~]?(['"`])\w+\1/
+        start_nesting&.tok =~ /<<[-~]?(['"`])\w+\1/
         $1 || ?"
       else
         nil
@@ -460,7 +486,7 @@ module IRB
         if first_token && first_token.state != Ripper::EXPR_DOT
           tokens_without_last_line = tokens[0..index]
           code_without_last_line = tokens_without_last_line.map(&:tok).join
-          opens_without_last_line = NestingParser.open_tokens(tokens_without_last_line)
+          opens_without_last_line = NestingParser.open_nestings(Prism.parse_lex(code_without_last_line, scopes: [local_variables]))
           if code_terminated?(code_without_last_line, tokens_without_last_line, opens_without_last_line, local_variables: local_variables)
             return last_line_tokens.map(&:tok).join
           end

data/lib/irb/source_finder.rb

@@ -29,10 +29,13 @@ module IRB
 
       def colorized_content
         if !binary_file? && file_exist?
-          end_line = find_end
           # To correctly colorize, we need to colorize full content and extract the relevant lines.
-          colored = IRB::Color.colorize_code(file_content)
-          colored.lines[@line - 1...end_line].join
+          colored_lines = IRB::Color.colorize_code(file_content).lines
+
+          # Handle wrong line number case: line_no passed to eval is wrong, file is edited after load, etc
+          return if colored_lines.size < @line
+
+          colored_lines[@line - 1...find_end].join
         elsif @ast_source
           IRB::Color.colorize_code(@ast_source)
         end
@@ -114,7 +117,7 @@ module IRB
       when "owner"
         target_method = owner_receiver.instance_method(method)
       when "receiver"
-        target_method = owner_receiver.method(method)
+        target_method = Kernel.instance_method(:method).bind_call(owner_receiver, method)
       end
       super_level.times do |s|
         target_method = target_method.super_method if target_method

data/lib/irb/version.rb

@@ -5,7 +5,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.15.2"
+  VERSION = "1.17.0"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2025-04-03"
+  @LAST_UPDATE_DATE = "2026-02-08"
 end

data/lib/irb/workspace.rb

@@ -55,6 +55,15 @@ EOF
           # Note that this will typically be IRB::TOPLEVEL_BINDING
           # This is to avoid RubyGems' local variables (see issue #17623)
           @binding = TOPLEVEL_BINDING.dup
+
+        when 5  # binding in Ruby::Box
+          unless defined?(Ruby::Box)
+            puts 'Context-mode 5 (binding in Ruby::Box) requires Ruby 4.0 or later.'
+            raise NameError, 'Ruby::Box not defined'
+          end
+
+          puts 'Context-mode 5 (binding in Ruby::Box) is experimental. It may be removed or changed without notice.'
+          @binding = Ruby::Box.new.eval('Kernel.binding')
         end
       end
 

data/lib/irb.rb

@@ -5,6 +5,7 @@
 #       by Keiju ISHITSUKA(keiju@ruby-lang.org)
 #
 
+require "prism"
 require "ripper"
 require "reline"
 
@@ -77,6 +78,15 @@ module IRB
     PROMPT_MAIN_TRUNCATE_OMISSION = '...'
     CONTROL_CHARACTERS_PATTERN = "\x00-\x1F"
 
+    # Track the nesting depth of run loops. This is used for history management
+    # only the outermost run loop should load/save history.
+    @run_nesting_depth = 0
+
+    class << self
+      # TODO: When refactoring to v2.0, find a better way to manage and track nesting sessions.
+      attr_accessor :run_nesting_depth
+    end
+
     # Returns the current context of this irb session
     attr_reader :context
     # The lexer used by this irb session
@@ -87,6 +97,7 @@ module IRB
     # Creates a new irb session
     def initialize(workspace = nil, input_method = nil, from_binding: false)
       @from_binding = from_binding
+      @prompt_part_cache = nil
       @context = Context.new(self, workspace, input_method)
       @context.workspace.load_helper_methods_to_main
       @signal_status = :IN_IRB
@@ -147,7 +158,10 @@ module IRB
     end
 
     def run(conf = IRB.conf)
-      in_nested_session = !!conf[:MAIN_CONTEXT]
+      # Use run_nesting_depth to determine if we're in a nested session.
+      in_nested_session = Irb.run_nesting_depth > 0
+      Irb.run_nesting_depth += 1
+
       conf[:IRB_RC].call(context) if conf[:IRB_RC]
       prev_context = conf[:MAIN_CONTEXT]
       conf[:MAIN_CONTEXT] = context
@@ -173,6 +187,8 @@ module IRB
           eval_input
         end
       ensure
+        Irb.run_nesting_depth -= 1
+
         # Do not restore to nil. It will cause IRB crash when used with threads.
         IRB.conf[:MAIN_CONTEXT] = prev_context if prev_context
 
@@ -238,13 +254,7 @@ module IRB
       end
     end
 
-    def readmultiline
-      prompt = generate_prompt([], false, 0)
-
-      # multiline
-      return read_input(prompt) if @context.io.respond_to?(:check_termination)
-
-      # nomultiline
+    def read_input_nomultiline(prompt)
       code = +''
       line_offset = 0
       loop do
@@ -265,6 +275,20 @@ module IRB
       end
     end
 
+    def readmultiline
+      with_prompt_part_cached do
+        prompt = generate_prompt([], false, 0)
+
+        if @context.io.respond_to?(:check_termination)
+          # multiline
+          read_input(prompt)
+        else
+          # nomultiline
+          read_input_nomultiline(prompt)
+        end
+      end
+    end
+
     def each_top_level_statement
       loop do
         code = readmultiline
@@ -314,15 +338,13 @@ module IRB
       end
       if @context.io.respond_to?(:dynamic_prompt)
         @context.io.dynamic_prompt do |lines|
-          tokens = RubyLex.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join, local_variables: @context.local_variables)
-          line_results = IRB::NestingParser.parse_by_line(tokens)
+          code = lines.map{ |l| l + "\n" }.join
+          tokens = RubyLex.ripper_lex_without_warning(code, local_variables: @context.local_variables)
+          parse_lex_result = Prism.parse_lex(code, scopes: [@context.local_variables])
+          line_results = IRB::NestingParser.parse_by_line(parse_lex_result)
           tokens_until_line = []
-          line_results.map.with_index do |(line_tokens, _prev_opens, next_opens, _min_depth), line_num_offset|
-            line_tokens.each do |token, _s|
-              # Avoid appending duplicated token. Tokens that include "n" like multiline
-              # tstring_content can exist in multiple lines.
-              tokens_until_line << token if token != tokens_until_line.last
-            end
+          line_results.map.with_index do |(_prev_opens, next_opens, _min_depth), line_num_offset|
+            tokens_until_line << tokens.shift while !tokens.empty? && tokens.first.pos[0] <= line_num_offset + 1
             continue = @scanner.should_continue?(tokens_until_line)
             generate_prompt(next_opens, continue, line_num_offset)
           end
@@ -335,8 +357,8 @@ module IRB
           next nil if !is_newline && lines[line_index]&.byteslice(0, byte_pointer)&.match?(/\A\s*\z/)
 
           code = lines[0..line_index].map { |l| "#{l}\n" }.join
-          tokens = RubyLex.ripper_lex_without_warning(code, local_variables: @context.local_variables)
-          @scanner.process_indent_level(tokens, lines, line_index, is_newline)
+          parse_lex_result = Prism.parse_lex(code, scopes: [@context.local_variables])
+          @scanner.process_indent_level(parse_lex_result, lines, line_index, is_newline)
         end
       end
     end
@@ -567,8 +589,15 @@ module IRB
 
     private
 
+    def with_prompt_part_cached
+      @prompt_part_cache = {}
+      yield
+    ensure
+      @prompt_part_cache = nil
+    end
+
     def generate_prompt(opens, continue, line_offset)
-      ltype = @scanner.ltype_from_open_tokens(opens)
+      ltype = @scanner.ltype_from_open_nestings(opens)
       indent = @scanner.calc_indent_level(opens)
       continue = opens.any? || continue
       line_no = @line_no + line_offset
@@ -598,25 +627,29 @@ module IRB
     end
 
     def truncate_prompt_main(str) # :nodoc:
-      str = str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
-      if str.size <= PROMPT_MAIN_TRUNCATE_LENGTH
-        str
-      else
-        str[0, PROMPT_MAIN_TRUNCATE_LENGTH - PROMPT_MAIN_TRUNCATE_OMISSION.size] + PROMPT_MAIN_TRUNCATE_OMISSION
+      if str.size > PROMPT_MAIN_TRUNCATE_LENGTH
+        str = str[0, PROMPT_MAIN_TRUNCATE_LENGTH - PROMPT_MAIN_TRUNCATE_OMISSION.size] + PROMPT_MAIN_TRUNCATE_OMISSION
       end
+      str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
     end
 
     def format_prompt(format, ltype, indent, line_no) # :nodoc:
+      # @prompt_part_cache could be nil in unit tests
+      part_cache = @prompt_part_cache || {}
       format.gsub(/%([0-9]+)?([a-zA-Z%])/) do
         case $2
         when "N"
           @context.irb_name
         when "m"
-          main_str = @context.safe_method_call_on_main(:to_s) rescue "!#{$!.class}"
-          truncate_prompt_main(main_str)
+          part_cache[:m] ||= (
+            main_str = "#{@context.safe_method_call_on_main(:to_s)}" rescue "!#{$!.class}"
+            truncate_prompt_main(main_str)
+          )
         when "M"
-          main_str = @context.safe_method_call_on_main(:inspect) rescue "!#{$!.class}"
-          truncate_prompt_main(main_str)
+          part_cache[:M] ||= (
+            main_str = "#{@context.safe_method_call_on_main(:inspect)}" rescue "!#{$!.class}"
+            truncate_prompt_main(main_str)
+          )
         when "l"
           ltype
         when "i"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: irb
 version: !ruby/object:Gem::Version
-  version: 1.15.2
+  version: 1.17.0
 platform: ruby
 authors:
 - aycabta
 - Keiju ISHITSUKA
 bindir: exe
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: reline
   requirement: !ruby/object:Gem::Requirement
@@ -61,16 +75,20 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rdoc_options"
+- CONTRIBUTING.md
+- EXTEND_IRB.md
 - Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
+- doc/COMMAND_LINE_OPTIONS.md
+- doc/COMPARED_WITH_PRY.md
+- doc/Configurations.md
+- doc/EXTEND_IRB.md
+- doc/Index.md
 - doc/irb/irb-tools.rd.ja
 - doc/irb/irb.rd.ja
 - exe/irb
-- irb.gemspec
 - lib/irb.rb
 - lib/irb/cmd/nop.rb
 - lib/irb/color.rb
@@ -170,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Interactive Ruby command-line tool for REPL (Read Eval Print Loop).
 test_files: []

data/Rakefile

@@ -1,52 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-require "rdoc/task"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test" << "test/lib"
-  t.libs << "lib"
-  t.ruby_opts << "-rhelper"
-  t.test_files = FileList["test/irb/**/test_*.rb"]
-end
-
-# To make sure they have been correctly setup for Ruby CI.
-desc "Run each irb test file in isolation."
-task :test_in_isolation do
-  failed = false
-
-  FileList["test/irb/**/test_*.rb"].each do |test_file|
-    ENV["TEST"] = test_file
-    begin
-      Rake::Task["test"].execute
-    rescue
-      failed = true
-      msg = "Test '#{test_file}' failed when being executed in isolation. Please make sure 'rake test TEST=#{test_file}' passes."
-      separation_line = '=' * msg.length
-
-      puts <<~MSG
-        #{separation_line}
-        #{msg}
-        #{separation_line}
-      MSG
-    end
-  end
-
-  fail "Some tests failed when being executed in isolation" if failed
-end
-
-Rake::TestTask.new(:test_yamatanooroti) do |t|
-  t.libs << 'test' << "test/lib"
-  t.libs << 'lib'
-  #t.loader = :direct
-  t.ruby_opts << "-rhelper"
-  t.pattern = 'test/irb/yamatanooroti/test_*.rb'
-end
-
-task :default => :test
-
-RDoc::Task.new do |rdoc|
-  rdoc.title = "IRB Documentation"
-  rdoc.main = "Index.md"
-  rdoc.rdoc_dir = "_site"
-  rdoc.options.push("lib")
-end

data/bin/console

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require_relative "../lib/irb"
-
-IRB.start(__FILE__)

data/bin/setup

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install

data/irb.gemspec

@@ -1,48 +0,0 @@
-begin
-  require_relative "lib/irb/version"
-rescue LoadError
-  # for Ruby core repository
-  require_relative "version"
-end
-
-Gem::Specification.new do |spec|
-  spec.name          = "irb"
-  spec.version       = IRB::VERSION
-  spec.authors       = ["aycabta", "Keiju ISHITSUKA"]
-  spec.email         = ["aycabta@gmail.com", "keiju@ruby-lang.org"]
-
-  spec.summary       = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
-  spec.description   = %q{Interactive Ruby command-line tool for REPL (Read Eval Print Loop).}
-  spec.homepage      = "https://github.com/ruby/irb"
-  spec.licenses      = ["Ruby", "BSD-2-Clause"]
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["documentation_uri"] = "https://ruby.github.io/irb/"
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/releases"
-
-  spec.files         = [
-    "Gemfile",
-    "LICENSE.txt",
-    "README.md",
-    "Rakefile",
-    "bin/console",
-    "bin/setup",
-    "doc/irb/irb-tools.rd.ja",
-    "doc/irb/irb.rd.ja",
-    "exe/irb",
-    "irb.gemspec",
-    "man/irb.1",
-  ] + Dir.chdir(File.expand_path('..', __FILE__)) do
-    Dir.glob("lib/**/*").map {|f| f unless File.directory?(f) }.compact
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
-
-  spec.add_dependency "reline", ">= 0.4.2"
-  spec.add_dependency "rdoc", ">= 4.0.0"
-  spec.add_dependency "pp", ">= 0.6.0"
-end