iruby 0.2.1 → 0.2.2

data/examples/display.ipynb

@@ -113,7 +113,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Ruby",
+   "display_name": "Ruby 2.1.2",
    "language": "ruby",
    "name": "ruby"
   },

data/examples/history.ipynb

@@ -0,0 +1,171 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ":out1"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    ":out1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ":out2"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    ":out2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       ":out3"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    ":out3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      ":out1\n",
+      ":out2\n",
+      ":out3\n",
+      ":out1\n",
+      ":out2\n",
+      ":out3\n",
+      ":out1\n",
+      ":out2\n",
+      ":out3\n",
+      ":out1\n",
+      ":out2\n",
+      ":out3\n",
+      ":out1\n",
+      ":out2\n",
+      ":out3\n",
+      "out1\n",
+      "out2\n",
+      "out3\n",
+      "out1\n",
+      "out2\n",
+      "out3\n",
+      "out1\n",
+      "out2\n",
+      "out3\n",
+      "out1\n",
+      "out2\n",
+      "out3\n",
+      "out1\n",
+      "out2\n",
+      "out3\n"
+     ]
+    }
+   ],
+   "source": [
+    "puts _iii\n",
+    "puts _ii\n",
+    "puts _i\n",
+    "\n",
+    "puts _i1\n",
+    "puts _i2\n",
+    "puts _i3\n",
+    "\n",
+    "puts _ih[1]\n",
+    "puts _ih[2]\n",
+    "puts _ih[3]\n",
+    "\n",
+    "puts In[1]\n",
+    "puts In[2]\n",
+    "puts In[3]\n",
+    "\n",
+    "puts In[-3]\n",
+    "puts In[-2]\n",
+    "puts In[-1]\n",
+    "\n",
+    "puts ___\n",
+    "puts __\n",
+    "puts _\n",
+    "\n",
+    "puts _1\n",
+    "puts _2\n",
+    "puts _3\n",
+    "\n",
+    "puts _oh[1]\n",
+    "puts _oh[2]\n",
+    "puts _oh[3]\n",
+    "\n",
+    "puts Out[1]\n",
+    "puts Out[2]\n",
+    "puts Out[3]\n",
+    "\n",
+    "puts Out[-3]\n",
+    "puts Out[-2]\n",
+    "puts Out[-1]"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Ruby 2.1.2",
+   "language": "ruby",
+   "name": "ruby"
+  },
+  "language_info": {
+   "file_extension": "rb",
+   "mimetype": "text/ruby",
+   "name": "ruby",
+   "version": "2.1.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

data/examples/stdout.ipynb

@@ -86,7 +86,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Ruby",
+   "display_name": "Ruby 2.1.2",
    "language": "ruby",
    "name": "ruby"
   },

data/examples/table.ipynb

@@ -306,11 +306,50 @@
    "source": [
     "IRuby.display IRuby.table({a:1,b:2,c:[3,4]})"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table><tr><th><span style='color:red'>a</span></th><th>b</th><th>c</th></tr><tr><td>1</td><td>2</td><td>3</td></tr><tr><td></td><td></td><td><span style='color:red'>4</span></td></tr></table>"
+      ],
+      "text/plain": [
+       "\"<table><tr><th><span style='color:red'>a</span></th><th>b</th><th>c</th></tr><tr><td>1</td><td>2</td><td>3</td></tr><tr><td></td><td></td><td><span style='color:red'>4</span></td></tr></table>\""
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "class Red < String\n",
+    "    def to_html\n",
+    "        \"<span style='color:red'>#{self}</span>\"\n",
+    "    end\n",
+    "end\n",
+    "\n",
+    "IRuby.display IRuby.table({Red.new(\"a\") => 1, b:2, c: [3, Red.new(\"4\")]})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Ruby",
+   "display_name": "Ruby 2.1.2",
    "language": "ruby",
    "name": "ruby"
   },

data/lib/iruby/backend.rb

