iruby 0.2.9 → 0.6.1

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.2.9'
+  VERSION = '0.6.1'
 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

data/test/helper.rb

@@ -0,0 +1,133 @@
+require "iruby"
+require "iruby/logger"
+require "json"
+require 'multi_json'
+require "pathname"
+require "test/unit"
+require "test/unit/rr"
+require "tmpdir"
+
+
+IRuby.logger = IRuby::MultiLogger.new(*Logger.new(STDERR, level: Logger::Severity::INFO))
+
+module IRubyTest
+  class TestBase < Test::Unit::TestCase
+    def self.startup
+      @__config_dir = Dir.mktmpdir("iruby-test")
+      @__config_path = Pathname.new(@__config_dir) + "config.json"
+      File.write(@__config_path, {
+        control_port: 50160,
+        shell_port: 57503,
+        transport: "tcp",
+        signature_scheme: "hmac-sha256",
+        stdin_port: 52597,
+        hb_port: 42540,
+        ip: "127.0.0.1",
+        iopub_port: 40885,
+        key: "a0436f6c-1916-498b-8eb9-e81ab9368e84"
+      }.to_json)
+
+      @__original_kernel_instance = IRuby::Kernel.instance
+    end
+
+    def self.shutdown
+      FileUtils.remove_entry_secure(@__config_dir)
+    end
+
+    def self.test_config_filename
+      @__config_path.to_s
+    end
+
+    def teardown
+      IRuby::Kernel.instance = @__original_kernel_instance
+    end
+
+    def with_session_adapter(session_adapter_name)
+      IRuby::Kernel.new(self.class.test_config_filename, session_adapter_name)
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+
+    def assert_output(stdout=nil, stderr=nil)
+      flunk "assert_output requires a block to capture output." unless block_given?
+
+      out, err = capture_io do
+        yield
+      end
+
+      y = check_assert_output_result(stderr, err, "stderr")
+      x = check_assert_output_result(stdout, out, "stdout")
+
+      (!stdout || x) && (!stderr || y)
+    end
+
+    private
+
+    def capture_io
+      captured_stdout = StringIO.new
+      captured_stderr = StringIO.new
+
+      orig_stdout, $stdout = $stdout, captured_stdout
+      orig_stderr, $stderr = $stderr, captured_stderr
+
+      yield
+
+      return captured_stdout.string, captured_stderr.string
+    ensure
+      $stdout = orig_stdout
+      $stderr = orig_stderr
+    end
+
+    def check_assert_output_result(expected, actual, name)
+      if expected
+        message = "In #{name}"
+        case expected
+        when Regexp
+          assert_match(expected, actual, message)
+        else
+          assert_equal(expected, actual, message)
+        end
+      end
+    end
+
+    def ignore_warning
+      saved, $VERBOSE = $VERBOSE , nil
+      yield
+    ensure
+      $VERBOSE = saved
+    end
+
+    def with_env(env)
+      keys = env.keys
+      saved_values = ENV.values_at(*keys)
+      ENV.update(env)
+      yield
+    ensure
+      if keys && saved_values
+        keys.zip(saved_values) do |k, v|
+          ENV[k] = v
+        end
+      end
+    end
+
+    def windows_only
+      omit('windows only test') unless windows?
+    end
+
+    def apple_only
+      omit('apple only test') unless windows?
+    end
+
+    def unix_only
+      omit('unix only test') if windows? || apple?
+    end
+
+    def windows?
+      /mingw|mswin/ =~ RUBY_PLATFORM
+    end
+
+    def apple?
+      /darwin/ =~ RUBY_PLATFORM
+    end
+  end
+end

data/test/integration_test.rb

@@ -1,40 +1,51 @@
-require 'test_helper'
-require 'open3'
+require 'pty'
 require 'expect'
 
-class IntegrationTest < IRubyTest
+class IRubyTest::IntegrationTest < IRubyTest::TestBase
   def setup
-    @stdin, @stdout, @stderr, @process = Open3.popen3('bin/iruby')
+    $expect_verbose = false # make true if you want to dump the output of iruby console
+
+    @in, @out, pid = PTY.spawn('bin/iruby --simple-prompt')
+    @waiter = Thread.start { Process.waitpid(pid) }
     expect 'In [', 30
     expect '1'
     expect ']:'
   end
 
   def teardown
-    @stdin.close
-    @stdout.close
-    @stderr.close
-    @process.kill
+    @in.close
+    @out.close
+    @waiter.join
   end
 
   def write(input)
-    @stdin.puts input
+    @out.puts input
   end
 
