iruby 0.2.7 → 0.5.0

data/lib/iruby/input/select.rb

@@ -0,0 +1,59 @@
+module IRuby
+  module Input
+    class Select < Label
+      needs :options, :default
+
+      builder :select do |*args, **params|
+        key = :select
+        key, *args = args if args.first.is_a? Symbol
+
+        params[:key] = unique_key(key)
+        params[:options] = args
+        params[:default] ||= false
+
+        unless params[:options].include? params[:default]
+          params[:options] = [nil, *params[:options].compact]
+        end
+
+        add_field Select.new(**params)
+      end
+
+      def widget_css
+        <<-CSS
+          .iruby-select {
+            min-width: 25%;
+            margin-left: 0 !important;
+          }
+        CSS
+      end
+
+      def widget_js
+        <<-JS
+          $('.iruby-select').change(function(){
+            $(this).data('iruby-value',
+              $(this).find('option:selected').text()
+            );
+          });
+        JS
+      end
+
+      def widget_html
+        widget_label do
+          div class: 'form-control' do
+            params = {
+              class: 'iruby-select',
+              :'data-iruby-key' => @key,
+              :'data-iruby-value' => @default
+            }
+
+            select **params do
+              @options.each do |o|
+                option o, selected: @default == o
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iruby/input/textarea.rb

@@ -0,0 +1,23 @@
+module IRuby
+  module Input
+    class Textarea < Field
+      needs rows: 5
+
+      builder :textarea do |key='textarea', **params|
+        params[:key] = unique_key key
+        add_field Textarea.new(**params)
+      end
+
+      def widget_html
+        widget_label do
+          textarea(
+            @default,
+            rows: @rows,
+            :'data-iruby-key' => @key,
+            class: 'form-control iruby-field'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/iruby/input/widget.rb

@@ -0,0 +1,34 @@
+module IRuby
+  module Input
+    class Widget < Erector::Widget
+      needs key: nil
+
+      def widget_js; end
+      def widget_css; end
+      def widget_html; end
+      def content; widget_html; end
+
+      def self.builder method, &block
+        Builder.instance_eval do
+          define_method method, &block
+        end
+      end
+
+      def widget_join method, *args
+        strings = args.map do |arg|
+          arg.is_a?(String) ? arg : arg.send(method)
+        end
+        strings.uniq.join("\n")
+      end
+
+      def widget_display
+        IRuby.display(IRuby.html(
+          Erector.inline{ style raw(widget_css) }.to_html
+        ))
+
+        IRuby.display(IRuby.html(to_html))
+        IRuby.display(IRuby.javascript(widget_js))
+      end
+    end
+  end
+end

data/lib/iruby/jupyter.rb

@@ -0,0 +1,77 @@
+module IRuby
+  module Jupyter
+    class << self
+      # User's default kernelspec directory is described here:
+      #     https://jupyter.readthedocs.io/en/latest/projects/jupyter-directories.html
+      def default_data_dir
+        case
+        when windows?
+          appdata = windows_user_appdata
+          if !appdata.empty?
+            File.join(appdata, 'jupyter')
+          else
+            jupyter_config_dir = ENV.fetch('JUPYTER_CONFIG_DIR', File.expand_path('~/.jupyter'))
+            File.join(jupyter_config_dir, 'data')
+          end
+        when apple?
+          File.expand_path('~/Library/Jupyter')
+        else
+          xdg_data_home = ENV.fetch('XDG_DATA_HOME', '')
+          data_home = xdg_data_home[0] ? xdg_data_home : File.expand_path('~/.local/share')
+          File.join(data_home, 'jupyter')
+        end
+      end
+
+      def kernelspec_dir(data_dir=nil)
+        data_dir ||= default_data_dir
+        File.join(data_dir, 'kernels')
+      end
+
+      private
+
+      # returns %APPDATA%
+      def windows_user_appdata
+        require 'fiddle/import'
+        check_windows
+        path = Fiddle::Pointer.malloc(2 * 300) # uint16_t[300]
+        csidl_appdata = 0x001a
+        case call_SHGetFolderPathW(Fiddle::NULL, csidl_appdata, Fiddle::NULL, 0, path)
+        when 0
+          len = (1 ... (path.size/2)).find {|i| path[2*i, 2] == "\0\0" }
+          path = path.to_str(2*len).encode(Encoding::UTF_8, Encoding::UTF_16LE)
+        else
+          ENV.fetch('APPDATA', '')
+        end
+      end
+
+      def call_SHGetFolderPathW(hwnd, csidl, hToken, dwFlags, pszPath)
+        require 'fiddle/import'
+        shell32 = Fiddle::Handle.new('shell32')
+        func = Fiddle::Function.new(
+          shell32['SHGetFolderPathW'],
+          [
+            Fiddle::TYPE_VOIDP,
+            Fiddle::TYPE_INT,
+            Fiddle::TYPE_VOIDP,
+            Fiddle::TYPE_INT,
+            Fiddle::TYPE_VOIDP
+          ],
+          Fiddle::TYPE_INT,
+          Fiddle::Importer.const_get(:CALL_TYPE_TO_ABI)[:stdcall])
+        func.(hwnd, csidl, hToken, dwFlags, pszPath)
+      end
+
+      def check_windows
+        raise 'the current platform is not Windows' unless windows?
+      end
+
+      def windows?
+        /mingw|mswin/ =~ RUBY_PLATFORM
+      end
+
+      def apple?
+        /darwin/ =~ RUBY_PLATFORM
+      end
+    end
+  end
+end

data/lib/iruby/kernel.rb

@@ -1,7 +1,6 @@
 module IRuby
   class Kernel
     RED = "\e[31m"
-    WHITE = "\e[37m"
     RESET = "\e[0m"
 
     class<< self
@@ -19,6 +18,8 @@ module IRuby
       $stdout = OStream.new(@session, :stdout)
       $stderr = OStream.new(@session, :stderr)
 
+      init_parent_process_poller
+
       @execution_count = 0
       @backend = create_backend
       @running = true
@@ -40,6 +41,7 @@ module IRuby
 
     def dispatch
       msg = @session.recv(:reply)
+      IRuby.logger.debug "Kernel#dispatch: msg = #{msg}"
       type = msg[:header]['msg_type']
       raise "Unknown message type: #{msg.inspect}" unless type =~ /comm_|_request\Z/ && respond_to?(type)
       begin
@@ -50,24 +52,32 @@ module IRuby
       end
     rescue Exception => e
       IRuby.logger.debug "Kernel error: #{e.message}\n#{e.backtrace.join("\n")}"
-      @session.send(:publish, :error, error_message(e))
+      @session.send(:publish, :error, error_content(e))
     end
 
     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: 'application/x-ruby',
-                      file_extension: 'rb'
-                    })
+                      file_extension: '.rb'
+                    },
+                    banner: "IRuby #{IRuby::VERSION} (with #{@session.description})",
+                    help_links: [
+                      {
+                        text: "Ruby Documentation",
+                        url:  "https://ruby-doc.org/"
+                      }
+                    ],
+                    status: :ok)
     end
 
     def send_status(status)