@@ -1,10 +1,45 @@
 module IRuby
+  In, Out = [nil], [nil]
+  ::In, ::Out = In, Out
+
+  module HistoryVariables
+    def eval(code, store_history)
+      b = TOPLEVEL_BINDING
+
+      b.local_variable_set(:_ih, In)  unless b.local_variable_defined?(:_ih)
+      b.local_variable_set(:_oh, Out) unless b.local_variable_defined?(:_oh)
+
+      out = super
+
+      # TODO Add IRuby.cache_size which controls the size of the Out array
+      # and sets the oldest entries and _<n> variables to nil.
+      if store_history
+        b.local_variable_set("_#{Out.size}", out)
+        b.local_variable_set("_i#{In.size}", code)
+
+        Out << out
+        In << code
+
+        b.local_variable_set(:___,  Out[-3])
+        b.local_variable_set(:__,   Out[-2])
+        b.local_variable_set(:_,    Out[-1])
+        b.local_variable_set(:_iii, In[-3])
+        b.local_variable_set(:_ii,  In[-2])
+        b.local_variable_set(:_i,   In[-1])
+      end
+
+      out
+    end
+  end
+
   class PlainBackend
+    prepend HistoryVariables
+
     def initialize
       Bond.start(debug: true)
     end
 
-    def eval(code)
+    def eval(code, store_history)
       TOPLEVEL_BINDING.eval(code)
     end
 
@@ -14,6 +49,8 @@ module IRuby
   end
 
   class PryBackend
+    prepend HistoryVariables
+
     def initialize
       require 'pry'
       Pry.pager = false # Don't use the pager
@@ -23,11 +60,10 @@ module IRuby
       raise 'Falling back to plain backend since your version of Pry is too old (the Pry instance doesn\'t support #eval). You may need to install the pry gem with --pre enabled.' unless @pry.respond_to?(:eval)
     end
 
-    def eval(code)
-      @pry.last_result = nil
+    def eval(code, store_history)
       raise SystemExit unless @pry.eval(code)
       raise @pry.last_exception if @pry.last_result_is_exception?
-      @pry.push_initial_binding unless @pry.current_binding
+      @pry.push_initial_binding unless @pry.current_binding # ensure that we have a binding
       @pry.last_result
     end
 

data/lib/iruby/comm.rb

@@ -5,9 +5,8 @@ module IRuby
     attr_writer :on_msg, :on_close
 
     class << self
-      def targets
-        @targets ||= {}
-      end
+      def target; @target ||= {} end
+      def comm;   @comm   ||= {} end
     end
 
     def initialize(target_name, comm_id = SecureRandom.uuid)
@@ -15,30 +14,17 @@ module IRuby
     end
 
     def open(**data)
-      content = {
-        comm_id: @comm_id,
-        data: data,
-        target_name: @target_name
-      }
-      Kernel.instance.session.send(:publish, 'comm_open', content)
-      Kernel.instance.comms[@comm_id] = self
+      Kernel.instance.session.send(:publish, :comm_open, comm_id: @comm_id, data: data, target_name: @target_name)
+      Comm.comm[@comm_id] = self
     end
 
     def send(**data)
-      content = {
-        comm_id: @comm_id,
-        data: data
-      }
-      Kernel.instance.session.send(:publish, 'comm_msg', content)
+      Kernel.instance.session.send(:publish, :comm_msg, comm_id: @comm_id, data: data)
     end
 
     def close(**data)
-      content = {
-        comm_id: @comm_id,
-        data: data
-      }
-      Kernel.instance.session.send(:publish, 'comm_close', content)
-      Kernel.instance.comms.delete(@comm_id)
+      Kernel.instance.session.send(:publish, :comm_close, comm_id: @comm_id, data: data)
+      Comm.comm.delete(@comm_id)
     end
 
     def on_msg(&b)
@@ -49,12 +35,12 @@ module IRuby
       @on_close = b
     end
 
