iruby 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39e9bb6cc42415e3ab312341fd04724112d2952a
-  data.tar.gz: 7ffcf1e9550a71da16c554dada617e81e4fa7a41
+  metadata.gz: 8b8da3f0c37d62309c5a113b463ab8567b1c49b9
+  data.tar.gz: 36649a74bcb7dbcd7c91628efc8fd37c8a6bf211
 SHA512:
-  metadata.gz: 699ae86c55615f002265cb48b9b53463c9ce228aff076a296b2f338a74423799b3781cdada02ad848b13ad307945da3d46be78e8cbc1274280836d4acbc1c08a
-  data.tar.gz: 34aa0376810e9e1a1f8f0f6d9dc68c10bd2d714ee690966dff6cd224ca6b3ab5068aee3009324aba7b566a2a7c8114223c2fafe9ba4e36658b3056f6634ee9db
+  metadata.gz: 1d1d55e0f01d3ddc87cde6a3d6a610265c010ac8c4b0cd22b18d326c85c783e462e23258e32ab6f3afaebbf83c19b0737c75793bcc2968e7b70d96377c243aa2
+  data.tar.gz: 98f46f4e30e7c8f745c783ffeaa89e16c6a79f71b18abc097a6b45c8ad50a48fe94927f11b5f52d545884201f45df59e831c98eaf1587cb6d3c21352a14ed7f7

data/README.md

@@ -2,69 +2,6 @@
 
 This is a Ruby kernel for IPython.
 
-It adds a special `iruby_profile` command for staging some customization
-that enables the Ruby kernel by default, and sets syntax-highlighting in the notebook
-to Ruby mode.
-
 ### Usage
 
