hirb 0.3.1 → 0.3.2

data/CHANGELOG.rdoc

@@ -1,6 +1,12 @@
+== 0.3.2
+* Added irb autocompletions for bond.
+* Fixed tests for ruby 1.9.
+* Changed tests to use bacon.
+* Removed jeweler in Rakefile and pointless $LOAD_PATH manipulation.
+
 == 0.3.1
-* Bug fix on DynamicView.class_to_method to allow overrides of default views
-* Modified mongo_mapper view to have _id first
+* Bug fix on DynamicView.class_to_method to allow overrides of default views.
+* Modified mongo_mapper view to have _id first.
 
 == 0.3.0
 * Added dynamic views.

data/Rakefile

@@ -1,53 +1,35 @@
 require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-begin
-  require 'rcov/rcovtask'
+require 'fileutils'
 
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/**/*_test.rb']
-    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
-    t.verbose = true
-  end
-rescue LoadError
-  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+def gemspec
+  @gemspec ||= eval(File.read('gemspec'), binding, 'gemspec')
 end
 
-begin
-  require 'jeweler'
-  require File.dirname(__FILE__) + "/lib/hirb/version"
+desc "Build the gem"
+task :gem=>:gemspec do
+  sh "gem build gemspec"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+end
 
-  Jeweler::Tasks.new do |s|
-    s.name = "hirb"
-    s.version = Hirb::VERSION
-    s.summary = "A mini view framework for console/irb that's easy to use, even while under its influence."
-    s.description = "Hirb currently provides a mini view framework for console applications, designed to improve irb's default output.  Hirb improves console output by providing a smart pager and auto-formatting output. The smart pager detects when an output exceeds a screenful and thus only pages output as needed. Auto-formatting adds a view to an output's class. This is helpful in separating views from content (MVC anyone?). The framework encourages reusing views by letting you package them in classes and associate them with any number of output classes."
-    s.email = "gabriel.horner@gmail.com"
-    s.homepage = "http://tagaholic.me/hirb/"
-    s.authors = ["Gabriel Horner"]
-    s.rubyforge_project = 'tagaholic'
-    s.has_rdoc = true
-    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
-    s.files = FileList["[A-Z]*", "{bin,lib,test}/**/*"]
-  end
+desc "Install the gem locally"
+task :install => :gem do
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version}}
+end
 
-rescue LoadError
-  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
 end
 
-Rake::TestTask.new do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
 end
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'test'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+desc 'Run tests'
+task :test do |t|
+  sh 'bacon -q -Ilib -I. test/*_test.rb'
 end
 
-task :default => :test
+task :default => :test

data/gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless Object.const_defined?(:Gem)
+require File.dirname(__FILE__) + "/lib/hirb/version"
+ 
+Gem::Specification.new do |s|
+  s.name        = "hirb"
+  s.version     = Hirb::VERSION
+  s.authors     = ["Gabriel Horner"]
+  s.email       = "gabriel.horner@gmail.com"
+  s.homepage    = "http://tagaholic.me/hirb/"
+  s.summary     = "A mini view framework for console/irb that's easy to use, even while under its influence."
+  s.description = "Hirb currently provides a mini view framework for console applications, designed to improve irb's default output.  Hirb improves console output by providing a smart pager and auto-formatting output. The smart pager detects when an output exceeds a screenful and thus only pages output as needed. Auto-formatting adds a view to an output's class. This is helpful in separating views from content (MVC anyone?). The framework encourages reusing views by letting you package them in classes and associate them with any number of output classes." 
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project = 'tagaholic'
+  s.add_development_dependency 'bacon'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'mocha-on-bacon'
+  s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc} ext/**/*.{rb,c}]) + %w{Rakefile gemspec}
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+end

data/lib/bond/completions/hirb.rb

