iruby 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1576475a17c04bbdc5080fede4710cf609c9cfb1268f692e8a11653095c2902b
-  data.tar.gz: 46c737c267739a44dc2a7a9d4ccd5c8d3fcf89fda1b4163e74d941bd0740ec44
+  metadata.gz: bc4c6b99aa811b7b1e6bf3e845c7dfa023dc26ce929dbc284836081d422c4b5f
+  data.tar.gz: f68c0f62665ec6bb302e460885ca6e54e93f7102b3cdf699cb67143155a6181a
 SHA512:
-  metadata.gz: 0225f7c54c11dc9668d6bbceff3dac9ba6e1d32e041355ab429b7f6b0bc204f8050f3420dfede65474614c259e7dba346db051f5414be5fb1fd2dffd9b5de894
-  data.tar.gz: 803cbe952a48614e1d7aeefef51f772c4420aeb07bf63a679384147fe12f10469380d733834126d206342a2c6a01d7d57d6202b8d64bd90921cd3825684d22c3
+  metadata.gz: 2de933258f837300d49209e51140276d9373ab6497c716cfe590d8e9e989d89a7e8e12410e4275c20d065e0fdfe1221c88074eb172bcadbab07c58077009d118
+  data.tar.gz: 3dfa8d4abbe218873e42626056d68bc24e2372f153f18316eb152ce08aa1f95c68b301cb41f7cf154ae8b5bb94324e9071296ff67f90325aed5b08dfa123cecd

data/CHANGES

@@ -1,3 +1,17 @@
+0.6.0 (2021-05-25)
+
+  Bug Fixes:
+    * Fix the handling of application/javascript https://github.com/SciRuby/iruby/issues/292, https://github.com/SciRuby/iruby/pull/294 (@kylekyle, @mrkn)
+
+  Enhancements:
+    * Add the `initialized` event in `IRuby::Kernel` class https://github.com/SciRuby/iruby/pull/168, https://github.com/SciRuby/iruby/pull/296 (@Yuki-Inoue, @mrkn)
+    * Add the following four events https://github.com/SciRuby/iruby/pull/295 (@mrkn):
+      * `pre-execute` -- occurs before every code execution
+      * `pre-run-cell` -- occurs before every non-silent code execution
+      * `post-execute` -- occurs after every code execution
+      * `post-run-cell` -- occurs after every non-silent code execution
+    * Replace Bond with IRB in PlainBackend https://github.com/SciRuby/iruby/pull/276, https://github.com/SciRuby/iruby/pull/297 (@cfis, @mrkn)
+
 0.5.0 (2021-03-25)
 
   Bug Fixes:

data/iruby.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.3.0'
 
-  s.add_dependency 'bond', '~> 0.5'
   s.add_dependency 'data_uri', '~> 0.1'
   s.add_dependency 'ffi-rzmq'
   s.add_dependency 'mime-types', '>= 3.3.1'

data/lib/iruby.rb

@@ -7,6 +7,7 @@ require 'set'
 
 require 'iruby/version'
 require 'iruby/jupyter'
+require 'iruby/event_manager'
 require 'iruby/kernel'
 require 'iruby/backend'
 require 'iruby/ostream'

data/lib/iruby/backend.rb

@@ -3,7 +3,7 @@ module IRuby
 
   module History
     def eval(code, store_history)
-      b = TOPLEVEL_BINDING
+      b = eval_binding
 
       b.local_variable_set(:_ih, In)  unless b.local_variable_defined?(:_ih)
       b.local_variable_set(:_oh, Out) unless b.local_variable_defined?(:_oh)
@@ -36,17 +36,27 @@ module IRuby
     prepend History
 
     def initialize
-      require 'bond'
-      Bond.start(debug: true)
-      @eval_path = '(iruby)'
+      require 'irb'
+      require 'irb/completion'
+      IRB.setup(nil)
+      @main = TOPLEVEL_BINDING.eval("self").dup
+      @workspace = IRB::WorkSpace.new(@main)
+      @irb = IRB::Irb.new(@workspace)
+      @eval_path = @irb.context.irb_path
+      IRB.conf[:MAIN_CONTEXT] = @irb.context
+    end
+
+    def eval_binding
+      @workspace.binding
     end
 
     def eval(code, store_history)
