iruby 0.1.13 → 0.2.0

data/iruby.gemspec

@@ -6,14 +6,14 @@ 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.authors       = ['Daniel Mendler', 'The SciRuby developers']
+  s.email         = ['mail@daniel-mendler.de']
   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.homepage      = 'https://github.com/SciRuby/iruby'
   s.license       = 'MIT'
 
-  s.files         = `git ls-files`.split($/)
+  s.files         = `git ls-files`.split($/).reject {|f| f =~ /\Aattic/ }
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^test/})
   s.require_paths = %w(lib)
@@ -22,10 +22,13 @@ Gem::Specification.new do |s|
   File.read('Gemfile').scan(/gem\s+'(.*?)'/) { m << "  * #{$1}\n" }
   s.post_install_message = m << "\n"
 
-  s.add_development_dependency 'rake'
+  s.required_ruby_version = '>= 2.0.0'
 
-  s.add_runtime_dependency 'bond', '~> 0.5.0'
-  s.add_runtime_dependency 'ffi-rzmq', '~> 2.0'
-  s.add_runtime_dependency 'multi_json', '~> 1.10.0'
-  s.add_runtime_dependency 'mimemagic', '~> 0.2.0'
+  s.add_development_dependency 'rake', '~> 10.4'
+  s.add_development_dependency 'minitest', '~> 5.6'
+
+  s.add_runtime_dependency 'bond', '~> 0.5'
+  s.add_runtime_dependency 'rbczmq', '~> 1.7'
+  s.add_runtime_dependency 'multi_json', '~> 1.11'
+  s.add_runtime_dependency 'mimemagic', '~> 0.3'
 end

data/lib/iruby.rb

@@ -1,4 +1,4 @@
-require 'ffi-rzmq'
+require 'rbczmq'
 require 'mimemagic'
 require 'multi_json'
 require 'bond'
@@ -14,3 +14,4 @@ require 'iruby/ostream'
 require 'iruby/formatter'
 require 'iruby/utils'
 require 'iruby/display'
+require 'iruby/comm'

data/lib/iruby/backend.rb

@@ -8,8 +8,8 @@ module IRuby
       TOPLEVEL_BINDING.eval(code)
     end
 
-    def complete(line, text)
-      Bond.agent.call(line, line)
+    def complete(code)
+      Bond.agent.call(code, code)
     end
   end
 
@@ -25,14 +25,14 @@ module IRuby
 
     def eval(code)
       @pry.last_result = nil
-      @pry.eval(code)
+      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.last_result
     end
 
-    def complete(line, text)
-      @pry.complete(line)
+    def complete(code)
+      @pry.complete(code)
     end
   end
 end

data/lib/iruby/comm.rb

@@ -0,0 +1,60 @@
+module IRuby
+  # Comm is a new messaging system for bidirectional communication.
+  # Both kernel and front-end listens for messages.
+  class Comm
+    attr_writer :on_msg, :on_close
+
+    class << self
+      def targets
+        @targets ||= {}
+      end
+    end
+
+    def initialize(target_name, comm_id = SecureRandom.uuid)
+      @target_name, @comm_id = target_name, comm_id
+    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
+    end
+
+    def send(**data)
+      content = {
+        comm_id: @comm_id,
+        data: data
+      }
+      Kernel.instance.session.send(:publish, 'comm_msg', content)
+    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)
+    end
+
+    def on_msg(&b)
+      @on_msg = b
+    end
+
+    def on_close(&b)
+      @on_close = b
+    end
+
+    def comm_msg(msg)
+      @on_msg.call(msg) if @on_msg
+    end
+
+    def comm_close
+      @on_close.call if @on_close
+    end
+  end
+end

data/lib/iruby/command.rb

@@ -1,18 +1,32 @@
-require 'shellwords'
-require 'fileutils'
-
 module IRuby
   class Command
-    IRUBYDIR = '~/.config/iruby'
-
     def initialize(args)
       @args = args