@@ -0,0 +1,14 @@
+complete(:methods=>%w{Hirb::View.enable Hirb.enable}) {
+  %w{config_file output_method output width height formatter pager pager_command}
+}
+complete(:methods=>%w{Hirb::Helpers::Table.render table}) {
+  %w{fields headers max_fields max_width resize number change_fields}+
+  %w{filters header_filter filter_any filter_classes vertical all_fields}+
+  %w{description escape_special_chars table_class hide_empty}
+}
+complete(:method=>"Hirb::Helpers::Tree.render") {
+  %w{type validate indent limit description multi_line_nodes value_method children_method}
+}
+complete(:methods=>%w{Hirb::Menu.render menu}) {
+  %w{helper_class prompt ask directions readline two_d default_field action multi_action action_object command}
+}

data/lib/hirb.rb

@@ -1,6 +1,3 @@
-current_dir = File.dirname(__FILE__)
-$:.unshift(current_dir) unless $:.include?(current_dir) || $:.include?(File.expand_path(current_dir))
-
 # Needed by Hirb::String to handle multibyte characters
 $KCODE = 'u' if RUBY_VERSION < '1.9'
 

data/lib/hirb/helpers/table.rb

@@ -164,7 +164,7 @@ module Hirb
     rows = filter_values(rows)
     rows.each_with_index {|e,i| e[:hirb_number] = (i + 1).to_s} if @options[:number]
     deleted_callbacks = Array(@options[:delete_callbacks]).map {|e| "#{e}_callback" }
-    (methods.grep(/_callback$/) - deleted_callbacks).sort.each do |meth|
+    (methods.grep(/_callback$/).map {|e| e.to_s} - deleted_callbacks).sort.each do |meth|
       rows = send(meth, rows, @options.dup)
     end
     validate_values(rows)

data/lib/hirb/version.rb

@@ -1,3 +1,3 @@
 module Hirb
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/test/auto_table_test.rb

@@ -1,32 +1,30 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Hirb::Helpers::AutoTableTest < Test::Unit::TestCase
-  context "auto table" do
-    test "converts nonarrays to arrays and renders" do
-      require 'set'
-      expected_table = <<-TABLE.unindent
-      +-------+
-      | value |
-      +-------+
-      | 1     |
-      | 2     |
-      | 3     |
-      +-------+
-      3 rows in set
-      TABLE
-      Hirb::Helpers::AutoTable.render(::Set.new([1,2,3])).should == expected_table
-    end
+describe "auto table" do
+  it "converts nonarrays to arrays and renders" do
+    require 'set'
+    expected_table = <<-TABLE.unindent
+    +-------+
+    | value |
+    +-------+
+    | 1     |
+    | 2     |
+    | 3     |
+    +-------+
+    3 rows in set
+    TABLE
+    Helpers::AutoTable.render(::Set.new([1,2,3])).should == expected_table
+  end
 
-    test "renders hash" do
-      expected_table = <<-TABLE.unindent
-      +---+-------+
-      | 0 | 1     |
-      +---+-------+
-      | a | 12345 |
-      +---+-------+
-      1 row in set
-      TABLE
-      Hirb::Helpers::AutoTable.render({:a=>12345}).should == expected_table
-    end
+  it "renders hash" do
+    expected_table = <<-TABLE.unindent
+    +---+-------+
+    | 0 | 1     |
+    +---+-------+
+    | a | 12345 |
+    +---+-------+
+    1 row in set
+    TABLE
+    Helpers::AutoTable.render({:a=>12345}).should == expected_table
   end
 end

data/test/bacon_extensions.rb

@@ -0,0 +1,26 @@
+module BaconExtensions
+  def self.included(mod)
+    mod.module_eval do
+      # nested context methods automatically inherit methods from parent contexts
+      def describe(*args, &block)
+        context = Bacon::Context.new(args.join(' '), &block)
+        (parent_context = self).methods(false).each {|e|
+          class<<context; self end.send(:define_method, e) {|*args| parent_context.send(e, *args)}
+        }
+        @before.each { |b| context.before(&b) }
+        @after.each { |b| context.after(&b) }
+        context.run
+      end
+    end
+  end
+
+  def xit(*args); end
+  def xdescribe(*args); end
+  def before_all; yield; end
+  def after_all; yield; end
+  def assert(description, &block)
+    it(description) do
+      block.call.should == true
+    end
+  end
+end

