iruby 0.4.0 → 0.7.1

data/Rakefile

@@ -1,17 +1,17 @@
-require 'rake/testtask'
+require "bundler/gem_helper"
 
-begin
-  require 'bundler/gem_tasks'
-rescue Exception
-end
+base_dir = File.join(File.dirname(__FILE__))
+
+helper = Bundler::GemHelper.new(base_dir)
+helper.install
 
 FileList['tasks/**.rake'].each {|f| load f }
 
-Rake::TestTask.new('test') do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.test_files = FileList['test/**/*_test.rb']
-  t.verbose = true
+desc "Run tests"
+task :test do
+  cd(base_dir) do
+    ruby("test/run-test.rb")
+  end
 end
 
 task default: 'test'

data/ci/Dockerfile.main.erb

@@ -1,8 +1,6 @@
 FROM iruby-test-base:ruby-<%= ruby_version %>
 
-RUN gem install cztop \
-    && gem install rbczmq -- --with-system-libs
-
+RUN gem install cztop
 RUN mkdir -p /iruby
 ADD . /iruby
 WORKDIR /iruby

data/iruby.gemspec

@@ -1,36 +1,30 @@
-# coding: utf-8
 require_relative 'lib/iruby/version'
-require 'date'
 
 Gem::Specification.new do |s|
   s.name          = 'iruby'
-  s.date          = Date.today.to_s
   s.version       = IRuby::VERSION
   s.authors       = ['Daniel Mendler', 'The SciRuby developers']
   s.email         = ['mail@daniel-mendler.de']
-  s.summary       = 'Ruby Kernel for Jupyter/IPython'
-  s.description   = 'A Ruby kernel for Jupyter/IPython frontends (e.g. notebook). Try it at try.jupyter.org.'
+  s.summary       = 'Ruby Kernel for Jupyter'
+  s.description   = 'A Ruby kernel for Jupyter environment. Try it at try.jupyter.org.'
   s.homepage      = 'https://github.com/SciRuby/iruby'
   s.license       = 'MIT'
 
-  s.files         = `git ls-files`.split($/)
+  s.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^test/})
-  s.require_paths = %w(lib)
+  s.require_paths = %w[lib]
 
-  m = "Consider installing the optional dependencies to get additional functionality:\n"
-  File.read('Gemfile').scan(/gem\s+'(.*?)'/) { m << "  * #{$1}\n" }
-  s.post_install_message = m << "\n"
+  s.required_ruby_version = '>= 2.3.0'
 
-  s.required_ruby_version = '>= 2.1.0'
+  s.add_dependency 'data_uri', '~> 0.1'
+  s.add_dependency 'ffi-rzmq'
+  s.add_dependency 'irb'
+  s.add_dependency 'mime-types', '>= 3.3.1'
+  s.add_dependency 'multi_json', '~> 1.11'
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
-  s.add_development_dependency 'ffi-rzmq'
   s.add_development_dependency 'pycall', '>= 1.2.1'
-
-  s.add_runtime_dependency 'bond', '~> 0.5'
-  s.add_runtime_dependency 'multi_json', '~> 1.11'
-  s.add_runtime_dependency 'mimemagic', '~> 0.3'
-  s.add_runtime_dependency 'data_uri', '~> 0.1'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'test-unit-rr'
 end

data/lib/iruby.rb

@@ -1,12 +1,16 @@
-require 'mimemagic'
+require 'fileutils'
+require 'mime/types'
 require 'multi_json'
 require 'securerandom'
 require 'openssl'
 require 'tempfile'
 require 'set'
+require 'stringio'
 
 require 'iruby/version'
 require 'iruby/jupyter'
+require 'iruby/event_manager'
+require 'iruby/logger'
 require 'iruby/kernel'
 require 'iruby/backend'
 require 'iruby/ostream'
@@ -24,11 +28,7 @@ if ENV.fetch('IRUBY_OLD_SESSION', false)
     begin
       require 'iruby/session/cztop'
     rescue LoadError
