iruby 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f7cb8c6ec6b18164c82d06e8e82dde35af450ac
-  data.tar.gz: 2bbb33fa995c381801d319eda788622ff7cf588a
+  metadata.gz: 47cc7be0c54041de9aa2e48644f0812f5f902bbc
+  data.tar.gz: a656cdee3051efdd8db801c68ca12796577f2a6c
 SHA512:
-  metadata.gz: ebf7533b241c7ed0586fb681079550f56b9b1e49a85ec1df3b1a38289efc0cef8bd04c1b3486c46735d627e2b27623eb67c1ec0bc8cbbbd438419feebbbcb2c0
-  data.tar.gz: 6f1c2ff436d7990eb99725b9c8d308763cdf9b1c068837bd17cc40d950146400e20fa35af323ff684bf868018965fe3f2268bb4d60ec0dc143bc3dacf5143367
+  metadata.gz: e18bc7e9a5fc371c552d58224a00ce42b0190c9e4e69e3be9c5bf0c2acaa137eaaf61d042c589197f77504d1fbd61aaa707306b41984d52386a86f7c8746cdae
+  data.tar.gz: 693f4ef8e4d09190326a05ee7ab62cbe2c06c72de5c7ab4c7a4ea502d720bbe363a9586bdba0fd4cc3a73c8db5d2fa807b019e73a39390725b3a05167c4c2432

data/CHANGES

@@ -1,3 +1,10 @@
+0.1.12
+
+  * IRuby#table add option maxrows
+  * powerful display system with format and datatype registry, see #25
+  * Add IRuby#javascript
+  * Add IRuby#svg
+
 0.1.11
 
   * Push binding if pry binding stack is empty

data/lib/iruby.rb

@@ -11,5 +11,6 @@ require 'iruby/kernel'
 require 'iruby/backend'
 require 'iruby/session'
 require 'iruby/ostream'
+require 'iruby/formatter'
 require 'iruby/utils'
 require 'iruby/display'

data/lib/iruby/display.rb

@@ -1,40 +1,206 @@
 module IRuby
