RubyGems - irb_hacks - Versions diffs - 0.1.1 → 0.2.0 - Mend

irb_hacks 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

data/MIT-LICENSE +20 -0
data/README.html +176 -0
data/README.md +164 -134
data/Rakefile +54 -0
data/VERSION.yml +3 -2
data/irb_hacks.gemspec +18 -14
data/lib/irb_hacks/core_ext/kernel/a_and_ae.rb +18 -11
data/lib/irb_hacks/core_ext/kernel/less.rb +15 -8
data/lib/irb_hacks/snippet.rb +10 -3
data/lib/irb_hacks.rb +10 -0
metadata +20 -7

data/MIT-LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Alex Fortuna
+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.html ADDED Viewed

@@ -0,0 +1,176 @@
+<head>
+  <meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
+  <link href="dev/github.css" rel="stylesheet" type="text/css" />
+</head>
+<h1 id="yet-another-set-of-irb-hacks">Yet Another Set of IRB Hacks</h1>
+<h2 id="setup">Setup</h2>
+<pre><code>$ gem sources --add http://rubygems.org
+$ gem install irb_hacks
+</code></pre>
+<p>Add to your <code>~/.irbrc</code>:</p>
+<pre><code>require "rubygems"
+require "irb_hacks"
+</code></pre>
+<p>Now fire up IRB for a quick test:</p>
+<pre><code>$ irb
+irb&gt; ae
+(snippet)&gt;&gt;
+</code></pre>
+<p>If you see “(snippet)”, you’re ready to go.</p>
+<h2 id="the-hacks">The Hacks</h2>
+<h3 id="code-snippets----a-and-ae">Code snippets – <code>a</code> and <code>ae</code></h3>
+<p>There’s often a need to invoke our work-in-progress code a number of times using the same arguments, wrapping block, etc. For that, “code snippets” feature is quite handy.</p>
+<p><code>irb_hacks</code> gem provides the two methods with short, meaningless (and thus conflict-free) names – <code>a</code> and <code>ae</code>. <code>a</code> means nothing, it’s just the first letter of the alphabet. <code>a</code> <strong>invokes</strong> the last-edited snippet. <code>ae</code> <strong>lets you edit</strong> the actual snippet (it roughly stands for “a” + “edit”).</p>
+<p>A very basic example:</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; puts "Hello, world"
+irb&gt; a
+Hello, world
+</code></pre>
+<p>Snippet arguments are supported. It’s an array called <code>args</code> in snippet context.</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; p "args", args
+irb&gt; a 10, 1.0, "a string"
+"args"
+[10, 1.0, "a string"]
+</code></pre>
+<p>Snippets work just like normal Ruby methods – they return the value of the last statement executed.</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; ["alfa", "zulu", "bravo"] + args
+irb&gt; puts a("charlie").sort
+alfa
+bravo
+charlie
+zulu
+</code></pre>
+<p>Snippets support code blocks. It’s a <code>Proc</code> called <code>block</code> in snippet context. Usage example follows (suppose you’re building a simplistic <code>/etc/passwd</code> parser).</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; File.readlines("/etc/passwd").map(&amp;block).each {|s| p s}; nil
+irb&gt; a {|s| ar = s.split(":"); {:name =&gt; ar[0], :uid =&gt; ar[2]}}
+{:uid=&gt;"0", :name=&gt;"root"}
+{:uid=&gt;"1", :name=&gt;"bin"}
+{:uid=&gt;"2", :name=&gt;"daemon"}
+{:uid=&gt;"3", :name=&gt;"adm"}
+...
+</code></pre>
+<p>Snippets are <strong>persistent</strong> though IRB invocations. That’s quite handy, since not all stuff can be dynamically reloaded and sometimes one has to restart IRB to ensure a clean reload.</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; puts "Snippets are persistent!"
+irb&gt; exit
+$ irb
+irb&gt; a
+Snippets are persistent!
+</code></pre>
+<p>Just in case, snippet history file is called <code>.irb_snippet_history</code> in your <code>$HOME</code>.</p>
+<p>Snippets maintain <strong>their own</strong> Readline history. When you press [Up] and [Down] keys in <code>ae</code>, you browse the previously used snippets, not just your previous IRB input. Don’t retype the snippet you used yesterday – press [Up] a couple times and you’ll see it.</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; puts "snippet one"
+irb&gt; hala
+irb&gt; bala
+irb&gt; ae
+(snippet)&gt;&gt; puts "snippet two"
+irb&gt; foo
+irb&gt; moo
+irb&gt; ae
+(snippet)&gt;&gt;
+# Pressing [Up] will give you...
+(snippet)&gt;&gt; puts "snippet two"
+# Pressing [Up] again will give you...
+(snippet)&gt;&gt; puts "snippet one"
+</code></pre>
+<h3 id="browse-program-data-with-gnu-less">Browse program data with GNU <code>less</code></h3>
+<p>Sometimes the data your code works with is too long to fit in a console window. The clearest example of this are variables filled with text content, e.g. <a href="http://github.com/whymirror/hpricot">Hpricot</a> documents/elements.</p>
+<p>To solve that, the greatest paging program of all times, GNU <code>less</code>, comes to the rescue.</p>
+<pre><code>$ irb
+irb&gt; files = Dir["/etc/*"].sort
+# Some bulky array...
+irb&gt; less files
+# ... which you browse interactively!
+</code></pre>
+<p>In block form, <code>less</code> hack intercepts everything output to <code>STDOUT</code> (and, optionally, to <code>STDERR</code>), and feeds it to the pager.</p>
+<pre><code>$ irb
+irb&gt; less do
+puts "Hello, world"
+end
+</code></pre>
+<p>Now with <code>STDERR</code> capture:</p>
+<pre><code>$ irb
+irb&gt; less(:stderr) do
+puts "to stdout"
+STDERR.puts "to stderr"
+end
+</code></pre>
+<p>To specify another paging program or tweak <code>less</code> options, write in your <code>~/.irbrc</code>:</p>
+<pre><code>IrbHacks.less_cmd = "more"
+</code></pre>
+<p>, or something else you find appropriate.</p>
+<h3 id="break-execution-and-return-instant-value">Break execution and return instant value</h3>
+<p>By using <code>IrbHacks.break(value)</code> you break snippet execution and make it return <code>value</code>. This is a simple yet powerful debugging technique.</p>
+<p>Suppose you’re debugging the code which contains something like:</p>
+<pre><code>csv.each_with_index do |fc_row, i|
+  row = OpenHash[*fc_row.map {|k, v| [(k.to_sym rescue k), (v.to_s.strip rescue v)]}.flatten(1)]
+  ...
+</code></pre>
+<p>There’s something wrong with the code and you want to see if <code>row</code> is given the correct value. To do it, use <code>IrbHacks.break</code>:</p>
+<pre><code>csv.each_with_index do |fc_row, i|
+  row = OpenHash[*fc_row.map {|k, v| [(k.to_sym rescue k), (v.to_s.strip rescue v)]}.flatten(1)]
+  IrbHacks.break(row)
+</code></pre>
+<p>Now all you have to do is write an <code>ae</code> snippet and call it. <code>row</code> value will be available in IRB for inspection:</p>
+<pre><code>irb&gt; ae
+(snippet)&gt;&gt; Klass.new.method(args)
+irb&gt; row = a
+# Back in IRB. Do whatever you want with `row` value now.
+irb&gt;
+</code></pre>
+<p>Each <code>IrbHacks.break</code> call raises an <code>IrbHacks::BreakException</code>. If you see them popping out during runtime, find the appropriate <code>IrbHacks.break</code> calls and defuse them.</p>
+<h2 id="feedback">Feedback</h2>
+<p>Send bug reports, suggestions and criticisms through <a href="http://github.com/dadooda/irb_hacks">project’s page on GitHub</a>.</p>
+<p>Licensed under the MIT License.</p>