-      TOPLEVEL_BINDING.eval(code, @eval_path, 1)
+      @irb.context.evaluate(code, 0)
+      @irb.context.last_value
     end
 
     def complete(code)
-      Bond.agent.call(code, code)
+      IRB::InputCompletor::CompletionProc.call(code)
     end
   end
 
@@ -64,6 +74,10 @@ module IRuby
       reset
     end
 
+    def eval_binding
+      TOPLEVEL_BINDING
+    end
+
     def eval(code, store_history)
       Pry.current_line = 1
       @pry.last_result = nil
@@ -96,7 +110,7 @@ module IRuby
     end
 
     def reset
-      @pry = Pry.new(output: $stdout, target: TOPLEVEL_BINDING)
+      @pry = Pry.new(output: $stdout, target: eval_binding)
     end
   end
 end

data/lib/iruby/display.rb

@@ -44,7 +44,18 @@ module IRuby
       private
 
       def protect(mime, data)
-        MIME::Type.new(mime).ascii? ? data.to_s : [data.to_s].pack('m0')
+        ascii?(mime) ? data.to_s : [data.to_s].pack('m0')
+      end
+
+      def ascii?(mime)
+        case mime
+        when "application/javascript"
+          # Special case for application/javascript.
+          # This needs because mime-types tells us application/javascript a non-text type.
+          true
+        else
+          MIME::Type.new(mime).ascii?
+        end
       end
 
       def render(data, obj, exact_mime, fuzzy_mime)

data/lib/iruby/event_manager.rb

@@ -0,0 +1,40 @@
+module IRuby
+  class EventManager
+    def initialize(available_events)
+      @available_events = available_events.dup.freeze
+      @callbacks = available_events.map {|n| [n, []] }.to_h
+    end
+
+    attr_reader :available_events
+
+    def register(event, &block)
+      check_available_event(event)
+      @callbacks[event] << block unless block.nil?
+      block
+    end
+
+    def unregister(event, callback)
+      check_available_event(event)
+      val = @callbacks[event].delete(callback)
+      unless val
+        raise ArgumentError,
+              "Given callable object #{callback} is not registered as a #{event} callback"
+      end
+      val
+    end
+
+    def trigger(event, *args, **kwargs)
+      check_available_event(event)
+      @callbacks[event].each do |fn|
+        fn.call(*args, **kwargs)
+      end
+    end
+
+    private
+
+    def check_available_event(event)
+      return if @callbacks.key?(event)
+      raise ArgumentError, "Unknown event name: #{event}", caller
+    end
+  end
+end

data/lib/iruby/kernel.rb

@@ -1,30 +1,47 @@
 module IRuby
+  ExecutionInfo = Struct.new(:raw_cell, :store_history, :silent)
+
   class Kernel
     RED = "\e[31m"
     RESET = "\e[0m"
 
-    class<< self
+    @events = EventManager.new([:initialized])
+
+    class << self
+      attr_reader :events
       attr_accessor :instance
     end
 
     attr_reader :session
 
-    def initialize(config_file)
+    EVENTS = [
+      :pre_execute,
+      :pre_run_cell,
+      :post_run_cell,
+      :post_execute
+    ].freeze
+
+    def initialize(config_file, session_adapter_name=nil)
       @config = MultiJson.load(File.read(config_file))
       IRuby.logger.debug("IRuby kernel start with config #{@config}")
       Kernel.instance = self
 
-      @session = Session.new(@config)
+      @session = Session.new(@config, session_adapter_name)
       $stdout = OStream.new(@session, :stdout)
       $stderr = OStream.new(@session, :stderr)
 
       init_parent_process_poller
 
+      @events = EventManager.new(EVENTS)
       @execution_count = 0
       @backend = create_backend
       @running = true
+
+      self.class.events.trigger(:initialized, self)
     end
 
+    attr_reader :events
+
     def create_backend
       PryBackend.new
     rescue Exception => e
@@ -83,8 +100,20 @@ module IRuby
 
     def execute_request(msg)
       code = msg[:content]['code']