+
+      ipython_dir = ENV['IPYTHONDIR'] || '~/.ipython'
+      @args.each do |arg|
+        ipython_dir = $1 if arg =~ /\A--ipython-dir=(.*)\Z/
+      end
+      ipython_dir = File.expand_path(ipython_dir)
+      @kernel_file = File.join(ipython_dir, 'kernels', 'ruby', 'kernel.json')
     end
 
     def run
-      raise 'Use --iruby-dir instead of --ipython-dir!' unless @args.grep(/\A--ipython-dir=.*\Z/).empty?
-
-      if @args.first == 'kernel'
+      case @args.first
+      when 'version', '-v', '--version'
+        require 'iruby/version'
+        puts IRuby::VERSION
+      when 'help', '-h', '--help'
+        print_help
+      when 'register'
+        if File.exist?(@kernel_file) && !@args.include?('--force')
+          STDERR.puts "#{@kernel_file} already exists!\nUse --force to force a register."
+          exit 1
+        end
+        register_kernel
+      when 'unregister'
+        unregister_kernel
+      when 'kernel'
         run_kernel
       else
         run_ipython
@@ -21,20 +35,49 @@ module IRuby
 
     private
 
+    def print_help
+      puts %{
+Usage:
+    iruby register        Register IRuby kernel into #{@kernel_file}.
+    iruby unregister      Remove #{@kernel_file}.
+    iruby console         Launch the IRuby terminal-based console.
+    iruby notebook        Launch the IRuby HTML notebook server.
+    ...                   Same as IPython.
+
+Please note that IRuby accepts the same parameters as IPython.
+Try `ipython help` for more information.
+}
+    end
+
     def run_kernel
+      require 'iruby/logger'
+      loggers = [Logger.new(STDOUT)]
+      @args.each do |arg|
+        loggers << Logger.new($1) if arg =~ /\A--log=(.*)\Z/
+      end
+      IRuby.logger = MultiLogger.new(*loggers)
+      IRuby.logger.level = @args.include?('--debug') ? Logger::DEBUG : Logger::INFO
+
       raise(ArgumentError, 'Not enough arguments to the kernel') if @args.size < 2 || @args.size > 4
       config_file, boot_file, working_dir = @args[1..-1]
       Dir.chdir(working_dir) if working_dir
+
       require boot_file if boot_file
+
+      begin
+        require 'bundler/setup'
+      rescue Exception
+      end
+
       require 'iruby'
       Kernel.new(config_file).run
     rescue Exception => ex
-      STDERR.puts "Kernel died: #{ex.message}\n#{ex.backtrace.join("\n")}"
+      IRuby.logger.fatal "Kernel died: #{ex.message}\n#{ex.backtrace.join("\n")}"
       raise
     end
 
     def check_version
-      required = '1.2.0'
+      required = '3.0.0'
       version = `ipython --version`.chomp
       if version < required
         STDERR.puts "Your IPython version #{version} is too old, at least #{required} is required"
@@ -45,55 +88,27 @@ module IRuby
     def run_ipython
       check_version
 
-      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)
-
       # We must use the console to launch the whole 0MQ-client-server stack
-      @args = %w(console --no-banner) + @args if @args.first.to_s !~ /\A\w+\Z/
+      @args = %w(console) + @args if @args.first.to_s !~ /\A\w/
+      register_kernel if %w(console qtconsole notebook).include?(@args.first) && !File.exist?(@kernel_file)
+      @args += %w(--kernel ruby) if %w(console qtconsole).include? @args.first
 
       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}"
-        `ipython profile create #{Shellwords.escape profile}`
-      end
-
-      kernel_cmd = []
-      kernel_cmd << ENV['BUNDLE_BIN_PATH'] << 'exec' if ENV['BUNDLE_BIN_PATH']
-      kernel_cmd += [File.expand_path($0), 'kernel', '{connection_file}']
-      kernel_cmd = "c.KernelManager.kernel_cmd = #{kernel_cmd.inspect}"
-      Dir[File.join(profile_dir, '*_config.py')].each do |path|
-        content = File.read(path)
-        content << kernel_cmd unless content.gsub!(/^c\.KernelManager\.kernel_cmd.*$/, kernel_cmd)
-        File.open(path, 'w') {|f| f.write(content) }
-      end
+    def register_kernel
+      require 'fileutils'
+      FileUtils.mkpath(File.dirname(@kernel_file))
+      File.write(@kernel_file, %{{
+  "argv":         [ "#{File.expand_path $0}", "kernel", "{connection_file}" ],
+  "display_name": "Ruby",
+  "language":     "ruby"
+}
+})
+    end
 
