iruby 0.3 → 0.7.0

data/lib/iruby/session/cztop.rb

@@ -36,6 +36,10 @@ module IRuby
       end
     end
 
+    def description
+      'old-stle session using cztop'
+    end
+
     # Build and send a message
     def send(socket, type, content)
       idents =

data/lib/iruby/session_adapter.rb

@@ -0,0 +1,72 @@
+module IRuby
+  class SessionAdapterNotFound < RuntimeError; end
+
+  module SessionAdapter
+    class BaseAdapter
+      def self.available?
+        load_requirements
+        true
+      rescue LoadError
+        false
+      end
+
+      def self.load_requirements
+        # Do nothing
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def name
+        self.class.name[/::(\w+)Adapter\Z/, 1].downcase
+      end
+
+      def make_router_socket(protocol, host, port)
+        socket, port = make_socket(:ROUTER, protocol, host, port)
+        [socket, port]
+      end
+
+      def make_pub_socket(protocol, host, port)
+        socket, port = make_socket(:PUB, protocol, host, port)
+        [socket, port]
+      end
+
+      def make_rep_socket(protocol, host, port)
+        socket, port = make_socket(:REP, protocol, host, port)
+        [socket, port]
+      end
+    end
+
+    require_relative 'session_adapter/ffirzmq_adapter'
+    require_relative 'session_adapter/cztop_adapter'
+    require_relative 'session_adapter/pyzmq_adapter'
+    require_relative 'session_adapter/test_adapter'
+
+    def self.select_adapter_class(name=nil)
+      classes = {
+        'ffi-rzmq' => SessionAdapter::FfirzmqAdapter,
+        'cztop' => SessionAdapter::CztopAdapter,
+        # 'pyzmq' => SessionAdapter::PyzmqAdapter
+        'test' => SessionAdapter::TestAdapter,
+      }
+      if (name ||= ENV.fetch('IRUBY_SESSION_ADAPTER', nil))
+        cls = classes[name]
+        unless cls.available?
+          if ENV['IRUBY_SESSION_ADAPTER']
+            raise SessionAdapterNotFound,
+                  "Session adapter `#{name}` from IRUBY_SESSION_ADAPTER is unavailable"
+          else
+            raise SessionAdapterNotFound,
+                  "Session adapter `#{name}` is unavailable"
+          end
+        end
+        return cls
+      end
+      classes.each_value do |cls|
+        return cls if cls.available?
+      end
+      raise SessionAdapterNotFound, "No session adapter is available"
+    end
+  end
+end

data/lib/iruby/session_adapter/cztop_adapter.rb

@@ -0,0 +1,45 @@
+module IRuby
+  module SessionAdapter
+    class CztopAdapter < BaseAdapter
+      def self.load_requirements
+        require 'cztop'
+      end
+
+      def send(sock, data)
+        sock << data
+      end
+
+      def recv(sock)
+        sock.receive
+      end
+
+      def heartbeat_loop(sock)
+        loop do
+          message = sock.receive
+          sock << message
+        end
+      end
+
+      private
+
+      def socket_type_class(type_symbol)
+        case type_symbol
+        when :ROUTER, :PUB, :REP
+          CZTop::Socket.const_get(type_symbol)
+        else
+          if CZTop::Socket.const_defined?(type_symbol)
+            raise ArgumentError, "Unsupported ZMQ socket type: #{type_symbol}"
+          else
+            raise ArgumentError, "Invalid ZMQ socket type: #{type_symbol}"
+          end
+        end
+      end
+
+      def make_socket(type_symbol, protocol, host, port)
+        uri = "#{protocol}://#{host}:#{port}"
+        socket_class = socket_type_class(type_symbol)
+        socket_class.new(uri)
+      end
+    end
+  end
+end

data/lib/iruby/session_adapter/ffirzmq_adapter.rb

