akitaonrails-utility_belt 1.0.10

data/lib/utility_belt/with.rb

@@ -0,0 +1,21 @@
+# Object#with -- by Dan Yoder, dev.zeraweb.com -- this is something from Pascal
+# and JavaScript. here's the use case.
+
+# instead of:
+#   some_object.do_x
+#   some_object.do_y
+#   some_object.do_z
+#
+# you can instead do:
+#   with(some_object)
+#     do_x
+#     do_y
+#     do_z
+#   end
+
+class Object
+  def with(object, &block)
+    object.instance_eval &block
+  end
+end
+

data/spec/convertable_to_file_spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'spec'
+require 'irb'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'utility_belt', 'convertable_to_file')
+
+describe ConvertableToFile do
+  include ConvertableToFile
+
+  before :each do
+    @tempfile = stub("temp file", :<< => nil, :path => nil)
+    Tempfile.stub!(:open).and_yield(@tempfile)
+  end
+
+  it "should create a temp file using object id as basename" do
+    should_receive(:object_id).and_return(6789)
+    Tempfile.should_receive(:open).with("6789").and_yield(@tempfile)
+    to_file
+  end
+
+  it "should dump self to the opened temp file" do
+    @tempfile.should_receive(:<<).with(self)
+    to_file
+  end
+
+  it "should return the temp file path" do
+    @tempfile.should_receive(:path).and_return("TEMP_PATH")
+    to_file.should == "TEMP_PATH"
+  end
+end

data/spec/equipper_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require 'lib/utility_belt/equipper'
+
+# Mocks for the gadgets
+UTILITY_BELT_IRB_STARTUP_PROCS = {}
+
+module IRB
+  def self.conf
+    {}
+  end
+end
+
+describe "UtilityBelt equipper" do
+
+  ALL_GADGETS = UtilityBelt::Equipper::GADGETS
+  DEFAULT_GADGETS = UtilityBelt::Equipper::DEFAULTS
+
+  before(:all) do
+    # I know, global variables are bad, but I can't get this to work otherwise
+    Kernel.__send__(:alias_method, :old_require, :require)
+    Kernel.__send__(:define_method, :require, proc {|library| $required_libs << library[13..-1] })
+  end
+
+  before(:each) do
+    $required_libs = []
+  end
+
+  after(:each) do
+    $required_libs = nil
+  end
+
+  after(:all) do
+    Kernel.__send__(:alias_method, :require, :old_require)
+  end
+
+  it "should load all gadgets" do
+    UtilityBelt.equip(:all)
+    $required_libs.should == ALL_GADGETS
+  end
+
+  it "should load no gadgets" do
+    UtilityBelt.equip(:none)
+    $required_libs.should == []
+  end
+
+  it "should load all default gadegts" do
+    UtilityBelt.equip(:defaults)
+    $required_libs.should == DEFAULT_GADGETS
+  end
+
+  it "should load all gadgets except is_an" do
+    UtilityBelt.equip(:all, :except => ['is_an'])
+    $required_libs.should == ALL_GADGETS - ['is_an']
+  end
+
+  it "should load no gadgets except is_an" do
+    UtilityBelt.equip(:none, :except => ['is_an'])
+    $required_libs.should == ['is_an']
+  end
+
+  it "should accept a string for the except-param" do
+    UtilityBelt.equip(:none, :except => 'is_an')
+    $required_libs.should == ['is_an']
+  end
+
+  it "should accept a symbol for the except-param" do
+    UtilityBelt.equip(:none, :except => :is_an)
+    $required_libs.should == ['is_an']
+  end
+end

data/spec/hash_math_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require "lib/utility_belt/hash_math"
+describe "Hash math" do
+
+  it "should add hashes" do
+    ({:a => :b} + {:c => :d}).should == {:a => :b, :c => :d}
+  end
+
+  it "should subtract hashes" do
+    ({:a => :b, :c => :d} - {:c => :d}).should == {:a => :b}
+  end
+
+  it "should subtract key/value pairs by key" do
+    ({:a => :b, :c => :d} - :c).should == {:a => :b}
+  end
+
+end