-      @execution_count += 1 if msg[:content]['store_history']
-      @session.send(:publish, :execute_input, code: code, execution_count: @execution_count)
+      store_history = msg[:content]['store_history']
+      silent = msg[:content]['silent']
+
+      @execution_count += 1 if store_history
+
+      unless silent
+        @session.send(:publish, :execute_input, code: code, execution_count: @execution_count)
+      end
+
+      events.trigger(:pre_execute)
+      unless silent
+        exec_info = ExecutionInfo.new(code, store_history, silent)
+        events.trigger(:pre_run_cell, exec_info)
+      end
 
       content = {
         status: :ok,
@@ -92,9 +121,10 @@ module IRuby
         user_expressions: {},
         execution_count: @execution_count
       }
+
       result = nil
       begin
-        result = @backend.eval(code, msg[:content]['store_history'])
+        result = @backend.eval(code, store_history)
       rescue SystemExit
         content[:payload] << { source: :ask_exit }
       rescue Exception => e
@@ -103,6 +133,10 @@ module IRuby
         content[:status] = :error
         content[:execution_count] = @execution_count
       end
+
+      events.trigger(:post_execute)
+      events.trigger(:post_run_cell, result) unless silent
+
       @session.send(:reply, :execute_reply, content)
       @session.send(:publish, :execute_result,
                     data: Display.display(result),

data/lib/iruby/ostream.rb

@@ -46,6 +46,11 @@ module IRuby
       lines.each { |s| write(s) }
     end
 
+    # Called by irb
+    def set_encoding(extern, intern)
+      a = extern
+    end
+
     private
 
     def build_string

data/lib/iruby/session_adapter.rb

@@ -10,6 +10,10 @@ module IRuby
         false
       end
 
+      def self.load_requirements
+        # Do nothing
+      end
+
       def initialize(config)
         @config = config
       end
@@ -37,12 +41,14 @@ module IRuby
     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]

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/version.rb

@@ -1,3 +1,3 @@
 module IRuby
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/test/helper.rb

@@ -1,10 +1,53 @@
 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?
 

data/test/iruby/event_manager_test.rb

@@ -0,0 +1,92 @@
+module IRubyTest
+  class EventManagerTest < TestBase
+    def setup
+      @man = IRuby::EventManager.new([:foo, :bar])
+    end
+
+    def test_available_events
+      assert_equal([:foo, :bar],
+                   @man.available_events)
+    end
+
+    sub_test_case("#register") do
+      sub_test_case("known event name") do
+        def test_register
+          fn = ->() {}
+          assert_equal(fn,
+                       @man.register(:foo, &fn))
+        end
+      end
+
+      sub_test_case("unknown event name") do
+        def test_register
+          assert_raise_message("Unknown event name: baz") do
+            @man.register(:baz) {}
+          end
+        end
+      end
+    end
+
+    sub_test_case("#unregister") do
+      sub_test_case("no event is registered") do
+        def test_unregister
+          fn = ->() {}
+          assert_raise_message("Given callable object #{fn} is not registered as a foo callback") do
+            @man.unregister(:foo, fn)
+          end
+        end
+      end
+
+      sub_test_case("the registered callable is given") do
+        def test_unregister
+          results = { values: [] }
+          fn = ->(a) { values << a }
+
+          @man.register(:foo, &fn)
+
+          results[:retval] = @man.unregister(:foo, fn)
+
+          @man.trigger(:foo, 42)
+
+          assert_equal({
+                         values: [],
+                         retval: fn
+                       },
+                       results)
+        end
+      end
+    end
+
+    sub_test_case("#trigger") do
+      sub_test_case("no event is registered") do
+        def test_trigger
+          assert_nothing_raised do
+            @man.trigger(:foo)
+          end
+        end
+      end
+
+      sub_test_case("some events are registered") do
+        def test_trigger
+          values = []
+          @man.register(:foo) {|a| values << a }
+          @man.register(:foo) {|a| values << 10*a }
+          @man.register(:foo) {|a| values << 100+a }
+
+          @man.trigger(:foo, 5)
+
+          assert_equal([5, 50, 105],
+                       values)
+        end
+      end
+
+      sub_test_case("unknown event name") do
+        def test_trigger
+          assert_raise_message("Unknown event name: baz") do
+            @man.trigger(:baz, 100)
+          end
+        end
+      end
+    end
+  end
+end

