irails 0.1.0

data/lib/irails/display.rb

@@ -0,0 +1,286 @@
+module IRails
+  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
+
+        fuzzy_mime = options[:format] # Treated like a fuzzy mime type
+        raise 'Invalid argument :format' unless !fuzzy_mime || String === fuzzy_mime
+        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']
+
+        # 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)
+      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 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
+      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(1, 0), 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_size, obj.column_size)
+      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}\\imath$"
+      end
+
+      type { Complex }
+      format 'text/latex' do |obj|
+        "$#{obj.real}+#{obj.imag}\\imath$"
+      end
+
+      type { Gnuplot::Plot }
+      format 'image/svg+xml' do |obj|
+        Tempfile.open('plot') do |f|
+          terminal = obj['terminal'].to_s.split(' ')
+          terminal[0] = 'svg'
+          terminal << 'enhanced' unless terminal.include?('noenhanced')
+          obj.terminal terminal.join(' ')
+          obj.output f.path
+          Gnuplot.open do |io|
+            io << obj.to_gplot
+            io << obj.store_datasets
+          end
+          File.read(f.path)
+        end
+      end
+
+      match do |obj|
+        defined?(Magick::Image) && Magick::Image === obj ||
+        defined?(MiniMagick::Image) && MiniMagick::Image === obj
+      end
+      format 'image' do |obj|
+        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
+      end
+
+      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_tex
+      format 'text/latex' do |obj|
+        obj.to_tex
+      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
+
+      respond_to :to_irails
+      format do |obj|
+        obj.to_irails
+      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/irails/formatter.rb

@@ -0,0 +1,146 @@
+module IRails
+  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, maxrows: 15, maxcols: 15, **options)
+      raise ArgumentError, 'Invalid :maxrows' if maxrows && maxrows < 3
+      raise ArgumentError, 'Invalid :maxcols' if maxcols && maxcols < 3
+
+      return obj unless obj.respond_to?(:each)
+
+      rows = []
+
+      if obj.respond_to?(:keys)
+        # Hash of Arrays
+        header = obj.keys
+        keys = (0...obj.keys.size).to_a
+        cols = obj.values.map {|x| [x].flatten(1) }
+        num_rows = cols.map(&:size).max
+        rows = []
+        (0...num_rows).each do |i|
+          rows << []
+          (0...cols.size).each do |j|
+            rows[i][j] = cols[j][i]
+          end
+        end
+      else
+        keys = nil
+        array_size = 0
+
+        obj.each do |row|
+          if row.respond_to?(:keys)
+            # Array of Hashes
+            keys ||= Set.new
+            keys.merge(row.keys)
+          elsif row.respond_to?(:map)
+            # Array of Arrays
+            array_size = row.size if array_size < row.size
+          end
+          rows << row
+        end
+
+        if header = keys
+          keys.merge(0...array_size)
+        else
+          keys = 0...array_size
+        end
+        keys = keys.to_a
+      end
+
+      header ||= keys if options[:header]
+
+      rows1, rows2 = rows, nil
+      keys1, keys2 = keys, nil
+      header1, header2 = header, nil
+
+      if maxcols && keys.size > maxcols
+        keys1 = keys[0...maxcols / 2]
+        keys2 = keys[-maxcols / 2...-1]
+        if header
+          header1 = header[0...maxcols / 2]
+          header2 = header[-maxcols / 2...-1]
+        end
+      end
+
+      if maxrows && rows.size > maxrows
+        rows1 = rows[0...maxrows / 2]
+        rows2 = rows[-maxrows / 2...-1]
+      end
+
+      table = '<table>'
+
+      if header1 && options[:header] != false
+        table << '<tr>' << header1.map {|k| "<th>#{cell k}</th>" }.join
+        table << "<th>&#8230;</th>" << header2.map {|k| "<th>#{cell k}</th>" }.join if keys2
+        table << '</tr>'
+      end
+
+      row_block(table, rows1, keys1, keys2)
+
+      if rows2
+        table << "<tr><td#{keys1.size > 1 ? " colspan='#{keys1.size}'" : ''}>&#8942;</td>"
+        table << "<td>&#8945;</td><td#{keys2.size > 1 ? " colspan='#{keys2.size}'" : ''}>&#8942;</td>" if keys2
+        table << '</tr>'
+
+        row_block(table, rows2, keys1, keys2)
+      end
+
+      table << '</table>'
+    end
+
+    private
+
+    def cell(obj)
+      obj.respond_to?(:to_html) ? obj.to_html : obj
+    end
+
+    def elem(row, k)
+      cell((row[k] rescue nil))
+    end
+
+    def row_block(table, rows, keys1, keys2)
+      cols = keys1.size
+      cols += keys2.size + 1 if keys2
+      rows.each_with_index do |row, i|
+        table << '<tr>'
+        if row.respond_to?(:map)
+          row_html = keys1.map {|k| "<td>#{elem row, k}</td>" }.join
+          if keys2
+            row_html << "<td#{rows.size > 1 ? " rowspan='#{rows.size}'" : ''}>&#8230;</td>" if i == 0
+            row_html << keys2.map {|k| "<td>#{elem row, k}</td>" }.join
+          end
+          if row_html.empty?
+            table << "<td#{cols > 1 ? " colspan='#{cols}'" : ''}></td>"
+          else
+            table << row_html
+          end
+        else
+          table << "<td#{cols > 1 ? " colspan='#{cols}'" : ''}>#{cell row}</td>"
+        end
+        table << '</tr>'
+      end
+    end
+  end
+end