-Clone this repository and run `bin/iruby_profile` to create the profile, then
-use IPython as usual:
-
-```bash
-git clone git://github.com/minrk/iruby
-cd iruby
-# build and install IRuby
-gem build iruby.gemspec
-$ gem install iruby-*.gem
-# Create an IPython profile with default config
-$ iruby_profile --create
-$ ipython notebook --profile=ruby
-```
-
-
-## Background
-
-### Building an in-browser REPL for Ruby (IRuby)
-
-Hey, I'm Josh Adams.  I'm a partner and CTO at isotope|eleven.  We alo host
-Birmingham, AL's Open Source Software meetup - BOSS.
-
-At one of these sessions in early 2012, Tom Brander did a presentation and used
-IPython in his browser to manage it (there was much code and it was executed
-live).  This was the first time I'd seen IPython in the browser where it
-actually worked like it was supposed to, and I was extremely impressed.
-
-If you've not seen IPython, it looks like this <* Insert Screenshot Here *> in
-its web-browser mode.  It also manages a lot of console-basd REPLs.
-
-Anyway, it has notebooks that you can save out to execute later, and you can
-pass them around as little code snippets for other people to check out.  It's
-very impressive.
-
-But I'm primarily a Rubyist, and I'm happy that way :)  I couldn't sit by while
-Python had this awesome tool that we lacked.  I looked around for a bit, and
-there was nothing like IPython in our ecosystem.  There were, however, quite a
-few people asking about it.  So I figured I'd do something about it.
-
-#### The Architecture
-
-So the IPython guys did a great job explaining their core architecture, both in
-words and in pared-down code, in a blog post they wrote concerning it.  In
-general, it works like this <* Diagram *>
-
-There's a kernel that runs in the background and gets connected to by a
-frontend.  They communicate using zeromq, and they send json formatted messages
-back and forth.  These messages are in a very well defined structure.  Anyway,
-this way the frontend of the repl is disconnected from the environment that's
-running it.
-
-So the code repository they linked to in their blog post included the kernel and
-the frontend as small-ish python files - around 300 and 200 lines respectively.
-We had a hack weekend at isotope|eleven where myself and Robby Clements got
-together and (when we weren't playing Counterstrike1.6) did the closest thing to
-a straight port that we could swing.  Within about 2 hours of work, we had a
-working proof of concept that was primarily a 1 to 1 port.
-
-The next move was to build the web frontend.  This just consists of a websocket
-server and a fairly basic frontend webpage.
+Install the rubygem using `gem install iruby` and then run `iruby notebook`.

data/Ruby Notebook.ipynb

@@ -1,47 +1,12 @@
 {
  "metadata": {
-  "name": ""
+  "name": "Ruby Notebook"
  },
  "nbformat": 3,
  "nbformat_minor": 0,
  "worksheets": [
   {
    "cells": [
-    {
-     "cell_type": "code",
-     "collapsed": false,
-     "input": [
-      "puts \"hi\"\n",
-      "raise \"zofe\""
-     ],
-     "language": "python",
-     "metadata": {},
-     "outputs": [
-      {
-       "output_type": "stream",
-       "stream": "stdout",
-       "text": [
-        "hi\n"
-       ]
-      },
-      {
-       "ename": "RuntimeError",
-       "evalue": "zofe",
-       "output_type": "pyerr",
-       "traceback": [
-        "\u001b[31mRuntimeError\u001b[0m: zofe",
-        "\u001b[37m<main>:1:in `<main>'\u001b[0m",
-        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/kernel.rb:116:in `eval'\u001b[0m",
-        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/kernel.rb:116:in `execute_request'\u001b[0m",
-        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/kernel.rb:176:in `start'\u001b[0m",
-        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/command.rb:60:in `run_kernel'\u001b[0m",
-        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/command.rb:15:in `run'\u001b[0m",
-        "\u001b[37m/home/minad/code/git/iruby/bin/iruby:6:in `<main>'\u001b[0m"
-       ]
-      }
-     ],
-     "prompt_number": 3
-    },
     {
      "cell_type": "markdown",
      "metadata": {},
@@ -65,22 +30,11 @@
       "    end\n",
       "end\n",
       "\n",
-      "Neat.new.eh?\n",
-      "\n",
-      "puts \"hi\""
+      "Neat.new.eh?"
      ],
-     "language": "python",
+     "language": "ruby",
      "metadata": {},
-     "outputs": [
-      {
-       "output_type": "stream",
-       "stream": "stdout",
-       "text": [
-        "hi\n"
-       ]
-      }
-     ],
-     "prompt_number": 2
+     "outputs": []
     },
     {
      "cell_type": "markdown",
@@ -106,26 +60,9 @@
       "\n",
       "ThatsPrettyCool.new.how_does_it_work?"
      ],
-     "language": "python",
+     "language": "ruby",
      "metadata": {},
-     "outputs": [
-      {
-       "output_type": "stream",
-       "stream": "stdout",
-       "text": [
-        "I'm glad you asked!\n"
-       ]
-      },
-      {
-       "metadata": {},
-       "output_type": "pyout",
-       "prompt_number": 4,
-       "text": [
-        "see_below"
-       ]
-      }
-     ],
-     "prompt_number": 4
+     "outputs": []
     },
     {
      "cell_type": "markdown",

data/lib/iruby.rb

@@ -7,5 +7,4 @@ require 'iruby/version'
 require 'iruby/kernel'
 require 'iruby/completer'
 require 'iruby/session'
-require 'iruby/out_stream'
-require 'iruby/display_hook'
+require 'iruby/ostream'

data/lib/iruby/command.rb

@@ -25,39 +25,8 @@ module IRuby
       Dir.chdir(working_dir) if working_dir
       require boot_file if boot_file
       require 'iruby'
-
-      config = MultiJson.load(File.read(config_file))
-
-      puts 'Starting the kernel'
-      puts config
-
-      c = ZMQ::Context.new
-
-      connection = "#{config['transport']}://#{config['ip']}:%d"
-
-      session = IRuby::Session.new('kernel', config['key'], config['signature_scheme'])
-
-      reply_socket = c.socket(ZMQ::XREP)
-      reply_socket.bind(connection % config['shell_port'])
-
-      pub_socket = c.socket(ZMQ::PUB)
-      pub_socket.bind(connection % config['iopub_port'])
-
-      hb_thread = Thread.new do
-        hb_socket = c.socket(ZMQ::REP)
-        hb_socket.bind(connection % config['hb_port'])
-        ZMQ::Device.new(ZMQ::FORWARDER, hb_socket, hb_socket)
-      end
-
-      puts "Use Ctrl-\\ (NOT Ctrl-C!) to terminate."
-
-      $stdout = IRuby::OutStream.new(session, pub_socket, 'stdout')
-      #$stderr = OutStream.new(session, pub_socket, 'stderr')
-
-      kernel = IRuby::Kernel.new(session, reply_socket, pub_socket)
-      $displayhook = IRuby::DisplayHook.new(kernel, session, pub_socket)
-
-      kernel.start
+      $iruby_kernel = Kernel.new(config_file)
+      $iruby_kernel.run
     end
 
     def run_ipython

data/lib/iruby/kernel.rb

@@ -1,193 +1,134 @@
 module IRuby
+  class Kernel
+    RED = "\e[31m"
+    WHITE = "\e[37m"
+    RESET = "\e[0m"
 
-  class ResponseWithMime
-    def initialize(response, mime)
-      @response = response
-      @mime = mime
-    end
-    attr_reader :mime
-    def inspect
-      @response.inspect
-    end
-    def to_s
-      @response.to_s
-    end
-  end
+    def initialize(config_file)
+      config = MultiJson.load(File.read(config_file))
 
-  class Kernel
-    def self.html(s)
-      @output_mime = "text/html"
-      s
-    end
+      puts 'Starting the kernel'
+      puts config
 
-    def execution_count
-      @execution_count
-    end
+      c = ZMQ::Context.new
 
-    def output_mime
-      @output_mime
-    end
+      connection = "#{config['transport']}://#{config['ip']}:%d"
+      @reply_socket = c.socket(ZMQ::XREP)
+      @reply_socket.bind(connection % config['shell_port'])
+
+      @pub_socket = c.socket(ZMQ::PUB)
+      @pub_socket.bind(connection % config['iopub_port'])
+
+      @hb_thread = Thread.new do
+        hb_socket = c.socket(ZMQ::REP)
+        hb_socket.bind(connection % config['hb_port'])
+        ZMQ::Device.new(ZMQ::FORWARDER, hb_socket, hb_socket)
+      end
+
+      puts 'Use Ctrl-\\ (NOT Ctrl-C!) to terminate.'
+
+      @session = Session.new('kernel', config['key'], config['signature_scheme'])
+
+      $stdout = OStream.new(@session, @pub_socket, 'stdout')
+      $stderr = OStream.new(@session, @pub_socket, 'stderr')
 
-    def initialize session, reply_socket, pub_socket
-      @session = session
-      @reply_socket = reply_socket
-      @pub_socket = pub_socket
-      @history = []
       @execution_count = 0
       @completer = Completer.new
+    end
 
-      # Build dict of handlers for message types
-      @handlers = {}
-      ['execute_request', 'complete_request', 'kernel_info_request'].each do |msg_type|
-        @handlers[msg_type] = msg_type
+    def run
+      send_status('starting')
+      while true
+        ident, msg = @session.recv(@reply_socket, 0)
+        type = msg[:header]['msg_type']
+        if type =~ /_request\Z/ && respond_to?(type)
+          send(type, ident, msg)
+        else
+          STDERR.puts "Unknown message type: #{msg[:header]['msg_type']} #{msg.inspect}"
+        end
       end
     end
 
-    def abort_queue
-      while true
-        #begin
-          ident = @reply_socket.recv(ZMQ::NOBLOCK)
-        #rescue Exception => e
-          #if e.errno == ZMQ::EAGAIN
-            #break
-          #else
-            #assert self.reply_socket.rcvmore(), "Unexpected missing message part."
-            #msg = self.reply_socket.recv_json()
-          #end
-        #end
-        msg_type = msg['header']['msg_type']
-        reply_type = msg_type.split('_')[0] + '_reply'
-        @session.send(@reply_socket, reply_type, {status: 'aborted'}, msg)
-        # reply_msg = @session.msg(reply_type, {status: 'aborted'}, msg)
-        # @reply_socket.send(ident,ZMQ::SNDMORE)
-        # @reply_socket.send(reply_msg.to_json)
-        # We need to wait a bit for requests to come in. This can probably
-        # be set shorter for true asynchronous clients.
-        sleep(0.1)
+    def display(obj, options={})
+      if obj
+        data = {}
+        data[obj.respond_to?(:mime) ? obj.mime : (options[:mime] || 'text/plain')] = obj.to_s
+        content = { data: data, metadata: {}, execution_count: @execution_count }
+        @session.send(@pub_socket, 'pyout', content)
       end
+      nil
     end
 
-    def kernel_info_request(ident, parent)
-      reply_content = {
+    def kernel_info_request(ident, msg)
+      content = {
         protocol_version: [4, 0],
 
         # Language version number (mandatory).
         # It is Python version number (e.g., [2, 7, 3]) for the kernel
         # included in IPython.
-        language_version: RUBY_VERSION.split('.').map { |x| x.to_i },
+        language_version: RUBY_VERSION.split('.').map(&:to_i),
 
         # Programming language in which kernel is implemented (mandatory).
         # Kernel included in IPython returns 'python'.
-        language: "ruby"
+        language: 'ruby'
       }
-      reply_msg = @session.send(@reply_socket, 'kernel_info_reply',
-            reply_content, parent, ident
-      )
+      @session.send(@reply_socket, 'kernel_info_reply', content, ident)
     end
 
-    def send_status(status, parent)
-      @session.send(@pub_socket, "status", {execution_state: status}, parent)
+    def send_status(status)
+      @session.send(@pub_socket, 'status', execution_state: status)
     end
 
-    def execute_request(ident, parent)
+    def execute_request(ident, msg)
       begin
-        code = parent['content']['code']
+        code = msg[:content]['code']
       rescue
-        STDERR.puts "Got bad msg: "
-        STDERR.puts parent
+        STDERR.puts "Got bad message: #{msg.inspect}"
         return
       end
-      # pyin_msg = @session.msg()
-      if ! parent['content'].fetch('silent', false)
-        @execution_count += 1
-      end
-      self.send_status("busy", parent)
-      @session.send(@pub_socket, 'pyin', {code: code}, parent)
-      reply_content = {status: 'ok',
-          payload: [],
-          user_variables: {},
-          user_expressions: {},
-        }
+      @execution_count += 1 unless msg[:content].fetch('silent', false)
+      send_status('busy')
+      @session.send(@pub_socket, 'pyin', code: code)
+      content = {
+        status: 'ok',
+        payload: [],
+        user_variables: {},
+        user_expressions: {},
+      }
       result = nil
       begin
-        $displayhook.parent = parent
-        $stdout.parent = parent
-
         result = TOPLEVEL_BINDING.eval(code)
       rescue Exception => e
-        # $stderr.puts e.inspect
-        #etype, evalue, tb = sys.exc_info()
-        ename, evalue, tb = e.class.to_s, e.message, e.backtrace
-        tb = format_exception(ename, evalue, tb)
-        #tb = "1, 2, 3"
-        exc_content = {
-          ename: ename,
-          evalue: evalue,
-          traceback: tb,
-          #etype: etype,
-          #status: 'error',
+        content = {
+          ename: e.class.to_s,
+          evalue: e.message,
+          etype: e.class.to_s,
+          traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *e.backtrace.map { |l| "#{WHITE}#{l}#{RESET}" }],
         }
-        # STDERR.puts exc_content
-        @session.send(@pub_socket, 'pyerr', exc_content, parent)
-
-        reply_content = exc_content
+        @session.send(@pub_socket, 'pyerr', content)
       end
-      reply_content['execution_count'] = @execution_count
-
-      # reply_msg = @session.msg('execute_reply', reply_content, parent)
-      #$stdout.puts reply_msg
-      #$stderr.puts reply_msg
-      #@session.send(@reply_socket, ident + reply_msg)
-      reply_msg = @session.send(@reply_socket, 'execute_reply', reply_content, parent, ident)
-      if reply_msg['content']['status'] == 'error'
-        abort_queue
-      end
-      if ! result.nil? and ! parent['content']['silent']
-        output = ResponseWithMime.new(result, TOPLEVEL_BINDING.eval("$mime_type"))
-        $displayhook.display(output)
-      end
-      self.send_status("idle", parent)
+      content[:execution_count] = @execution_count
+
+      @session.send(@reply_socket, 'execute_reply', content, ident)
+      display(result) if result && !msg[:content]['silent']
+      send_status('idle')
     end
 
-    def complete_request(ident, parent)
-      matches = {
-        matches: @completer.complete(parent['content']['line'], parent['content']['text']),
+    def complete_request(ident, msg)
+      content = {
+        matches: @completer.complete(msg[:content]['line'], msg[:content]['text']),
         status: 'ok',
-        matched_text: parent['content']['line'],
+        matched_text: msg[:content]['line'],
       }
-      completion_msg = @session.send(@reply_socket, 'complete_reply',
-                                     matches, parent, ident)
-      return nil
+      @session.send(@reply_socket, 'complete_reply', content, ident)
     end
+  end
 
-    def start()
-      self.send_status("starting", nil)
-      while true
-        ident, msg = @session.recv(@reply_socket, 0)
-        begin
-          handler = @handlers[msg['header']['msg_type']]
-        rescue
-          handler = nil
-        end
-        if handler.nil?
-          STDERR.puts "UNKNOWN MESSAGE TYPE: #{msg['header']['msg_type']} #{msg}"
-        else
-          # STDERR.puts 'handling ' + omsg.inspect
-          send(handler, ident, msg)
-        end
-      end
-    end
-
-  private
-    RED = "\e[31m"
-    WHITE = "\e[37m"
-    RESET = "\e[0m"
-
-    def format_exception(name, value, backtrace)
-      tb = []
-      tb << "#{RED}#{name}#{RESET}: #{value}"
-      tb.concat(backtrace.map { |l| "#{WHITE}#{l}#{RESET}" })
-      tb
+  module Hooks
+    def display(obj, options={})
+      $iruby_kernel.display(obj, options)
     end
   end
 end
+
+include IRuby::Hooks

data/lib/iruby/ostream.rb

@@ -0,0 +1,42 @@
+module IRuby
+  # IO-like object that publishes to 0MQ socket.
+  class OStream
+    def initialize(session, socket, name)
+      @session = session
+      @socket = socket
+      @name = name
+    end
+
+    def close
+      @socket = nil
+    end
+
+    def flush
+    end
+
+    def isatty
+      false
+    end
+    alias tty? isatty
+
+    def read(*args)
+      raise IOError, 'not opened for reading'
+    end
+    alias next read
+    alias readline read
+
+    def write(s)
+      raise 'I/O operation on closed file' unless @socket
+      @session.send(@socket, 'stream', { name: @name, data: s.to_s })
+      nil
+    end
+
+    def puts(s)
+      write "#{s}\n"
+    end
+
+    def writelines(lines)
+      lines.each { |s| write(s) }
+    end
+  end
+end

data/lib/iruby/session.rb

@@ -6,295 +6,81 @@ module IRuby
       @username = username
       @session = SecureRandom.uuid
       @msg_id = 0
-
-      raise 'Unknown signature scheme' unless sign_scheme =~ /\Ahmac-(.*)\Z/
-      @digest = OpenSSL::Digest::Digest.new($1)
-      @key = key
-    end
-
-    # Sign a message with HMAC digest. If no auth, return b''.
-
-    # Parameters
-    # ----------
-    # msg_list : list
-    #     The [p_header,p_parent,p_content] part of the message list.
-    def sign(msg_list)
-      return '' unless @key
-      hmac = OpenSSL::HMAC.new(@key, @digest)
-      msg_list.each do |m|
-        hmac.update(m)
+      if key && sign_scheme
+        raise 'Unknown signature scheme' unless sign_scheme =~ /\Ahmac-(.*)\Z/
+        @hmac = OpenSSL::HMAC.new(key, OpenSSL::Digest::Digest.new($1))
       end
-      hmac.hexdigest
     end
 
-    def msg_header
-      h = {
-        msg_id: @msg_id,
+    # Build and send a message
+    def send(socket, type, content, ident=nil)
+      header = {
+        msg_type: type,
+        msg_id:   @msg_id,
         username: @username,
-        session: @session
+        session:  @session
       }
       @msg_id += 1
-      h
-    end
-
-    def msg(msg_type, content=nil, parent=nil)
-      msg = {}
-      msg['header'] = msg_header
-      msg['parent_header'] = parent ? parent['header'] : {}
-      msg['metadata'] = {}
-      msg['header']['msg_type'] = msg_type
-      msg['content'] = content || {}
-      return msg
-    end
-
-    # Build and send a message via stream or socket.
-    #
-    #   The message format used by this function internally is as follows:
-    #
-    #   [ident1,ident2,...,DELIM,HMAC,p_header,p_parent,p_content,
-    #    buffer1,buffer2,...]
-    #
-    #   The serialize/unserialize methods convert the nested message dict into this
-    #   format.
-    #
-    #   Parameters
-    #   ----------
-    #
-    #   stream : zmq.Socket or ZMQStream
-    #       The socket-like object used to send the data.
-    #   msg_or_type : str or Message/dict
-    #       Normally, msg_or_type will be a msg_type unless a message is being
-    #       sent more than once. If a header is supplied, this can be set to
-    #       None and the msg_type will be pulled from the header.
-    #
-    #   content : dict or None
-    #       The content of the message (ignored if msg_or_type is a message).
-    #   header : dict or None
-    #       The header dict for the message (ignores if msg_to_type is a message).
-    #   parent : Message or dict or None
-    #       The parent or parent header describing the parent of this message
-    #       (ignored if msg_or_type is a message).
-    #   ident : bytes or list of bytes
-    #       The zmq.IDENTITY routing path.
-    #   subheader : dict or None
-    #       Extra header keys for this message's header (ignored if msg_or_type
-    #       is a message).
-    #   buffers : list or None
-    #       The already-serialized buffers to be appended to the message.
-    #   track : bool
-    #       Whether to track.  Only for use with Sockets, because ZMQStream
-    #       objects cannot track messages.
-    #
-    #   Returns
-    #   -------
-    #   msg : dict
-    #       The constructed message.
-    #   (msg,tracker) : (dict, MessageTracker)
-    #       if track=True, then a 2-tuple will be returned,
-    #       the first element being the constructed
-    #       message, and the second being the MessageTracker
-    def send(stream, msg_or_type, content=nil, parent=nil, ident=nil, buffers=nil, subheader=nil, track=false, header=nil)
-      if !stream.is_a?(ZMQ::Socket)
-        raise "stream must be Socket or ZMQSocket, not %r"%stream.class
-      end
-
-      if msg_or_type.is_a?(Hash)
-        msg = msg_or_type
-      else
-        msg = self.msg(msg_or_type, content, parent)
-      end
 
-      buffers ||= []
-      to_send = self.serialize(msg, ident)
-      flag = 0
-      if buffers.any?
-        flag = ZMQ::SNDMORE
-        _track = false
-      else
-        _track=track
-      end
-      if track
-        to_send.each_with_index do |part, i|
-          if i == to_send.length - 1
-            flag = 0
-          else
-            flag = ZMQ::SNDMORE
-          end
-          stream.send_string(part, flag)
-        end
-      else
-        to_send.each_with_index do |part, i|
-          if i == to_send.length - 1
-            flag = 0
-          else
-            flag = ZMQ::SNDMORE
-          end
-          stream.send_string(part, flag)
-        end
+      list = serialize(header, content, ident)
+      list.each_with_index do |part, i|
+        socket.send_string(part, i == list.size - 1 ? 0 : ZMQ::SNDMORE)
       end
-      # STDOUT.puts '-'*30
-      # STDOUT.puts "SENDING"
-      # STDOUT.puts to_send
-      # STDOUT.puts to_send.length
-      # STDOUT.puts '-'*30
-
-      #buffers.each do |b|
-        #stream.send(b, flag, copy=False)
-      #end
-      #if buffers:
-          #if track:
-              #tracker = stream.send(buffers[-1], copy=False, track=track)
-          #else:
-              #tracker = stream.send(buffers[-1], copy=False)
-
-      # omsg = Message(msg)
-      #if self.debug:
-          #pprint.pprint(msg)
-          #pprint.pprint(to_send)
-          #pprint.pprint(buffers)
-
-      #msg['tracker'] = tracker
-
-      return msg
     end
 
-    def recv(socket, mode=ZMQ::NOBLOCK)
-      begin
-        msg = []
-        frame = ""
-        rc = socket.recv_string(frame, mode)
-        ZMQ::Util.error_check("zmq_msg_send", rc)
-
-        msg << frame
-        while socket.more_parts?
-          begin
-            frame = ""
-            rc = socket.recv_string(frame, mode)
-            ZMQ::Util.error_check("zmq_msg_send", rc)
-            msg << frame
-          rescue
-          end
+    # Receive a message and decode it
+    def recv(socket, mode)
+      msg = []
+      while msg.empty? || socket.more_parts?
+        begin
+          frame = ''
+          rc = socket.recv_string(frame, mode)
+          ZMQ::Util.error_check('zmq_msg_send', rc)
+          msg << frame
+        rescue
         end
-        # Skip everything before DELIM, then munge the three json objects into the
-        # one the rest of my code expects
-        i = msg.index(DELIM)
-        idents = msg[0..i-1]
-        msg_list = msg[i+1..-1]
-      end
-      return idents, unserialize(msg_list)
-    end
-
-    # Serialize the message components to bytes.
-    #
-    # This is roughly the inverse of unserialize. The serialize/unserialize
-    # methods work with full message lists, whereas pack/unpack work with
-    # the individual message parts in the message list.
-    #
-    # Parameters
-    # ----------
-    # msg : dict or Message
-    #     The nexted message dict as returned by the self.msg method.
-    #
-    # Returns
-    # -------
-    # msg_list : list
-    #     The list of bytes objects to be sent with the format:
-    #     [ident1,ident2,...,DELIM,HMAC,p_header,p_parent,p_content,
-    #      buffer1,buffer2,...]. In this list, the p_* entities are
-    #     the packed or serialized versions, so if JSON is used, these
-    #     are utf8 encoded JSON strings.
-    def serialize(msg, ident=nil)
-      content = msg.fetch('content', {})
-      if content.nil?
-        content = {}.to_json
-      elsif content.is_a?(Hash)
-        content = content.to_json
-      #elsif isinstance(content, bytes):
-          # content is already packed, as in a relayed message
-          #pass
-      #elsif isinstance(content, unicode):
-          # should be bytes, but JSON often spits out unicode
-          #content = content.encode('utf8')
-      else
-        raise "Content incorrect type: %s"%type(content)
-      end
-
-      real_message = [MultiJson.dump(msg['header']),
-                      MultiJson.dump(msg['parent_header']),
-                      MultiJson.dump(msg['metadata']),
-                      MultiJson.dump(msg['content']),
-                    ]
-
-      to_send = []
-
-      if ident.is_a?(Array)
-        # accept list of idents
-        to_send += ident
-      elsif !ident.nil?
-        to_send << ident
       end
-      to_send << DELIM
 
-      signature = self.sign(real_message)
-      to_send << signature
-
-      to_send += real_message
-      # STDOUT.puts to_send
-      # STDOUT.puts to_send.length
-
-      return to_send
+      i = msg.index(DELIM)
+      idents, msg_list = msg[0..i-1], msg[i+1..-1]
+      msg = unserialize(msg_list)
+      @last_received_header = msg[:header]
+      return idents, msg
     end
 
-    # Unserialize a msg_list to a nested message dict.
-    # This is roughly the inverse of serialize. The serialize/unserialize
-    # methods work with full message lists, whereas pack/unpack work with
-    # the individual message parts in the message list.
+    private
 
-    # Parameters:
-    # -----------
-    # msg_list : list of bytes or Message objects
-    #     The list of message parts of the form [HMAC,p_header,p_parent,
-    #     p_content,buffer1,buffer2,...].
-    # content : bool (True)
-    #     Whether to unpack the content dict (True), or leave it packed
-    #     (False).
-    # copy : bool (True)
-    #     Whether to return the bytes (True), or the non-copying Message
-    #     object in each place (False).
+    def serialize(header, content, ident)
+      msg = [MultiJson.dump(header),
+             MultiJson.dump(@last_received_header || {}),
+             '{}',
+             MultiJson.dump(content || {})]
+      ([ident].flatten.compact << DELIM << sign(msg)) + msg
+    end
 
-    # Returns
-    # -------
-    # msg : dict
-    #     The nested message dict with top-level keys [header, parent_header,
-    #     content, buffers].
-    def unserialize(msg_list, content=true, copy=true)
+    def unserialize(msg_list)
       minlen = 5
-      message = {}
-      unless copy
-        minlen.times do |i|
-          msg_list[i] = msg_list[i].bytes
-        end
-      end
-      unless msg_list.length >= minlen
-        raise "malformed message, must have at least %i elements"%minlen
-      end
-
-      raise "Invalid signature" unless self.sign(msg_list[1..-1]) == msg_list[0]
+      raise 'malformed message, must have at least #{minlen} elements' unless msg_list.length >= minlen
+      s, header, parent_header, metadata, content, buffers = *msg_list
+      raise 'Invalid signature' unless s == sign(msg_list[1..-1])
+      {
+        header: MultiJson.load(header),
+        parent_header: MultiJson.load(parent_header),
+        metadata: MultiJson.load(metadata),
+        content: MultiJson.load(content),
+        buffers: buffers
+      }
+    end
 
-      header = msg_list[1]
-      message['header'] = MultiJson.load(header)
-      message['msg_id'] = header['msg_id']
-      message['msg_type'] = header['msg_type']
-      message['parent_header'] = MultiJson.load(msg_list[2])
-      message['metadata'] = MultiJson.load(msg_list[3])
-      if content
-        message['content'] = MultiJson.load(msg_list[4])
+    # Sign using HMAC
+    def sign(list)
+      if @hmac
+        @hmac.reset
+        list.each {|m| @hmac.update(m) }
+        @hmac.hexdigest
       else
-        message['content'] = msg_list[4]
+        ''
       end
-
-      message['buffers'] = msg_list[4..-1]
-      return message
     end
   end
 end

data/lib/iruby/version.rb

@@ -1,3 +1,3 @@
 module IRuby
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Damián Silvani
@@ -85,14 +85,16 @@ files:
 - Rakefile
 - Ruby Notebook.ipynb
 - attic/output/html.rb
+- attic/test/helper.rb
+- attic/test/html_test.rb
+- attic/test/output_maps_test.rb
 - bin/iruby
 - iruby.gemspec
 - lib/iruby.rb
 - lib/iruby/command.rb
 - lib/iruby/completer.rb
-- lib/iruby/display_hook.rb
 - lib/iruby/kernel.rb
-- lib/iruby/out_stream.rb
+- lib/iruby/ostream.rb
 - lib/iruby/session.rb
 - lib/iruby/version.rb
 - static/base/images/favicon.ico
@@ -101,9 +103,6 @@ files:
 - static/base/images/src/ruby.svg
 - static/custom/custom.css
 - static/custom/custom.js
-- test/helper.rb
-- test/html_test.rb
-- test/output_maps_test.rb
 homepage: https://github.com/minad/iruby
 licenses:
 - MIT
@@ -124,11 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A Ruby kernel for IPython frontends (notebook console, etc.)
-test_files:
-- test/helper.rb
-- test/html_test.rb
-- test/output_maps_test.rb
+test_files: []

data/lib/iruby/display_hook.rb

@@ -1,29 +0,0 @@
-module IRuby
-  class DisplayHook
-    attr_writer :parent
-
-    def initialize kernel, session, pub_socket
-      @kernel = kernel
-      @session = session
-      @pub_socket = pub_socket
-      @parent = {}
-    end
-
-    def display(obj)
-      if obj.nil?
-        return
-      end
-      # STDERR.puts @kernel.user_ns
-      # @user_ns._ = obj
-      # STDERR.puts "displayhook call:"
-      # STDERR.puts @parent_header.inspect
-      #@pub_socket.send(msg.to_json)
-      data = {}
-      output = obj
-      data['text/plain'] = output
-      data[obj.mime] =  output
-      content = {data: data, metadata: {}, execution_count: @kernel.execution_count}
-      @session.send(@pub_socket, 'pyout', content, @parent)
-    end
-  end
-end

data/lib/iruby/out_stream.rb

@@ -1,93 +0,0 @@
-module IRuby
-  class OutStream
-    #A file like object that publishes the stream to a 0MQ PUB socket.
-
-    attr_writer :parent
-
-    def initialize session, pub_socket, name, max_buffer=200
-      @session = session
-      @pub_socket = pub_socket
-      @name = name
-      @buffer = []
-      @buffer_len = 0
-      @max_buffer = max_buffer
-      @parent = {}
-    end
-
-    def close
-      @pub_socket = nil
-    end
-
-    def flush
-      # STDERR.puts("flushing, parent to follow")
-      # STDERR.puts @parent.inspect
-      if @pub_socket.nil?
-        raise 'I/O operation on closed file'
-      else
-        if @buffer
-          data = @buffer.join('')
-          content = { name: @name, data: data }
-          if ! @session
-            return
-          end
-          # msg = @session.msg('stream', content, @parent) if @session
-          # FIXME: Wha?
-          # STDERR.puts msg.to_json
-          #@pub_socket.send(msg.to_json)
-          @session.send(@pub_socket, 'stream', content, @parent)
-          @buffer_len = 0
-          @buffer = []
-          nil
-        end
-      end
-    end
-
-    def isatty
-      false
-    end
-    alias tty? isatty
-
-    def next
-      raise IOError, 'not opened for reading'
-    end
-
-    def read(*args)
-      raise IOError, 'not opened for reading'
-    end
-    alias readline read
-
-    def write(s)
-      if @pub_socket.nil?
-        raise 'I/O operation on closed file'
-      else
-        s = s.to_s
-        @buffer << s
-        @buffer_len += s.length
-        _maybe_send
-      end
-    end
-
-    def puts(s)
-      write "#{s}\n"
-    end
-
-    def _maybe_send
-      #if self._buffer[-1].include?('\n')
-        flush
-      #end
-      #if @bufferlen > @max_buffer
-        #flush
-      #end
-    end
-
-    def writelines sequence
-      if @pub_socket.nil?
-        raise 'I/O operation on closed file'
-      else
-        sequence.each do |s|
-          write(s)
-        end
-      end
-    end
-  end
-end