iruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39e9bb6cc42415e3ab312341fd04724112d2952a
+  data.tar.gz: 7ffcf1e9550a71da16c554dada617e81e4fa7a41
+SHA512:
+  metadata.gz: 699ae86c55615f002265cb48b9b53463c9ce228aff076a296b2f338a74423799b3781cdada02ad848b13ad307945da3d46be78e8cbc1274280836d4acbc1c08a
+  data.tar.gz: 34aa0376810e9e1a1f8f0f6d9dc68c10bd2d714ee690966dff6cd224ca6b3ab5068aee3009324aba7b566a2a7c8114223c2fafe9ba4e36658b3056f6634ee9db

data/.gitignore

@@ -0,0 +1,19 @@
+.ipynb_checkpoints/
+*.gem
+*.rbc
+*.log
+.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,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -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,13 @@
+require 'rake/testtask'
+
+begin
+  require 'bundler/gem_tasks'
+rescue Exception
+end
+
+Rake::TestTask.new('test') do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end

data/Ruby Notebook.ipynb

@@ -0,0 +1,180 @@
+{
+ "metadata": {
+  "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "puts \"hi\"\n",
+      "raise \"zofe\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "hi\n"
+       ]
+      },
+      {
+       "ename": "RuntimeError",
+       "evalue": "zofe",
+       "output_type": "pyerr",
+       "traceback": [
+        "\u001b[31mRuntimeError\u001b[0m: zofe",
+        "\u001b[37m<main>:1:in `<main>'\u001b[0m",
+        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/kernel.rb:116:in `eval'\u001b[0m",
+        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/kernel.rb:116:in `execute_request'\u001b[0m",
+        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/kernel.rb:176:in `start'\u001b[0m",
+        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/command.rb:60:in `run_kernel'\u001b[0m",
+        "\u001b[37m/home/minad/code/git/iruby/lib/iruby/command.rb:15:in `run'\u001b[0m",
+        "\u001b[37m/home/minad/code/git/iruby/bin/iruby:6:in `<main>'\u001b[0m"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "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?\n",
+      "\n",
+      "puts \"hi\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "hi\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "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": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "I'm glad you asked!\n"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 4,
+       "text": [
+        "see_below"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "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/attic/output/html.rb

@@ -0,0 +1,217 @@
+module IRuby
+  module Output
+    module HTML
+      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]
+        elsif d.first.respond_to?(:keys) # array of hashes
+          columns = d.first.keys
+          r << "<tr>#{columns.map{|c| "<th>#{c.to_s}</th>"}.join}</tr>"
+        else # array
+          columns = (0 .. d.first.length)
+        end
+        d.each{|row|
+          r << "<tr>"
+          columns.each{|column|
+            r << "<td>#{row[column].to_s}</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|
+          label = data[0].strip
+          label = "?" if label == ''
+          g.data(label, 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| 
+            icon_url = nil
+            icon_url = p.icon_url if p.respond_to?(:icon_url)
+            icon_url = "http://www.google.com/intl/en_us/mapfiles/ms/micons/#{p.icon}-dot.png"if p.respond_to?(:icon)
+            "{" + [ 
+              "location: new google.maps.LatLng(#{p.lat.to_f}, #{p.lon.to_f})",
+               p.respond_to?(:weight) && p.weight && "weight: #{p.weight.to_i} ",
+               p.respond_to?(:label)  && "label: #{p.label.to_s.to_json}",
+               p.respond_to?(:z_index)  && "z_index: #{p.z_index.to_json}",
+               icon_url  && "icon_url: #{icon_url.to_json}",
+            ].reject{|x| ! x}
+             .join(",") + "}"
+          }.join(',') + "]"
+        end
+        def self.base_map(o)
+          zoom = o.delete(:zoom)
+          center = o.delete(:center)
+          map_type = o.delete(:map_type)
+          width = o.delete(:width) || "500px"
+          height = o.delete(:height) || "500px"
+r = <<E
+<div id='map-canvas' style='width: #{width}; height: #{height};'></div>
+<script src="https://maps.googleapis.com/maps/api/js?v=3.exp&sensor=false&libraries=visualization&callback=initialize"></script>
+
+<script>
+  function initialize() {
+    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);
+
+#{yield}
+  }
+</script>
+E
+        r
+
+        end
+        def self.heatmap(o)
+          data = o.delete(:points)
+          points = points2latlng(data)
+          radius = o.delete(:radius)
+          raise "Missing :points parameter" if not data
+          base_map(o){<<E
+    var points = #{points};
+    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({
+      radius: #{radius.to_json} || 10,
+      data: pointArray
+    });
+
+    heatmap.setMap(map);
+E
+          }
+
+        end
+        def self.markers(o)
+          data = o.delete(:points)
+          points = points2latlng(data)
+          radius = o.delete(:radius)
+          raise "Missing :points parameter" if not data
+          base_map(o){<<E
+    var points = #{points};
+    if (! zoom){
+      for (var i = 0; i < points.length; i++) {
+        latlngbounds.extend(points[i].location);
+     }
+     map.fitBounds(latlngbounds);
+    }
+
+    for (var i=0; i<points.length; i++){
+       var marker = new google.maps.Marker({
+          position: points[i].location,
+          map: map,
+          icon: points[i].icon_url,
+          zIndex: points[i].z_index,
+          title: points[i].label
+      });
+    }
+
+E
+          }
+
+        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