jnv-iruby 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7e6455a899a0f5681f903057acdb3d9bbb6eaa26
+  data.tar.gz: dc4375cd4ca2bddc059dcc414f92dcc7895c2f54
+SHA512:
+  metadata.gz: 67542fdf88d6c60c9d450f17ffcc4ed9ffa5a101b148117139cc85def8f8e5a0d570dacdd99b80d96a47892a0ce672381559f5e4709a772e7c7466fa4f3a926d
+  data.tar.gz: 7eee6d884ef082dc39340e6d4cf4581ab1ddcdbad323ad5b580f05fcb2f8145e2558e4c96358a98aa0c3ee2b0d3876992479f808d40318bb1cdfeac956f6ec33

data/.gitignore

@@ -0,0 +1,18 @@
+.ipynb_checkpoints/
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Damián Silvani
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# IRuby
+
+This is a Ruby kernel for IPython.
+
+It adds a special `iruby_profile` command for staging some customization
+that enables the Ruby kernel by default, and sets syntax-highlighting in the notebook
+to Ruby mode.
+
+### Usage
+
+Clone this repository and run `bin/iruby_profile` to create the profile, then
+use IPython as usual:
+
+```bash
+git clone git://github.com/minrk/iruby
+cd iruby
+# build and install IRuby
+gem build iruby.gemspec
+$ gem install iruby-*.gem
+# Create an IPython profile with default config
+$ iruby_profile --create
+$ ipython notebook --profile=ruby
+```
+
+
+## Background
+
+### Building an in-browser REPL for Ruby (IRuby)
+
+Hey, I'm Josh Adams.  I'm a partner and CTO at isotope|eleven.  We alo host
+Birmingham, AL's Open Source Software meetup - BOSS.
+
+At one of these sessions in early 2012, Tom Brander did a presentation and used
+IPython in his browser to manage it (there was much code and it was executed
+live).  This was the first time I'd seen IPython in the browser where it
+actually worked like it was supposed to, and I was extremely impressed.
+
+If you've not seen IPython, it looks like this <* Insert Screenshot Here *> in
+its web-browser mode.  It also manages a lot of console-basd REPLs.
+
+Anyway, it has notebooks that you can save out to execute later, and you can
+pass them around as little code snippets for other people to check out.  It's
+very impressive.
+
+But I'm primarily a Rubyist, and I'm happy that way :)  I couldn't sit by while
+Python had this awesome tool that we lacked.  I looked around for a bit, and
+there was nothing like IPython in our ecosystem.  There were, however, quite a
+few people asking about it.  So I figured I'd do something about it.
+
+#### The Architecture
+
+So the IPython guys did a great job explaining their core architecture, both in
+words and in pared-down code, in a blog post they wrote concerning it.  In
+general, it works like this <* Diagram *>
+
+There's a kernel that runs in the background and gets connected to by a
+frontend.  They communicate using zeromq, and they send json formatted messages
+back and forth.  These messages are in a very well defined structure.  Anyway,
+this way the frontend of the repl is disconnected from the environment that's
+running it.
+
+So the code repository they linked to in their blog post included the kernel and
+the frontend as small-ish python files - around 300 and 200 lines respectively.
+We had a hack weekend at isotope|eleven where myself and Robby Clements got
+together and (when we weren't playing Counterstrike1.6) did the closest thing to
+a straight port that we could swing.  Within about 2 hours of work, we had a
+working proof of concept that was primarily a 1 to 1 port.
+
+The next move was to build the web frontend.  This just consists of a websocket
+server and a fairly basic frontend webpage.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/Ruby Notebook.ipynb

@@ -0,0 +1,117 @@
+{
+ "metadata": {
+  "name": "Ruby Notebook"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "# This is an IPython notebook, backed by a ruby kernel.\n",
+      "\n",
+      "I wrote a kernel in Ruby that adheres to the [IPython](http://ipython.org/) messaging protocol.  Then I modified IPython, with the help of minrk from #ipython, to instantiate my Ruby Kernel instead of its own Python kernel.\n",
+      "\n",
+      "The IPython KernelManager initializes the RubyKernel with popen, and from that point communication occurs over ZeroMQ, exactly as in IPython's kernel.\n",
+      "\n",
+      "Once that was done, it's easy to execute ruby against that kernel right in the browser."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "class Neat\n",
+      "    def eh?\n",
+      "        \"hell yes it is.\"\n",
+      "    end\n",
+      "end\n",
+      "\n",
+      "Neat.new.eh?"
+     ],
+     "language": "ruby",
+     "metadata": {},
+     "outputs": []
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "## What does this give you?\n",
+      "\n",
+      "This gives us a very fancy web notebook interface for Ruby.  It's a very good tool for programming presentations.  Tom Brander's presentation to the BOSS meetup group made me realize exactly how far IPython had come since I last saw it, and I knew I wanted to have it for ruby.\n",
+      "\n",
+      "It's basically an in-browser REPL loop, with some extra goodies."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "class ThatsPrettyCool\n",
+      "    def how_does_it_work?\n",
+      "        puts \"I'm glad you asked!\"\n",
+      "        :see_below\n",
+      "    end\n",
+      "end\n",
+      "\n",
+      "ThatsPrettyCool.new.how_does_it_work?"
+     ],
+     "language": "ruby",
+     "metadata": {},
+     "outputs": []
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "### Here's how it works\n",
+      "\n",
+      "Each notebook has its own kernel.  When you open a notebook in the web interface, a kernel is started in the background by the IPython webserver.  A websocket is then used to connect the frontend directly to the kernel, more or less, and they pass messages back and forth.\n",
+      "\n",
+      "All of the messages are in a JSON format.  The actual information passed over the wire between the web server and the kernel is a little different, but it basically just includes some session/auth information, and then the components of the message serialized, too be unserialized on the Kernel into the full json message again.\n",
+      "\n",
+      "### What does a message look like?\n",
+      "\n",
+      "A given JSON message looks like this:\n",
+      "\n",
+      "    {\"header\"=>\n",
+      "      {\"username\"=>\"username\",\n",
+      "       \"msg_id\"=>\"38C1E3299BB14F7C99D95504CEAE4856\",\n",
+      "       \"msg_type\"=>\"execute_request\",\n",
+      "       \"session\"=>\"BAC5EA31BC6F4C1D888DD5F8C46B6F9D\"},\n",
+      "     \"msg_id\"=>\"msg_id\",\n",
+      "     \"msg_type\"=>\"msg_type\",\n",
+      "     \"parent_header\"=>{},\n",
+      "     \"content\"=>\n",
+      "      {\"user_variables\"=>[],\n",
+      "       \"allow_stdin\"=>false,\n",
+      "       \"code\"=>\n",
+      "        \"class ThatsPrettyCool\\n  def how_does_it_work?\\n    puts \\\"I'm glad you asked!\\\"\\n  end\\nend\\n\\nThatsPrettyCool.new.how_does_it_work?\",\n",
+      "       \"silent\"=>false,\n",
+      "       \"user_expressions\"=>{}},\n",
+      "     \"buffers\"=>[]}"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "### What remains to be done for this to be 'complete'?\n",
+      "\n",
+      "- Right now, I'm not passing back the 'return value of the last expression' like you'd expect a proper REPL to do.  I'm not exactly sure how to get the analog of python's sys.displayhook working, but I welcome anyone to teach me how it's done :)  I can probably figure it out from the pry source.\n",
+      "- backtraces are a little bit wonky right now and don't give you the proper backtrace into the executed code, but rather into the Kernel's source where the eval loop runs...not very helpful.\n",
+      "- There aren't any tests.\n",
+      "- It would be nice to support the fancy IPython graph and html-table gooies, I'll look into that.\n",
+      "- IPython supports tab-completion in the browser REPL, but my kernel doesn't know how to respond to those messages.\n",
+      "- There are some other message types I've not yet implemented, but I don't really see the problem at present :)"
+     ]
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}