data/spec/interactive_editor_spec.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'spec'
+require 'irb'
+require 'delegate'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'utility_belt', 'interactive_editor')
+
+# Using SimpleDelegator allows us to replace the constants without triggering a
+# "constant redefined" warning.
+module StubPlatform
+  ARCH = SimpleDelegator.new(:x86)
+  OS   = SimpleDelegator.new(:unix)
+  IMPL = SimpleDelegator.new(:linux)
+end
+
+# Sneak a stub Platform class into InteractiveEditor so that we don't have to
+# override constants on the real Platform module
+#
+# P.S. This ugliness is why libraries should always prefer to expose methods
+# over constants.
+class InteractiveEditor
+  Platform = StubPlatform
+end
+
+describe InteractiveEditor, "given no clues as to what editor to use" do
+  before :each do
+    ENV.delete("VISUAL")
+    ENV.delete("EDITOR")
+    Kernel.stub!(:test).and_return(false)
+    File.stub!(:executable?).and_return(false)
+  end
+
+  it "should complain" do
+    lambda do
+      InteractiveEditor.sensible_editor
+    end.should raise_error
+  end
+end
+
+describe InteractiveEditor,
+         "given a Mac OS X platform and no editor environment vars" do
+
+  before :each do
+    ENV.delete("VISUAL")
+    ENV.delete("EDITOR")
+    @old_impl = StubPlatform::IMPL.__getobj__
+    StubPlatform::IMPL.__setobj__(:macosx)
+  end
+
+  after :each do
+    StubPlatform::IMPL.__setobj__(@old_impl)
+  end
+
+  it "should use the OS X 'open' command as the default editor" do
+    InteractiveEditor.sensible_editor.should == "open"
+  end
+end
+
+# xdg-open is a facility from the freedesktop.org, available on some recent free
+# desktop operating systems (like Ubuntu).  It uses the desktop environments
+# filetype associations to determine what program to open a file in.
+describe InteractiveEditor,
+         "given a Linux OS and no environment vars" do
+
+  before :each do
+    ENV.delete("VISUAL")
+    ENV.delete("EDITOR")
+    @old_impl = StubPlatform::IMPL.__getobj__
+    StubPlatform::OS.__setobj__(:linux)
+    File.stub!(:executable?).and_return(true)
+  end
+
+  after :each do
+    StubPlatform::IMPL.__setobj__(@old_impl)
+  end
+
+  it "should attempt to use 'xdg-open' command as the default editor" do
+    File.should_receive(:executable?).
+      with("/usr/bin/xdg-open").
+      and_return(true)
+    InteractiveEditor.sensible_editor.should == "/usr/bin/xdg-open"
+  end
+end
+
+# /usr/bin/sensible-editor is a Debian-ism AFAIK
+describe InteractiveEditor,
+         "given the existence of /usr/bin/sensible-editor and no xdg-open" do
+  it "should use /usr/bin/sensible-editor as the default editor" do
+    File.should_receive(:executable?).
+      with("/usr/bin/xdg-open").
+      and_return(false)
+    File.should_receive(:executable?).
+      with("/usr/bin/sensible-editor").
+      and_return(true)
+    InteractiveEditor.sensible_editor.should == "/usr/bin/sensible-editor"
+  end
+end
+
+describe InteractiveEditor, "given an EDITOR environment variable" do
+  before :each do
+    File.stub!(:executable?).and_return(true)
+    ENV["EDITOR"] = "MY_EDITOR"
+  end
+
+  after :each do
+    ENV.delete("EDITOR")
+  end
+
+  it "should use the EDITOR environment variable to determine a sensible editor" do
+    InteractiveEditor.sensible_editor.should == "MY_EDITOR"
+  end
+end
+
+describe InteractiveEditor, "given a VISUAL environment variable" do
+  before :each do
+    File.stub!(:executable?).and_return(true)
+    ENV["EDITOR"] = "MY_EDITOR"
+    ENV["VISUAL"] = "MY_VISUAL_EDITOR"
+  end
+
+  after :each do
+    ENV.delete("EDITOR")
+    ENV.delete("VISUAL")
+  end
+
+  it "should use the environment variable to determine a sensible editor" do
+    InteractiveEditor.sensible_editor.should == "MY_VISUAL_EDITOR"
+  end
+end
+
+describe InteractiveEditing, "(calling out to an external editor)" do
+  before :each do
+    @it          = Object.new
+    @it.extend(InteractiveEditing)
+    @editor      = stub("Editor", :edit_interactively => nil)
+    @editor_path = stub("Editor Path")
+    InteractiveEditor.stub!(:sensible_editor).and_return(@editor_path)
+    InteractiveEditor.stub!(:new).and_return(@editor)
+  end
+
+  it "should use InteractiveEditor to determine default editor" do
+    @it.edit_interactively
+    IRB.conf[:interactive_editors][@editor_path].should equal(@editor)
+  end
+end