-    def comm_msg(msg)
-      @on_msg.call(msg) if @on_msg
+    def handle_msg(data)
+      @on_msg.call(data) if @on_msg
     end
 
-    def comm_close
-      @on_close.call if @on_close
+    def handle_close(data)
+      @on_close.call(data) if @on_close
     end
   end
 end

data/lib/iruby/command.rb

@@ -18,7 +18,7 @@ module IRuby
       case @args.first
       when 'version', '-v', '--version'
         require 'iruby/version'
-        puts IRuby::VERSION
+        puts "IRuby #{IRuby::VERSION}, Ruby #{RUBY_VERSION}"
       when 'help', '-h', '--help'
         print_help
       when 'register'
@@ -103,7 +103,7 @@ Try `ipython help` for more information.
       FileUtils.mkpath(@kernel_dir)
       File.write(@kernel_file, %{{
   "argv":         [ "#{File.expand_path $0}", "kernel", "{connection_file}" ],
-  "display_name": "Ruby",
+  "display_name": "Ruby #{RUBY_VERSION}",
   "language":     "ruby"
 }
 })

data/lib/iruby/formatter.rb

@@ -92,8 +92,8 @@ module IRuby
       table = '<table>'
 
       if header1 && options[:header] != false
-        table << '<tr>' << header1.map {|k| "<th>#{k}</th>" }.join
-        table << "<th>&#8230;</th>" << header2.map {|k| "<th>#{k}</th>" }.join if keys2
+        table << '<tr>' << header1.map {|k| "<th>#{cell k}</th>" }.join
+        table << "<th>&#8230;</th>" << header2.map {|k| "<th>#{cell k}</th>" }.join if keys2
         table << '</tr>'
       end
 
@@ -112,16 +112,24 @@ module IRuby
 
     private
 
+    def cell(obj)
+      obj.respond_to?(:to_html) ? obj.to_html : obj
+    end
+
+    def elem(row, k)
+      cell((row[k] rescue nil))
+    end
+
     def row_block(table, rows, keys1, keys2)
       cols = keys1.size
       cols += keys2.size + 1 if keys2
       rows.each_with_index do |row, i|
         table << '<tr>'
         if row.respond_to?(:map)
-          row_html = keys1.map {|k| "<td>#{row[k] rescue nil}</td>" }.join
+          row_html = keys1.map {|k| "<td>#{elem row, k}</td>" }.join
           if keys2
             row_html << "<td#{rows.size > 1 ? " rowspan='#{rows.size}'" : ''}>&#8230;</td>" if i == 0
-            row_html << keys2.map {|k| "<td>#{row[k] rescue nil}</td>" }.join
+            row_html << keys2.map {|k| "<td>#{elem row, k}</td>" }.join
           end
           if row_html.empty?
             table << "<td#{cols > 1 ? " colspan='#{cols}'" : ''}></td>"
@@ -129,7 +137,7 @@ module IRuby
             table << row_html
           end
         else
-          table << "<td#{cols > 1 ? " colspan='#{cols}'" : ''}>#{row}</td>"
+          table << "<td#{cols > 1 ? " colspan='#{cols}'" : ''}>#{cell row}</td>"
         end
         table << '</tr>'
       end

data/lib/iruby/kernel.rb

@@ -8,43 +8,20 @@ module IRuby
       attr_accessor :instance
     end
 
-    attr_reader :session, :comms
+    attr_reader :session
 
     def initialize(config_file)
       @config = MultiJson.load(File.read(config_file))
-
       IRuby.logger.debug("IRuby kernel start with config #{@config}")
-
       Kernel.instance = self
 
