iruby 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14aea673b75a6fe8884eff08c52b8831bbcec141df2525ed4c0a877738654271
-  data.tar.gz: 89e5e091e67b7ef85f98ca0cb9ebe65cef0e32aacd75351c81b0c287666939c0
+  metadata.gz: 11ac6e3f7e6588a384c9f149d6c3fe4060b7cea7d1ff6461c3ea1acc8cadebf6
+  data.tar.gz: 4c57af32989ee7a9d7671220647279f727021d9e6d29f9d40bf1bed0e0fc4ec0
 SHA512:
-  metadata.gz: 53b824e32c52cbf2893b24310ba4d3c7caa52ec872f36f57644a95bdd139232b4b5e032f161fb86baf94d011964caf9d739a4795af6805fd174360ed866477fa
-  data.tar.gz: ee663bca3c4a67730d73e709c24d827af73e7c58734afe4dffc22c685c909462e9c9113f9548a8f1c8b5ce33b0b94338386b24c07978db547fab1caa21828ea7
+  metadata.gz: a1d623a6b5b4e46c2845048241fa6abfd535d72e648fd431f42c21c7f895f72f29b2443d74339342e83c5017040ff5f55ff4b0442909649b1ef0afb452c0ba20
+  data.tar.gz: '0394ca9c46e802a2532534058acc3af98c6e93e62a60cc035977af441c61145cfda13b224f8f1da1a8b90b48159f6aa858da7c939db2fed4f4329dcd5f2e9ea0'

data/.github/workflows/ubuntu.yml

@@ -1,8 +1,14 @@
 name: CI
 
 on:
-- push
-- pull_request
+  push:
+    branches:
+    - master
+  pull_request:
+    types:
+    - opened
+    - synchronize
+    - reopened
 
 jobs:
   test:
@@ -35,6 +41,7 @@ jobs:
 
     - name: Install requirements on ubuntu
       run: |
+        sudo apt update
         sudo apt install -y --no-install-recommends \
                  libczmq-dev \
                  python3 \

data/CHANGES.md

@@ -1,3 +1,14 @@
+# 0.7.1 (2021-06-21)
+
+## Enhancements
+
+* Add support of `to_iruby_mimebundle` format method https://github.com/SciRuby/iruby/pull/304 (@mrkn)
+
+## Bug Fixes
+
+* Prevent unintentional display the result of Session#send (@mrkn)
+* Update display formatter for Gruff::Base to prevent warning (@mrkn)
+
 # 0.7.0 (2021-05-28)
 
 ## Enhancements
@@ -7,9 +18,14 @@
 
 ## Bug Fixes
 
-* Follow the messages and hooks orders during execute_request processing (@mrkn)
 * Fix the handling of image/svg+xml https://github.com/SciRuby/iruby/pull/300, https://github.com/SciRuby/iruby/pull/301 (@kojix2)
 
+# 0.6.1 (2021-05-26)
+
+## Bug Fixes
+
+* Follow the messages and hooks orders during execute_request processing (@mrkn)
+
 # 0.6.0 (2021-05-25)
 
 ## Bug Fixes

data/lib/iruby/display.rb

@@ -2,6 +2,22 @@ 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)
@@ -24,17 +40,41 @@ module IRuby
           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.
-        if exact_mime && data.none? { |m, _| exact_mime == m }
+        if exact_mime && !data.key?(exact_mime)
           data[exact_mime] = protect(exact_mime, obj)
         end
 
@@ -67,7 +107,21 @@ module IRuby
         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) }
 
@@ -88,6 +142,8 @@ module IRuby
         # 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
@@ -98,6 +154,19 @@ 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
 
@@ -120,6 +189,60 @@ 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, :priority
 
@@ -147,37 +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)
@@ -275,13 +383,24 @@ module IRuby
         end
       end
 
