jnv-iruby 0.0.2

data/lib/iruby/kernel.rb

@@ -0,0 +1,220 @@
+require 'ffi-rzmq'
+require 'json'
+require 'ostruct'
+require 'term/ansicolor'
+
+require 'iruby/kernel_completer'
+require 'iruby/session'
+require 'iruby/out_stream'
+require 'iruby/display_hook'
+require 'iruby/output/html'
+
+
+class String
+  include Term::ANSIColor
+end
+
+module IRuby
+
+  class ResponseWithMime
+    def initialize(response, mime)
+      @response = response
+      @mime = mime
+    end
+    attr_reader :mime
+    def inspect
+      @response.inspect
+    end
+    def to_s
+      @response.to_s
+    end
+  end
+
+  class BindingWithMime < OpenStruct
+    def mime_type=(v)
+      @mime_type = v
+    end
+    def mime_type
+      @mime_type || 'text/plain'
+    end
+  end
+
+
+  class Kernel
+    attr_accessor :user_ns
+
+    def self.html(s)
+      @output_mime = "text/html"
+      s
+    end
+
+    def execution_count
+      @execution_count
+    end
+
+    def output_mime
+      @output_mime
+    end
+
+    def initialize session, reply_socket, pub_socket
+      @session = session
+      @reply_socket = reply_socket
+      @pub_socket = pub_socket
+      @user_ns = BindingWithMime.new.send(:binding)
+      @history = []
+      @execution_count = 0
+      #@compiler = CommandCompiler.new()
+      @completer = KernelCompleter.new(@user_ns)
+
+      # Build dict of handlers for message types
+      @handlers = {}
+      ['execute_request', 'complete_request', 'kernel_info_request'].each do |msg_type|
+        @handlers[msg_type] = msg_type
+      end
+    end
+
+    def abort_queue
+      while true
+        #begin
+          ident = @reply_socket.recv(ZMQ::NOBLOCK)
+        #rescue Exception => e
+          #if e.errno == ZMQ::EAGAIN
+            #break
+          #else
+            #assert self.reply_socket.rcvmore(), "Unexpected missing message part."
+            #msg = self.reply_socket.recv_json()
+          #end
+        #end
+        msg_type = msg['header']['msg_type']
+        reply_type = msg_type.split('_')[0] + '_reply'
+        @session.send(@reply_socket, reply_type, {status: 'aborted'}, msg)
+        # reply_msg = @session.msg(reply_type, {status: 'aborted'}, msg)
+        # @reply_socket.send(ident,ZMQ::SNDMORE)
+        # @reply_socket.send(reply_msg.to_json)
+        # We need to wait a bit for requests to come in. This can probably
+        # be set shorter for true asynchronous clients.
+        sleep(0.1)
+      end
+    end
+
+    def kernel_info_request(ident, parent)
+      reply_content = {
+        protocol_version: [4, 0],
+
+        # Language version number (mandatory).
+        # It is Python version number (e.g., [2, 7, 3]) for the kernel
+        # included in IPython.
+        language_version: RUBY_VERSION.split('.').map { |x| x.to_i },
+
+        # Programming language in which kernel is implemented (mandatory).
+        # Kernel included in IPython returns 'python'.
+        language: "ruby"
+      }
+      reply_msg = @session.send(@reply_socket, 'kernel_info_reply',
+            reply_content, parent, ident
+      )
+    end
+    
+    def send_status(status, parent)
+      @session.send(@pub_socket, "status", {execution_state: status}, parent)
+    end
+
+    def execute_request(ident, parent)
+      begin
+        code = parent['content']['code']
+      rescue
+        STDERR.puts "Got bad msg: "
+        STDERR.puts parent
+        return
+      end
+      # pyin_msg = @session.msg()
+      if ! parent['content'].fetch('silent', false)
+        @execution_count += 1
+      end
+      self.send_status("busy", parent)
+      @session.send(@pub_socket, 'pyin', {code: code}, parent)
+      reply_content = {status: 'ok',
+          payload: [],
+          user_variables: {},
+          user_expressions: {},
+        }
+      result = nil
+      begin
+        $displayhook.set_parent(parent)
+        $stdout.set_parent(parent)
+
+        eval("@mime_type=nil",@user_ns)
+        result = eval(code, @user_ns)
+      rescue Exception => e
+        # $stderr.puts e.inspect
+        #etype, evalue, tb = sys.exc_info()
+        ename, evalue, tb = e.class.to_s, e.message, e.backtrace
+        tb = format_exception(ename, evalue, tb)
+        #tb = "1, 2, 3"
+        exc_content = {
+          ename: ename,
+          evalue: evalue,
+          traceback: tb,
+          #etype: etype,
+          #status: 'error',
+        }
+        # STDERR.puts exc_content
+        @session.send(@pub_socket, 'pyerr', exc_content, parent)
+
+        reply_content = exc_content
+      end
+      reply_content['execution_count'] = @execution_count
+      
+      # reply_msg = @session.msg('execute_reply', reply_content, parent)
+      #$stdout.puts reply_msg
+      #$stderr.puts reply_msg
+      #@session.send(@reply_socket, ident + reply_msg)
+      reply_msg = @session.send(@reply_socket, 'execute_reply', reply_content, parent, ident)
+      if reply_msg['content']['status'] == 'error'
+        abort_queue
+      end
+      if ! result.nil? and ! parent['content']['silent']
+        output = ResponseWithMime.new(result, eval("@mime_type",@user_ns))
+        $displayhook.display(output)
+      end
+      self.send_status("idle", parent)
+    end
+
+    def complete_request(ident, parent)
+      matches = {
+        matches: @completer.complete(parent['content']['line'], parent['content']['text']),
+        status: 'ok',
+        matched_text: parent['content']['line'],
+      }
+      completion_msg = @session.send(@reply_socket, 'complete_reply',
+                                     matches, parent, ident)
+      return nil
+    end
+
+    def start()
+      self.send_status("starting", nil)
+      while true
+        ident, msg = @session.recv(@reply_socket, 0)
+        begin
+          handler = @handlers[msg['header']['msg_type']]
+        rescue
+          handler = nil
+        end
+        if handler.nil?
+          STDERR.puts "UNKNOWN MESSAGE TYPE: #{msg['header']['msg_type']} #{msg}"
+        else
+          # STDERR.puts 'handling ' + omsg.inspect
+          send(handler, ident, msg)
+        end
+      end
+    end
+
+  private
+    def format_exception(name, value, backtrace)
+      tb = []
+      tb << "#{name.red}: #{value}"
+      tb.concat(backtrace.map { |l| l.white })
+      tb
+    end
+  end
+end