-      c = ZMQ::Context.new
-
-      connection = "#{@config['transport']}://#{@config['ip']}:%d"
-      reply_socket = c.socket(:ROUTER)
-      reply_socket.bind(connection % @config['shell_port'])
-
-      pub_socket = c.socket(:PUB)
-      pub_socket.bind(connection % @config['iopub_port'])
-
-      Thread.new do
-        begin
-          hb_socket = c.socket(:REP)
-          hb_socket.bind(connection % @config['hb_port'])
-          ZMQ.proxy(hb_socket, hb_socket)
-        rescue Exception => ex
-          IRuby.logger.fatal "Kernel heartbeat died: #{ex.message}\n"#{ex.backtrace.join("\n")}"
-        end
-      end
-
-      @session = Session.new('kernel', @config, publish: pub_socket, reply: reply_socket)
-
-      $stdout = OStream.new(@session, 'stdout')
-      $stderr = OStream.new(@session, 'stderr')
+      @session = Session.new(@config)
+      $stdout = OStream.new(@session, :stdout)
+      $stderr = OStream.new(@session, :stderr)
 
       @execution_count = 0
       @backend = create_backend
       @running = true
-      @comms = {}
     end
 
     def create_backend
@@ -55,55 +32,48 @@ module IRuby
     end
 
     def run
-      send_status('starting')
+      send_status :starting
       while @running
-        ident, msg = @session.recv(:reply)
+        msg = @session.recv(:reply)
         type = msg[:header]['msg_type']
         if type =~ /comm_|_request\Z/ && respond_to?(type)
-          send_status('busy')
-          send(type, ident, msg)
-          send_status('idle')
+          send_status :busy
+          send(type, msg)
+          send_status :idle
         else
           IRuby.logger.error "Unknown message type: #{msg[:header]['msg_type']} #{msg.inspect}"
         end
       end
     end
 
-    def kernel_info_request(ident, msg)
-      content = {
-        protocol_version: '5.0',
-        implementation: 'iruby',
-        implementation_version: IRuby::VERSION,
-        language_info: {
-          name: 'ruby',
-          version: RUBY_VERSION,
-          mimetype: 'text/ruby',
-          file_extension: 'rb',
-        },
-        banner: "IRuby #{IRuby::VERSION}"
-      }
-      @session.send(:reply, 'kernel_info_reply', content, ident)
+    def kernel_info_request(msg)
+      @session.send(:reply, :kernel_info_reply,
+                    protocol_version: '5.0',
+                    implementation: 'iruby',
+                    banner: "IRuby #{IRuby::VERSION}",
+                    implementation_version: IRuby::VERSION,
+                    language_info: {
+                      name: 'ruby',
+                      version: RUBY_VERSION,
+                      mimetype: 'text/ruby',
+                      file_extension: 'rb'
+                    })
     end
 
     def send_status(status)
-      @session.send(:publish, 'status', {execution_state: status})
+      @session.send(:publish, :status, execution_state: status)
     end
 
-    def execute_request(ident, msg)
-      begin
-        code = msg[:content]['code']
-      rescue
-        IRuby.logger.fatal "Got bad message: #{msg.inspect}"
-        return
-      end
-      @execution_count += 1 unless msg[:content].fetch('silent', false)
-      @session.send(:publish, 'execute_input', {code: code, execution_count: @execution_count}, ident)
+    def execute_request(msg)
+      code = msg[:content]['code']
+      @execution_count += 1 if msg[:content]['store_history']
+      @session.send(:publish, :execute_input, code: code, execution_count: @execution_count)
 
       result = nil
       begin
-        result = @backend.eval(code)
+        result = @backend.eval(code, msg[:content]['store_history'])
         content = {
-          status: 'ok',
+          status: :ok,
           payload: [],
           user_expressions: {},
           execution_count: @execution_count
@@ -112,90 +82,67 @@ module IRuby
         raise
       rescue Exception => e
         content = {
-          status: 'error',
+          status: :error,
           ename: e.class.to_s,
           evalue: e.message,
           traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *e.backtrace.map { |l| "#{WHITE}#{l}#{RESET}" }],
           execution_count: @execution_count
         }
-        @session.send(:publish, 'error', content, ident)
+        @session.send(:publish, :error, content)
       end