-      begin
-        require 'iruby/session/rbczmq'
-      rescue LoadError
-        STDERR.puts "You should install ffi-rzmq, cztop, or rbczmq before running iruby notebook. See README."
-      end
+      STDERR.puts "Please install ffi-rzmq or cztop before running iruby. See README."
     end
   end
 else

data/lib/iruby/backend.rb

@@ -1,10 +1,9 @@
 module IRuby
   In, Out = [nil], [nil]
-  ::In, ::Out = In, Out
 
   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)
@@ -33,45 +32,74 @@ module IRuby
   end
 
   class PlainBackend
+    attr_reader :eval_path
     prepend History
 
     def initialize
-      require 'bond'
-      Bond.start(debug: true)
+      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)
+      @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
 
   class PryBackend
+    attr_reader :eval_path
     prepend History
 
     def initialize
       require 'pry'
-      Pry.memory_size = 3 
+      Pry.memory_size = 3
       Pry.pager = false # Don't use the pager
       Pry.print = proc {|output, value|} # No result printing
       Pry.exception_handler = proc {|output, exception, _| }
+      @eval_path = Pry.eval_path
       reset
     end
 
+    def eval_binding
+      TOPLEVEL_BINDING
+    end
+
     def eval(code, store_history)
+      Pry.current_line = 1
       @pry.last_result = nil
       unless @pry.eval(code)
         reset
         raise SystemExit
       end
-      unless @pry.eval_string.empty?
+
+      # Pry::Code.complete_expression? return false
+      if !@pry.eval_string.empty?
         syntax_error = @pry.eval_string
         @pry.reset_eval_string
-        @pry.evaluate_ruby syntax_error
+        @pry.evaluate_ruby(syntax_error)
+
+      # Pry::Code.complete_expression? raise SyntaxError
+      # evaluate again for current line number
+      elsif @pry.last_result_is_exception? &&
+              @pry.last_exception.is_a?(SyntaxError) &&
+              @pry.last_exception.is_a?(Pry::UserError)
+         @pry.evaluate_ruby(code)
       end
+
       raise @pry.last_exception if @pry.last_result_is_exception?
       @pry.push_initial_binding unless @pry.current_binding # ensure that we have a binding
       @pry.last_result
@@ -82,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/command.rb

@@ -1,7 +1,4 @@
-require 'iruby/jupyter'
-
-require 'fileutils'
-require 'multi_json'
+require 'iruby'
 
 module IRuby
   class Command
@@ -92,7 +89,6 @@ Try `ipython help` for more information.
     end
 
     def run_kernel
-      require 'iruby/logger'
       IRuby.logger = MultiLogger.new(*Logger.new(STDOUT))
       STDOUT.sync = true # FIXME: This can make the integration test.
 
@@ -131,7 +127,7 @@ Try `ipython help` for more information.
       check_registered_kernel
       check_bundler {|e| STDERR.puts "Could not load bundler: #{e.message}" }
 
-      Kernel.exec('ipython', *@args)
+      Process.exec('ipython', *@args)
     end
 
     def check_registered_kernel

data/lib/iruby/display.rb

@@ -1,64 +1,149 @@
+require "set"
+
 module IRuby
   module Display
+    DEFAULT_MIME_TYPE_FORMAT_METHODS = {
+      "text/html" => :to_html,
+      "text/markdown" => :to_markdown,
+      "image/svg+xml" => :to_svg,
+      "image/png" => :to_png,
+      "appliation/pdf" => :to_pdf,
+      "image/jpeg" => :to_jpeg,
+      "text/latex" => [:to_latex, :to_tex],
+      # NOTE: Do not include the entry of "application/json" because
+      #       all objects can respond to `to_json` due to json library
+      # "application/json" => :to_json,
+      "application/javascript" => :to_javascript,
+      nil => :to_iruby,
+      "text/plain" => :inspect
+    }.freeze
+
     class << self
+      # @private
       def convert(obj, options)
         Representation.new(obj, options)
       end
 