-  def expect(pattern, timeout = 1)
-    assert @stdout.expect(pattern, timeout), "#{pattern} expected"
+  def expect(pattern, timeout = 10)
+    assert @in.expect(pattern, timeout), "#{pattern} expected, but timeout"
+  end
+
+  def wait_prompt
+    expect 'In ['
+    expect ']:'
   end
 
   def test_interaction
+    omit("This test too much unstable")
+
     write '"Hello, world!"'
     expect '"Hello, world!"'
 
+    wait_prompt
     write 'puts "Hello!"'
     expect 'Hello!'
 
+    wait_prompt
     write '12 + 12'
     expect '24'
 
+    wait_prompt
     write 'ls'
     expect 'self.methods'
   end

data/test/iruby/backend_test.rb

@@ -0,0 +1,37 @@
+module IRubyTest
+  class PlainBackendTest < IRubyTest::TestBase
+    def setup
+      @plainbackend = IRuby::PlainBackend.new
+    end
+
+    def test_eval_one_plus_two
+      assert_equal 3, @plainbackend.eval('1+2', false)
+    end
+
+    def test_complete_req
+      assert_includes @plainbackend.complete('req'), 'require'
+    end
+
+    def test_complete_2_dot
+      assert_includes @plainbackend.complete('2.'), '2.even?'
+    end
+  end
+
+  class PryBackendTest < IRubyTest::TestBase
+    def setup
+      @prybackend = IRuby::PryBackend.new
+    end
+
+    def test_eval_one_plus_two
+      assert_equal 3, @prybackend.eval('1+2', false)
+    end
+
+    def test_complete_req
+      assert_includes @prybackend.complete('req'), 'require'
+    end
+
+    def test_complete_2_dot
+      assert_includes @prybackend.complete('2.'), '2.even?'
+    end
+  end
+end

data/test/iruby/command_test.rb