+      format_magick_image = ->(obj) do
+        format = obj.format || 'PNG'
+        [
+          format == 'PNG' ? 'image/png' : 'image/jpeg',
+          obj.to_blob {|i| i.format = format }
+        ]
+      end
+
       match do |obj|
         defined?(Magick::Image) && Magick::Image === obj ||
           defined?(MiniMagick::Image) && MiniMagick::Image === obj
       end
+      format 'image', &format_magick_image
+
+      type { Gruff::Base }
       format 'image' do |obj|
-        format = obj.format || 'PNG'
-        [format == 'PNG' ? 'image/png' : 'image/jpeg', obj.to_blob { |i| i.format = format }]
+        image = obj.to_image
+        format_magick_image.(obj.to_image)
       end
 
       match do |obj|
@@ -298,39 +417,19 @@ module IRuby
         end
       end
 
-      type { Gruff::Base }
-      format 'image/png', &:to_blob
-
-      respond_to :to_html
-      format 'text/html', &:to_html
-
-      respond_to :to_latex
-      format 'text/latex', &:to_latex
-
-      respond_to :to_tex
-      format 'text/latex', &:to_tex
-
-      respond_to :to_javascript
-      format 'text/javascript', &:to_javascript
-
-      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(&:to_iruby)
-
       match { |obj| obj.respond_to?(:path) && obj.method(:path).arity == 0 && File.readable?(obj.path) }
       format do |obj|
         mime = MIME::Types.of(obj.path).first.to_s
-        [mime, File.read(obj.path)] if SUPPORTED_MIMES.include?(mime)
+        if mime && DEFAULT_MIME_TYPE_FORMAT_METHODS.key?(mime)
+          [mime, File.read(obj.path)]
+        end
       end
-
-      type { Object }
-      priority(-1000)
-      format 'text/plain', &:inspect
     end
   end
 end

data/lib/iruby/utils.rb

@@ -9,6 +9,9 @@ module IRuby
       Kernel.instance.session.send(:publish, :display_data,
                                    data: Display.display(obj, options),
                                    metadata: {}) unless obj.nil?
+      # The next `nil` is necessary to prevent unintentional displaying
+      # the result of Session#send
+      nil
     end
 
     # Clear the output area

data/lib/iruby/version.rb

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

data/test/iruby/display_test.rb