data/spec/language_greps_spec.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require "lib/utility_belt/language_greps"
+describe "language greps" do
+
+  it "should handle String#blank?" do
+    "".should be_blank
+  end
+
+end

data/spec/pastie_spec.rb

@@ -0,0 +1,92 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+Platform = Module.new unless Object.const_defined?('Platform')
+Net = Module.new unless Object.const_defined?('Net')
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','lib/utility_belt'))
+UtilityBelt.equip(:pastie)
+include UtilityBelt::Pastie
+Clipboard = UtilityBelt::Clipboard unless Object.const_defined?('Clipboard')
+
+describe "pastie being called" do
+
+  before(:all) do
+    Net::HTTP = mock('HTTP') unless Net.const_defined?('HTTP')
+    URI = mock('URI') unless Object.const_defined?('URI')
+    Clipboard = mock('clipboard') unless Object.const_defined?('Clipboard')
+  end
+
+  before(:each) do
+    @page = mock('page')
+    @page.stub!(:body).and_return('href="foo"')
+    Net::HTTP.stub!(:post_form).and_return(@page)
+    URI.stub!(:parse)
+    Clipboard.stub!(:read)
+    Clipboard.stub!(:write)
+    Kernel.stub!(:system)
+  end
+
+  it "should be available in global namespace and not blow-up with default stub/mocking" do
+    pastie
+  end
+
+  it "should uri-parse the pastie uri" do
+    URI.should_receive(:parse).with("http://pastie.caboo.se/pastes/create")
+    pastie
+  end
+
+  it "should pass the uri-parsed result into the post" do
+    URI.should_receive(:parse).and_return('a_uri_object')
+    Net::HTTP.should_receive(:post_form).with('a_uri_object', anything()).and_return(@page)
+    pastie
+  end
+
+  it "should call system open on the pastie return" do
+    @page.should_receive(:body).and_return('href="returned_url"')
+    case Platform::IMPL
+    when :macosx
+      Kernel.should_receive(:system).with("open returned_url")
+    when :mswin
+      Kernel.should_receive(:system).with("start returned_url")
+    end
+    pastie
+  end
+
+  it "should write resulting url into the clipboard" do
+    @page.should_receive(:body).and_return('href="returned_url"')
+    Clipboard.should_receive(:write).with('returned_url')
+    pastie
+  end
+
+  describe "with no parameter it uses the clipboard" do
+    it "should read the clipboard" do
+      Clipboard.should_receive(:read)
+      pastie
+    end
+
+    it "should put the clipboard results in the post to pastie" do
+      Clipboard.should_receive(:read).and_return('bar')
+      Net::HTTP.should_receive(:post_form).with(anything(),{"paste_parser" => "ruby",
+        "paste[authorization]" => "burger",
+        "paste[body]" => 'bar'}).and_return(@page)
+      pastie
+    end
+  end
+
+ describe "with a parameter instead" do
+   #TODO: windows/linux safer now, since no clipboard functionality?
+    it "should not even read the clipboard" do
+      Clipboard.should_not_receive(:read)
+      pastie "baz"
+    end
+
+    it "should pass in the parameter instead" do
+      Net::HTTP.should_receive(:post_form).with(anything(),{"paste_parser" => "ruby",
+        "paste[authorization]" => "burger",
+        "paste[body]" => 'baz'}).and_return(@page)
+      pastie "baz"
+    end
+  end
+end