+      IRuby.logger.debug "Send status: #{status}"
       @session.send(:publish, :status, execution_state: status)
     end
 
@@ -88,8 +98,10 @@ module IRuby
       rescue SystemExit
         content[:payload] << { source: :ask_exit }
       rescue Exception => e
-        content = error_message(e)
+        content = error_content(e)
         @session.send(:publish, :error, content)
+        content[:status] = :error
+        content[:execution_count] = @execution_count
       end
       @session.send(:reply, :execute_reply, content)
       @session.send(:publish, :execute_result,
@@ -98,26 +110,33 @@ module IRuby
                     execution_count: @execution_count) unless result.nil? || msg[:content]['silent']
     end
 
-    def error_message(e)
-      { status: :error,
-        ename: e.class.to_s,
+    def error_content(e)
+      rindex = e.backtrace.rindex{|line| line.start_with?(@backend.eval_path)} || -1
+      backtrace = SyntaxError === e  && rindex == -1 ? [] : e.backtrace[0..rindex]
+      { 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 }
+        traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *backtrace] }
+    end
+
+    def is_complete_request(msg)
+      # FIXME: the code completeness should be judged by using ripper or other Ruby parser
+      @session.send(:reply, :is_complete_reply,
+                    status: :unknown)
     end
 
     def complete_request(msg)
       # HACK for #26, only complete last line
       code = msg[:content]['code']
-      if start = code.rindex("\n")
+      if start = code.rindex(/\s|\R/)
         code = code[start+1..-1]
         start += 1
       end
       @session.send(:reply, :complete_reply,
                     matches: @backend.complete(code),
-                    status: :ok,
                     cursor_start: start.to_i,
-                    cursor_end: msg[:content]['cursor_pos'])
+                    cursor_end: msg[:content]['cursor_pos'],
+                    metadata: {},
+                    status: :ok)
     end
 
     def connect_request(msg)
@@ -136,14 +155,8 @@ module IRuby
     end
 
     def inspect_request(msg)