data/README.md CHANGED Viewed

@@ -1,134 +1,164 @@
-Yet another set of IRB hacks
-============================
-Setup
------
-    $ gem sources --add http://gemcutter.org
-    $ gem install irb_hacks
-Add to your `~/.irbrc`:
-    require "rubygems"
-    require "irb_hacks"
-Now fire up IRB for a quick test:
-    $ irb
-    irb> ae
-    (snippet)>>
-If you see "(snippet)", you're ready to go.
-The Hacks
----------
-### Code snippets -- `a` and `ae` ###
-There's often a need to invoke our work-in-progress code a number of times using the same arguments, wrapping block, etc. For that, "code snippets" feature is quite handy.
-`irb_hacks` gem provides the two methods with short, meaningless (and thus conflict-free) names -- `a` and `ae`. `a` means nothing, it's just the first letter of the alphabet. `a` **invokes** the last-edited snippet. `ae` **lets you edit** the actual snippet (it roughly stands for "a" + "edit").
-A very basic example:
-    irb> ae
-    (snippet)>> puts "Hello, world"
-    irb> a
-    Hello, world
-Snippet arguments are supported. It's an array called `args` in snippet context.
-    irb> ae
-    (snippet)>> p "args", args
-    irb> a 10, 1.0, "a string"
-    "args"
-    [10, 1.0, "a string"]
-Snippets work just like normal Ruby methods -- they return the value of the last statement executed.
-    irb> ae
-    (snippet)>> ["alfa", "zulu", "bravo"] + args
-    irb> puts a("charlie").sort
-    alfa
-    bravo
-    charlie
-    zulu
-Snippets support code blocks. It's a `Proc` called `block` in snippet context. Usage example follows (suppose we're building a simplistic `/etc/passwd` parser).
-    irb> ae
-    (snippet)>> File.readlines("/etc/passwd").map(&block).each {|s| p s}; nil
-    irb> a {|s| ar = s.split(":"); {:name => ar[0], :uid => ar[2]}}
-    {:uid=>"0", :name=>"root"}
-    {:uid=>"1", :name=>"bin"}
-    {:uid=>"2", :name=>"daemon"}
-    {:uid=>"3", :name=>"adm"}
-    ...
-Snippets are **persistent** though IRB invocations. That's quite handy, since not all stuff can be dynamically reloaded and sometimes we have to restart IRB to ensure clean reload.
-    irb> ae
-    (snippet)>> puts "Snippets are persistent!"
-    irb> exit
-    $ irb
-    irb> a
-    Snippets are persistent!
-Just in case, snippet history file is called `.irb_snippet_history` in your `$HOME`.
-Snippets maintain **their own** Realine history. When you press [Up] and [Down] keys in `ae`, you browse the previously used snippets, not just your previous IRB input. Don't retype the snippet you used yesterday -- press [Up] a couple times and you'll see it.
-    irb> ae
-    (snippet)>> puts "snippet one"
-    irb> hala
-    irb> bala
-    irb> ae
-    (snippet)>> puts "snippet two"
-    irb> foo
-    irb> moo
-    irb> ae
-    (snippet)>>
-    ## Pressing [Up] will give you...
-    (snippet)>> puts "snippet two"
-    ## Pressing [Up] again will give you...
-    (snippet)>> puts "snippet one"
-### Browse program data with GNU `less` ###
-Sometimes the data your code works with is too long to fit in a console window. The clearest example of this are variables filled with text content, e.g. [Hpricot](http://github.com/whymirror/hpricot) documents/elements.
-To solve that, the greatest paging program of all times, GNU `less`, comes to the rescue.
-    $ irb
-    irb> files = Dir["/etc/*"].sort
-    ## Some bulky array...
-    irb> less files
-    ## ... which we browse interactively :).
-In block form, `less` hack intercepts everything output to `STDOUT` (and, optionally, to `STDERR`), and feeds it to the pager.
-    $ irb
-    irb> less do
-    puts "Hello, world"
-    end
-Now with `STDERR` capture:
-    $ irb
-    irb> less(:stderr) do
-    puts "to stdout"
-    STDERR.puts "to stderr"
-    end
-To specify another paging program or tweak `less` options, write in your `~/.irbrc`:
-    IrbHacks.less_cmd = "more"
-, or something else you find appropriate.
-Feedback
---------
-Send bug reports, suggestions and criticisms through [project's page on GitHub](http://github.com/dadooda/irb_hacks).
+Yet Another Set of IRB Hacks
+============================
+Setup
+-----
+    $ gem sources --add http://rubygems.org
+    $ gem install irb_hacks
+Add to your `~/.irbrc`:
+    require "rubygems"
+    require "irb_hacks"
+Now fire up IRB for a quick test:
+    $ irb
+    irb> ae
+    (snippet)>>
+If you see "(snippet)", you're ready to go.
+The Hacks
+---------
+### Code snippets -- `a` and `ae` ###
+There's often a need to invoke our work-in-progress code a number of times using the same arguments, wrapping block, etc. For that, "code snippets" feature is quite handy.
+`irb_hacks` gem provides the two methods with short, meaningless (and thus conflict-free) names -- `a` and `ae`. `a` means nothing, it's just the first letter of the alphabet. `a` **invokes** the last-edited snippet. `ae` **lets you edit** the actual snippet (it roughly stands for "a" + "edit").
+A very basic example:
+    irb> ae
+    (snippet)>> puts "Hello, world"
+    irb> a
+    Hello, world
+Snippet arguments are supported. It's an array called `args` in snippet context.
+    irb> ae
+    (snippet)>> p "args", args
+    irb> a 10, 1.0, "a string"
+    "args"
+    [10, 1.0, "a string"]
+Snippets work just like normal Ruby methods -- they return the value of the last statement executed.
+    irb> ae
+    (snippet)>> ["alfa", "zulu", "bravo"] + args
+    irb> puts a("charlie").sort
+    alfa
+    bravo
+    charlie
+    zulu
+Snippets support code blocks. It's a `Proc` called `block` in snippet context. Usage example follows (suppose you're building a simplistic `/etc/passwd` parser).
+    irb> ae
+    (snippet)>> File.readlines("/etc/passwd").map(&block).each {|s| p s}; nil
+    irb> a {|s| ar = s.split(":"); {:name => ar[0], :uid => ar[2]}}
+    {:uid=>"0", :name=>"root"}
+    {:uid=>"1", :name=>"bin"}
+    {:uid=>"2", :name=>"daemon"}
+    {:uid=>"3", :name=>"adm"}
+    ...
+Snippets are **persistent** though IRB invocations. That's quite handy, since not all stuff can be dynamically reloaded and sometimes one has to restart IRB to ensure a clean reload.
+    irb> ae
+    (snippet)>> puts "Snippets are persistent!"
+    irb> exit
+    $ irb
+    irb> a
+    Snippets are persistent!
+Just in case, snippet history file is called `.irb_snippet_history` in your `$HOME`.
+Snippets maintain **their own** Readline history. When you press [Up] and [Down] keys in `ae`, you browse the previously used snippets, not just your previous IRB input. Don't retype the snippet you used yesterday -- press [Up] a couple times and you'll see it.
+    irb> ae
+    (snippet)>> puts "snippet one"
+    irb> hala
+    irb> bala
+    irb> ae
+    (snippet)>> puts "snippet two"
+    irb> foo
+    irb> moo
+    irb> ae
+    (snippet)>>
+    # Pressing [Up] will give you...
+    (snippet)>> puts "snippet two"
+    # Pressing [Up] again will give you...
+    (snippet)>> puts "snippet one"
+### Browse program data with GNU `less` ###
+Sometimes the data your code works with is too long to fit in a console window. The clearest example of this are variables filled with text content, e.g. [Hpricot](http://github.com/whymirror/hpricot) documents/elements.
+To solve that, the greatest paging program of all times, GNU `less`, comes to the rescue.
+    $ irb
+    irb> files = Dir["/etc/*"].sort
+    # Some bulky array...
+    irb> less files
+    # ... which you browse interactively!
+In block form, `less` hack intercepts everything output to `STDOUT` (and, optionally, to `STDERR`), and feeds it to the pager.
+    $ irb
+    irb> less do
+    puts "Hello, world"
+    end
+Now with `STDERR` capture:
+    $ irb
+    irb> less(:stderr) do
+    puts "to stdout"
+    STDERR.puts "to stderr"
+    end
+To specify another paging program or tweak `less` options, write in your `~/.irbrc`:
+    IrbHacks.less_cmd = "more"
+, or something else you find appropriate.
+### Break execution and return instant value ###
+By using `IrbHacks.break(value)` you break snippet execution and make it return `value`. This is a simple yet powerful debugging technique.
+Suppose you're debugging the code which contains something like:
+    csv.each_with_index do |fc_row, i|
+      row = OpenHash[*fc_row.map {|k, v| [(k.to_sym rescue k), (v.to_s.strip rescue v)]}.flatten(1)]
+      ...
+There's something wrong with the code and you want to see if `row` is given the correct value. To do it, use `IrbHacks.break`:
+    csv.each_with_index do |fc_row, i|
+      row = OpenHash[*fc_row.map {|k, v| [(k.to_sym rescue k), (v.to_s.strip rescue v)]}.flatten(1)]
+      IrbHacks.break(row)
+Now all you have to do is write an `ae` snippet and call it. `row` value will be available in IRB for inspection:
+    irb> ae
+    (snippet)>> Klass.new.method(args)
+    irb> row = a
+    # Back in IRB. Do whatever you want with `row` value now.
+    irb>
+Each `IrbHacks.break` call raises an `IrbHacks::BreakException`. If you see them popping out during runtime, find the appropriate `IrbHacks.break` calls and defuse them.
+Feedback
+--------
+Send bug reports, suggestions and criticisms through [project's page on GitHub](http://github.com/dadooda/irb_hacks).
+Licensed under the MIT License.

data/Rakefile ADDED Viewed

@@ -0,0 +1,54 @@
+require "yaml"
+#require 'rake/gempackagetask'
+GEM_NAME = "irb_hacks"
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.name = GEM_NAME
+    gem.summary = "Yet another set of IRB hacks"
+    gem.description = "Yet another set of IRB hacks"
+    gem.email = "alex.r@askit.org"
+    gem.homepage = "http://github.com/dadooda/irb_hacks"
+    gem.authors = ["Alex Fortuna"]
+    gem.files = FileList[
+      "[A-Z]*",
+      "*.gemspec",
+      "lib/**/*.rb",
+    ]
+  end
+rescue LoadError
+  STDERR.puts "This gem requires Jeweler to be built"
+end
+desc "Rebuild gemspec and package"
+task :rebuild => [:gemspec, :build]
+desc "Push (publish) gem to Gemcutter"
+task :push do
+  # Yet found no way to ask Jeweler forge a complete version string for us.
+  vh = YAML.load(File.read("VERSION.yml"))
+  version = [vh[:major], vh[:minor], vh[:patch]].join(".")
+  pkgfile = File.join("pkg", [GEM_NAME, "-", version, ".gem"].to_s)
+  Kernel.system("gem", "push", pkgfile)
+end
+#Rake::GemPackageTask.new(spec) do |p|
+#  p.need_tar = true if RUBY_PLATFORM !~ /mswin/
+#end
+desc "Compile README preview"
+task :readme do
+  require "kramdown"
+  doc = Kramdown::Document.new(File.read "README.md")
+  fn = "README.html"
+  puts "Writing '#{fn}'..."
+  File.open(fn, "w") do |f|
+    f.write(File.read "dev/head.html")
+    f.write(doc.to_html)
+  end
+  puts ": ok"
+end

data/VERSION.yml CHANGED Viewed

@@ -1,4 +1,5 @@
 ---
-:patch: 1
 :major: 0
-:minor: 1
+:minor: 2
+:patch: 0
+#:build: pre

data/irb_hacks.gemspec CHANGED Viewed

@@ -1,43 +1,47 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE
-# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 Gem::Specification.new do |s|
   s.name = %q{irb_hacks}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Fortuna"]
-  s.date = %q{2010-01-18}
+  s.date = %q{2010-12-13}
   s.description = %q{Yet another set of IRB hacks}
   s.email = %q{alex.r@askit.org}
   s.extra_rdoc_files = [
+    "README.html",
     "README.md"
   ]
   s.files = [
     "CHANGELOG.md",
-     "README.md",
-     "VERSION.yml",
-     "irb_hacks.gemspec",
-     "lib/irb_hacks.rb",
-     "lib/irb_hacks/core_ext/kernel/a_and_ae.rb",
-     "lib/irb_hacks/core_ext/kernel/less.rb",
-     "lib/irb_hacks/snippet.rb"
+    "MIT-LICENSE",
+    "README.html",
+    "README.md",
+    "Rakefile",
+    "VERSION.yml",
+    "irb_hacks.gemspec",
+    "lib/irb_hacks.rb",
+    "lib/irb_hacks/core_ext/kernel/a_and_ae.rb",
+    "lib/irb_hacks/core_ext/kernel/less.rb",
+    "lib/irb_hacks/snippet.rb"
   ]
   s.homepage = %q{http://github.com/dadooda/irb_hacks}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Yet another set of IRB hacks}
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else
   end
 end

data/lib/irb_hacks/core_ext/kernel/a_and_ae.rb CHANGED Viewed

@@ -13,21 +13,28 @@ module IrbHacks   #:nodoc:
         def ae(*args)
           IrbHacks::Snippet.edit(*args)
         end
-      end
+      end # SingletonMethods
+      module InstanceMethods
+        private
-      ::Kernel.extend SingletonMethods
+        def a(*args, &block)
+          ::Kernel.a(*args, &block)
+        end
+        def ae(*args)
+          ::Kernel.ae(*args)
+        end
+      end
     end
   end
 end
-module Kernel   #:nodoc:
-  private
-  def a(*args, &block)
-    ::Kernel.a(*args, &block)
-  end
+Kernel.extend IrbHacks::CoreExtensions::Kernel::SingletonMethods
-  def ae(*args)
-    ::Kernel.ae(*args)
-  end
+module Kernel   #:nodoc:
+  include IrbHacks::CoreExtensions::Kernel::InstanceMethods
 end
+# Reinclude module into those using it.
+ObjectSpace.each_object(Module) {|m| (m.class_eval {include Kernel} if m.include? Kernel) rescue nil}

data/lib/irb_hacks/core_ext/kernel/less.rb CHANGED Viewed

@@ -31,7 +31,7 @@ module IrbHacks   #:nodoc:
             # Non-block invocation.
             if args.size < 1
               # We're interactive anyway. Why not give user a quick prompt?
-              STDERR.puts "Nothing to show. Invoke as less(args) or less(options, &block)."
+              STDERR.puts "Nothing to show. Invoke as less(args) or less(options, &block)"
             else
               File.popen(less_cmd, "w") do |f|
                 f.puts args
@@ -69,21 +69,28 @@ module IrbHacks   #:nodoc:
               STDOUT.reopen(old_stdout)
               STDERR.reopen(old_stderr) if o_stderr
             end
-          end # if block or no block.
+          end # if block
           nil
         end # less
       end # SingletonMethods
-      ::Kernel.extend SingletonMethods
+      module InstanceMethods
+        private
+        def less(*args, &block)
+          ::Kernel.less(*args, &block)
+        end
+      end # InstanceMethods
     end # Kernel
   end # CoreExtensions
 end
-module Kernel   #:nodoc:
-  private
+Kernel.extend IrbHacks::CoreExtensions::Kernel::SingletonMethods
-  def less(*args, &block)
-    ::Kernel.less(*args, &block)
-  end
+module Kernel   #:nodoc:
+  include IrbHacks::CoreExtensions::Kernel::InstanceMethods
 end
+# Reinclude module into those using it.
+ObjectSpace.each_object(Module) {|m| (m.class_eval {include Kernel} if m.include? Kernel) rescue nil}

data/lib/irb_hacks/snippet.rb CHANGED Viewed

@@ -2,8 +2,9 @@ require "readline"
 module IrbHacks   #:nodoc:
   module Snippet
+    #TODO: Configured values. Config is common for entire IrbHacks.
     HISTORY_FILE = File.join(ENV["HOME"], ".irb_snippet_history")
-    HISTORY_SIZE = 20
+    HISTORY_SIZE = 500
     # Edit code snippet.
     def self.edit
@@ -55,13 +56,19 @@ module IrbHacks   #:nodoc:
         nil
       end
-      @history = [%{puts "YOUR test code here"}] if not @history.is_a? Array
+      @history = [%{puts "YOUR test code here"}] if not @history
     end
     # Run code snippet.
+    # If <tt>IrbHacks.break</tt> is called anywhere, immediately return its argument.
     def self.run(*args, &block)
       if (code = @history.last)
-        eval(code, &block)
+        begin
+          eval(code, &block)
+        rescue IrbHacks::BreakException => e
+          # If invoked as documented, `e.message` is always an array.
+          e.message[0]
+        end
       end
     end

data/lib/irb_hacks.rb CHANGED Viewed

@@ -3,6 +3,14 @@ require "yaml"
 Dir[File.join(File.dirname(__FILE__), "irb_hacks/**/*.rb")].each {|fn| require fn}
 module IrbHacks
+  # Break execution, return value if invoked from `a`.
+  #
+  #   IrbHacks.break
+  #   IrbHacks.break("hi")
+  def self.break(value = nil)
+    raise BreakException, [value]
+  end
   def self.less_cmd
     @less_cmd
   end
@@ -11,6 +19,8 @@ module IrbHacks
     @less_cmd = cmd
   end
+  class BreakException < Exception; end
   #--------------------------------------- Defaults
   self.less_cmd = "less -R"

metadata CHANGED Viewed

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: irb_hacks
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  prerelease: false
+  segments:
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alex Fortuna
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2010-01-18 00:00:00 +03:00
+date: 2010-12-13 00:00:00 +03:00
 default_executable:
 dependencies: []
@@ -20,10 +25,14 @@ executables: []
 extensions: []
 extra_rdoc_files:
+- README.html
 - README.md
 files:
 - CHANGELOG.md
+- MIT-LICENSE
+- README.html
 - README.md
+- Rakefile
 - VERSION.yml
 - irb_hacks.gemspec
 - lib/irb_hacks.rb
@@ -35,26 +44,30 @@ homepage: http://github.com/dadooda/irb_hacks
 licenses: []
 post_install_message:
-rdoc_options:
-- --charset=UTF-8
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
+      segments:
+      - 0
       version: "0"
-  version:
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
+      segments:
+      - 0
       version: "0"
-  version:
 requirements: []
 rubyforge_project:
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key:
 specification_version: 3
 summary: Yet another set of IRB hacks