iruby 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3315e60fa2fabec2327df00d481249757ce9c199
-  data.tar.gz: 33f5306f10e6f51f64483e63b96cc3055f75e118
+  metadata.gz: edce35917d38e538781f2ab3827063693e6c6417
+  data.tar.gz: 9048d037809e1c69ff223c9363a2e743a5466931
 SHA512:
-  metadata.gz: d314e35b4f4331892cb7bee54c6ca5aab5a3d86f058c8b34472672831da21d37e88093babeabb8d0daaadd1dc2ac5508310c3c3b5767c98b7ccee7d5d7335510
-  data.tar.gz: f3543ff4d8c01cddc5c9091ffd4d78d95c3a74b5baba7efd4dc0c122487048de55f84b117d077bdde4bc3e9a90ad4db484087df0ab246b1bddd359d4ffa10b42
+  metadata.gz: 319cc7a36eadd9c88ee9aad9cf9a3ae845d32d17efc8c00ec228ae89988b1273ffb2e26e0721ff3337454cd7e7d27ca36d9885fef05b4d9198d14268c5b1785b
+  data.tar.gz: c0ff35cf5547c57343919a427041ed4fb297f3947f26b795252522bf85d7850f7ad44a23c73807606394a9078a68503f3bbaf36074bade8ced1e4b6da22aae91

data/CHANGES

@@ -1,3 +1,20 @@
+0.2.9 (2016-05-02)
+  
+  Bug Fixes:
+    * Fix an error where a NoMethodError was being raised where a table rendered using an Array of Hashes has more than `maxcols` columns. (@CGamesPlay)
+    * Patch PryBackend to throw unterminated string and unexpected end-of-file syntax errors (@kylekyle)
+
+  Enhnacements:
+    * Add an IRuby::Input class which provides widgets for getting inputs from users. (@kylekyle)
+    * Add data_uri dependency (@kylekyle)
+    * Added a clear_output display function (@mrkn)
+    * Doc fixes for installation (@kozo2, @generall)
+
+0.2.8 (2015-12-06)
+
+  * Add compatibility with ffi-rzmq
+  * Windows support
+
 0.2.7 (2015-07-02)
 
   * Fix problem with autoloaded constants in Display, problem with sciruby gem

data/README.md