-      result = @backend.eval(msg[:content]['code'])
-      @session.send(:reply, :inspect_reply,
-                    status: :ok,
-                    data: Display.display(result),
-                    metadata: {})
-    rescue Exception => e
-      IRuby.logger.warn "Inspection error: #{e.message}\n#{e.backtrace.join("\n")}"
-      @session.send(:reply, :inspect_reply, status: :error)
+      # not yet implemented. See (#119).
+      @session.send(:reply, :inspect_reply, status: :ok, found: false, data: {}, metadata: {})
     end
 
     def comm_open(msg)
@@ -161,5 +174,37 @@ module IRuby
       Comm.comm[comm_id].handle_close(msg[:content]['data'])
       Comm.comm.delete(comm_id)
     end
+
+    private
+
+    def init_parent_process_poller
+      pid = ENV.fetch('JPY_PARENT_PID', 0).to_i
+      return unless pid > 1
+
+      case RUBY_PLATFORM
+      when /mswin/, /mingw/
+        # TODO
+      else
+        @parent_poller = start_parent_process_pollar_unix
+      end
+    end
+
+    def start_parent_process_pollar_unix
+      Thread.start do
+        IRuby.logger.warn("parent process poller thread started.")
+        loop do
+          begin
+            current_ppid = Process.ppid
+            if current_ppid == 1
+              IRuby.logger.warn("parent process appears to exited, shutting down.")
+              exit!(1)
+            end
+            sleep 1
+          rescue Errno::EINTR
+            # ignored
+          end
+        end
+      end
+    end
   end
 end

data/lib/iruby/ostream.rb

@@ -25,22 +25,38 @@ module IRuby
     alias_method :next, :read
     alias_method :readline, :read
 
-    def write(s)
-      raise 'I/O operation on closed file' unless @session
-      @session.send(:publish, :stream, name: @name, text: s.to_s)
-      nil
+    def write(*obj)
+      str = build_string { |sio| sio.write(*obj) }
+      session_send(str)
     end
     alias_method :<<, :write
     alias_method :print, :write
 
-    def puts(*lines)
-      lines = [''] if lines.empty?
-      lines.each { |s| write("#{s}\n")}
-      nil
+    def printf(format, *obj)
+      str = build_string { |sio| sio.printf(format, *obj) }
+      session_send(str)
+    end
+
+    def puts(*obj)
+      str = build_string { |sio| sio.puts(*obj) }
+      session_send(str)
     end
 
     def writelines(lines)
       lines.each { |s| write(s) }
     end
+
+    private
+
+    def build_string
+      StringIO.open { |sio| yield(sio); sio.string }
+    end
+
+    def session_send(str)
+      raise 'I/O operation on closed file' unless @session
+
+      @session.send(:publish, :stream, name: @name, text: str)
+      nil
+    end
   end
 end

data/lib/iruby/session.rb

@@ -1,98 +1,116 @@
+require 'iruby/session_adapter'
+require 'iruby/session/mixin'
+
+require 'securerandom'
+
 module IRuby
   class Session
-    DELIM = '<IDS|MSG>'
+    include SessionSerialize
+
+    def initialize(config, adapter_name=nil)
+      @config = config
+      @adapter = create_session_adapter(config, adapter_name)
 
-    def initialize(config)
-      c = ZMQ::Context.new
+      setup
+      setup_sockets
+      setup_heartbeat
+      setup_security
+    end
 
-      connection = "#{config['transport']}://#{config['ip']}:%d"
-      reply_socket = c.socket(:ROUTER)
-      reply_socket.bind(connection % config['shell_port'])
+    attr_reader :adapter, :config
 
-      pub_socket = c.socket(:PUB)
-      pub_socket.bind(connection % config['iopub_port'])
+    def description
+      "#{@adapter.name} session adapter"
+    end
 
-      Thread.new do
+    def setup
+    end
+
+    def setup_sockets
+      protocol, host = config.values_at('transport', 'ip')
+      shell_port = config['shell_port']
+      iopub_port = config['iopub_port']
+      stdin_port = config['stdin_port']
+
+      @shell_socket, @shell_port = @adapter.make_router_socket(protocol, host, shell_port)
+      @iopub_socket, @iopub_port = @adapter.make_pub_socket(protocol, host, iopub_port)
+      @stdin_socket, @stdin_port = @adapter.make_router_socket(protocol, host, stdin_port)
+
+      @sockets = {
+        publish: @iopub_socket,
+        reply:   @shell_socket,
+        stdin:   @stdin_socket
+      }
+    end
+
+    def setup_heartbeat
+      protocol, host = config.values_at('transport', 'ip')
+      hb_port = config['hb_port']
+      @hb_socket, @hb_port = @adapter.make_rep_socket(protocol, host, hb_port)
+      @heartbeat_thread = Thread.start do
         begin