-  class Display
-    attr_reader :data
-
-    SUPPORTED_MIMES = %w(
-    text/plain
-    text/html
-    text/latex
-    application/json
-    application/javascript
-    image/png
-    image/jpeg
-    image/svg+xml)
-
-    def initialize(obj, options)
-      @data = { 'text/plain' => obj.inspect }
-      if options[:mime]
-        add(options[:mime], obj)
-      elsif obj.respond_to?(:to_iruby)
-        add(*obj.to_iruby)
-      elsif obj.respond_to?(:to_html)
-        add('text/html', obj.to_html)
-      elsif obj.respond_to?(:to_svg)
-        obj.render if defined?(Rubyvis) && Rubyvis::Mark === obj
-        add('image/svg+xml', obj.to_svg)
-      elsif obj.respond_to?(:to_latex)
-        add('text/latex', obj.to_latex)
-      elsif defined?(Gruff::Base) && Gruff::Base === obj
-        add('image/png', obj.to_blob)
-      elsif (defined?(Magick::Image) && Magick::Image === obj) ||
-           (defined?(MiniMagick::Image) && MiniMagick::Image === obj)
-        format = obj.format || 'PNG'
-        add(format == 'PNG' ? 'image/png' : 'image/jpeg', obj.to_blob {|i| i.format = format })
-      elsif obj.respond_to?(:path) && File.readable?(obj.path)
-        mime = MimeMagic.by_path(obj.path).to_s
-        add(mime, File.read(obj.path)) if SUPPORTED_MIMES.include?(mime)
-      elsif defined?(Gnuplot::Plot) && Gnuplot::Plot === obj
+  module Display
+    class << self
+      def convert(obj, options)
+        Representation.new(obj, options)
+      end
+
+      def display(obj, options = {})
+        obj = convert(obj, options)
+        options = obj.options
+        obj = obj.object
+
+        exact_mime = options[:mime]
+        fuzzy_mime = options[:format] # Treated like a fuzzy mime type
+        raise 'Invalid argument :format' unless !fuzzy_mime || String === fuzzy_mime
+        if exact_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']
+
+        # 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 }
+
+        data
+      end
+
+      private
+
+      def protect(mime, data)
+        MimeMagic.new(mime).text? ? data.to_s : [data.to_s].pack('m0')
+      end
+
+      def render(data, obj, exact_mime, fuzzy_mime)
+        # Filter matching renderer by object type
+        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
+
+        # Find fuzzy matching display by fuzzy_mime
+        matching_renderer ||= renderer.find {|r| r.mime && r.mime.include?(fuzzy_mime) } if fuzzy_mime
+
+        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)
+          if mime && result && (!exact_mime || exact_mime == mime) && (!fuzzy_mime || mime.include?(fuzzy_mime))
+            data[mime] = protect(mime, result)
+            break
+          end
+        end
+
+        nil
+      end
+    end
+
+    class Representation
+      attr_reader :object, :options
+
+      def initialize(object, options)
+        @object, @options = object, options
+      end
+
+      class << self
+        alias old_new new
+
+        def new(obj, options)
+          options = { format: options } if String === options
+          if Representation === obj
+            options = obj.options.merge(options)
+            obj = obj.object
+          end
+          old_new(obj, options)
+        end
+      end
+    end
+
+    class Renderer
+      attr_reader :match, :mime, :render, :priority
+
+      def initialize(match, mime, render, priority)
+        @match, @mime, @render, @priority = match, mime, render, priority
+      end
+
+      def match?(obj)
+        @match.call(obj)
+      rescue NameError
+        false
+      end
+
+      def render(obj)
+        result = @render.call(obj)
+        Array === result ? result : [@mime, result]
+      end
+    end
+
+    module Registry
+      extend self
+
+      def renderer
+        @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
+        priority 0
+        nil
+      end
+
+      def respond_to(name)
+        match {|obj| obj.respond_to?(name) }
+      end
+
+      def type(&block)
+        match {|obj| block.call === obj }
+      end
+
+      def priority(p)
+        @priority = p
+        nil
+      end
+
+      def format(mime = nil, &block)
+        renderer << Renderer.new(@match, mime, block, @priority)
+        renderer.sort_by! {|r| -r.priority }
+
+        # Decrease priority implicitly for all formats
+        # which are added later for a type.
+        # Overwrite with the `priority` method!
+        @priority -= 1
+        nil
+      end
+
+      type { NMatrix }
+      format 'text/latex' do |obj|
+        obj.dim == 2 ?
+         LaTeX.matrix(obj, obj.shape[0], obj.shape[1]) :
+          LaTeX.vector(obj.to_a)
+      end
+
+      type { NArray }
+      format 'text/latex' do |obj|
+        obj.dim == 2 ?
+        LaTeX.matrix(obj.transpose, obj.shape[1], obj.shape[0]) :
+          LaTeX.vector(obj.to_a)
+      end
+      format 'text/html' do |obj|
+        HTML.table(obj.to_a)
+      end
+
+      type { Matrix }
+      format 'text/latex' do |obj|
+        LaTeX.matrix(obj, obj.row_count, obj.column_count)
+      end
+      format 'text/html' do |obj|
+        HTML.table(obj.to_a)
+      end
+
+      type { GSL::Matrix }
+      format 'text/latex' do |obj|
+        LaTeX.matrix(obj, obj.size1, obj.size2)
+      end
+      format 'text/html' do |obj|
+        HTML.table(obj.to_a)
+      end
+
+      type { GSL::Vector }
+      format 'text/latex' do |obj|
+        LaTeX.vector(obj.to_a)
+      end
+      format 'text/html' do |obj|
+        HTML.table(obj.to_a)
+      end
+
+      type { GSL::Complex }
+      format 'text/latex' do |obj|
+        "$#{obj.re}+#{obj.im}i$"
+      end
+
+      type { Gnuplot::Plot }
+      format 'image/svg+xml' do |obj|
         Tempfile.open('plot') do |f|
           obj.terminal 'svg enhanced'
           obj.output f.path
@@ -42,47 +208,58 @@ module IRuby
             io << obj.to_gplot
             io << obj.store_datasets
           end
-          add('image/svg+xml', File.read(f.path))
+          File.read(f.path)
         end