data/lib/irails/kernel.rb

@@ -0,0 +1,165 @@
+module IRails
+  class Kernel
+    RED = "\e[31m"
+    WHITE = "\e[37m"
+    RESET = "\e[0m"
+
+    class<< self
+      attr_accessor :instance
+    end
+
+    attr_reader :session
+
+    def initialize(config_file)
+      @config = MultiJson.load(File.read(config_file))
+      IRails.logger.debug("IRails kernel start with config #{@config}")
+      Kernel.instance = self
+
+      @session = Session.new(@config)
+      $stdout = OStream.new(@session, :stdout)
+      $stderr = OStream.new(@session, :stderr)
+
+      @execution_count = 0
+      @backend = create_backend
+      @running = true
+    end
+
+    def create_backend
+      PryBackend.new
+    rescue Exception => e
+      IRails.logger.warn "Could not load PryBackend: #{e.message}\n#{e.backtrace.join("\n")}" unless LoadError === e
+      PlainBackend.new
+    end
+
+    def run
+      send_status :starting
+      while @running
+        dispatch
+      end
+    end
+
+    def dispatch
+      msg = @session.recv(:reply)
+      type = msg[:header]['msg_type']
+      raise "Unknown message type: #{msg.inspect}" unless type =~ /comm_|_request\Z/ && respond_to?(type)
+      begin
+        send_status :busy
+        send(type, msg)
+      ensure
+        send_status :idle
+      end
+    rescue Exception => e
+      IRails.logger.debug "Kernel error: #{e.message}\n#{e.backtrace.join("\n")}"
+      @session.send(:publish, :error, error_message(e))
+    end
+
+    def kernel_info_request(msg)
+      @session.send(:reply, :kernel_info_reply,
+                    protocol_version: '5.0',
+                    implementation: 'irails',
+                    banner: "IRails #{IRails::VERSION}",
+                    implementation_version: IRails::VERSION,
+                    language_info: {
+                      name: 'ruby',
+                      version: RUBY_VERSION,
+                      mimetype: 'application/x-ruby',
+                      file_extension: '.rb'
+                    })
+    end
+
+    def send_status(status)
+      @session.send(:publish, :status, execution_state: status)
+    end
+
+    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)
+
+      content = {
+        status: :ok,
+        payload: [],
+        user_expressions: {},
+        execution_count: @execution_count
+      }
+      result = nil
+      begin
+        result = @backend.eval(code, msg[:content]['store_history'])
+      rescue SystemExit
+        content[:payload] << { source: :ask_exit }
+      rescue Exception => e
+        content = error_message(e)
+        @session.send(:publish, :error, content)
+      end
+      @session.send(:reply, :execute_reply, content)
+      @session.send(:publish, :execute_result,
+                    data: Display.display(result),
+                    metadata: {},
+                    execution_count: @execution_count) unless result.nil? || msg[:content]['silent']
+    end
+
+    def error_message(e)
+      { status: :error,
+        ename: e.class.to_s,
+        evalue: e.message,
+        traceback: ["#{RED}#{e.class}#{RESET}: #{e.message}", *e.backtrace.map { |l| "#{WHITE}#{l}#{RESET}" }],
+        execution_count: @execution_count }
+    end
+
+    def complete_request(msg)
+      # HACK for #26, only complete last line
+      code = msg[:content]['code']
+      if start = code.rindex("\n")
+        code = code[start+1..-1]
+        start += 1
+      end
+      @session.send(:reply, :complete_reply,
+                    matches: @backend.complete(code),
+                    status: :ok,
+                    cursor_start: start.to_i,
+                    cursor_end: msg[:content]['cursor_pos'])
+    end
+
+    def connect_request(msg)
+      @session.send(:reply, :connect_reply, Hash[%w(shell_port iopub_port stdin_port hb_port).map {|k| [k, @config[k]] }])
+    end
+
+    def shutdown_request(msg)
+      @session.send(:reply, :shutdown_reply, msg[:content])
+      @running = false
+    end
+
+    def history_request(msg)
+      # we will just send back empty history for now, pending clarification
+      # as requested in ipython/ipython#3806
+      @session.send(:reply, :history_reply, history: [])
+    end
+
+    def inspect_request(msg)
+      result = @backend.eval(msg[:content]['code'])
+      @session.send(:reply, :inspect_reply,
+                    status: :ok,
+                    data: Display.display(result),
+                    metadata: {})
+    rescue Exception => e
+      IRails.logger.warn "Inspection error: #{e.message}\n#{e.backtrace.join("\n")}"
+      @session.send(:reply, :inspect_reply, status: :error)
+    end
+
+    def comm_open(msg)
+      comm_id = msg[:content]['comm_id']
+      target_name = msg[:content]['target_name']
+      Comm.comm[comm_id] = Comm.target[target_name].new(target_name, comm_id)
+    end
+
+    def comm_msg(msg)
+      Comm.comm[msg[:content]['comm_id']].handle_msg(msg[:content]['data'])
+    end
+
+    def comm_close(msg)
+      comm_id = msg[:content]['comm_id']
+      Comm.comm[comm_id].handle_close(msg[:content]['data'])
+      Comm.comm.delete(comm_id)
+    end
+  end
+end