-      @session.send(:reply, 'execute_reply', content, ident)
+      @session.send(:reply, :execute_reply, content)
       unless result.nil? || msg[:content]['silent']
-        @session.send(:publish, 'execute_result', data: Display.display(result), metadata: {}, execution_count: @execution_count)
+        @session.send(:publish, :execute_result, data: Display.display(result), metadata: {}, execution_count: @execution_count)
       end
     end
 
-    def complete_request(ident, msg)
-      content = {
-        matches: @backend.complete(msg[:content]['code']),
-        status: 'ok',
-        cursor_start: 0,
-        cursor_end: msg[:content]['cursor_pos']
-      }
-      @session.send(:reply, 'complete_reply', content, ident)
+    def complete_request(msg)
+      @session.send(:reply, :complete_reply,
+                    matches: @backend.complete(msg[:content]['code']),
+                    status: :ok,
+                    cursor_start: 0,
+                    cursor_end: msg[:content]['cursor_pos'])
     end
 
-    def connect_request(ident, msg)
-      content = {
-        shell_port: config['shell_port'],
-        iopub_port: config['iopub_port'],
-        stdin_port: config['stdin_port'],
-        hb_port:    config['hb_port']
-      }
-      @session.send(:reply, 'connect_reply', content, ident)
+    def connect_request(msg)
+      @session.send(:reply, :connect_reply, Hash[%w(shell_port iopub_port stdin_port hb_port).map {|k| [k, @config[k]] }])
     end
 
-    def shutdown_request(ident, msg)
-      @session.send(:reply, 'shutdown_reply', msg[:content], ident)
+    def shutdown_request(msg)
+      @session.send(:reply, :shutdown_reply, msg[:content])
       @running = false
     end
 
-    def history_request(ident, msg)
+    def history_request(msg)
       # we will just send back empty history for now, pending clarification
       # as requested in ipython/ipython#3806
-      content = {
-        history: []
-      }
-      @session.send(:reply, 'history_reply', content, ident)
+      @session.send(:reply, :history_reply, history: [])
     end
 
-    def inspect_request(ident, msg)
-      o = @backend.eval(msg[:content]['oname'])
-      content = {
-        oname: msg[:content]['oname'],
-        found: true,
-        ismagic: false,
-        isalias: false,
-        docstring: '', # TODO
-        type_class: o.class.superclass.to_s,
-        string_form: o.inspect
-      }
-      content[:length] = o.length if o.respond_to?(:length)
-      @session.send(:reply, 'inspect_reply', content, ident)
+    def inspect_request(msg)
+      result = @backend.eval(msg[:content]['code'])
+      @session.send(:reply, :inspect_reply,
+                    status: :ok,
+                    data: Display.display(result),
+                    metadata: {})
     rescue Exception
-      content = {
-        oname: msg[:content]['oname'],
-        found: false
-      }
-      @session.send(:reply, 'inspect_reply', content, ident)
+      @session.send(:reply, :inspect_reply, status: 'error')
     end
 
-    def comm_open(ident, msg)
+    def comm_open(msg)
       comm_id = msg[:content]['comm_id']
       target_name = msg[:content]['target_name']
-      target = Comm.targets[target_name]
-      @comms[comm_id] = target.new(target_name, comm_id)
+      Comm.comm[comm_id] = Comm.target[target_name].new(target_name, comm_id)
     end
 
-    def comm_msg(ident, msg)
-      @comms[msg[:content]['comm_id']].comm_msg(msg[:content]['data'])
+    def comm_msg(msg)
+      Comm.comm[msg[:content]['comm_id']].handle_msg(msg[:content]['data'])
     end
 
-    def comm_close(ident, msg)
+    def comm_close(msg)
       comm_id = msg[:content]['comm_id']
-      @comms[comm_id].comm_close
-      @comms.delete(comm_id)
+      Comm.comm[comm_id].handle_close(msg[:content]['data'])
+      Comm.comm.delete(comm_id)
     end
   end
 end