-      elsif defined?(Matrix) && Matrix === obj
-        add('text/latex', format_matrix(obj, obj.row_count, obj.column_count))
-      elsif defined?(GSL::Matrix) && GSL::Matrix === obj
-        add('text/latex', format_matrix(obj, obj.size1, obj.size2))
-      elsif defined?(GSL::Vector) && GSL::Vector === obj
-        add('text/latex', format_vector(obj.to_a))
-      elsif defined?(GSL::Complex) && GSL::Complex === obj
-        add('text/latex', "$#{obj.re}+#{obj.im}i$")
-      elsif defined?(NArray) && NArray === obj
-        add('text/latex', obj.dim == 2 ?
-            format_matrix(obj.transpose, obj.shape[1], obj.shape[0]) :
-            format_vector(obj.to_a))
-      elsif defined?(NMatrix) && NMatrix === obj
-        add('text/latex', obj.dim == 2 ?
-            format_matrix(obj, obj.shape[0], obj.shape[1]) :
-            format_vector(obj.to_a))
       end
-    end
 
-    private
+      match {|obj| Magick::Image === obj || MiniMagick::Image === obj }
+      format 'image' do |obj|
+        format = obj.format || 'PNG'
+        [format == 'PNG' ? 'image/png' : 'image/jpeg', obj.to_blob {|i| i.format = format }]
+      end
 
-    def format_vector(v)
-      "$$\\left(\\begin{array}{#{'c' * v.size}} #{v.map(&:to_s).join(' & ')} \\end{array}\\right)$$"
-    end
+      type { Gruff::Base }
+      format 'image/png' do |obj|
+        obj.to_blob
+      end
 
-    def format_matrix(m, row_count, column_count)
-      s = "$$\\left(\\begin{array}{#{'c' * column_count}}\n"
-      (0...row_count).each do |i|
-        s << '  ' << m[i,0].to_s
-        (1...column_count).each do |j|
-          s << '&' << m[i,j].to_s
-        end
-        s << "\\\\\n"
+      respond_to :to_html
+      format 'text/html' do |obj|
+        obj.to_html
+      end
+
+      respond_to :to_latex
+      format 'text/latex' do |obj|
+        obj.to_latex
+      end
+
+      respond_to :to_javascript
+      format 'text/javascript' do |obj|
+        obj.to_javascript
+      end
+
+      respond_to :to_svg
+      format 'image/svg+xml' do |obj|
+        obj.render if defined?(Rubyvis) && Rubyvis::Mark === obj
+        obj.to_svg
       end
-      s << "\\end{array}\\right)$$"
-    end
 