data/lib/iruby/kernel_completer.rb

@@ -0,0 +1,30 @@
+require 'bond'
+
+module IRuby
+  class KernelCompleter
+    class FakeReadline
+      def self.setup(arg)
+      end
+
+      def self.line_buffer
+        @line_buffer
+      end
+    end
+
+    def initialize(ns)
+      @ns = ns
+      Bond.start(readline: FakeReadline, debug: true)
+    end
+
+    def complete(line, text)
+      tab(line)
+    end
+
+  private
+    def tab(full_line, last_word=full_line)
+      # TODO use @ns as binding
+      Bond.agent.weapon.instance_variable_set('@line_buffer', full_line)
+      Bond.agent.call(last_word)
+    end
+  end
+end

data/lib/iruby/message.rb

@@ -0,0 +1,44 @@
+module IRuby
+  class Message
+    # A simple message object that maps dict keys to attributes.
+
+    # A Message can be created from a dict and a dict from a Message instance
+    # simply by calling dict(msg_obj)."""
+
+    def initialize msg_dict
+      @dct = {}
+      msg_dict.each_pair do |k, v|
+        if v.is_a?(Hash)
+          v = Message.new(v)
+        end
+        @dct[k] = v
+      end
+    end
+
+    def method_missing(m, *args, &block)
+      @dct[m.to_s]
+    end
+
+    def self.msg_header(msg_id, username, session)
+      return {
+        msg_id: msg_id,
+        username: username,
+        session: session
+      }
+    end
+
+    def self.extract_header(msg_or_header)
+      # Given a message or header, return the header.
+      if msg_or_header.nil?
+        return {}
+      end
+      # See if msg_or_header is the entire message.
+      h = msg_or_header['header']
+      # See if msg_or_header is just the header
+      #h ||= msg_or_header['msg_id']
+      h ||= msg_or_header
+
+      return h
+    end
+  end
+end