@@ -0,0 +1,55 @@
+module IRuby
+  module SessionAdapter
+    class FfirzmqAdapter < BaseAdapter
+      def self.load_requirements
+        require 'ffi-rzmq'
+      end
+
+      def send(sock, data)
+        data.each_with_index do |part, i|
+          sock.send_string(part, i == data.size - 1 ? 0 : ZMQ::SNDMORE)
+        end
+      end
+
+      def recv(sock)
+        msg = []
+        while msg.empty? || sock.more_parts?
+          begin
+            frame = ''
+            rc = sock.recv_string(frame)
+            ZMQ::Util.error_check('zmq_msg_recv', rc)
+            msg << frame
+          rescue
+          end
+        end
+        msg
+      end
+
+      def heartbeat_loop(sock)
+        @heartbeat_device = ZMQ::Device.new(sock, sock)
+      end
+
+      private
+
+      def make_socket(type, protocol, host, port)
+        case type
+        when :ROUTER, :PUB, :REP
+          type = ZMQ.const_get(type)
+        else
+          if ZMQ.const_defined?(type)
+            raise ArgumentError, "Unsupported ZMQ socket type: #{type_symbol}"
+          else
+            raise ArgumentError, "Invalid ZMQ socket type: #{type_symbol}"
+          end
+        end
+        zmq_context.socket(type).tap do |sock|
+          sock.bind("#{protocol}://#{host}:#{port}")
+        end
+      end
+
+      def zmq_context
+        @zmq_context ||= ZMQ::Context.new
+      end
+    end
+  end
+end

data/lib/iruby/session_adapter/pyzmq_adapter.rb

@@ -0,0 +1,77 @@
+module IRuby
+  module SessionAdapter
+    class PyzmqAdapter < BaseAdapter
+
+      class << self
+        def load_requirements
+          require 'pycall'
+          import_pyzmq
+        end
+
+        def import_pyzmq
+          @zmq = PyCall.import_module('zmq')
+        rescue PyCall::PyError => error
+          raise LoadError, error.message
+        end
+
+        attr_reader :zmq
+      end
+
+      def make_router_socket(protocol, host, port)
+        make_socket(:ROUTER, protocol, host, port)
+      end
+
+      def make_pub_socket(protocol, host, port)
+        make_socket(:PUB, protocol, host, port)
+      end
+
+      def heartbeat_loop(sock)
+        PyCall.sys.path.append(File.expand_path('../pyzmq', __FILE__))
+        heartbeat = PyCall.import_module('iruby.heartbeat')
+        @heartbeat_thread = heartbeat.Heartbeat.new(sock)
+        @heartbeat_thread.start
+      end
+
+      private
+
+      def socket_type(type_symbol)
+        case type_symbol
+        when :ROUTER, :PUB, :REP
+          zmq[type_symbol]
+        else
+          raise ArgumentError, "Unknown ZMQ socket type: #{type_symbol}"
+        end
+      end
+
+      def make_socket(type_symbol, protocol, host, port)
+        type = socket_type(type_symbol)
+        sock = zmq_context.socket(type)
+        bind_socket(sock, protocol, host, port)
+        sock
+      end
+
+      def bind_socket(sock, protocol, host, port)
+        iface = "#{protocol}://#{host}"
+        case protocol
+        when 'tcp'
+          if port <= 0
+            port = sock.bind_to_random_port(iface)
+          else
+            sock.bind("#{iface}:#{port}")
+          end
+        else
+          raise ArgumentError, "Unsupported protocol: #{protocol}"
+        end
+        [sock, port]
+      end
+
+      def zmq_context
+        zmq.Context.instance
+      end
+
+      def zmq
+        self.class.zmq
+      end
+    end
+  end
+end

data/lib/iruby/session_adapter/test_adapter.rb

@@ -0,0 +1,49 @@
+require 'iruby/session/mixin'
+
+module IRuby
+  module SessionAdapter
+    class TestAdapter < BaseAdapter
+      include IRuby::SessionSerialize
+
+      DummySocket = Struct.new(:type, :protocol, :host, :port)
+
+      def initialize(config)
+        super
+
+        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
+
+        @send_callback = nil
+        @recv_callback = nil
+      end
+
+      attr_accessor :send_callback, :recv_callback
+
+      def send(sock, data)
+        unless @send_callback.nil?
+          @send_callback.call(sock, unserialize(data))
+        end
+      end
+
+      def recv(sock)
+        unless @recv_callback.nil?
+          serialize(@recv_callback.call(sock))
+        end
+      end
+
+      def heartbeat_loop(sock)
+      end
+
+      private
+
+      def make_socket(type, protocol, host, port)
+        DummySocket.new(type, protocol, host, port)
+      end
+    end
+  end
+end

data/lib/iruby/utils.rb