-      static_dir = File.join(profile_dir, 'static')
-      target_dir = File.join(File.dirname(__FILE__), 'static')
-      unless (File.readlink(static_dir) rescue nil) == target_dir
-        FileUtils.rm_rf(static_dir) rescue nil
-        begin
-          FileUtils.ln_sf(target_dir, static_dir)
-        rescue => ex
-          STDERR.puts "Could not create directory #{static_dir}: #{ex.message}"
-        end
-      end
+    def unregister_kernel
+      File.unlink(@kernel_file)
     end
   end
 end

data/lib/iruby/display.rb

@@ -30,12 +30,6 @@ module IRuby
         # as the given mime type.
         data[exact_mime] = protect(exact_mime, obj) if exact_mime && !data.any? {|m,_| exact_mime == m }
 
-        # HACK for IPython #6259
-        # https://github.com/ipython/ipython/issues/6259
-        if js = data.delete('application/javascript')
-          data['text/html'] = "<script type='text/javascript'>#{js}</script>"
-        end
-
         data
       end
 
@@ -173,7 +167,7 @@ module IRuby
       type { NArray }
       format 'text/latex' do |obj|
         obj.dim == 2 ?
-        LaTeX.matrix(obj.transpose, obj.shape[1], obj.shape[0]) :
+        LaTeX.matrix(obj.transpose(1, 0), obj.shape[1], obj.shape[0]) :
           LaTeX.vector(obj.to_a)
       end
       format 'text/html' do |obj|
@@ -182,7 +176,7 @@ module IRuby
 
       type { Matrix }
       format 'text/latex' do |obj|
-        LaTeX.matrix(obj, obj.row_count, obj.column_count)
+        LaTeX.matrix(obj, obj.row_size, obj.column_size)
       end
       format 'text/html' do |obj|
         HTML.table(obj.to_a)
@@ -228,8 +222,8 @@ module IRuby
       end
 
       match do |obj|
-        defined?(Magic::Image) && Magic::Image === obj ||
-        defined?(MiniMagic::Image) && MiniMagic::Image === obj
+        defined?(Magick::Image) && Magick::Image === obj ||
+        defined?(MiniMagick::Image) && MiniMagick::Image === obj
       end
       format 'image' do |obj|
         format = obj.format || 'PNG'

data/lib/iruby/formatter.rb

@@ -24,11 +24,9 @@ module IRuby
   module HTML
     extend self
 
-    def table(obj, options = {})
-      options[:maxrows] = 15 unless options.include?(:maxrows)
-      options[:maxcols] = 15 unless options.include?(:maxcols)
-      raise ArgumentError, 'Invalid :maxrows' if options[:maxrows] && options[:maxrows] < 3
-      raise ArgumentError, 'Invalid :maxcols' if options[:maxcols] && options[:maxcols] < 3
+    def table(obj, maxrows: 15, maxcols: 15, **options)
+      raise ArgumentError, 'Invalid :maxrows' if maxrows && maxrows < 3
+      raise ArgumentError, 'Invalid :maxcols' if maxcols && maxcols < 3
 
       return obj unless obj.respond_to?(:each)
 
@@ -77,18 +75,18 @@ module IRuby
       keys1, keys2 = keys, nil
       header1, header2 = header, nil
 
-      if options[:maxcols] && keys.size > options[:maxcols]
-        keys1 = keys[0...options[:maxcols] / 2]
-        keys2 = keys[-options[:maxcols] / 2...-1]
+      if maxcols && keys.size > maxcols
+        keys1 = keys[0...maxcols / 2]
+        keys2 = keys[-maxcols / 2...-1]
         if header
-          header1 = header[0...options[:maxcols] / 2]
-          header2 = header[-options[:maxcols] / 2...-1]
+          header1 = header[0...maxcols / 2]
+          header2 = header[-maxcols / 2...-1]
         end
       end
 