+      # @private
       def display(obj, options = {})
         obj = convert(obj, options)
         options = obj.options
         obj = obj.object
 
         fuzzy_mime = options[:format] # Treated like a fuzzy mime type
-        raise 'Invalid argument :format' unless !fuzzy_mime || String === fuzzy_mime
+        unless !fuzzy_mime || String === fuzzy_mime
+          raise 'Invalid argument :format'
+        end
+
         if exact_mime = options[:mime]
           raise 'Invalid argument :mime' unless String === exact_mime
           raise 'Invalid mime type' unless exact_mime.include?('/')
         end
 
-        data = {}
-
-        # Render additional representation
-        render(data, obj, exact_mime, fuzzy_mime)
-
-        # IPython always requires a text representation
-        render(data, obj, 'text/plain', nil) unless data['text/plain']
+        data = render_mimebundle(obj, exact_mime, fuzzy_mime)
+
+        # Render by additional formatters
+        render_by_registry(data, obj, exact_mime, fuzzy_mime)
+
+        # Render by to_xxx methods
+        DEFAULT_MIME_TYPE_FORMAT_METHODS.each do |mime, methods|
+          next if mime.nil? && !data.empty? # for to_iruby
+
+          next if mime && data.key?(mime)   # do not overwrite
+
+          method = Array(methods).find {|m| obj.respond_to?(m) }
+          next if method.nil?
+
+          result = obj.send(method)
+          case mime
+          when nil # to_iruby
+            case result
+            when nil
+              # do nothing
+              next
+            when Array
+              mime, result = result
+            else
+              warn(("Ignore the result of to_iruby method of %p because " +
+                    "it does not return a pair of mime-type and formatted representation") % obj)
+              next
+            end
+          end
+          data[mime] = result
+        end
 
         # As a last resort, interpret string representation of the object
         # as the given mime type.
-        data[exact_mime] = protect(exact_mime, obj) if exact_mime && !data.any? {|m,_| exact_mime == m }
+        if exact_mime && !data.key?(exact_mime)
+          data[exact_mime] = protect(exact_mime, obj)
+        end
 
         data
       end
 
-      def clear_output(wait=false)
-        IRuby::Kernel.instance.session.send(:publish, :clear_output, {wait: wait})
+      # @private
+      def clear_output(wait = false)
+        IRuby::Kernel.instance.session.send(:publish, :clear_output, wait: wait)
       end
 
       private
 
       def protect(mime, data)
-        MimeMagic.new(mime).text? ? data.to_s : [data.to_s].pack('m0')
+        ascii?(mime) ? data.to_s : [data.to_s].pack('m0')
+      end
+
+      # Each of the following mime types must be a text type,
+      # but mime-types library tells us it is a non-text type.
+      FORCE_TEXT_TYPES = Set[
+        "application/javascript",
+        "image/svg+xml"
+      ].freeze
+
+      def ascii?(mime)
+        if FORCE_TEXT_TYPES.include?(mime)
+          true
+        else
+          MIME::Type.new(mime).ascii?
+        end
       end
 
-      def render(data, obj, exact_mime, fuzzy_mime)
+      private def render_mimebundle(obj, exact_mime, fuzzy_mime)
+        data = {}
+        if obj.respond_to?(:to_iruby_mimebundle)
+          include_mime = [exact_mime].compact
+          formats, metadata = obj.to_iruby_mimebundle(include: include_mime)
+          formats.each do |mime, value|
+            if fuzzy_mime.nil? || mime.include?(fuzzy_mime)
+              data[mime] = value
+            end
+          end
+        end
+        data
+      end
+
+      private def render_by_registry(data, obj, exact_mime, fuzzy_mime)
         # Filter matching renderer by object type
-        renderer = Registry.renderer.select {|r| r.match?(obj) }
+        renderer = Registry.renderer.select { |r| r.match?(obj) }
 
         matching_renderer = nil
 
         # Find exactly matching display by exact_mime