-    def add(mime, data)
-      @data[mime] = MimeMagic.new(mime).text? ? data.to_s : [data.to_s].pack('m0')
+      respond_to :to_iruby
+      format do |obj|
+        obj.to_iruby
+      end
+
+      match {|obj| obj.respond_to?(:path) && 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
+      end
     end
   end
 end

data/lib/iruby/formatter.rb

@@ -0,0 +1,73 @@
+module IRuby
+  module LaTeX
+    extend self
+
+    def vector(v)
+      x = 'c' * v.size
+      y = v.map(&:to_s).join(' & ')
+      "$$\\left(\\begin{array}{#{x}} #{y} \\end{array}\\right)$$"
+    end
+
+    def matrix(m, row_count, column_count)
+      s = "$$\\left(\\begin{array}{#{'c' * column_count}}\n"
+      (0...row_count).each do |i|
+        s << '  ' << m[i,0].to_s
+        (1...column_count).each do |j|
+          s << '&' << m[i,j].to_s
+        end
+        s << "\\\\\n"
+      end
+      s << "\\end{array}\\right)$$"
+    end
+  end
+
+  module HTML
+    extend self
+
+    def table(obj, options = {})
+      options[:maxrows] = 15 unless options.include?(:maxrows)
+      return obj unless Enumerable === obj
+      keys = nil
+      size = 0
+      rows = []
+      obj.each_with_index do |row, i|
+        row = row.flatten(1) if obj.respond_to?(:keys)
+        if row.respond_to?(:keys)
+          # Array of Hashes
+          keys ||= Set.new
+          keys.merge(row.keys)
+        elsif row.respond_to?(:map)
+          # Array of Arrays
+          size = row.size if size < row.size
+        end
+        if options[:maxrows] && i > options[:maxrows]
+          rows << '...'
+          break
+        end
+        rows << row
+      end
+      table = '<table>'
+      if keys
+        keys.merge(0...size)
+        table << '<tr>' << keys.map {|k| "<th>#{k}</th>"}.join << '</tr>'
+      else
+        keys = 0...size
+      end
+      rows.each do |row|
+        table << '<tr>'
+        if row.respond_to?(:map)
+          row = keys.map {|k| "<td>#{row[k] rescue nil}</td>" }
+          if row.empty?
+            table << "<td#{keys.size > 1 ? " colspan='#{keys.size}'" : ''}></td>"
+          else
+            table << row.join
+          end
+        else
+          table << "<td#{keys.size > 1 ? " colspan='#{keys.size}'" : ''}>#{row}</td>"
+        end
+        table << '</tr>'
+      end
+      table << '</table>'
+    end
+  end
+end

data/lib/iruby/kernel.rb

@@ -68,7 +68,7 @@ module IRuby
 
     def display(obj, options={})
       unless obj.nil?
-        content = { data: Display.new(obj, options).data, metadata: {}, execution_count: @execution_count }
+        content = { data: Display.display(obj, options), metadata: {}, execution_count: @execution_count }
         @session.send(@pub_socket, 'pyout', content)
       end
       nil

data/lib/iruby/utils.rb

@@ -1,71 +1,33 @@
 module IRuby
-  class MimeString < String
-    attr_reader :mime
-
-    def initialize(mime, data)
-      super(data.to_s)
-      @mime = mime
-    end
-
-    def to_iruby
-      [@mime, self]
-    end
+  def self.convert(object, options)
+    Display.convert(object, options)
   end
 
-  def self.display(obj, options={})
+  def self.display(obj, options = {})
     Kernel.instance.display(obj, options)
   end
 
-  def self.table(obj)
-    return obj unless Enumerable === obj
-    keys = nil
-    size = 0
-    rows = []
-    obj.each do |row|
-      row = row.flatten(1) if obj.respond_to?(:keys)
-      if row.respond_to?(:keys)
-        # Array of Hashes
-        keys ||= Set.new
-        keys.merge(row.keys)
-      elsif row.respond_to?(:map)
-        # Array of Arrays
-        size = row.size if size < row.size
-      end
-      rows << row
-    end
-    table = '<table>'
-    if keys
-      keys.merge(0...size)
-      table << '<tr>' << keys.map {|k| "<th>#{k}</th>"}.join << '</tr>'
-    else
-      keys = 0...size
-    end
-    rows.each do |row|
-      table << '<tr>'
-      if row.respond_to?(:map)
-        row = keys.map {|k| "<td>#{row[k] rescue nil}</td>" }
-        if row.empty?
-          table << "<td#{keys.size > 1 ? " colspan='#{keys.size}'" : ''}></td>"
-        else
-          table << row.join
-        end
-      else
-        table << "<td#{keys.size > 1 ? " colspan='#{keys.size}'" : ''}>#{row}</td>"
-      end
-      table << '</tr>'
-    end
-    html(table << '</table>')
+  def self.table(s)
+    html(HTML.table(s))
   end
 
   def self.latex(s)
-    MimeString.new('text/latex', s)
+    convert(s, mime: 'text/latex')
   end
 
   def self.math(s)
-    MimeString.new('text/latex', "$$#{s}$$")
+    convert("$$#{s}$$", mime: 'text/latex')
   end
 
   def self.html(s)
-    MimeString.new('text/html', s)
+    convert(s, mime: 'text/html')
+  end
+
+  def self.javascript(s)
+    convert(s, mime: 'application/javascript')
+  end
+
+  def self.svg(s)
+    convert(s, mime: 'image/svg+xml')
   end
 end

data/lib/iruby/version.rb

@@ -1,3 +1,3 @@
 module IRuby
-  VERSION = '0.1.11'
+  VERSION = '0.1.12'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iruby
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Damián Silvani
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-08 00:00:00.000000000 Z
+date: 2014-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -106,6 +106,7 @@ files:
 - lib/iruby/backend.rb
 - lib/iruby/command.rb
 - lib/iruby/display.rb
+- lib/iruby/formatter.rb
 - lib/iruby/kernel.rb
 - lib/iruby/ostream.rb
 - lib/iruby/session.rb