-      if options[:maxrows] && rows.size > options[:maxrows]
-        rows1 = rows[0...options[:maxrows] / 2]
-        rows2 = rows[-options[:maxrows] / 2...-1]
+      if maxrows && rows.size > maxrows
+        rows1 = rows[0...maxrows / 2]
+        rows2 = rows[-maxrows / 2...-1]
       end
 
       table = '<table>'

data/lib/iruby/kernel.rb

@@ -8,102 +8,96 @@ module IRuby
       attr_accessor :instance
     end
 
+    attr_reader :session, :comms
+
     def initialize(config_file)
       @config = MultiJson.load(File.read(config_file))
 
-      #puts 'Starting the kernel'
-      #puts config
-      #puts 'Use Ctrl-\\ (NOT Ctrl-C!) to terminate.'
+      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(ZMQ::XREP)
-      @reply_socket.bind(connection % @config['shell_port'])
+      reply_socket = c.socket(:ROUTER)
+      reply_socket.bind(connection % @config['shell_port'])
 
-      @pub_socket = c.socket(ZMQ::PUB)
-      @pub_socket.bind(connection % @config['iopub_port'])
+      pub_socket = c.socket(:PUB)
+      pub_socket.bind(connection % @config['iopub_port'])
 
       Thread.new do
         begin
-          hb_socket = c.socket(ZMQ::REP)
+          hb_socket = c.socket(:REP)
           hb_socket.bind(connection % @config['hb_port'])
-          ZMQ::Device.new(hb_socket, hb_socket)
+          ZMQ.proxy(hb_socket, hb_socket)
         rescue Exception => ex
-          STDERR.puts "Kernel heartbeat died: #{ex.message}\n"#{ex.backtrace.join("\n")}"
+          IRuby.logger.fatal "Kernel heartbeat died: #{ex.message}\n"#{ex.backtrace.join("\n")}"
         end
       end
 
-      @session = Session.new('kernel', @config)
+      @session = Session.new('kernel', @config, publish: pub_socket, reply: reply_socket)
 
-      $stdout = OStream.new(@session, @pub_socket, 'stdout')
-      $stderr = OStream.new(@session, @pub_socket, 'stderr')
+      $stdout = OStream.new(@session, 'stdout')
+      $stderr = OStream.new(@session, 'stderr')
 
       @execution_count = 0
       @backend = create_backend
       @running = true
+      @comms = {}
     end
 
     def create_backend
       PryBackend.new
     rescue Exception => ex
-      STDERR.puts ex.message unless LoadError === ex
+      IRuby.logger.warn ex.message unless LoadError === ex
       PlainBackend.new
     end
 
     def run
       send_status('starting')
       while @running
-        ident, msg = @session.recv(@reply_socket, 0)
+        ident, msg = @session.recv(:reply)
         type = msg[:header]['msg_type']
-        if type =~ /_request\Z/ && respond_to?(type)
+        if type =~ /comm_|_request\Z/ && respond_to?(type)
+          send_status('busy')
           send(type, ident, msg)
+          send_status('idle')
         else
-          STDERR.puts "Unknown message type: #{msg[:header]['msg_type']} #{msg.inspect}"
+          IRuby.logger.error "Unknown message type: #{msg[:header]['msg_type']} #{msg.inspect}"
         end
       end
     end
 
-    def display(obj, options={})
-      unless obj.nil?
-        content = { data: Display.display(obj, options), metadata: {}, execution_count: @execution_count }
-        @session.send(@pub_socket, 'pyout', content)
-      end
-      nil
-    end
-
     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(&:to_i),
-
-        # Programming language in which kernel is implemented (mandatory).
-        # Kernel included in IPython returns 'python'.
-        language: 'ruby'
+        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_socket, 'kernel_info_reply', content, ident)
+      @session.send(:reply, 'kernel_info_reply', content, ident)
     end
 
     def send_status(status)
-      @session.send(@pub_socket, 'status', execution_state: status)
+      @session.send(:publish, 'status', {execution_state: status})
     end
 
     def execute_request(ident, msg)
       begin
         code = msg[:content]['code']
       rescue
