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

irb_hacks 0.1.1 → 0.2.0

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