-          hb_socket = c.socket(:REP)
-          hb_socket.bind(connection % config['hb_port'])
-          ZMQ.proxy(hb_socket, hb_socket)
+          # NOTE: this loop is copied from CZTop's old session code
+          @adapter.heartbeat_loop(@hb_socket)
         rescue Exception => e
           IRuby.logger.fatal "Kernel heartbeat died: #{e.message}\n#{e.backtrace.join("\n")}"
         end
       end
+    end
 
-      @sockets = { publish: pub_socket, reply: reply_socket }
-      @session = SecureRandom.uuid
-      unless config['key'].to_s.empty? || config['signature_scheme'].to_s.empty?
-        raise 'Unknown signature scheme' unless config['signature_scheme'] =~ /\Ahmac-(.*)\Z/
-        @hmac = OpenSSL::HMAC.new(config['key'], OpenSSL::Digest.new($1))
+    def setup_security
+      @session_id = SecureRandom.uuid
+      unless config['key'].empty? || config['signature_scheme'].empty?
+        unless config['signature_scheme'] =~ /\Ahmac-/
+          raise "Unknown signature_scheme: #{config['signature_scheme']}"
+        end
+        digest_algorithm = config['signature_scheme'][/\Ahmac-(.*)\Z/, 1]
+        @hmac = OpenSSL::HMAC.new(config['key'], OpenSSL::Digest.new(digest_algorithm))
       end
     end
 
-    # Build and send a message
-    def send(socket, type, content)
-      idents =
-        if socket == :reply && @last_recvd_msg
-          @last_recvd_msg[:idents]
-        else
-          type == :stream ? "stream.#{content[:name]}" : type
-        end
+    def send(socket_type, message_type, content)
+      sock = check_socket_type(socket_type)
+      idents = if socket_type == :reply && @last_recvd_msg
+                 @last_recvd_msg[:idents]
+               else
+                 message_type == :stream ? "stream.#{content[:name]}" : message_type
+               end
       header = {
-        msg_type: type,
+        msg_type: message_type,
         msg_id:   SecureRandom.uuid,
         username: 'kernel',
-        session:  @session,
+        session:  @session_id,
         version:  '5.0'
       }
-      @sockets[socket].send_message(serialize(idents, header, content))
+      @adapter.send(sock, serialize(idents, header, content))
     end
 
-    # Receive a message and decode it
-    def recv(socket)
-      @last_recvd_msg = unserialize(@sockets[socket].recv_message)
+    def recv(socket_type)
+      sock = check_socket_type(socket_type)
+      data = @adapter.recv(sock)
+      @last_recvd_msg = unserialize(data)
     end
 
-    private
-
-    def serialize(idents, header, content)
-      msg = [MultiJson.dump(header),
-             MultiJson.dump(@last_recvd_msg ? @last_recvd_msg[:header] : {}),
-             '{}',
-             MultiJson.dump(content || {})]
-      frames = ([*idents].compact.map(&:to_s) << DELIM << sign(msg)) + msg
-      IRuby.logger.debug "Sent #{frames.inspect}"
-      ZMQ::Message(*frames)
+    def recv_input
+      sock = check_socket_type(:stdin)
+      data = @adapter.recv(sock)
+      unserialize(data)[:content]["value"]
     end
 
-    def unserialize(msg)
-      raise 'no message received' unless msg
-      frames = msg.to_a.map(&:to_s)
-      IRuby.logger.debug "Received #{frames.inspect}"
-
-      i = frames.index(DELIM)
-      idents, msg_list = frames[0..i-1], frames[i+1..-1]
-
-      minlen = 5
-      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])
-      {
-        idents:        idents,
-        header:        MultiJson.load(header),
-        parent_header: MultiJson.load(parent_header),
-        metadata:      MultiJson.load(metadata),
-        content:       MultiJson.load(content),
-        buffers:       buffers
-      }
+    private
+
+    def check_socket_type(socket_type)
+      case socket_type
+      when :publish, :reply, :stdin
+        @sockets[socket_type]
+      else
+        raise ArgumentError, "Invalid socket type #{socket_type}"
+      end
     end
 
-    # Sign using HMAC
-    def sign(list)
-      return '' unless @hmac
-      @hmac.reset
-      list.each {|m| @hmac.update(m) }
-      @hmac.hexdigest
+    def create_session_adapter(config, adapter_name)
+      adapter_class = SessionAdapter.select_adapter_class(adapter_name)
+      adapter_class.new(config)
     end
   end
 end