-        STDERR.puts "Got bad message: #{msg.inspect}"
+        IRuby.logger.fatal "Got bad message: #{msg.inspect}"
         return
       end
       @execution_count += 1 unless msg[:content].fetch('silent', false)
-      send_status('busy')
-      @session.send(@pub_socket, 'pyin', code: code)
+      @session.send(:publish, 'execute_input', {code: code, execution_count: @execution_count}, ident)
 
       result = nil
       begin
@@ -111,33 +105,35 @@ module IRuby
         content = {
           status: 'ok',
           payload: [],
-          user_variables: {},
           user_expressions: {},
           execution_count: @execution_count
         }
+      rescue SystemExit
+        raise
       rescue Exception => e
         content = {
+          status: 'error',
           ename: e.class.to_s,
           evalue: e.message,
-          etype: e.class.to_s,
-          status: 'error',
           traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *e.backtrace.map { |l| "#{WHITE}#{l}#{RESET}" }],
           execution_count: @execution_count
         }
-        @session.send(@pub_socket, 'pyerr', content)
+        @session.send(:publish, 'error', content, ident)
+      end
+      @session.send(:reply, 'execute_reply', content, ident)
+      unless result.nil? || msg[:content]['silent']
+        @session.send(:publish, 'execute_result', data: Display.display(result), metadata: {}, execution_count: @execution_count)
       end
-      @session.send(@reply_socket, 'execute_reply', content, ident)
-      display(result) unless msg[:content]['silent']
-      send_status('idle')
     end
 
     def complete_request(ident, msg)
       content = {
-        matches: @backend.complete(msg[:content]['line'], msg[:content]['text']),
+        matches: @backend.complete(msg[:content]['code']),
         status: 'ok',
-        matched_text: msg[:content]['line'],
+        cursor_start: 0,
+        cursor_end: msg[:content]['cursor_pos']
       }
-      @session.send(@reply_socket, 'complete_reply', content, ident)
+      @session.send(:reply, 'complete_reply', content, ident)
     end
 
     def connect_request(ident, msg)
@@ -147,11 +143,11 @@ module IRuby
         stdin_port: config['stdin_port'],
         hb_port:    config['hb_port']
       }
-      @session.send(@reply_socket, 'connect_reply', content, ident)
+      @session.send(:reply, 'connect_reply', content, ident)
     end
 
     def shutdown_request(ident, msg)
-      @session.send(@reply_socket, 'shutdown_reply', msg[:content], ident)
+      @session.send(:reply, 'shutdown_reply', msg[:content], ident)
       @running = false
     end
 
@@ -161,10 +157,10 @@ module IRuby
       content = {
         history: []
       }
-      @session.send(@reply_socket, 'history_reply', content, ident)
+      @session.send(:reply, 'history_reply', content, ident)
     end
 
-    def object_info_request(ident, msg)
+    def inspect_request(ident, msg)
       o = @backend.eval(msg[:content]['oname'])
       content = {
         oname: msg[:content]['oname'],
@@ -172,18 +168,34 @@ module IRuby
         ismagic: false,
         isalias: false,
         docstring: '', # TODO
-        type_class: o.class.to_s,
         type_class: o.class.superclass.to_s,
         string_form: o.inspect
       }
       content[:length] = o.length if o.respond_to?(:length)
-      @session.send(@reply_socket, 'object_info_reply', content, ident)
+      @session.send(:reply, 'inspect_reply', content, ident)
     rescue Exception
       content = {
         oname: msg[:content]['oname'],
         found: false
       }
-      @session.send(@reply_socket, 'object_info_reply', content, ident)
+      @session.send(:reply, 'inspect_reply', content, ident)
+    end
+
+    def comm_open(ident, 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)
+    end
+
+    def comm_msg(ident, msg)
+      @comms[msg[:content]['comm_id']].comm_msg(msg[:content]['data'])
+    end
+
+    def comm_close(ident, msg)
+      comm_id = msg[:content]['comm_id']
+      @comms[comm_id].comm_close
+      @comms.delete(comm_id)
     end
   end
 end