data/test/iruby/kernel_test.rb

@@ -0,0 +1,153 @@
+require "base64"
+
+module IRubyTest
+  class KernelTest < TestBase
+    def setup
+      super
+      with_session_adapter("test")
+      @kernel = IRuby::Kernel.instance
+    end
+
+    sub_test_case("iruby_initialized event") do
+      def setup
+        super
+        @initialized_kernel = nil
+        @callback = IRuby::Kernel.events.register(:initialized) do |kernel|
+          @initialized_kernel = kernel
+        end
+      end
+
+      def teardown
+        IRuby::Kernel.events.unregister(:initialized, @callback)
+      end
+
+      def test_iruby_initialized_event
+        with_session_adapter("test")
+        assert_same(IRuby::Kernel.instance, @initialized_kernel)
+      end
+    end
+
+    def test_execute_request
+      obj = Object.new
+
+      class << obj
+        def to_html
+          "<b>HTML</b>"
+        end
+
+        def inspect
+          "!!! inspect !!!"
+        end
+      end
+
+      ::IRubyTest.define_singleton_method(:test_object) { obj }
+
+      msg_types = []
+      execute_reply = nil
+      execute_result = nil
+      @kernel.session.adapter.send_callback = ->(sock, msg) do
+        header = msg[:header]
+        content = msg[:content]
+        msg_types << header["msg_type"]
+        case header["msg_type"]
+        when "execute_reply"
+          execute_reply = content
+        when "execute_result"
+          execute_result = content
+        end
+      end
+
+      msg = {
+        content: {
+          "code" => "IRubyTest.test_object",
+          "silent" => false,
+          "store_history" => false,
+          "user_expressions" => {},
+          "allow_stdin" => false,
+          "stop_on_error" => true,
+        }
+      }
+      @kernel.execute_request(msg)
+
+      assert_equal({
+                     msg_types: [ "execute_input", "execute_reply", "execute_result" ],
+                     execute_reply: {
+                       status: "ok",
+                       user_expressions: {},
+                     },
+                     execute_result: {
+                       data: {
+                         "text/html" => "<b>HTML</b>",
+                         "text/plain" => "!!! inspect !!!"
+                       },
+                       metadata: {},
+                     }
+                   },
+                   {
+                     msg_types: msg_types,
+                     execute_reply: {
+                       status: execute_reply["status"],
+                       user_expressions: execute_reply["user_expressions"]
+                     },
+                     execute_result: {
+                       data: execute_result["data"],
+                       metadata: execute_result["metadata"]
+                     }
+                   })
+    end
+
+    def test_events_around_of_execute_request
+      event_history = []
+
+      @kernel.events.register(:pre_execute) do
+        event_history << :pre_execute
+      end
+
+      @kernel.events.register(:pre_run_cell) do |exec_info|
+        event_history << [:pre_run_cell, exec_info]
+      end
+
+      @kernel.events.register(:post_execute) do
+        event_history << :post_execute
+      end
+
+      @kernel.events.register(:post_run_cell) do |result|
+        event_history << [:post_run_cell, result]
+      end
+
+      msg = {
+        content: {
+          "code" => "true",
+          "silent" => false,
+          "store_history" => false,
+          "user_expressions" => {},
+          "allow_stdin" => false,
+          "stop_on_error" => true,
+        }
+      }
+      @kernel.execute_request(msg)
+
+      msg = {
+        content: {
+          "code" => "true",
+          "silent" => true,
+          "store_history" => false,
+          "user_expressions" => {},
+          "allow_stdin" => false,
+          "stop_on_error" => true,
+        }
+      }
+      @kernel.execute_request(msg)
+
+      assert_equal([
+                     :pre_execute,
+                     [:pre_run_cell, IRuby::ExecutionInfo.new("true", false, false)],
+                     :post_execute,
+                     [:post_run_cell, true],
+                     :pre_execute,
+                     :post_execute
+                   ],
+                   event_history)
+    end
+  end
+end