data/test/console_test.rb

@@ -1,12 +1,10 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Hirb::ConsoleTest < Test::Unit::TestCase
-  context "parse_input" do
-    test "config is set if it wasn't before" do
-      reset_config
-      Hirb::View.expects(:render_output)
-      Hirb::Console.render_output('blah')
-      Hirb::View.config.is_a?(Hash).should == true
-    end
+describe "parse_input" do
+  it "config is set if it wasn't before" do
+    reset_config
+    View.expects(:render_output)
+    Console.render_output('blah')
+    View.config.is_a?(Hash).should == true
   end
-end
+end

data/test/dynamic_view_test.rb

@@ -1,100 +1,94 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Hirb
-  class DynamicViewTest < Test::Unit::TestCase
-    def output_expects(output, expects)
-      Helpers::ObjectTable.expects(:render).with(output, expects)
-      Helpers::AutoTable.render(output)
-    end
-    after(:all) { Formatter.dynamic_config = {} }
-
-    context "add" do
-      before(:all) { View.load_config }
+describe "DynamicView" do
+  def output_expects(output, expects)
+    Helpers::ObjectTable.expects(:render).with(output, expects)
+    Helpers::AutoTable.render(output)
+  end
 
-      test "raises error if no :helper option" do
-        assert_raises(ArgumentError) {
-          Hirb.add_dynamic_view 'Blah', {}
-        }.message.should =~ /:helper.*required/
-      end
+  describe "add" do
+    before_all { View.load_config }
 
-      test "raises error if :helper option not a dynamic_view module" do
-        assert_raises(ArgumentError) {
-          Hirb.add_dynamic_view('Blah', :helper=>:table) {|obj| }
-        }.message.should =~ /:helper.*must/
-      end
+    it "raises error if no :helper option" do
+      lambda { Hirb.add_dynamic_view 'Blah', {} }.should.raise(ArgumentError).
+        message.should =~ /:helper.*required/
+    end
 
-      test "raises error if views module not a module" do
-        assert_raises(ArgumentError) {
-          Hirb.add_dynamic_view 'Blah', :helper=>:auto_table
-        }.message.should =~ /must be a module/
-      end
+    it "raises error if :helper option not a dynamic_view module" do
+      lambda { Hirb.add_dynamic_view('Blah', :helper=>:table) {|obj| } }.
+        should.raise(ArgumentError).message.should =~ /:helper.*must/
+    end
 
-      test "adds a view with block" do
-        Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
-          {:fields=>obj.class::DAYNAMES}
-        end
-        output_expects [Date.new], :fields=>Date::DAYNAMES
-      end
+    it "raises error if views module not a module" do
+      lambda { Hirb.add_dynamic_view 'Blah', :helper=>:auto_table }.should.raise(ArgumentError).
+        message.should =~ /must be a module/
+    end
 
-      test "when adding views with a block, second view for same class overrides first one" do
-        Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
-          {:fields=>obj.class::DAYNAMES}
-        end
-        Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
-          {:fields=>[:blah]}
-        end
-        output_expects [Date.new], :fields=>[:blah]
+    it "adds a view with block" do
+      Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
+        {:fields=>obj.class::DAYNAMES}
       end
+      output_expects [Date.new], :fields=>Date::DAYNAMES
     end
 
-    test "class_to_method and method_to_class convert to each other" do
-      ["DBI::Row", "Hirb::View"].each do |e|
-        Helpers::AutoTable.method_to_class(DynamicView.class_to_method(e).downcase).should == e
+    it "when adding views with a block, second view for same class overrides first one" do
+      Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
+        {:fields=>obj.class::DAYNAMES}
+      end
+      Hirb.add_dynamic_view('Date', :helper=>:auto_table) do |obj|
+        {:fields=>[:blah]}
       end