data/lib/irails/logger.rb

@@ -0,0 +1,19 @@
+require 'logger'
+
+module IRails
+  class << self
+    attr_accessor :logger
+  end
+
+  class MultiLogger < BasicObject
+    attr_reader :loggers
+
+    def initialize(*loggers)
+      @loggers = loggers
+    end
+
+    def method_missing(name, *args, &b)
+      @loggers.map {|x| x.respond_to?(name) && x.public_send(name, *args, &b) }.any?
+    end
+  end
+end

data/lib/irails/ostream.rb

@@ -0,0 +1,46 @@
+module IRails
+  # IO-like object that publishes to 0MQ socket.
+  class OStream
+    attr_accessor :sync
+
+    def initialize(session, name)
+      @session, @name = session, name
+    end
+
+    def close
+      @session = nil
+    end
+
+    def flush
+    end
+
+    def isatty
+      false
+    end
+    alias_method :tty?, :isatty
+
+    def read(*args)
+      raise IOError, 'not opened for reading'
+    end
+    alias_method :next, :read
+    alias_method :readline, :read
+
+    def write(s)
+      raise 'I/O operation on closed file' unless @session
+      @session.send(:publish, :stream, name: @name, text: s.to_s)
+      nil
+    end
+    alias_method :<<, :write
+    alias_method :print, :write
+
+    def puts(*lines)
+      lines = [''] if lines.empty?
+      lines.each { |s| write("#{s}\n")}
+      nil
+    end
+
+    def writelines(lines)
+      lines.each { |s| write(s) }
+    end
+  end
+end