data/spec/pipe_spec.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+require 'spec'
+require 'irb'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'utility_belt', 'pipe')
+
+describe "String#|" do
+  before :each do
+    @pipe = stub(:pipe, :write => nil, :close_write => nil, :read => nil)
+    IO.stub!(:popen).and_yield(@pipe).and_return("RESULT")
+  end
+
+  it "should open a pipe" do
+    IO.should_receive(:popen).with("COMMAND", 'r+').and_return(@pipe)
+    "foo" | "COMMAND"
+  end
+
+  it "should write itself to the the pipe, close it, then read from it" do
+    @pipe.should_receive(:write).with("foo").ordered
+    @pipe.should_receive(:close_write).ordered
+    @pipe.should_receive(:read)
+
+    "foo" | "COMMAND"
+  end
+
+  it "should return the result of the IO.popen block" do
+    ("foo" | "COMMAND").should == "RESULT"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# Make sure Rubygems' mangling of the path is already done before we do our own
+# mangling.
+require 'rubygems'
+
+# Ensure that when we require UtilityBelt libs they are from the files under
+# test, NOT from the installed gem.
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), ".."))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))

data/spec/string_to_proc_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+require "lib/utility_belt/string_to_proc"
+describe "String to Proc" do
+
+  before(:all) do
+    @one2five = 1..5
+  end
+
+  it "should handle simple arrow notation" do
+    @one2five.map(&'x -> x + 1').should eql(@one2five.map { |x| x + 1 })
+    @one2five.map(&'x -> x*x').should eql(@one2five.map { |x| x*x })
+    @one2five.inject(&'x y -> x*y').should eql(@one2five.inject { |x,y| x*y })
+    'x y -> x**y'.to_proc()[2,3].should eql(lambda { |x,y| x**y }[2,3])
+    'y x -> x**y'.to_proc()[2,3].should eql(lambda { |y,x| x**y }[2,3])
+  end
+
+  it "should handle chained arrows" do
+    'x -> y -> x**y'.to_proc()[2][3].should eql(lambda { |x| lambda { |y| x**y } }[2][3])
+    'x -> y z -> y**(z-x)'.to_proc()[1][2,3].should eql(lambda { |x| lambda { |y,z| y**(z-x) } }[1][2,3])
+  end
+
+  it "should handle the default parameter" do
+    @one2five.map(&'2**_/2').should eql(@one2five.map { |x| 2**x/2 })
+    @one2five.select(&'_%2==0').should eql(@one2five.select { |x| x%2==0 })
+  end
+
+  it "should handle point-free notation" do
+    @one2five.inject(&'*').should eql(@one2five.inject { |mem, var| mem * var })
+    @one2five.select(&'>2').should eql(@one2five.select { |x| x>2 })
+    @one2five.select(&'2<').should eql(@one2five.select { |x| 2<x })
+    @one2five.map(&'2*').should eql(@one2five.map { |x| 2*x })
+    (-3..3).map(&'.abs').should eql((-3..3).map { |x| x.abs })
+  end
+
+  it "should handle implied parameters as best it can" do
+    @one2five.inject(&'x*y').should eql(@one2five.inject(&'*'))
+    'x**y'.to_proc()[2,3].should eql(8)
+    'y**x'.to_proc()[2,3].should eql(8)
+  end
+
+end