irt 1.1.1

data/lib/irt/directives.rb

@@ -0,0 +1,28 @@
+require 'irt/directives/test'
+
+module IRT
+  module Directives
+
+    extend self
+    extend Test
+
+    # Evaluate a file as it were inserted at that line
+    # a relative file_path is considered to be relative to the including file
+    # i.e. '../file_in_the_same_dir.irt'
+    def eval_file(file_path)
+      parent_context = IRB.CurrentContext
+      new_io = IRB::FileInputMethod.new(File.expand_path(file_path, parent_context.io.file_name))
+      new_irb = IRB::Irb.new(parent_context.workspace, new_io)
+      new_irb.context.irb_name = File.basename(new_io.file_name)
+      new_irb.context.irb_path = new_io.file_name
+      IRT::Session.eval_input(new_irb.context, :file)
+      IRT::Session.exit
+    end
+    alias_method :insert_file, :eval_file
+
+    def irt_at_exit(&block)
+      IRB.conf[:AT_EXIT] << proc(&block)
+    end
+
+  end
+end

data/lib/irt/directives/test.rb

@@ -0,0 +1,84 @@
+module IRT
+  module Directives
+    module Test
+      extend self
+
+      @@tests = 0
+      @@oks = 0
+      @@diffs = 0
+      @@errors = 0
+      @@last_desc = nil
+
+      def desc(description)
+        @@last_desc = description
+      end
+
+      def _eql?(saved)
+        actual = IRB.CurrentContext.last_value
+        run_test(saved, actual, :value)
+      end
+      alias_method :test_value_eql?, :_eql?
+      alias_method :last_value_eql?, :_eql?
+
+      def _yaml_eql?(saved)
+        actual = IRT.yaml_dump(IRB.CurrentContext.last_value)
+        run_test(saved, actual, :yaml)
+      end
+      alias_method :last_yaml_eql?, :_yaml_eql?
+      alias_method :test_yaml_eql?, :_yaml_eql?
+
+      def test_summary #:nodoc:
+        return unless @@tests > 0
+        if @@tests == @@oks
+          str = @@tests == 1 ? " The TEST is OK! " : " All #{@@tests} TESTs are OK! "
+          puts str.ok_color.bold
+        else
+          puts "#{@@tests} TEST#{'s' unless @@tests == 1}: ".bold +
+               "#{@@oks} OK#{'s' unless @@oks == 1}, ".ok_color.bold +
+               "#{@@diffs} DIFF#{'s' unless @@diffs == 1}, ".diff_color.bold +
+               "#{@@errors} ERROR#{'s' unless @@errors == 1}.".error_color.bold
+        end
+    end
+
+    def load_helper_files
+      return unless IRT.autoload_helper_files
+      irt_file_path = Pathname.new($0).realpath
+      container_path = Pathname.getwd.parent
+      down_path = irt_file_path.relative_path_from container_path
+      down_path.dirname.descend do |p|
+       helper_path = container_path.join(p, 'irt_helper.rb')
+       begin
+         require helper_path
+       rescue LoadError
+       end
+      end
+    end
+
+  private
+
+      def run_test(saved, actual, kind)
+        context = IRB.CurrentContext
+        tno = '%3d' % @@tests += 1
+        d = @@last_desc || 'Test'
+        @@last_desc = nil
+        begin
+          if saved == actual
+            @@oks += 1
+            puts "#{tno}. OK!".ok_color.bold + " #{d}".ok_color
+          else
+            @@diffs += 1
+            puts "#{tno}. DIFFS!".diff_color.bold + %( #{d}\n     ).diff_color +
+              %( at #{context.irb_path}: #{context.last_line_no} ).file_color.reversed.bold
+            puts IRT.differ.new(saved, actual, kind).output
+            IRT::Session.enter(:interactive) if IRT.irt_on_diffs
+          end
+        rescue Exception
+          @@errors += 1
+          puts "#{tno}. ERROR! ".error_color.bold + d.error_color
+          raise
+        end
+      end
+
+    end
+  end
+end

data/lib/irt/extensions/irb.rb

@@ -0,0 +1,45 @@
+require 'irb'
+require 'irt/extensions/irb/context'
+require 'irt/extensions/irb/commands'
+
+module IRB #:nodoc:
+
+  class << self
+    alias_method :irb_init_config, :init_config
+    alias_method :irb_setup, :setup
+  end
+
+  def IRB.setup(ap_path=nil)
+    irb_setup(ap_path)
+    IRT.init_files
+  end
+
+  def IRB.init_config(ap_path)
+    irb_init_config(ap_path)
+
+    @CONF[:AP_NAME] = 'irt'
+    @CONF[:PROMPT][:IRT] = { :PROMPT_I => "%02n >> ",
+                             :PROMPT_S => '   "> ',
+                             :PROMPT_C => "%02n ?> ",
+                             :PROMPT_N => "%02n -> ",
+                             :RETURN   => "   => %s\n" }
+    @CONF[:PROMPT_MODE] = :IRT
+    @CONF[:ECHO] = false
+    @CONF[:VERBOSE] = false
+    @CONF[:SAVE_HISTORY] = 100
+    @CONF[:HISTORY_FILE] = File.expand_path '~/.irt-history'
+    @CONF[:AT_EXIT] ||= []
+    @CONF[:AT_EXIT] << proc{ IRT::Session.enter(:interactive) if IRB.CurrentContext.irt_mode == :file } if !!ENV['IRT_INTERACTIVE_EOF']
+    @CONF[:AT_EXIT] << proc{ IRT::Directives.test_summary }
+    @CONF[:AT_EXIT] << proc{ print "\e[0m" if Colorer.color? } # reset colors
+    @CONF[:RC_NAME_GENERATOR] = proc {|rc| File.expand_path '~/.irtrc' }
+
+    IRT.init
+  end
+
+  def IRB.irb_exit(irb, ret)
+    IRT::Session.exit
+    throw :IRB_EXIT, ret
+  end
+
+end

data/lib/irt/extensions/irb/commands.rb

@@ -0,0 +1,42 @@
+require 'irt/commands/log'
+require 'irt/commands/test'
+require 'irt/commands/system'
+require 'irt/commands/core'
+require 'irt/commands/help'
+require 'irt/commands/ri'
+require 'fileutils'
+
+module IRB
+  module ExtendCommandBundle #:nodoc:
+
+    include IRT::Commands::Log
+    include IRT::Commands::Test
+    include IRT::Commands::System
+    include IRT::Commands::Core
+    include IRT::Commands::Help
+    include IRT::Commands::Ri
+    include FileUtils
+
+    alias_method :x, :irb_exit
+    alias_method :q, :irb_exit
+    alias_method :xx, :abort
+    alias_method :qq, :abort
+    alias_method :irb, :irt
+
+    def method_missing(method, *args, &block)
+      IRB.conf[:MAIN_CONTEXT] && IRB.conf[:MAIN_CONTEXT].irt_mode == :file && IRT::Directives.respond_to?(method) ?
+        IRT::Directives.send(method, *args, &block) :
+        super
+    end
+
+  private
+
+    def ensure_session
+      if context.irt_mode == :file
+        m = caller[0].match(/`(\w*)'$/).captures[0]
+        raise IRT::SessionModeError, "You cannot use the :#{m} method in #{context.irt_mode} mode."
+      end
+    end
+
+  end
+end

data/lib/irt/extensions/irb/context.rb

@@ -0,0 +1,147 @@
+require 'irb/context'
+
+module IRB
+  class Context #:nodoc:
+
+    attr_accessor :parent_context, :current_line, :binding_file, :binding_line_no, :backtrace_map
+    attr_reader :current_line_no, :last_line_no
+    attr_writer :irt_mode
+
+    def file_line_pointers
+      file = line = nil
+      c = self
+      until file
+        case c.irt_mode
+        when :binding
+          file = c.binding_file
+          line = c.binding_line_no
+        when :file
+          file = c.irb_path
+          line = c.last_line_no
+        end
+        c = c.parent_context
+      end
+      [file, line]
+    end
+
+    def irt_mode
+      @irt_mode ||= :file
+    end
+
+    alias_method :evaluate_and_set_last_value, :evaluate
+    def evaluate(line, line_no)
+      @current_line = line
+      @current_line_no = line_no + line.chomp.count("\n")
+      if @exception_raised
+        IRT::Session.enter(:interactive) if irt_mode == :file
+        @exception_raised = false
+      end
+      log_file_line(line_no) if irt_mode == :file
+      begin
+        # ri arg to string
+        if m = line.match(/^(\s*ri[ \t]+)(.+)$/)
+          pre, to_search = m.captures
+          line = "#{pre}#{to_search.inspect}" unless to_search.match(/^('|").+\1$/)
+        else
+          IRT::Commands::Ri.reset_choices_map
+        end
+        # skip setting last_value for non_setting_commands
+        if line =~ /^\s*(#{IRT.log.non_setting_commands * '|'})\b/
+          self.echo = false
+          res = @workspace.evaluate(self, line, irb_path, line_no)
+          if line =~ /^\s*(#{IRT.log.ignored_echo_commands * '|'})\b/
+            output_ignored_echo_value(res)
+          end
+        else
+          self.echo = irt_mode == :file ? false : true
+          evaluate_and_set_last_value(line, line_no)
+        end
+      rescue Exception => e
+        @exception_raised = true
+        process_exception(e)
+        print "\e[31m" if Colorer.color?
+        raise
+      else
+        log_session_line(line, line_no) unless irt_mode == :file
+      end
+    end
+
+    %w[prompt_i prompt_s prompt_c prompt_n].each do |m|
+      define_method(m) do
+        pr = instance_variable_get("@#{m}")
+        col_pr = pr.send "#{irt_mode}_color"
+        # workaround for Readline bug see http://www.ruby-forum.com/topic/213807
+        if IRT.fix_readline_prompt
+          col_pr.gsub(/^(.*)#{pr}(.*)$/, "\001\\1\002#{pr}\001\\2\002")
+        else
+          col_pr
+        end
+      end
+    end
+
+    def return_format(color=:actual_color, ignored=false)
+      ret = ignored ? @return_format.sub(/=/,'#') : @return_format
+      ret.send color
+    end
+
+private
+
+    def process_exception(e)
+      return if IRT.debug
+      bktr = e.backtrace.reject {|m| File.expand_path(m).match(/^#{IRT.lib_path}/) || workspace.filter_backtrace(m).nil? }
+      e.set_backtrace( e.class.name.match(/^IRT::/) ? bktr : map_backtrace(bktr) )
+    end
+
+    def map_backtrace(bktr)
+      @backtrace_map = {}
+      mapped_bktr = []
+      reverted_error_colors = 'xxx'.error_color.match(/^(.*)xxx(.*)$/).captures.reverse
+      index_format = sprintf '%s%%s%s', *reverted_error_colors
+      bktr.each_with_index do |m, i|
+        unless i + 1 > back_trace_limit || m.match(/^\(.*\)/)
+          @backtrace_map[i] = m.split(':')[0..1]
+          index = sprintf index_format, " [#{i}]"
+        end
+        mapped_bktr << "#{m}#{index}"
+      end
+      mapped_bktr
+    end
+
+    def log_file_line(line_no)
+      log_lines(@current_line, line_no)
+    end
+
+    def log_session_line(line, line_no)
+      # @current_line might get changed by the IRT::Commands::Test methods,
+      # while the line arg is the original command
+      segments = line.chomp.split("\n", -1)
+      last_segment = segments.pop
+      if last_segment.match(/^[ \t]*(#{IRT::Commands::Test.own_methods * '|'})\b/)
+        log_lines segments.map{|s| "#{s}\n"}.join, line_no
+        @last_line_no = @last_line_no ? @last_line_no + 1 : line_no
+        @current_line.each_line do |l|
+          IRT.log.add_line l, @last_line_no
+        end
+      else
+        log_lines(@current_line, line_no)
+      end
+    end
+
+    def log_lines(str, line_no)
+      i = -1
+      str.each_line do |l|
+        @last_line_no = line_no + i+=1
+        IRT.log.add_line l, @last_line_no
+      end
+    end
+
+     def output_ignored_echo_value(value)
+       if inspect?
+        printf return_format(:ignored_color,false), value.inspect
+      else
+        printf return_format(:ignored_color,false), value
+      end
+    end
+
+  end
+end

data/lib/irt/extensions/kernel.rb

@@ -0,0 +1,18 @@
+require 'stringio'
+module Kernel
+
+  def capture
+    out = StringIO.new
+    $stdout = out
+    yield
+    return out.string
+  ensure
+    $stdout = STDOUT
+  end
+
+  def irt(bind)
+    raise IRT::ArgumentTypeError, "You must pass binding instead of #{bind.class.name} object" unless bind.is_a?(Binding)
+    IRT::Session.enter :binding, bind
+  end
+
+end

data/lib/irt/extensions/method.rb

@@ -0,0 +1,36 @@
+class Method
+
+  def location
+    f = l = nil
+    n = case
+        when arity >= 0
+          arity
+        when arity == -1
+          0
+        when arity < -1
+          arity.abs - 1
+        end
+    arr = Array.new(n)
+    set_trace_func proc{ |event, file, line, meth_name, binding, classname|
+      if event.eql?('call') && name.match(meth_name.to_s)
+        f = file
+        l = line
+        set_trace_func nil
+        throw :method_located
+      end
+    }
+    catch(:method_located) { call *arr }
+    set_trace_func nil
+    [f,l]
+  end
+
+  def info
+    file, line = location
+    { :name       => name,
+      :class_name => owner.name,
+      :file       => file,
+      :line       => line,
+      :arity      => arity }
+  end
+
+end

data/lib/irt/extensions/object.rb

@@ -0,0 +1,7 @@
+class Object
+
+  def own_methods
+    methods - self.class.methods
+  end
+
+end

data/lib/irt/hunks.rb

@@ -0,0 +1,111 @@
+module IRT
+  class Log
+
+    class Hunk < Array
+
+      attr_reader :header, :color
+
+      def initialize(header)
+        @header = header
+      end
+
+      def add_line(content, line_no)
+        self << [content.chomp, line_no]
+      end
+
+      def render(wanted=nil)
+        return unless size > 0
+        Log.print_border
+        render_header
+        wanted ||= size
+        last(wanted).each do |content, line_no|
+          Log.print_border
+          render_line(content, line_no)
+        end
+      end
+
+      def lines_str
+        map{|content, line_no| content }.join("\n")
+      end
+
+      def last_line_no
+        last && last[1]
+      end
+
+      def header_name
+        @header
+      end
+
+      def render_header
+        puts "     #{header_name}     ".send(color).bold.reversed.or("***** #{header_name} *****")
+      end
+
+      def render_line(content, line_no)
+        lcontent = content.send(color)
+        lno = ('%3d ' % line_no).send(color).reversed
+        puts "#{lno} #{lcontent}"
+      end
+
+      def inspect
+        %(<#{self.class.name} #{header_name}>)
+      end
+
+    end
+
+
+    class FileHunk < Hunk
+
+      def initialize(header=nil)
+        @color = :file_color
+        @header = header || IRB.CurrentContext.irb_path
+      end
+
+      def header_name
+        File.basename(@header)
+      end
+
+    end
+
+
+    class InteractiveHunk < Hunk
+
+      def initialize
+        @color = :interactive_color
+        @header = IRB.CurrentContext.irb_name
+      end
+
+      def add_line(content, line_no)
+        ignored = IRT.log.ignored_commands + %w[_]
+        return if content.match(/^\s*(#{ignored * '|'})\b/)
+        super
+      end
+
+    end
+
+
+    class InspectHunk < InteractiveHunk
+
+      def initialize
+        super
+        @color = :inspect_color
+      end
+
+      def add_line(content, line_no)
+      end
+
+    end
+
+    class BindingHunk < InteractiveHunk
+
+      def initialize
+        super
+        @color = :binding_color
+      end
+
+      def add_line(content, line_no)
+      end
+
+    end
+
+  end
+end