-        matching_renderer = renderer.find {|r| exact_mime == r.mime } if exact_mime
+        if exact_mime
+          matching_renderer = renderer.find { |r| exact_mime == r.mime }
+        end
 
         # Find fuzzy matching display by fuzzy_mime
-        matching_renderer ||= renderer.find {|r| r.mime && r.mime.include?(fuzzy_mime) } if fuzzy_mime
+        if fuzzy_mime
+          matching_renderer ||= renderer.find { |r| r.mime&.include?(fuzzy_mime) }
+        end
 
         renderer.unshift matching_renderer if matching_renderer
 
         # Return first render result which has the right mime type
         renderer.each do |r|
           mime, result = r.render(obj)
+          next if data.key?(mime)
+
           if mime && result && (!exact_mime || exact_mime == mime) && (!fuzzy_mime || mime.include?(fuzzy_mime))
             data[mime] = protect(mime, result)
             break
@@ -69,11 +154,25 @@ module IRuby
       end
     end
 
+    private def render_by_to_iruby(data, obj)
+      if obj.respond_to?(:to_iruby)
+        result = obj.to_iruby
+        mime, rep = case result
+                    when Array
+                      result
+                    else
+                      [nil, result]
+                    end
+        data[mime] = rep
+      end
+    end
+
     class Representation
       attr_reader :object, :options
 
       def initialize(object, options)
-        @object, @options = object, options
+        @object = object
+        @options = options
       end
 
       class << self
@@ -90,11 +189,68 @@ module IRuby
       end
     end
 
+    class FormatMatcher
+      def initialize(&block)
+        @block = block
+      end
+
+      def call(obj)
+        @block.(obj)
+      end
+
+      def inspect
+        "#{self.class.name}[%p]" % @block
+      end
+    end
+
+    class RespondToFormatMatcher < FormatMatcher
+      def initialize(name)
+        super() {|obj| obj.respond_to?(name) }
+        @name = name
+      end
+
+      attr_reader :name
+
+      def inspect
+        "#{self.class.name}[respond_to?(%p)]" % name
+      end
+    end
+
+    class TypeFormatMatcher < FormatMatcher
+      def initialize(class_block)
+        super() do |obj|
+          begin
+            self.klass === obj
+          # We have to rescue all exceptions since constant autoloading could fail with a different error
+          rescue Exception
+            false
+          end
+        end
+        @class_block = class_block
+      end
+
+      def klass
+        @class_block.()
+      end
+
+      def inspect
+        klass = begin
+                  @class_block.()
+                rescue Exception
+                  @class_block
+                end
+        "#{self.class.name}[%p]" % klass
+      end
+    end
+
     class Renderer
-      attr_reader :match, :mime, :render, :priority
+      attr_reader :match, :mime, :priority
 
       def initialize(match, mime, render, priority)
-        @match, @mime, @render, @priority = match, mime, render, priority
+        @match = match
+        @mime = mime
+        @render = render
+        @priority = priority
       end
 
       def match?(obj)
@@ -114,36 +270,22 @@ module IRuby
         @renderer ||= []
       end
 
-      SUPPORTED_MIMES = %w(
-        text/plain
-        text/html
-        text/latex
-        application/json
-        application/javascript
-        image/png
-        image/jpeg
-        image/svg+xml)
-
       def match(&block)
-        @match = block
+        @match = FormatMatcher.new(&block)
         priority 0
         nil
       end
 
       def respond_to(name)
-        match {|obj| obj.respond_to?(name) }
+        @match = RespondToFormatMatcher.new(name)
+        priority 0
+        nil
       end
 
       def type(&block)
-        match do |obj|
-          begin
-            block.call === obj
-          # We have to rescue all exceptions since constant autoloading could fail with a different error
-          rescue Exception
-          rescue #NameError
-            false
-          end
-        end
+        @match = TypeFormatMatcher.new(block)
+        priority 0
+        nil
       end
 
       def priority(p)