@@ -4,34 +4,45 @@ module IRuby
       Display.convert(object, options)
     end
 
+    # Display the object
     def display(obj, options = {})
       Kernel.instance.session.send(:publish, :display_data,
                                    data: Display.display(obj, options),
-                                   metadata: {},
-                                   source: 'ruby') unless obj.nil?
+                                   metadata: {}) unless obj.nil?
     end
 
+    # Clear the output area
+    def clear_output(wait=false)
+      Display.clear_output(wait)
+    end
+
+    # Format the given object into HTML table
     def table(s, **options)
       html(HTML.table(s, options))
     end
 
+    # Treat the given string as LaTeX text
     def latex(s)
       convert(s, mime: 'text/latex')
     end
     alias tex latex
 
+    # Format the given string of TeX equation into LaTeX text
     def math(s)
       convert("$$#{s}$$", mime: 'text/latex')
     end
 
+    # Treat the given string as HTML
     def html(s)
       convert(s, mime: 'text/html')
     end
 
+    # Treat the given string as JavaScript code
     def javascript(s)
       convert(s, mime: 'application/javascript')
     end
 
+    # Treat the given string as SVG text
     def svg(s)
       convert(s, mime: 'image/svg+xml')
     end

data/lib/iruby/version.rb

@@ -1,3 +1,3 @@
 module IRuby
-  VERSION = '0.3'
+  VERSION = '0.7.0'
 end

data/run-test.sh

@@ -0,0 +1,12 @@
+#! /bin/bash
+
+set -ex
+
+export PYTHON=python3
+
+ADAPTERS="cztop ffi-rzmq pyzmq"
+
+for adapter in $ADAPTERS; do
+  export IRUBY_TEST_SESSION_ADAPTER_NAME=$adapter
+  bundle exec rake test TESTOPTS=-v
+done

data/tasks/ci.rake

@@ -0,0 +1,65 @@
+namespace :ci do
+  namespace :docker do
+    def ruby_version
+      @ruby_version ||= ENV['ruby_version']
+    end
+
+    def ruby_image_name
+      @ruby_image_name ||= "rubylang/ruby:#{ruby_version}-bionic"
+    end
+
+    def iruby_test_base_image_name
+      @iruby_test_base_image_name ||= "iruby-test-base:ruby-#{ruby_version}"
+    end
+
+    def iruby_test_image_name
+      @docker_image_name ||= begin
+                               "sciruby/iruby-test:ruby-#{ruby_version}"
+                             end
+    end
+
+    def docker_image_found?(image_name)
+      image_id = `docker images -q #{image_name}`.chomp
+      image_id.length > 0
+    end
+
+    directory 'tmp'
+
+    desc "Build iruby-test-base docker image"
+    task :build_test_base_image => 'tmp' do
+      unless docker_image_found?(iruby_test_base_image_name)
+        require 'erb'
+        dockerfile_content = ERB.new(File.read('ci/Dockerfile.base.erb')).result(binding)
+        File.write('tmp/Dockerfile', dockerfile_content)
+        sh 'docker', 'build', '-t', iruby_test_base_image_name, '-f', 'tmp/Dockerfile', '.'
+      end
+    end
+
+    desc "Pull docker image of ruby"
+    task :pull_ruby_image do
+      sh 'docker', 'pull', ruby_image_name
+    end
+
+    desc "Build iruby-test docker image"
+    task :build_test_image => 'tmp' do
+      require 'erb'
+      dockerfile_content = ERB.new(File.read('ci/Dockerfile.main.erb')).result(binding)
+      File.write('tmp/Dockerfile', dockerfile_content)
+      sh 'docker', 'build', '-t', iruby_test_image_name, '-f', 'tmp/Dockerfile', '.'
+    end
+
+    desc 'before_install script for CI with Docker'
+    task :before_install => :pull_ruby_image
+    task :before_install => :build_test_base_image
+
+    desc 'install script for CI with Docker'
+    task :install => :build_test_image
+
+    desc 'main script for CI with Docker'
+    task :script do
+      volumes = ['-v', "#{Dir.pwd}:/iruby"] if ENV['attach_pwd']
+      sh 'docker', 'run', '--rm', '-it', *volumes,
+         iruby_test_image_name, 'bash', 'run-test.sh'
+    end
+  end
+end