data/test/iruby/mime_test.rb

@@ -1,14 +1,25 @@
 class IRubyTest::MimeTest < IRubyTest::TestBase
   sub_test_case("IRuby::Display") do
-    def test_display_with_mime_type
-      html = "<b>Bold Text</b>"
+    sub_test_case(".display") do
+      sub_test_case("with mime type") do
+        test("text/html") do
+          html = "<b>Bold Text</b>"
 
-      obj = Object.new
-      obj.define_singleton_method(:to_s) { html }
+          obj = Object.new
+          obj.define_singleton_method(:to_s) { html }
 
-      res = IRuby::Display.display(obj, mime: "text/html")
-      assert_equal({ plain: obj.inspect,       html: html },
-                   { plain: res["text/plain"], html: res["text/html"] })
+          res = IRuby::Display.display(obj, mime: "text/html")
+          assert_equal({ plain: obj.inspect,       html: html },
+                       { plain: res["text/plain"], html: res["text/html"] })
+        end
+
+        test("application/javascript") do
+          data = "alert('Hello World!')"
+          res = IRuby::Display.display(data, mime: "application/javascript")
+          assert_equal(data,
+                       res["application/javascript"])
+        end
+      end
     end
   end
 

data/test/iruby/session_test.rb

@@ -38,6 +38,7 @@ module IRubyTest
         stub(IRuby::SessionAdapter::CztopAdapter).available? { false }
         stub(IRuby::SessionAdapter::FfirzmqAdapter).available? { false }
         stub(IRuby::SessionAdapter::PyzmqAdapter).available? { false }
+        stub(IRuby::SessionAdapter::TestAdapter).available? { false }
         assert_raises IRuby::SessionAdapterNotFound do
           IRuby::Session.new(@session_config)
         end

data/test/run-test.rb

@@ -14,5 +14,6 @@ $LOAD_PATH.unshift(lib_dir.to_s)
 require_relative "helper"
 
 ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"] ||= "10000"
+ENV["IRUBY_TEST_SESSION_ADAPTER_NAME"] ||= "ffi-rzmq"
 
 exit Test::Unit::AutoRunner.run(true, test_dir)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iruby
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Daniel Mendler
@@ -9,22 +9,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-25 00:00:00.000000000 Z
+date: 2021-05-25 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bond
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: data_uri
   requirement: !ruby/object:Gem::Requirement
@@ -168,6 +154,7 @@ files:
 - lib/iruby/comm.rb
 - lib/iruby/command.rb
 - lib/iruby/display.rb
+- lib/iruby/event_manager.rb
 - lib/iruby/formatter.rb
 - lib/iruby/input.rb
 - lib/iruby/input/README.ipynb
@@ -200,6 +187,7 @@ files:
 - lib/iruby/session_adapter/cztop_adapter.rb
 - lib/iruby/session_adapter/ffirzmq_adapter.rb
 - lib/iruby/session_adapter/pyzmq_adapter.rb
+- lib/iruby/session_adapter/test_adapter.rb
 - lib/iruby/utils.rb
 - lib/iruby/version.rb
 - logo/logo-32x32.png
@@ -211,7 +199,9 @@ files:
 - test/integration_test.rb
 - test/iruby/backend_test.rb
 - test/iruby/command_test.rb
+- test/iruby/event_manager_test.rb
 - test/iruby/jupyter_test.rb
+- test/iruby/kernel_test.rb
 - test/iruby/mime_test.rb
 - test/iruby/multi_logger_test.rb
 - test/iruby/session_adapter/cztop_adapter_test.rb
@@ -248,7 +238,9 @@ test_files:
 - test/integration_test.rb
 - test/iruby/backend_test.rb
 - test/iruby/command_test.rb
+- test/iruby/event_manager_test.rb
 - test/iruby/jupyter_test.rb
+- test/iruby/kernel_test.rb
 - test/iruby/mime_test.rb
 - test/iruby/multi_logger_test.rb
 - test/iruby/session_adapter/cztop_adapter_test.rb