iruby 0.0.1

data/bin/iruby

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'iruby/command'
+
+IRuby::Command.new(ARGV).run

data/iruby.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+require File.dirname(__FILE__) + '/lib/iruby/version'
+require 'date'
+
+Gem::Specification.new do |s|
+  s.name          = 'iruby'
+  s.date          = Date.today.to_s
+  s.version       = IRuby::VERSION
+  s.authors       = ['Damián Silvani', 'Min RK', 'martin sarsale', 'Josh Adams', 'Daniel Mendler']
+  s.email         = ['benjaminrk@gmail.com']
+  s.description   = 'Ruby Kernel for IPython'
+  s.summary       = 'A Ruby kernel for IPython frontends (notebook console, etc.)'
+  s.homepage      = 'https://github.com/minad/iruby'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^test/})
+  s.require_paths = %w(lib)
+
+  s.add_development_dependency 'rake'
+
+  s.add_runtime_dependency 'bond'
+  s.add_runtime_dependency 'ffi-rzmq'
+  s.add_runtime_dependency 'multi_json'
+end

data/lib/iruby.rb

@@ -0,0 +1,11 @@
+require 'ffi-rzmq'
+require 'securerandom'
+require 'multi_json'
+require 'bond'
+require 'openssl'
+require 'iruby/version'
+require 'iruby/kernel'
+require 'iruby/completer'
+require 'iruby/session'
+require 'iruby/out_stream'
+require 'iruby/display_hook'

data/lib/iruby/command.rb

@@ -0,0 +1,103 @@
+require 'shellwords'
+
+module IRuby
+  class Command
+    IRUBYDIR = '~/.config/iruby'
+
+    def initialize(args)
+      @args = args
+    end
+
+    def run
+      raise 'Use --iruby-dir instead of --ipython-dir!' unless @args.grep(/\A--ipython-dir=.*\Z/).empty?
+
+      if @args.first == 'kernel'
+        run_kernel
+      else
+        run_ipython
+      end
+    end
+
+    private
+
+    def run_kernel
+      config_file, boot_file, working_dir = @args[1..-1]
+      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
+    end
+
+    def run_ipython
+      dir = @args.grep(/\A--iruby-dir=.*\Z/)
+      @args -= dir
+      dir = dir.last.to_s.sub(/\A--profile=/, '')
+      dir = ENV['IRUBYDIR'] || IRUBYDIR if dir.empty?
+      dir = File.expand_path(dir)
+      ENV['IPYTHONDIR'] = dir
+
+      if @args.size == 3 && @args[0] == 'profile' && @args[1] == 'create'
+        profile = @args[2]
+      else
+        profile = @args.grep(/\A--profile=.*\Z/).last.to_s.sub(/\A--profile=/, '')
+        profile = 'default' if profile.empty?
+      end
+
+      create_profile(dir, profile)
+      Kernel.exec('ipython', *@args)
+    end
+
+    def create_profile(dir, profile)
+      profile_dir = File.join(dir, "profile_#{profile}")
+      unless File.directory?(profile_dir)
+        puts "Creating profile directory #{profile_dir}"
+        system("ipython profile create #{Shellwords.escape profile}")
+      end
+
+      kernel_cmd = "c.KernelManager.kernel_cmd = ['#{File.expand_path $0}', 'kernel', '{connection_file}']"
+      Dir[File.join(profile_dir, '*_config.py')].each do |path|
+        File.open(path, 'r+') do |f|
+          content = f.read
+          content << kernel_cmd unless content.gsub!(/^c\.KernelManager\.kernel_cmd.*$/, kernel_cmd)
+          f.pos = 0
+          f.write(content)
+        end
+      end
+
+      static_dir = File.join(profile_dir, 'static')
+      File.symlink(File.join(File.dirname(__FILE__), '..', '..', 'static'), static_dir) unless File.exists?(static_dir)
+    end
+  end
+end

data/lib/iruby/completer.rb

@@ -0,0 +1,19 @@
+module IRuby
+  class Completer
+    module Readline
+      class<< self
+        attr_accessor :line_buffer
+        def setup(arg); end
+      end
+    end
+
+    def initialize
+      Bond.start(readline: Readline, debug: true)
+    end
+
+    def complete(line, text)
+      Readline.line_buffer = line
+      Bond.agent.call(line)
+    end
+  end
+end

data/lib/iruby/display_hook.rb

@@ -0,0 +1,29 @@
+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/kernel.rb

@@ -0,0 +1,193 @@
+module IRuby
+
+  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
+
+  class Kernel
+    def self.html(s)
+      @output_mime = "text/html"
+      s
+    end
+
+    def execution_count
+      @execution_count
+    end
+
+    def output_mime
+      @output_mime
+    end
+
+    def initialize session, reply_socket, pub_socket
+      @session = session
+      @reply_socket = reply_socket
+      @pub_socket = pub_socket
+      @history = []
+      @execution_count = 0
+      @completer = Completer.new
+
+      # Build dict of handlers for message types
+      @handlers = {}
+      ['execute_request', 'complete_request', 'kernel_info_request'].each do |msg_type|
+        @handlers[msg_type] = msg_type
+      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)
+      end
+    end
+
+    def kernel_info_request(ident, parent)
+      reply_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 },
+
+        # Programming language in which kernel is implemented (mandatory).
+        # Kernel included in IPython returns 'python'.
+        language: "ruby"
+      }
+      reply_msg = @session.send(@reply_socket, 'kernel_info_reply',
+            reply_content, parent, ident
+      )
+    end
+
+    def send_status(status, parent)
+      @session.send(@pub_socket, "status", {execution_state: status}, parent)
+    end
+
+    def execute_request(ident, parent)
+      begin
+        code = parent['content']['code']
+      rescue
+        STDERR.puts "Got bad msg: "
+        STDERR.puts parent
+        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: {},
+        }
+      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',
+        }
+        # STDERR.puts exc_content
+        @session.send(@pub_socket, 'pyerr', exc_content, parent)
+
+        reply_content = exc_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)
+    end
+
+    def complete_request(ident, parent)
+      matches = {
+        matches: @completer.complete(parent['content']['line'], parent['content']['text']),
+        status: 'ok',
+        matched_text: parent['content']['line'],
+      }
+      completion_msg = @session.send(@reply_socket, 'complete_reply',
+                                     matches, parent, ident)
+      return nil
+    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
+    end
+  end
+end

data/lib/iruby/out_stream.rb

@@ -0,0 +1,93 @@
+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