data/bin/iruby_kernel

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+
+USAGE = <<-EOS
+This script is not intended to be used manually.
+
+To start an IPython Notebook server with IRuby, first create a profile with
+`iruby_profile`, then use `ipython notebook` to start the server:
+
+    $ iruby_profile --create
+    $ ipython notebook --profile=ruby
+
+Read more at http://ipython.org/ipython-doc/dev/interactive/notebook.html
+
+EOS
+
+def start_kernel!(config_path, boot_file=nil)
+  #ENV["BUNDLE_GEM"] = "/home/munshkr/overol-parsers/Gemfile"
+  #ENV["APP_ROOT"] = "/home/munshkr/overol-parsers"
+
+  require boot_file if boot_file
+  require 'iruby/kernel'
+
+  configfile = File.read(config_path)
+  config = JSON.parse(configfile)
+
+  c = ZMQ::Context.new
+
+  shell_port = config['shell_port']
+  pub_port = config['iopub_port']
+  hb_port = config['hb_port']
+
+  ip = '127.0.0.1'
+  connection = ('tcp://%s' % ip) + ':%i'
+  shell_conn = connection % shell_port
+  pub_conn = connection % pub_port
+  hb_conn = connection % hb_port
+
+  $stdout.puts "Starting the kernel..."
+  $stdout.puts "On:",shell_conn, pub_conn, hb_conn
+
+  session = IRuby::Session.new('kernel')
+
+  reply_socket = c.socket(ZMQ::XREP)
+  reply_socket.bind(shell_conn)
+
+  pub_socket = c.socket(ZMQ::PUB)
+  pub_socket.bind(pub_conn)
+
+  hb_thread = Thread.new do
+    hb_socket = c.socket(ZMQ::REP)
+    hb_socket.bind(hb_conn)
+    ZMQ::Device.new(ZMQ::FORWARDER, hb_socket, hb_socket)
+  end
+
+  stdout = IRuby::OutStream.new(session, pub_socket, 'stdout')
+  #stderr = OutStream.new(session, pub_socket, 'stderr')
+  old_stdout = STDOUT
+  $stdout = stdout
+  #$stderr = stderr
+
+
+  kernel = IRuby::Kernel.new(session, reply_socket, pub_socket)
+  display_hook = IRuby::DisplayHook.new(kernel, session, pub_socket)
+  $displayhook = display_hook
+
+  # For debugging convenience, put sleep and a string in the namespace, so we
+  # have them every time we start.
+  #kernel.user_ns['sleep'] = sleep
+  #kernel.user_ns['s'] = 'Test string'
+
+  old_stdout.puts "Use Ctrl-\\ (NOT Ctrl-C!) to terminate."
+  kernel.start()
+end
+
+
+if ARGV.size == 0 || ARGV.size > 2
+  puts USAGE
+  exit(1)
+end
+config_path, boot_file = ARGV
+
+if !File.exists?(config_path)
+  puts "Config file '#{config_path}' does not exist"
+  exit(2)
+end
+
+if boot_file && !File.exists?(boot_file)
+  puts "File '#{boot_file}' does not exist"
+  exit(3)
+end
+
+start_kernel!(config_path, boot_file)