@@ -0,0 +1,207 @@
+require 'iruby/command'
+
+module IRubyTest
+  class CommandTest < TestBase
+    def test_with_empty_argv
+      with_env('JUPYTER_DATA_DIR' => nil,
+               'IPYTHONDIR' => nil) do
+        assert_output(nil, /\A\z/) do
+          @command = IRuby::Command.new([])
+          kernel_dir = File.join(IRuby::Jupyter.kernelspec_dir, 'ruby')
+          assert_equal(kernel_dir, @command.kernel_dir)
+          assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+        end
+      end
+    end
+
+    def test_with_JUPYTER_DATA_DIR
+      Dir.mktmpdir do |tmpdir|
+        with_env('JUPYTER_DATA_DIR' => tmpdir,
+                 'IPYTHONDIR' => nil) do
+          assert_output(nil, /\A\z/) do
+            @command = IRuby::Command.new([])
+            kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+            assert_equal(kernel_dir, @command.kernel_dir)
+            assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+          end
+        end
+      end
+    end
+
+    def test_with_IPYTHONDIR
+      Dir.mktmpdir do |tmpdir|
+        with_env('JUPYTER_DATA_DIR' => nil,
+                 'IPYTHONDIR' => tmpdir) do
+          assert_output(nil, /IPYTHONDIR is deprecated\. Use JUPYTER_DATA_DIR instead\./) do
+            @command = IRuby::Command.new([])
+            kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+            assert_equal(kernel_dir, @command.kernel_dir)
+            assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+          end
+        end
+      end
+    end
+
+    def test_with_JUPYTER_DATA_DIR_and_IPYTHONDIR
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => tmpdir2) do
+            assert_output(nil, /both JUPYTER_DATA_DIR and IPYTHONDIR are supplied; IPYTHONDIR is ignored\./) do
+              @command = IRuby::Command.new([])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              assert_equal(kernel_dir, @command.kernel_dir)
+              assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+            end
+          end
+        end
+      end
+    end
+
+    def test_with_ipython_dir_option
+      Dir.mktmpdir do |tmpdir|
+        with_env('JUPYTER_DATA_DIR' => nil,
+                 'IPYTHONDIR' => nil) do
+          assert_output(nil, /--ipython-dir is deprecated\. Use JUPYTER_DATA_DIR environment variable instead\./) do
+            @command = IRuby::Command.new(%W[--ipython-dir=#{tmpdir}])
+            kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+            assert_equal(kernel_dir, @command.kernel_dir)
+            assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+          end
+        end
+      end
+    end
+
+    def test_with_JUPYTER_DATA_DIR_and_ipython_dir_option
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => nil) do
+            assert_output(nil, /both JUPYTER_DATA_DIR and --ipython-dir are supplied; --ipython-dir is ignored\./) do
+              @command = IRuby::Command.new(%W[--ipython-dir=#{tmpdir2}])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              assert_equal(kernel_dir, @command.kernel_dir)
+              assert_equal(File.join(kernel_dir, 'kernel.json'), @command.kernel_file)
+            end
+          end
+        end
+      end
+    end
+
+    def test_register_when_there_is_kernel_in_ipython_dir
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => nil,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            ignore_warning do
+              @command = IRuby::Command.new(["register", "--ipython-dir=~/.ipython"])
+              assert_equal("#{tmpdir2}/.ipython/kernels/ruby/kernel.json", @command.kernel_file)
+              @command.run
+              assert(File.file?("#{tmpdir2}/.ipython/kernels/ruby/kernel.json"))
+            end
+          end
+
+          with_env('JUPYTER_DATA_DIR' => nil,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            @command = IRuby::Command.new(["register"])
+            assert_output(nil, /IRuby kernel file already exists in the deprecated IPython's data directory\.\nUsing --force, you can replace the old kernel file with the new one in Jupyter's data directory\./) do
+              @command.run
+            end
+            assert(File.file?(File.join(@command.ipython_kernel_dir, 'kernel.json')))
+            refute(File.file?(@command.kernel_file))
+
+            @command = IRuby::Command.new(["register", "--force"])
+            assert_output(nil, nil) do
+              @command.run
+            end
+            refute(File.exist?(@command.ipython_kernel_dir))
+            assert(File.file?(@command.kernel_file))
+          end
+        end
+      end
+    end
+
+    def test_register_and_unregister_with_JUPYTER_DATA_DIR
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            assert_output(nil, nil) do
+              @command = IRuby::Command.new(['register'])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              kernel_file = File.join(kernel_dir, 'kernel.json')
+              assert(!File.file?(kernel_file))
+
+              @command.run
+              assert(File.file?(kernel_file))
+
+              @command = IRuby::Command.new(['unregister'])
+              @command.run
+              assert(!File.file?(kernel_file))
+            end
+          end
+        end
+      end
+    end
+
+    def test_register_and_unregister_with_JUPYTER_DATA_DIR_when_there_is_kernel_in_ipython_dir
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('HOME' => tmpdir2) do
+            ignore_warning do
+              @command = IRuby::Command.new(["register", "--ipython-dir=~/.ipython"])
+              assert_equal("#{tmpdir2}/.ipython/kernels/ruby/kernel.json", @command.kernel_file)
+              @command.run
+              assert(File.file?("#{tmpdir2}/.ipython/kernels/ruby/kernel.json"))
+            end
+          end
+
+          with_env('JUPYTER_DATA_DIR' => tmpdir,
+                   'IPYTHONDIR' => nil,
+                   'HOME' => tmpdir2) do
+            @command = IRuby::Command.new(["register"])
+            assert_output(nil, /IRuby kernel file already exists in the deprecated IPython's data directory\.\nUsing --force, you can replace the old kernel file with the new one in Jupyter's data directory\./) do
+              @command.run
+            end
+            assert(File.file?(File.join(@command.ipython_kernel_dir, 'kernel.json')))
+            refute(File.file?(@command.kernel_file))
+
+            @command = IRuby::Command.new(["register", "--force"])
+            assert_output(nil, nil) do
+              @command.run
+            end
+            refute(File.file?(File.join(@command.ipython_kernel_dir, 'kernel.json')))
+            assert(File.file?(@command.kernel_file))
+          end
+        end
+      end
+    end
+
+    def test_register_and_unregister_with_IPYTHONDIR
+      Dir.mktmpdir do |tmpdir|
+        Dir.mktmpdir do |tmpdir2|
+          with_env('JUPYTER_DATA_DIR' => nil,
+                   'IPYTHONDIR' => tmpdir,
+                   'HOME' => tmpdir2) do
+            ignore_warning do
+              @command = IRuby::Command.new(['register'])
+              kernel_dir = File.join(tmpdir, 'kernels', 'ruby')
+              kernel_file = File.join(kernel_dir, 'kernel.json')
+              assert(!File.file?(kernel_file))
+
+              @command.run
+              assert(File.file?(kernel_file))
+
+              @command = IRuby::Command.new(['unregister'])
+              @command.run
+              assert(!File.file?(kernel_file))
+            end
+          end
+        end
+      end
+    end
+  end
+end