@@ -29,11 +29,13 @@ Now you can run iruby with:
 #### Windows
 At first install IPython/Jupyter. I recommend an installation using [Enthought Canopy](https://www.enthought.com/).
 
-After that install libzmq.dll (v3.2.x, x86) from [the website of ZeroMQ](http://zeromq.org/area:download).
+Please update your PATH to include build tools or download the DevKit from http://rubyinstaller.org/downloads and follow [this instructions](http://github.com/oneclick/rubyinstaller/wiki/Development-Kit).
 
-Rename `libzmq-v100-mt-3_x_x.dll` to `libzmq.dll`.
+After that install ZeroMQ Legacy Stable Release 3.2.4 [x86 build for Windows XP SP3 and newer](http://miru.hk/archive/ZeroMQ-3.2.4~miru1.0-x86.exe).
 
-Add the path to /bin to the PATH system variable.
+Rename `libzmq-v100-mt-3_2_4.dll` to `libzmq.dll`.
+
+Add the dll path to the PATH system variable.
 
 Run two commands below:
 
@@ -46,14 +48,12 @@ Now you can run iruby with:
 
 #### Mac
 I recommend an installation using [Anaconda](https://store.continuum.io/cshop/anaconda/).
-I have not checked the installation to MacOS X, but four lines below were necessary in v0.1.x.
 
-    conda remove zeromq (If you installed anaconda)
-    brew install zeromq
-    gem install ffi-rzmq
-    gem install iruby
+After that, run three commands shown below.
 
-Send us pull-request if you Mac users successed in installing IRuby in another way.
+    brew install libtool autoconf automake autogen
+    gem install rbczmq
+    gem install iruby
 
 #### FreeBSD
 
@@ -93,6 +93,26 @@ Then, install iruby and related ports and gems.
     $ gem build iruby.gemspec
     $ sudo gem install iruby-0.2.7.gem
     ```
+### Installation for jRuby
+
+Since jRuby is fully compatible with Ruby version 2.2, it is possible to use iruby with jRuby. 
+It can be helpful if you want to use java classes in your iruby notebook.
+This will require the following software:
+* jRuby version >= 9.0.4.0
+* ZeroMQ version >= 4.1.4 (You may have to build it from source.)
+* ffi-rzmq gem
+* this iruby gem
+
+After installation, make sure that your `env` is set up to jruby.
+```shell
+$ env ruby -v
+```
+If you use RVM, it is enough to switch the current version to jruby.
+If you have already used iruby with a different version, you need to generate a new kernel:
+```shell
+$ iruby register --force
+```
+After that you can use iruby with jRuby in usual way.
 
 ### After the installation
 

data/iruby.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'bond', '~> 0.5'
   s.add_runtime_dependency 'multi_json', '~> 1.11'
   s.add_runtime_dependency 'mimemagic', '~> 0.3'
+  s.add_runtime_dependency 'data_uri', '~> 0.1'
 end

data/lib/iruby.rb

@@ -8,6 +8,7 @@ require 'iruby/version'
 require 'iruby/kernel'
 require 'iruby/backend'
 require 'iruby/ostream'
+require 'iruby/input'
 require 'iruby/formatter'
 require 'iruby/utils'
 require 'iruby/display'

data/lib/iruby/backend.rb

@@ -66,6 +66,11 @@ module IRuby
         reset
         raise SystemExit
       end
+      unless @pry.eval_string.empty?
+        syntax_error = @pry.eval_string
+        @pry.reset_eval_string
+        @pry.evaluate_ruby syntax_error
+      end
       raise @pry.last_exception if @pry.last_result_is_exception?
       @pry.push_initial_binding unless @pry.current_binding # ensure that we have a binding
       @pry.last_result

data/lib/iruby/display.rb

@@ -32,6 +32,10 @@ module IRuby
         data
       end
 
+      def clear_output(wait=false)
+        IRuby::Kernel.instance.session.send(:publish, :clear_output, {wait: wait})
+      end
+
       private
 
       def protect(mime, data)

data/lib/iruby/formatter.rb

@@ -61,7 +61,8 @@ module IRuby
           rows << row
         end
 
-        if header = keys
+        if keys
+          header = keys.to_a
           keys.merge(0...array_size)
         else
           keys = 0...array_size

data/lib/iruby/input.rb

@@ -0,0 +1,41 @@
+module IRuby
+  module Input
+    # autoload so that erector is not a required
+    # runtime dependency of IRuby
+    autoload :Builder, 'iruby/input/autoload'
+
+    def input prompt='Input'
+      result = form{input label: prompt}
+      result[:input] unless result.nil?
+    end
+
+    def password prompt='Password'
+      result = form{password label: prompt}
+      result[:password] unless result.nil?
+    end
+
+    def form &block
+      builder = Builder.new &block
+      form = InputForm.new(
+        fields: builder.fields, 
+        buttons: builder.buttons
+      )
+      form.widget_display
+      builder.process_result form.submit
+    end
+       
+    def popup title='Input', &block
+      builder = Builder.new &block
+      form = InputForm.new fields: builder.fields
+      popup = Popup.new(
+        title: title, 
+        form: form, 
+        buttons: builder.buttons
+      )
+      popup.widget_display
+      builder.process_result form.submit
+    end
+  end
+
+  extend Input
+end

data/lib/iruby/input/README.ipynb

@@ -0,0 +1,450 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# IRuby Input\n",
+    "\n",
+    "The `IRuby::Input` class makes it easier for IRuby users to get input from users. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "name = IRuby.input 'Enter your name'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following input methods are supported on the `IRuby` module:\n",
+    "\n",
+    "| method | description |\n",
+    "| -------- | -------- |\n",
+    "| `input(prompt)`   | Prompts the user for a line of input |\n",
+    "| `password(prompt)`   | Prompts the user for a password |\n",
+    "| `form(&block)`   | Presents a form to the user |\n",
+    "| `popup(title,&block)`   | Displays a form to the user as a popup |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Forms\n",
+    "\n",
+    "Forms are groups of inputs to be collected from the user. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  input :username\n",
+    "  password :password\n",
+    "  button\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The following methods are available to build forms: \n",
+    "\n",
+    "| method | description |\n",
+    "| -------- | -------- |\n",
+    "| `input(key=:input)`   | Prompts the user for a line of input |\n",
+    "| `textarea(key=:textarea),`   | Adds a textarea to the form |\n",
+    "| `password(key=:password)`   | Prompts the user for a password |\n",
+    "| `button(key=:done, color: :blue)`   | Adds a submit button to the form |\n",
+    "| `cancel(prompt='Cancel')`   | Adds a cancel button to the form |\n",
+    "| `text(string)`   | Adds text to the form |\n",
+    "| `html(&block)`   | Inserts HTML from the given [erector block](https://github.com/erector/erector)   |\n",
+    "| `file(key=:file)`   | Adds a file input to the form |\n",
+    "| `date(key=:date)`   | Adds a date picker to the form |\n",
+    "| `select(*options)`   | Adds a dropdown select input to the form |\n",
+    "| `radio(*options)`   | Adds a radio select input to the form |\n",
+    "| `checkbox(*options)`   | Adds checkbox inputs to the form |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Popups\n",
+    " \n",
+    "Popups are just forms in a bootstrap modal. They are useful when users **Run All** in a notebook with a lot of inputs. The popups always appear in the same spot, so users don't have to scroll down to find the next input. \n",
+    "\n",
+    "Popups accept a `title` argument, for example: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.popup 'Please enter your name' do \n",
+    "  input\n",
+    "  button\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Submit and cancel\n",
+    "\n",
+    "The enter key will submit an input or form and the escape key will cancel it. Canceled inputs are returned as `nil`. Inputs are automatically canceled if destroyed. An input can be destroyed by clearing its cell's output. The `cancel` button will cancel a form and all other buttons will submit it. \n",
+    "\n",
+    "After a form destroyed, the cell's output is cleared. Be careful not to prompt for input in a block that has previous output you would like to keep. Output is cleared to prevent forms from interferring with one another and to ensure that inputs are not inadvertently saved to the notebook. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.popup 'Confirm' do \n",
+    "  text 'Are you sure you want to continue?'\n",
+    "  cancel 'No'\n",
+    "  button 'Yes'\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Custom keys\n",
+    "\n",
+    "Every widget has an entry in the final results hash. A custom key can be passed as the first parameter to the hash. If no key is provided, the widget name is used as the key. The `cancel` widget has no key; it's first parameter is its label. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do\n",
+    "  input :username\n",
+    "  password :password\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Custom labels\n",
+    "\n",
+    "Field labels appear to the left of the field. Button labels appear as the text on the button. `cancel` labels are passed as the first argument. All other widgets' labels are set using the `label` parameter. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  input :name, label: 'Please enter your name'\n",
+    "  cancel 'None of your business!'\n",
+    "  button :submit, label: 'All done'\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Buttons\n",
+    "\n",
+    "Buttons do not appear in the final hash unless they are clicked. If clicked, their value is `true`. Here are the various colors a button can be:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  IRuby::Input::Button::COLORS.each_key do |color|\n",
+    "    button color, color: color\n",
+    "  end\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Textareas\n",
+    "\n",
+    "Textareas are multiline inputs that are convenient for larger inputs. If you need a line return when typing in a textarea, use shift+enter since enter will submit the form."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  text 'Enter email addresses, one per line (use shift+enter for newlines)'\n",
+    "  textarea :emails\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Text and HTML\n",
+    "\n",
+    "You can insert lines of text or custom html using their respective helpers:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  html { h1 'Choose a Stooge' }\n",
+    "  text 'Choose your favorite stooge'\n",
+    "  select :stooge, 'Moe', 'Larry', 'Curly'\n",
+    "  button\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dropdowns\n",
+    "\n",
+    "Selects are dropdowns of options. By default, the first supplied option is selected. If you don't want any default value, use `nil` as the first parameter. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  text 'Do you have a favorite Stooge?' \n",
+    "  select :stooge, nil, 'Moe', 'Larry', 'Curly'\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Radio selects and checkboxes\n",
+    "\n",
+    "Like selects, radio selects and checkboxes take multiple arguments, each one an option. If the first argument is a symbol, it is used as the key. \n",
+    "\n",
+    "Note that the `checkbox` widget will always return `nil` or an array. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  radio :children, *(0..12), label: 'How many children do you have?'\n",
+    "  checkbox :gender, 'Male', 'Female', 'Intersex', label: 'Select the genders of your children'\n",
+    "  button\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Files\n",
+    "\n",
+    "Since file widgets capture the enter key, you should include a button when creating forms that contain only a file input:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "IRuby.form do \n",
+    "  file :avatar, label: 'Choose an Avatar'\n",
+    "  button :submit\n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "File widgets return a hash with three keys: \n",
+    "\n",
+    "* `data`: The contents of the file as a string\n",
+    "* `content_type`: The type of file, such as `text/plain` or `image/jpeg`\n",
+    "* `name`: The name of the uploaded file"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example\n",
+    "\n",
+    "Here is an example form that uses every built-in widget. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "result = IRuby.form do \n",
+    "  html { h1 'The Everything Form' }\n",
+    "  text 'Marvel at the strange and varied inputs!'\n",
+    "  date\n",
+    "  file\n",
+    "  input :username\n",
+    "  password\n",
+    "  textarea\n",
+    "  radio *(1..10)\n",
+    "  checkbox 'Fish', 'Cat', 'Dog', label: 'Animals'\n",
+    "  select :color, *IRuby::Input::Button::COLORS.keys\n",
+    "  cancel                     \n",
+    "  button    \n",
+    "end"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Writing your own widget\n",
+    "\n",
+    "Most form methods are `IRuby::Input::Widget` instances. A `Widget` is an [`Erector::Widget`](https://github.com/erector/erector) with some additional helpers. Here is the `cancel` widget:\n",
+    "\n",
+    "```ruby\n",
+    "module IRuby\n",
+    "  module Input\n",
+    "    class Cancel < Widget\n",
+    "      needs :label\n",
+    "\n",
+    "      builder :cancel do |label='Cancel'|\n",
+    "        add_button Cancel.new(label: label)\n",
+    "      end\n",
+    "\n",
+    "      def widget_css\n",
+    "        \".iruby-cancel { margin-left: 5px; }\"\n",
+    "      end\n",
+    "\n",
+    "      def widget_js\n",
+    "        <<-JS\n",
+    "          $('.iruby-cancel').click(function(){\n",
+    "            $('#iruby-form').remove();\n",
+    "          });\n",
+    "        JS\n",
+    "      end\n",
+    "\n",
+    "      def widget_html\n",
+    "        button(\n",
+    "          @label,\n",
+    "          type: 'button', \n",
+    "          :'data-dismiss' => 'modal',\n",
+    "          class: \"btn btn-danger pull-right iruby-cancel\"\n",
+    "        )\n",
+    "      end\n",
+    "    end\n",
+    "  end\n",
+    "end\n",
+    "```\n",
+    "\n",
+    "The following methods are available for widgets to use or override: \n",
+    "\n",
+    "| method | description |\n",
+    "| -------- | -------- |\n",
+    "| `widget_js`   | Returns the widget's Javascript |\n",
+    "| `widget_css`   | Returns the widget's CSS |\n",
+    "| `widget_html`   | Returns the widget's   |\n",
+    "| `builder(method,&block)`   | Class method to add form building helpers. |\n",
+    "\n",
+    "The following methods are available in the `builder` block:\n",
+    "\n",
+    "| method | description |\n",
+    "| -------- | -------- |\n",
+    "| `add_field(field)` | Adds a widget to the form's field area |\n",
+    "| `add_button(button)` | Adds a button to the form's button area |\n",
+    "| `process(key,&block)`   | Register a custom processing block for the given key in the results hash |\n",
+    "| `unique_key(key)` | Returns a unique key for the given key. Use this to make sure that there are no key collisions in the final results hash. |\n",
+    "\n",
+    "A canceled form always returns `nil`. Otherwise, the form collects any element with a `data-iruby-key` and non-falsey `data-iruby-value` and passes those to the processor proc registered for the key. See the `File` widget for a more involved example of processing results."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Ruby 2.2.1",
+   "language": "ruby",
+   "name": "ruby"
+  },
+  "language_info": {
+   "file_extension": ".rb",
+   "mimetype": "application/x-ruby",
+   "name": "ruby",
+   "version": "2.2.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}