@@ -0,0 +1,188 @@
+module IRubyTest
+  class DisplayTest < TestBase
+    def setup
+      @object = Object.new
+      @object.instance_variable_set(:@to_html_called, false)
+      @object.instance_variable_set(:@to_markdown_called, false)
+      @object.instance_variable_set(:@to_iruby_called, false)
+      @object.instance_variable_set(:@to_iruby_mimebundle_called, false)
+
+      class << @object
+        attr_reader :to_html_called
+        attr_reader :to_markdown_called
+        attr_reader :to_iruby_called
+        attr_reader :to_iruby_mimebundle_called
+
+        def html
+          "<b>html</b>"
+        end
+
+        def markdown
+          "*markdown*"
+        end
+
+        def inspect
+          "!!! inspect !!!"
+        end
+      end
+    end
+
+    def define_to_html
+      class << @object
+        def to_html
+          @to_html_called = true
+          html
+        end
+      end
+    end
+
+    def define_to_markdown
+      class << @object
+        def to_markdown
+          @to_markdown_called = true
+          markdown
+        end
+      end
+    end
+
+    def define_to_iruby
+      class << @object
+        def to_iruby
+          @to_iruby_called = true
+          ["text/html", "<b>to_iruby</b>"]
+        end
+      end
+    end
+
+    def define_to_iruby_mimebundle
+      class << @object
+        def to_iruby_mimebundle(include: [])
+          @to_iruby_mimebundle_called = true
+          mimes = if include.empty?
+                    ["text/html", "text/markdown", "application/json"]
+                  else
+                    include
+                  end
+          formats = mimes.map { |mime|
+            result = case mime
+                     when "text/html"
+                       "<i>html</i>"
+                     when "text/markdown"
+                       "**markdown**"
+                     when "application/json"
+                       %Q[{"mimebundle": "json"}]
+                     end
+            [mime, result]
+          }.to_h
+          metadata = {}
+          return formats, metadata
+        end
+      end
+    end
+
+    def assert_iruby_display(expected)
+      assert_equal(expected,
+                   {
+                     result: IRuby::Display.display(@object),
+                     to_html_called: @object.to_html_called,
+                     to_markdown_called: @object.to_markdown_called,
+                     to_iruby_called: @object.to_iruby_called,
+                     to_iruby_mimebundle_called: @object.to_iruby_mimebundle_called
+                   })
+    end
+
+    sub_test_case("the object cannot handle all the mime types") do
+      def test_display
+        assert_iruby_display({
+                               result: {"text/plain" => "!!! inspect !!!"},
+                               to_html_called: false,
+                               to_markdown_called: false,
+                               to_iruby_called: false,
+                               to_iruby_mimebundle_called: false
+                             })
+      end
+    end
+
+    sub_test_case("the object can respond to to_iruby") do
+      def setup
+        super
+        define_to_iruby
+      end
+
+      def test_display
+        assert_iruby_display({
+                               result: {
+                                 "text/html" => "<b>to_iruby</b>",
+                                 "text/plain" => "!!! inspect !!!"
+                               },
+                               to_html_called: false,
+                               to_markdown_called: false,
+                               to_iruby_called: true,
+                               to_iruby_mimebundle_called: false
+                             })
+      end
+
+      sub_test_case("the object can respond to to_markdown") do
+        def setup
+          super
+          define_to_markdown
+        end
+
+        def test_display
+          assert_iruby_display({
+                                 result: {
+                                   "text/markdown" => "*markdown*",
+                                   "text/plain" => "!!! inspect !!!"
+                                 },
+                                 to_html_called: false,
+                                 to_markdown_called: true,
+                                 to_iruby_called: false,
+                                 to_iruby_mimebundle_called: false
+                               })
+        end
+      end
+
+      sub_test_case("the object can respond to to_html") do
+        def setup
+          super
+          define_to_html
+        end
+
+        def test_display
+          assert_iruby_display({
+                                 result: {
+                                   "text/html" => "<b>html</b>",
+                                   "text/plain" => "!!! inspect !!!"
+                                 },
+                                 to_html_called: true,
+                                 to_markdown_called: false,
+                                 to_iruby_called: false,
+                                 to_iruby_mimebundle_called: false
+                               })
+        end
+
+        sub_test_case("the object can respond to to_iruby_mimebundle") do
+          def setup
+            super
+            define_to_iruby_mimebundle
+          end
+
+          def test_display
+            assert_iruby_display({
+                                   result: {
+                                     "text/html" => "<i>html</i>",
+                                     "text/markdown" => "**markdown**",
+                                     "application/json" => %Q[{"mimebundle": "json"}],
+                                     "text/plain" => "!!! inspect !!!"
+                                   },
+                                   to_html_called: false,
+                                   to_markdown_called: false,
+                                   to_iruby_called: false,
+                                   to_iruby_mimebundle_called: true
+                                 })
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iruby
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Daniel Mendler
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-28 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: data_uri
@@ -213,6 +213,7 @@ files:
 - test/integration_test.rb
 - test/iruby/backend_test.rb
 - test/iruby/command_test.rb
+- test/iruby/display_test.rb
 - test/iruby/event_manager_test.rb
 - test/iruby/jupyter_test.rb
 - test/iruby/kernel_test.rb
@@ -243,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.0.dev
+rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
 summary: Ruby Kernel for Jupyter
@@ -252,6 +253,7 @@ test_files:
 - test/integration_test.rb
 - test/iruby/backend_test.rb
 - test/iruby/command_test.rb
+- test/iruby/display_test.rb
 - test/iruby/event_manager_test.rb
 - test/iruby/jupyter_test.rb
 - test/iruby/kernel_test.rb