+      output_expects [Date.new], :fields=>[:blah]
     end
+  end
 
-    test "class_to_method converts correctly" do
-      DynamicView.class_to_method("DBI::Row").should == 'd_b_i__row_view'
+  it "class_to_method and method_to_class convert to each other" do
+    ["DBI::Row", "Hirb::View"].each do |e|
+      Helpers::AutoTable.method_to_class(DynamicView.class_to_method(e).downcase).should == e
     end
+  end
 
-    context "dynamic_view" do
-      def define_view(mod_name= :Blah, &block)
-        mod = Views.const_set(mod_name, Module.new)
-        mod_block = block_given? ? block : lambda {|obj| {:fields=>obj.class::DAYNAMES}}
-        mod.send(:define_method, :date_view, mod_block)
-        Hirb.add_dynamic_view mod, :helper=>:auto_table
-      end
+  it "class_to_method converts correctly" do
+    DynamicView.class_to_method("DBI::Row").should == 'd_b_i__row_view'
+  end
 
-      before(:all) { View.load_config }
-      before(:each) { Formatter.dynamic_config = {} }
-      after(:each) { Views.send(:remove_const, :Blah) }
-      after(:all) { reset_config }
+  describe "dynamic_view" do
+    def define_view(mod_name= :Blah, &block)
+      mod = Views.const_set(mod_name, Module.new)
+      mod_block = block_given? ? block : lambda {|obj| {:fields=>obj.class::DAYNAMES}}
+      mod.send(:define_method, :date_view, mod_block)
+      Hirb.add_dynamic_view mod, :helper=>:auto_table
+    end
 
-      test "sets a view's options" do
-        define_view
-        output_expects [Date.new], :fields=>Date::DAYNAMES
-      end
+    before_all { View.load_config }
+    before { Formatter.dynamic_config = {} }
+    after { Views.send(:remove_const, :Blah) }
 
-      test "does override existing formatter dynamic_config" do
-        Formatter.dynamic_config["Date"] = {:class=>Helpers::Table}
-        define_view
-        Formatter.dynamic_config["Date"].should == {:class=>Hirb::Helpers::AutoTable, :ancestor=>true}
-      end
+    it "sets a view's options" do
+      define_view
+      output_expects [Date.new], :fields=>Date::DAYNAMES
+    end
 
-      test "raises a readable error when error occurs in a view" do
-        define_view {|obj| raise 'blah' }
-        assert_raises(RuntimeError) {
-          Helpers::AutoTable.render([Date.new])
-        }.message.should =~ /'Date'.*date_view.*\nblah/
-      end
+    it "does override existing formatter dynamic_config" do
+      Formatter.dynamic_config["Date"] = {:class=>Helpers::Table}
+      define_view
+      Formatter.dynamic_config["Date"].should == {:class=>Hirb::Helpers::AutoTable, :ancestor=>true}
+    end
+
+    it "raises a readable error when error occurs in a view" do
+      define_view {|obj| raise 'blah' }
+      lambda { Helpers::AutoTable.render([Date.new]) }.should.raise(RuntimeError).
+        message.should =~ /'Date'.*date_view.*\nblah/
+    end
 
-      test "another view can reuse an old view's options" do
-        define_view
-        define_view(:Blah2) do |obj|
-          {:fields=>obj.class::DAYNAMES + ['blah']}
-        end
-        output_expects [Date.new], :fields=>(Date::DAYNAMES + ['blah'])
+    it "another view can reuse an old view's options" do
+      define_view
+      define_view(:Blah2) do |obj|
+        {:fields=>obj.class::DAYNAMES + ['blah']}
       end
+      output_expects [Date.new], :fields=>(Date::DAYNAMES + ['blah'])
     end
+    after_all { reset_config }
   end
-end
+  after_all { Formatter.dynamic_config = {} }
+end

data/test/formatter_test.rb