data/lib/iruby/out_stream.rb

@@ -0,0 +1,95 @@
+module IRuby
+  class OutStream
+    #A file like object that publishes the stream to a 0MQ PUB socket.
+
+    def initialize session, pub_socket, name, max_buffer=200
+      @session = session
+      @pub_socket = pub_socket
+      @name = name
+      @_buffer = []
+      @_buffer_len = 0
+      @max_buffer = max_buffer
+      @parent_header = {}
+    end
+
+    def set_parent parent
+      header = Message.extract_header(parent)
+      @parent_header = header
+    end
+
+    def close
+      @pub_socket = nil
+    end
+
+    def flush
+      # STDERR.puts("flushing, parent to follow")
+      # STDERR.puts @parent_header.inspect
+      if @pub_socket.nil?
+        raise 'I/O operation on closed file'
+      else
+        if @_buffer
+          data = @_buffer.join('')
+          content = { name: @name, data: data }
+          if ! @session
+            return
+          end
+          # msg = @session.msg('stream', content, @parent_header) if @session
+          # FIXME: Wha?
+          # STDERR.puts msg.to_json
+          #@pub_socket.send(msg.to_json)
+          @session.send(@pub_socket, 'stream', content, @parent_header)
+          @_buffer_len = 0
+          @_buffer = []
+          nil
+        end
+      end
+    end
+
+    def isattr
+      return false
+    end
+
+    def next
+      raise 'Read not supported on a write only stream.'
+    end
+
+    def read size=0
+      raise 'Read not supported on a write only stream.'
+    end
+    alias readline read
+
+    def write s
+      if @pub_socket.nil?
+        raise 'I/O operation on closed file'
+      else
+        s = s.to_s
+        @_buffer << s
+        @_buffer_len += s.length
+        _maybe_send
+      end
+    end
+
+    def puts str
+      write "#{str}\n"
+    end
+
+    def _maybe_send
+      #if self._buffer[-1].include?('\n')
+        flush
+      #end
+      #if @_buffer_len > @max_buffer
+        #flush
+      #end
+    end
+
+    def writelines sequence
+      if @pub_socket.nil?
+        raise 'I/O operation on closed file'
+      else
+        sequence.each do |s|
+          write(s)
+        end
+      end
+    end
+  end
+end

data/lib/iruby/output/html.rb

