irt 1.1.1

data/lib/irt/commands/core.rb

@@ -0,0 +1,52 @@
+module IRT
+  module Commands
+    module Core
+
+      def irt(obj=nil)
+        irt_mode = context.irt_mode
+        to_mode = case obj
+                  when nil
+                    :interactive
+                  when Binding
+                    :binding
+                  else
+                    :inspect
+                  end
+        raise IRT::SessionModeError, "You cannot pass binding in #{irt_mode} mode" \
+          if to_mode == :binding && (irt_mode == :binding || caller[0].match(/^\(/))
+        raise IRT::SessionModeError, "You cannot open another interactive session in #{irt_mode} mode" \
+          if to_mode == :interactive && irt_mode != :file
+        IRT::Session.enter to_mode, obj
+      end
+      alias_method :open_session, :irt # legacy method
+
+      %w[p y pp ap].each do |m|
+        define_method(m) do |*args|
+          args = [context.last_value] if args.empty?
+          super *args
+        end
+      end
+
+      def vdiff(a,b)
+        puts IRT::Differ.new(a,b, :value, {:a_marker => 'a',
+                                           :b_marker => 'b',
+                                           :a_label => '',
+                                           :b_label => ''}).output
+      end
+      alias_method :vd, :vdiff
+
+      # rerun the same shell command
+      def rerun
+        ensure_session
+        IRB.irb_at_exit
+        str = "Rerunning: `#{ENV['IRT_COMMAND']}`"
+        puts
+        puts " #{str} ".error_color.bold.reversed.or("*** #{str} ***")
+        puts
+        exec ENV["IRT_COMMAND"]
+      end
+      alias_method :rr, :rerun
+
+    end
+  end
+end

data/lib/irt/commands/help.rb

@@ -0,0 +1,111 @@
+module IRT
+  module Commands
+    module Help
+
+      def irt_help
+        ensure_session
+        puts %(
+#{" NOTICE ".log_color.reversed.bold}
+- The #{"Commands".interactive_color.bold} are methods generally available in any IRT session
+- The #{"Directives".file_color.bold} are methods available in any file but not in IRT sessions
+- The #{"Extensions".log_color.bold} are methods available anywhere
+
+#{" Inspecting Commands ".interactive_color.reversed.bold}
+    irt object              Opens an inspecting session into object
+    vdiff|vd obj_a, obj_b   Prints the visual diff of the yaml dump of 2 objects
+    cat args                Similar to system cat
+    ls args                 Similar to system ls
+
+#{" Log Commands ".interactive_color.reversed.bold}
+    log|l [limit]           Prints limit or 'tail_size' lines of the virtual log
+    full_log|ll             Prints all the lines in the virtual log
+    print_lines|pl          Prints the last lines of the current session
+                            without numbers (for easy copying)
+    print_all_lines|pll     Like print_line but prints all the sessions lines
+
+#{" In Place Editing Commands ".interactive_color.reversed.bold}
+    (<editor> can be 'vi', 'nano|nn', 'edit|ed')
+    <editor>                Uses <editor> to open the current evalued file at
+                            the current evalued line for in place edit
+    <editor> file[, line]   Uses <editor> to open file [at line] for in place
+                            editing
+    <editor> hash           Uses <editor> to open hash[:file] at the hash[:line]
+    <editor> array          Uses <editor> to open array[0] at the array[1] line
+    <editor> traceline      Uses <editor> to open the file at line in traceline
+                            e.g.: nn "from /path/to/file.rb:34:in 'any_method'"
+                                  nn "a_gem (1.2.3) lib/file.rb:13:in 'a_meth'"
+    <editor> n              Uses <editor> to open the backtraced file [n] at
+                            the backtraced line
+
+#{" Copy-Edit Commands ".interactive_color.reversed.bold + " (use copy_to_clipboard_command)".interactive_color.bold}
+    copy_lines|cl           Copy the last session lines
+    copy_all_lines|cll      Copy the lines of all the sessions
+    cnano|cnn               Like nano, but copy the last session lines first
+    cvi                     Like vi, but copy the last session lines first
+    cedit|ced               Like edit, but copy the last session lines first
+
+#{" Test Commands ".interactive_color.reversed.bold + " (only available in interactive sessions)".interactive_color.bold}
+    add_desc|dd desc        Adds a description for the test in the log
+    add_test|tt             Adds a test in the log, checking the last value (_)
+                            by automatically choosing the :_eql?, or :_yaml_eql?
+                            method, depending on the type of the last value (_)
+    add_test|tt desc        Like add_test but adds a 'desc' directive first'
+    save_as|sa path         Saves the current irt file as path and runs it
+
+#{" FileUtils Commands ".interactive_color.reversed.bold}
+    All the FileUtils methods are availabe as IRT Commands
+    (e.g. pwd, touch, mkdir, mv, cp, rm, rm_rf, compare_files, ...)
+
+#{" Enhanced Commands ".interactive_color.reversed.bold}
+    p, pp, ap, y            When invoked with no arguments print the last_value
+                            (e.g. just type 'y' instead 'y _')
+
+#{" Documentation Commands ".interactive_color.reversed.bold}
+    ri to_search            Search the ri doc for to_search (no quotes needed)
+    ri obj.any_method       Search the method.owner ri doc for of any_method
+                            (no quotes needed, and completion available)
+                            e.g.: ri "".eql?  #=> ri doc for String#eql?
+                                  ri [].eql?  #=> ri doc for Array#eql?
+    ri n                    Search the ri doc for the method n in a multiple
+                            choices list
+
+#{" Misc Commands ".interactive_color.reversed.bold}
+    x|q                     Aliases for exit (from the current session)
+    xx|qq                   Aliases for abort (abort the irt process)
+    status|ss               Prints the session status line
+    rerun|rr                Reruns the same file
+    irt_help|hh             Shows this screen
+
+#{" Session Directives ".file_color.reversed.bold}
+    irt                     Opens an interactive session which retains the
+                            current variables and the last value (_)
+    irt binding             Opens a binding session at the line of the call
+
+#{" Test Directives ".file_color.reversed.bold + " (auto added by the Test Commands)".file_color.bold}
+    desc description        Adds a description to the next test
+    _eql? val               Runs a test checking _ == val
+    _yaml_eql? yaml_dump    Runs a test checking y _ == yaml_dump
+
+#{" Helper Directives ".file_color.reversed.bold}
+    insert_file file        Evaluates file as it were inserted at that line
+    eval_file               Alias for eval_file
+    irt_at_exit block       Ensures execution of block at exit (useful for
+                            cleanup of test env)
+
+#{" Extensions ".log_color.reversed.bold}
+    Kernel#capture block    Executes block and returns a string containing the
+                            captured stdout
+    Object#own_methods      Returns the methods implemented by the receiver
+                            itself (not inherited)
+    Method#location         When possible, it returns file and line where the
+                            method is defined. It is uitable to be passed to the
+                            in place editing commands.
+    Method#info             Returns useful info about the method. It is suitable
+                            to be passed to the in place editing commands.
+)
+      end
+      alias_method :hh, :irt_help
+
+    end
+  end
+end

data/lib/irt/commands/log.rb

@@ -0,0 +1,52 @@
+module IRT
+  module Commands
+    module Log
+
+      def log(limit=nil)
+        ensure_session
+        IRT.log.print limit || IRT.log.tail_size
+        IRT.log.print_status
+      end
+      alias_method :l, :log
+
+      def full_log
+        ensure_session
+        IRT.log.print
+        IRT.log.print_status
+      end
+      alias_method :ll, :full_log
+
+      def status
+        ensure_session
+        IRT.log.print_status
+      end
+      alias_method :ss, :status
+
+      def print_lines
+        ensure_session
+        lines_str = IRT.log.last.lines_str
+        return if lines_str.empty?
+        puts
+        puts lines_str
+        puts
+      end
+      alias_method :pl, :print_lines
+
+      def print_all_lines
+        ensure_session
+        lines = []
+        IRT.log.reject{|h| h.class == IRT::Log::FileHunk }.each do |h|
+          ls = h.lines_str
+          lines << ls unless ls.empty?
+        end
+        unless lines.empty?
+          puts
+          puts lines.join("\n\n")
+          puts
+        end
+      end
+      alias_method :pll, :print_all_lines
+
+    end
+  end
+end

data/lib/irt/commands/ri.rb

@@ -0,0 +1,59 @@
+module IRT
+  module Commands
+    module Ri
+
+      @@choices_map = {}
+
+      def self.reset_choices_map
+        @@choices_map = {}
+      end
+
+      def ri(arg)
+        ensure_session
+        raise IRT::NotImplementedError, "No available ri_command_format for this system." unless IRT.ri_command_format
+        case
+        when arg.nil?, arg.empty?
+          return puts('nil')
+        when arg.match(/^\d+$/)
+          if @@choices_map.key?(arg)
+            to_search = @@choices_map[arg]
+          else
+            raise IndexError, "No such method index -- [#{arg}]"
+          end
+        else
+          segm = arg.split('.')
+          to_search = segm.pop
+          unless segm.empty?
+            begin
+              meth = eval "#{segm.join('.')}.method(:#{to_search})", IRB.CurrentContext.workspace.binding
+              to_search = "#{meth.owner.name}##{meth.name}"
+            rescue
+              raise NoMethodError, %(undefined method "#{to_search}" for "#{segm.join('.')}")
+            end
+          end
+        end
+        process_ri to_search
+      end
+
+    private
+
+      def process_ri(to_search)
+        ri = `#{sprintf(IRT.ri_command_format, to_search)}`
+         if m = ri.match(/^(-+.*Multiple choices:.*\n\n)(.+)/m)
+           output, methods = m.captures
+           IRT::Commands::Ri.reset_choices_map
+           fmt = "%+7s  %s\n"
+           methods.gsub(/\s+/, '').split(',').each_with_index do |m, i|
+             @@choices_map[(i+1).to_s] = m
+             output << sprintf( fmt, "#{i+1}", m )
+           end
+           output << "\n"
+         else
+           output = ri
+         end
+        puts output
+      end
+
+    end
+  end
+end

data/lib/irt/commands/system.rb

@@ -0,0 +1,102 @@
+module IRT
+  module Commands
+    module System
+
+      def cat(*args)
+        ensure_session
+        return system "cat #{context.file_line_pointers.first}" if args.empty?
+        system "cat #{args * ' '}"
+      end
+
+      def ls(*args)
+        ensure_session
+        args = %w[.] if args.empty?
+        system "ls #{args * ' '}"
+      end
+
+      def copy_lines
+        ensure_session
+        copy_to_clipboard :print_lines
+      end
+      alias_method :cl, :copy_lines
+
+      def copy_all_lines
+        ensure_session
+        copy_to_clipboard :print_all_lines
+      end
+      alias_method :cll, :copy_all_lines
+
+      %w[vi nano edit].each do |n|
+        eval <<-EOE, binding, __FILE__, __LINE__+1
+          def #{n}(*args)
+            ensure_session
+            run_editor(:#{n}, *args)
+          end
+        EOE
+        eval <<-EOE, binding, __FILE__, __LINE__+1
+          def c#{n}(*args)
+            ensure_session
+            copy_lines
+            #{n} *args
+          end
+        EOE
+      end
+      alias_method :nn, :nano
+      alias_method :ed, :edit
+      alias_method :cnn, :cnano
+      alias_method :ced, :cedit
+
+    private
+
+      def run_editor(cmd, *args)
+        cmd_format = IRT.send("#{cmd}_command_format".to_sym)
+        raise IRT::NotImplementedError, "#{cmd}_command_format missing" unless cmd_format
+        arg = args.first if args.size == 1
+        file, line = case
+                     when args.empty?
+                       context.file_line_pointers
+                     when arg.is_a?(Integer)
+                       if context.backtrace_map.key?(arg)
+                         context.backtrace_map[arg]
+                       else
+                         raise IRT::IndexError, "No such backtrace index -- [#{arg}]"
+                         return
+                       end
+                     when arg.is_a?(Array)
+                       arg
+                     when arg.is_a?(Hash)
+                       [arg[:file], arg[:line]]
+                     when arg.is_a?(String) && m = arg.match(/(?:([\w]+) \(([\w.]+)\))? ?([+\w\/\n.-]+):(\d+)/m)
+                        gem, vers, f, l = m.captures
+                        if gem
+                          Gem.path.each do |p|
+                            gp = File.join(p, 'gems', "#{gem}-#{vers}", f)
+                            break [gp, l] if File.exist?(gp)
+                          end
+                        else
+                          [f.gsub("\n", ''), l]
+                        end
+                     else
+                       args
+                     end
+        system sprintf(cmd_format, file, line)
+      end
+
+      def copy_to_clipboard(cmd)
+        raise IRT::NotImplementedError, "No known copy_to_clipboard_command for this system." \
+          unless IRT.copy_to_clipboard_command
+        lines_str = capture { send(cmd) }
+        return unless lines_str.match(/\w/m)
+        begin
+          IO.popen(IRT.copy_to_clipboard_command, 'w') do |io|
+            io.puts lines_str.strip
+          end
+          print lines_str
+        rescue Exception
+          raise IRT::NotImplementedError, "This system does not appear to support the \`#{IRT.copy_to_clipboard_command}\` command."
+        end
+      end
+
+    end
+  end
+end

data/lib/irt/commands/test.rb

@@ -0,0 +1,60 @@
+module IRT
+  module Commands
+    module Test
+
+      extend self
+
+      def add_desc(description)
+        mode = context.irt_mode
+        raise IRT::SessionModeError, "You cannot add a test description in #{mode} mode." unless mode == :interactive
+        desc_str = %(desc "#{description}")
+        context.current_line = desc_str
+        puts
+        puts desc_str.interactive_color
+        puts
+      end
+      alias_method :dd, :add_desc
+
+      def add_test(description='')
+        mode = context.irt_mode
+        raise IRT::SessionModeError, "You cannot add a test in #{mode} mode." unless mode == :interactive
+        last_value = context.last_value
+        begin
+          evaled = context.workspace.evaluate(self, last_value.inspect)
+        rescue Exception
+        end
+        # the eval of the last_value.inspect == the last_value
+        test_str = if evaled == last_value
+                     # same as _? but easier to read for multiline strings
+                     if last_value.is_a?(String) && last_value.match(/\n/)
+                       str = last_value.split("\n").map{|l| l.inspect.sub(/^"(.*)"$/,'\1') }.join("\n")
+                       last_value.match(/\n$/) ? "_eql? <<EOS\n#{str}\nEOS" : "_eql? %(#{str})"
+                     else
+                       "_eql?( #{last_value.inspect} )"
+                     end
+                   else # need YAML
+                     "_yaml_eql? %(#{IRT.yaml_dump(last_value)})"
+                   end
+        desc_str = description.empty? ? '' : %(desc "#{description}"\n)
+        str = desc_str + test_str
+        context.current_line = str
+        puts
+        puts str.interactive_color
+        puts
+      end
+      alias_method :tt, :add_test
+
+      def save_as(path)
+        path = File.expand_path(path)
+        if File.exists?(path)
+          return if IRT.prompter.no? %(Do you want to overwrite "#{path}"?), :hint => '[y|<enter=n]', :default => 'n'
+        end
+        cp IRT.irt_file, path
+        ENV['IRT_COMMAND'] = ENV['IRT_COMMAND'].sub(/#{Regexp.quote(IRT.irt_file)}/, path)
+        rerun
+      end
+      alias_method :sa, :save_as
+
+    end
+  end
+end

data/lib/irt/differ.rb

@@ -0,0 +1,87 @@
+require 'differ'
+module IRT
+  class Differ
+
+    def initialize(a, b, kind=:value, options={})
+      if kind == :value
+        a = IRT.yaml_dump a
+        b = IRT.yaml_dump b
+      end
+      @a = a
+      @b = b
+      @options = { :a_label  => 'saved',
+                   :b_label  => 'actual',
+                   :a_marker => '~',
+                   :b_marker => '!' }.merge options
+      IRT::Differ::Format.options = @options
+      @diff = ::Differ.diff_by_line(@b, @a)
+    end
+
+    def output
+      out = "\n"
+      out << " = same ".reversed.bold.or('***** diff ')
+      out << " #{@options[:a_marker]} #{@options[:a_label]} ".diff_a_color.reversed.bold.
+          or(" (#{@options[:a_marker]} #{@options[:a_label]}) ")
+      out << " #{@options[:b_marker]} #{@options[:b_label]} ".diff_b_color.reversed.bold.
+          or(" (#{@options[:b_marker]} #{@options[:b_label]}) ")
+      out << "\n"
+      diff = @diff.format_as(IRT::Differ::Format)
+      out << diff.sub(/^\n/,'')
+      out << "\n"
+      out
+    end
+
+    module Format
+      extend self
+
+      attr_accessor :options
+
+      def format(change)
+       (change.is_a?(String) && as_same(change)) ||
+       (change.change? && as_change(change)) ||
+       (change.delete? && as_delete(change)) ||
+       (change.insert? && as_insert(change)) ||
+       ''
+      end
+
+      private
+
+      def process(string, mark='=', color=:null, bold=:null)
+        string.sub(/^\n/,'').split("\n").map do |s|
+          " #{mark} ".send(color).send(bold).reversed.or(" #{mark} ") + ' ' + s.send(color)
+        end.join("\n") + "\n"
+      end
+
+      def as_same(string)
+        process string
+      end
+
+      def as_insert(change)
+        process(change.insert(), options[:b_marker], :diff_b_color, :bold)
+      end
+
+      def as_delete(change)
+        process(change.delete(), options[:a_marker], :diff_a_color, :bold)
+      end
+
+      def as_change(change)
+        as_delete(change) << as_insert(change)
+      end
+    end
+
+  end
+end
+
+module Differ
+  class Diff
+
+    def format_as(f)
+      f = Differ.format_for(f)
+      @raw.inject('') do |sum, part|
+        part = f.format(part)
+        sum << part
+      end
+    end
+
+  end
+end