@@ -1,45 +1,48 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Hirb
-class FormatterTest < Test::Unit::TestCase
+describe "Formatter" do
   def set_formatter(hash={})
     @formatter = Formatter.new(hash)
   end
 
-  context "klass_config" do
-    test "recursively merges ancestor options" do
-      set_formatter "String"=>{:args=>[1,2], :options=>{:fields=>[:to_s]}},
+  describe "klass_config" do
+    it "recursively merges ancestor options" do
+      @formatter = set_formatter "String"=>{:args=>[1,2], :options=>{:fields=>[:to_s]}},
         "Object"=>{:method=>:object_output, :ancestor=>true, :options=>{:vertical=>true}},
         "Kernel"=>{:method=>:default_output}
       expected_result = {:method=>:object_output, :args=>[1, 2], :ancestor=>true, :options=>{:fields=>[:to_s], :vertical=>true}}
       @formatter.klass_config(::String).should == expected_result
     end
 
-    test "doesn't merge ancestor options" do
-      set_formatter "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output}, "Kernel"=>{:method=>:default_output}
+    it "doesn't merge ancestor options" do
+      @formatter = set_formatter "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output},
+       "Kernel"=>{:method=>:default_output}
       @formatter.klass_config(::String).should == {:args=>[1, 2]}
     end
 
-    test "returns hash when nothing found" do
+    it "returns hash when nothing found" do
       set_formatter.klass_config(::String).should == {}
     end
 
-    context "with dynamic_config" do
-      after(:each) { Formatter.dynamic_config = {}}
+    describe "with dynamic_config" do
+      def set_formatter(hash={})
+        @formatter = Formatter.new(hash)
+      end
+      after { Formatter.dynamic_config = {}}
 
-      test "merges ancestor options and sets local config" do
+      it "merges ancestor options and sets local config" do
         Formatter.dynamic_config = {"Object"=>{:method=>:blah}, "Kernel"=>{:args=>[1,2], :ancestor=>true}}
         set_formatter.klass_config(::String).should == {:args=>[1,2], :ancestor=>true}
         @formatter.config['Kernel'].should == {:args=>[1,2], :ancestor=>true}
       end
 
-      test "uses local config over dynamic_config" do
+      it "uses local config over dynamic_config" do
         Formatter.dynamic_config = {"String"=>{:method=>:blah}}
         set_formatter "String"=>{:args=>[1,2]}
         @formatter.klass_config(::String).should == {:args=>[1,2]}
       end
 
-      test "uses dynamic_config and sets local config" do
+      it "uses dynamic_config and sets local config" do
         Formatter.dynamic_config = {"String"=>{:method=>:blah}}
         set_formatter.klass_config(::String).should == {:method=>:blah}
         @formatter.config['String'].should == {:method=>:blah}
@@ -47,30 +50,30 @@ class FormatterTest < Test::Unit::TestCase
     end
   end
 
-  context "formatter methods:" do
-    before(:all) { eval "module ::Dooda; end" }
+  describe "formatter methods:" do
+    before_all { eval "module ::Dooda; end" }
 
-    test "add_view sets formatter config" do
-      set_formatter
+    it "add_view sets formatter config" do
+      @formatter = set_formatter
       @formatter.add_view ::Dooda, :class=>"DoodaView"
       @formatter.klass_config(::Dooda).should == {:class=>"DoodaView"}
     end
 
-    test "add_view overwrites existing formatter config" do
-      set_formatter "Dooda"=>{:class=>"DoodaView"}
+    it "add_view overwrites existing formatter config" do
+      @formatter = set_formatter "Dooda"=>{:class=>"DoodaView"}
       @formatter.add_view ::Dooda, :class=>"DoodaView2"
       @formatter.klass_config(::Dooda).should == {:class=>"DoodaView2"}
     end
 