@@ -0,0 +1,168 @@
+module IRuby
+  module Output
+    module HTML
+      require "gruff"
+      require "base64"
+      def self.table(data)
+        #
+        # data = {a: 1, b:2}
+
+        if data.respond_to?(:keys)
+          d = data
+        else
+          d = data
+        end
+
+        r = "<table>"
+        if d.respond_to?(:keys) # hash
+          columns = [0,1]
+        else
+          columns = d.first.keys
+          r << "<tr>#{columns.map{|c| "<th>#{c}</th>"}.join("\n")}</tr>"
+        end
+        d.each{|row|
+          r << "<tr>"
+          columns.each{|column|
+            r << "<td>#{row[column]}</td>"
+          }
+          r << "</tr>"
+        }
+        r << "</table>"
+        r
+      end
+
+      def self.image(image)
+        data = image.respond_to?(:to_blob) ? image.to_blob : image
+        "<img src='data:image/png;base64,#{Base64.encode64(data)}'>"
+      end
+
+      def self.chart_pie(o)
+        data=o.delete(:data)
+        title=o.delete(:title)
+        size=o.delete(:size) || 300
+        g = Gruff::Pie.new(size)
+        g.title = title if title
+        data.each do |data|
+          g.data(data[0], data[1])
+        end
+        image(g.to_blob)
+      end
+
+      def self.chart_bar(o)
+        data=o.delete(:data)
+        title=o.delete(:title)
+        size=o.delete(:size) || 300
+
+        klass = o.delete(:stacked) ? Gruff::StackedBar : Gruff::Bar
+        g = klass.new(size)
+
+        if labels=o.delete(:labels)
+          if ! labels.respond_to?(:keys)
+            labels = Hash[labels.map.with_index{|v,k| [k,v]}]
+          end
+          g.labels = labels
+        end
+
+        g.title = title if title
+        data.each do |data|
+          g.data(data[0], data[1])
+        end
+        image(g.to_blob)
+
+      end
+
+      module Gmaps
+        def self.points2latlng(points)
+          "[" + points.reject{|p| not p.lat or not p.lon}.map{|p| 
+            "  {location: new google.maps.LatLng(#{p.lat.to_f}, #{p.lon.to_f}) #{", weight: #{p.weight.to_i}" if p.respond_to?(:weight) and p.weight} } "
+          }.join(',') + "]"
+        end
+        def self.heatmap(o)
+          data = o.delete(:points)
+          raise "Missing :points parameter" if not data
+
+          points = points2latlng(data)
+          zoom = o.delete(:zoom)
+          center = o.delete(:center)
+          map_type = o.delete(:map_type)
+r = <<E
+<div id='map-canvas' style='width: 500px; height: 500px;'></div>
+<script src="https://maps.googleapis.com/maps/api/js?v=3.exp&sensor=false&libraries=visualization&callback=initialize"></script>
+
+<script>
+  function initialize() {
+    var points = #{points};
+    var latlngbounds = new google.maps.LatLngBounds();
+    var zoom = #{zoom.to_json};
+    var center = #{center.to_json};
+    var map_type = #{map_type.to_json} || google.maps.MapTypeId.SATELLITE;
+
+    var mapOptions = { 
+      mapTypeId: map_type
+    };
+
+    if (zoom){
+      mapOptions.zoom = zoom
+    }
+    if (center){
+      mapOptions.center = new google.maps.LatLng(center.lat, center.lon)
+    }
+
+    map = new google.maps.Map(document.getElementById('map-canvas'), mapOptions);
+
+    if (! zoom){
+      for (var i = 0; i < points.length; i++) {
+        latlngbounds.extend(points[i].location);
+     }
+     map.fitBounds(latlngbounds);
+    }
+
+
+    var pointArray = new google.maps.MVCArray(points);
+
+    heatmap = new google.maps.visualization.HeatmapLayer({
+      data: pointArray
+    });
+
+    heatmap.setMap(map);
+  }
+  console.log("finished pre- init!")
+</script>
+E
+        STDERR.write("#{r}\n\n")
+        r
+        end
+      end
+      #stolen from https://github.com/Bantik/heatmap/blob/master/lib/heatmap.rb
+      module WordCloud
+
+        def self.wordcloud(histogram={})
+          html = %{<div class="wordcloud">}
+          histogram.keys.sort{|a,b| histogram[a] <=> histogram[b]}.reverse.each do |k|
+            next if histogram[k] < 1
+            _max = histogram_max(histogram) * 2
+            _size = element_size(histogram, k)
+            _heat = element_heat(histogram[k], _max)
+            html << %{
+        <span class="wordcloud_element" style="color: ##{_heat}#{_heat}#{_heat}; font-size: #{_size}px;">#{k}</span>
+      }
+          end
+          html << %{<br style="clear: both;" /></div>}
+        end
+
+        def self.histogram_max(histogram)
+          histogram.map{|k,v| histogram[k]}.max
+        end
+
+        def self.element_size(histogram, key)
+          (((histogram[key] / histogram.map{|k,v| histogram[k]}.reduce(&:+).to_f) * 100) + 5).to_i
+        end
+
+        def self.element_heat(val, max)
+          sprintf("%02x" % (200 - ((200.0 / max) * val)))
+        end
+
+      end
+    end
+  end
+end