@@ -153,7 +295,7 @@ module IRuby
 
       def format(mime = nil, &block)
         renderer << Renderer.new(@match, mime, block, @priority)
-        renderer.sort_by! {|r| -r.priority }
+        renderer.sort_by! { |r| -r.priority }
 
         # Decrease priority implicitly for all formats
         # which are added later for a type.
@@ -170,6 +312,7 @@ module IRuby
       end
 
       type { Numo::NArray }
+      format 'text/plain', &:inspect
       format 'text/latex' do |obj|
         obj.ndim == 2 ?
         LaTeX.matrix(obj, obj.shape[0], obj.shape[1]) :
@@ -180,6 +323,7 @@ module IRuby
       end
 
       type { NArray }
+      format 'text/plain', &:inspect
       format 'text/latex' do |obj|
         obj.dim == 2 ?
         LaTeX.matrix(obj.transpose(1, 0), obj.shape[1], obj.shape[0]) :
@@ -239,61 +383,52 @@ module IRuby
         end
       end
 
-      match do |obj|
-        defined?(Magick::Image) && Magick::Image === obj ||
-        defined?(MiniMagick::Image) && MiniMagick::Image === obj
-      end
-      format 'image' do |obj|
+      format_magick_image = ->(obj) do
         format = obj.format || 'PNG'
-        [format == 'PNG' ? 'image/png' : 'image/jpeg', obj.to_blob {|i| i.format = format }]
-      end
-
-      type { Gruff::Base }
-      format 'image/png' do |obj|
-        obj.to_blob
+        [
+          format == 'PNG' ? 'image/png' : 'image/jpeg',
+          obj.to_blob {|i| i.format = format }
+        ]
       end
 
-      respond_to :to_html
-      format 'text/html' do |obj|
-        obj.to_html
+      match do |obj|
+        defined?(Magick::Image) && Magick::Image === obj ||
+          defined?(MiniMagick::Image) && MiniMagick::Image === obj
       end
+      format 'image', &format_magick_image
 
-      respond_to :to_latex
-      format 'text/latex' do |obj|
-        obj.to_latex
+      type { Gruff::Base }
+      format 'image' do |obj|
+        image = obj.to_image
+        format_magick_image.(obj.to_image)
       end
 
-      respond_to :to_tex
-      format 'text/latex' do |obj|
-        obj.to_tex
+      match do |obj|
+        defined?(Vips::Image) && Vips::Image === obj
       end
-
-      respond_to :to_javascript
-      format 'text/javascript' do |obj|
-        obj.to_javascript
+      format do |obj|
+        # handles Vips::Error, vips_image_get: field "vips-loader" not found
+        loader = obj.get('vips-loader') rescue nil
+        if loader == 'jpegload'
+          ['image/jpeg', obj.write_to_buffer('.jpg')]
+        else
+          # falls back to png for other/unknown types
+          ['image/png', obj.write_to_buffer('.png')]
+        end
       end
 
-      respond_to :to_svg
+      type { Rubyvis::Mark }
       format 'image/svg+xml' do |obj|
-        obj.render if defined?(Rubyvis) && Rubyvis::Mark === obj
+        obj.render
         obj.to_svg
       end
 
-      respond_to :to_iruby
-      format do |obj|
-        obj.to_iruby
-      end
-
-      match {|obj| obj.respond_to?(:path) && File.readable?(obj.path) }
+      match { |obj| obj.respond_to?(:path) && obj.method(:path).arity == 0 && File.readable?(obj.path) }
       format do |obj|
-        mime = MimeMagic.by_path(obj.path).to_s
-        [mime, File.read(obj.path)] if SUPPORTED_MIMES.include?(mime)
-      end
-
-      type { Object }
-      priority -1000
-      format 'text/plain' do |obj|
-        obj.inspect
+        mime = MIME::Types.of(obj.path).first.to_s
+        if mime && DEFAULT_MIME_TYPE_FORMAT_METHODS.key?(mime)
+          [mime, File.read(obj.path)]
+        end
       end
     end
   end