-    test "parse_console_options passes all options except for formatter options into :options" do
-      set_formatter
+    it "parse_console_options passes all options except for formatter options into :options" do
+      @formatter = set_formatter
       options = {:class=>'blah', :method=>'blah', :output_method=>'blah', :blah=>'blah'}
       expected_options = {:class=>'blah', :method=>'blah', :output_method=>'blah', :options=>{:blah=>'blah'}}
       @formatter.parse_console_options(options).should == expected_options
     end
   end
 
-  context "format_output" do
+  describe "format_output" do
     def view_output(*args, &block); View.view_output(*args, &block); end
     def render_method(*args); View.render_method(*args); end
 
@@ -78,7 +81,7 @@ class FormatterTest < Test::Unit::TestCase
       Hirb.enable :output=>value
     end
 
-    before(:all) { 
+    before_all {
       eval %[module ::Commify
         def self.render(strings)
           strings = [strings] unless strings.is_a?(Array)
@@ -87,76 +90,75 @@ class FormatterTest < Test::Unit::TestCase
       end]
       reset_config
     }
-    before(:each) { View.formatter = nil; reset_config }
-    after(:each) { Hirb.disable }
+    before { View.formatter = nil; reset_config }
+    after { Hirb.disable }
     
-    test "formats with method option" do
+    it "formats with method option" do
       eval "module ::Kernel; def commify(string); string.split('').join(','); end; end"
       enable_with_output "String"=>{:method=>:commify}
       render_method.expects(:call).with('d,u,d,e')
       view_output('dude')
     end
     
-    test "formats with class option" do
+    it "formats with class option" do
       enable_with_output "String"=>{:class=>"Commify"}
       render_method.expects(:call).with('d,u,d,e')
       view_output('dude')
     end
     
-    test "formats with class option as symbol" do
+    it "formats with class option as symbol" do
       enable_with_output "String"=>{:class=>:auto_table}
       Helpers::AutoTable.expects(:render)
       view_output('dude')
     end
 
-    test "formats output array" do
+    it "formats output array" do
       enable_with_output "String"=>{:class=>"Commify"}
       render_method.expects(:call).with('d,u,d,e')
       view_output(['dude'])
     end
     
-    test "formats with options option" do
+    it "formats with options option" do
       eval "module ::Blahify; def self.render(*args); end; end"
       enable_with_output "String"=>{:class=>"Blahify", :options=>{:fields=>%w{a b}}}
       Blahify.expects(:render).with('dude', :fields=>%w{a b})
       view_output('dude')
     end
     
-    test "doesn't format and returns false when no format method found" do
+    it "doesn't format and returns false when no format method found" do
       Hirb.enable
       render_method.expects(:call).never
       view_output(Date.today).should == false
     end
     
-    test "formats with output_method option as method" do
+    it "formats with output_method option as method" do
       enable_with_output 'String'=>{:class=>"Commify", :output_method=>:chop}
       render_method.expects(:call).with('d,u,d')
       view_output('dude')
     end
 
-    test "formats with output_method option as proc" do
+    it "formats with output_method option as proc" do
       enable_with_output 'String'=>{:class=>"Commify", :output_method=>lambda {|e| e.chop}}
       render_method.expects(:call).with('d,u,d')
       view_output('dude')
     end
 
-    test "formats output array with output_method option" do
+    it "formats output array with output_method option" do
       enable_with_output 'String'=>{:class=>"Commify", :output_method=>:chop}
       render_method.expects(:call).with("d,u,d\nm,a")
       view_output(['dude', 'man'])
     end
 
-    test "formats with explicit class option" do
+    it "formats with explicit class option" do
       enable_with_output 'String'=>{:class=>"Blahify"}
       render_method.expects(:call).with('d,u,d,e')
       view_output('dude', :class=>"Commify")
     end
     
-    test "formats with explicit options option merges with existing options" do
+    it "formats with explicit options option merges with existing options" do
       enable_with_output "String"=>{:class=>"Commify", :options=>{:fields=>%w{f1 f2}}}
       Commify.expects(:render).with('dude', :max_width=>10, :fields=>%w{f1 f2})
       view_output('dude', :options=>{:max_width=>10})
     end
   end
 end
-end