data/bin/iruby_profile

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'trollop'
+
+opts = Trollop::options do
+  banner <<-EOS
+`iruby_profile` creates an IPython profile already customized for using the
+IRuby kernel.  You can specify a custom name with --name, the real name will
+have 'iruby_' prepended.
+
+Examples:
+  $ iruby_profile --create
+  # creates profile at $(ipython locate profile ruby)
+
+  $ iruby_profile --create --name='special'
+  # creates profile at $(ipython locate profile special)
+
+To use the profile, start IPython as usual:
+  $ ipython notebook --profile='ruby'
+
+Options:
+EOS
+
+  opt :create, 'Create a profile', default: false
+  opt :name,   'Profile name', type: :string, default: 'ruby'
+end
+
+if not opts[:create_given]
+  puts "Try --help first."
+  exit(1)
+end
+
+if opts[:create]
+  require 'iruby/profile'
+
+  p = IRuby::Profile.new(opts[:name])
+  p.create!
+end

data/iruby.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jnv-iruby"
+  spec.version       = IRuby::VERSION
+  spec.authors       = ["Damián Silvani", "Min RK", "martin sarsale", "Josh Adams"]
+  spec.email         = ["benjaminrk@gmail.com"]
+  spec.description   = %q{Ruby Kernel for IPython}
+  spec.summary       = %q{A Ruby kernel for IPython frontends (notebook console, etc.)}
+  spec.homepage      = "https://github.com/minrk/iruby"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "bond"
+  spec.add_runtime_dependency "ffi-rzmq"
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "term-ansicolor"
+  spec.add_runtime_dependency "trollop"
+  spec.add_runtime_dependency "uuid"
+  spec.add_runtime_dependency "gruff"
+end

data/lib/iruby.rb

@@ -0,0 +1,4 @@
+require 'iruby/version'
+
+module IRuby
+end

data/lib/iruby/display_hook.rb

@@ -0,0 +1,33 @@
+require 'iruby/message'
+
+module IRuby
+  class DisplayHook
+    def initialize kernel, session, pub_socket
+      @kernel = kernel
+      @session = session
+      @pub_socket = pub_socket
+      @parent_header = {}
+    end
+
+    def display(obj)
+      if obj.nil?
+        return
+      end
+      # STDERR.puts @kernel.user_ns
+      # @user_ns._ = obj
+      # STDERR.puts "displayhook call:"
+      # STDERR.puts @parent_header.inspect
+      #@pub_socket.send(msg.to_json)
+      data = {}
+      output = obj
+      data['text/plain'] = output
+      data[obj.mime] =  output
+      content = {data: data, metadata: {}, execution_count: @kernel.execution_count}
+      @session.send(@pub_socket, 'pyout', content, @parent_header)
+    end
+
+    def set_parent parent
+      @parent_header = Message.extract_header(parent)
+    end
+  end
+end