hirb 0.2.10 → 0.3.0

data/lib/hirb/views/rails.rb

@@ -0,0 +1,19 @@
+module Hirb::Views::Rails #:nodoc:
+  def active_record__base_view(obj)
+    {:fields=>get_active_record_fields(obj)}
+  end
+
+  def get_active_record_fields(obj)
+    fields = obj.class.column_names.map {|e| e.to_sym }
+    # if query used select
+    if obj.attributes.keys.sort != obj.class.column_names.sort
+      selected_columns = obj.attributes.keys
+      sorted_columns = obj.class.column_names.dup.delete_if {|e| !selected_columns.include?(e) }
+      sorted_columns += (selected_columns - sorted_columns)
+      fields = sorted_columns.map {|e| e.to_sym}
+    end
+    fields
+  end
+end
+
+Hirb::DynamicView.add Hirb::Views::Rails, :helper=>:auto_table

data/test/dynamic_view_test.rb

@@ -0,0 +1,96 @@
+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 }
+
+      test "raises error if no :helper option" do
+        assert_raises(ArgumentError) {
+          Hirb.add_dynamic_view 'Blah', {}
+        }.message.should =~ /:helper.*required/
+      end
+
+      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
+
+      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
+
+      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
+
+      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]
+      end
+    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
+      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
+
+      before(:all) { View.load_config }
+      before(:each) { Formatter.dynamic_config = {} }
+      after(:each) { Views.send(:remove_const, :Blah) }
+      after(:all) { reset_config }
+
+      test "sets a view's options" do
+        define_view
+        output_expects [Date.new], :fields=>Date::DAYNAMES
+      end
+
+      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
+
+      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
+
+      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'])
+      end
+    end
+  end
+end

data/test/formatter_test.rb

@@ -2,14 +2,12 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 
 module Hirb
 class FormatterTest < Test::Unit::TestCase
-  context "formatter" do
-    def set_formatter(hash={})
-      @formatter = Formatter.new(hash)
-    end
-
-    before(:all) { eval "module ::Dooda; end" }
+  def set_formatter(hash={})
+    @formatter = Formatter.new(hash)
+  end
 
-    test "klass_config recursively merges ancestor options" do
+  context "klass_config" do
+    test "recursively merges ancestor options" do
       set_formatter "String"=>{:args=>[1,2], :options=>{:fields=>[:to_s]}},
         "Object"=>{:method=>:object_output, :ancestor=>true, :options=>{:vertical=>true}},
         "Kernel"=>{:method=>:default_output}
@@ -17,33 +15,50 @@ class FormatterTest < Test::Unit::TestCase
       @formatter.klass_config(::String).should == expected_result
     end
 
-    test "klass_config doesn't merge ancestor options" do
+    test "doesn't merge ancestor options" do
       set_formatter "String"=>{:args=>[1,2]}, "Object"=>{:method=>:object_output}, "Kernel"=>{:method=>:default_output}
-      expected_result = {:args=>[1, 2]}
-      @formatter.klass_config(::String).should == expected_result
+      @formatter.klass_config(::String).should == {:args=>[1, 2]}
     end
 
-    test "klass_config returns hash when nothing found" do
+    test "returns hash when nothing found" do
       set_formatter.klass_config(::String).should == {}
     end
 
-    test "reload detects new Hirb::Views" do
-      set_formatter
-      @formatter.config.keys.include?('Zzz').should be(false)
-      eval "module ::Hirb::Views::Zzz; def self.render; end; end"
-      @formatter.reload
-      @formatter.config.keys.include?('Zzz').should be(true)
+    context "with dynamic_config" do
+      after(:each) { Formatter.dynamic_config = {}}
+
+      test "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
+        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
+        Formatter.dynamic_config = {"String"=>{:method=>:blah}}
+        set_formatter.klass_config(::String).should == {:method=>:blah}
+        @formatter.config['String'].should == {:method=>:blah}
+      end
     end
+  end
+
+  context "formatter methods:" do
+    before(:all) { eval "module ::Dooda; end" }
 
-    test "format_class sets formatter config" do
+    test "add_view sets formatter config" do
       set_formatter
-      @formatter.format_class ::Dooda, :class=>"DoodaView"
+      @formatter.add_view ::Dooda, :class=>"DoodaView"
       @formatter.klass_config(::Dooda).should == {:class=>"DoodaView"}
     end
 
-    test "format_class overwrites existing formatter config" do
+    test "add_view overwrites existing formatter config" do
       set_formatter "Dooda"=>{:class=>"DoodaView"}
-      @formatter.format_class ::Dooda, :class=>"DoodaView2"
+      @formatter.add_view ::Dooda, :class=>"DoodaView2"
       @formatter.klass_config(::Dooda).should == {:class=>"DoodaView2"}
     end
 
@@ -55,33 +70,6 @@ class FormatterTest < Test::Unit::TestCase
     end
   end
 
-  context "enable" do
-    before(:each) { View.formatter = nil; reset_config }
-    after(:each) { Hirb.disable }
-
-    def formatter_config
-      View.formatter.config
-    end
-    
-    test "sets default formatter config" do
-      eval "module ::Hirb::Views::Something_Base; def self.render; end; end"
-      Hirb.enable
-      formatter_config["Something::Base"].should == {:class=>"Hirb::Views::Something_Base"}
-    end
-  
-    test "sets default formatter config with default_options" do
-      eval "module ::Hirb::Views::Blah; def self.render; end; def self.default_options; {:ancestor=>true}; end; end"
-      Hirb.enable
-      formatter_config["Blah"].should == {:class=>"Hirb::Views::Blah", :ancestor=>true}
-    end
-  
-    test "sets formatter config" do
-      class_hash = {"Something::Base"=>{:class=>"BlahBlah"}}
-      Hirb.enable :output=>class_hash
-      formatter_config['Something::Base'].should == class_hash['Something::Base']
-    end
-  end
-
   context "format_output" do
     def view_output(*args, &block); View.view_output(*args, &block); end
     def render_method(*args); View.render_method(*args); end

data/test/table_test.rb

@@ -27,7 +27,17 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       +---+---+
       1 row in set
       TABLE
-      table([{:a=>1, :b=>2}], :headers=>nil).should == expected_table
+      table([{:a=>1, :b=>2}], :headers=>false).should == expected_table
+    end
+
+    test "with no headers and nil fields renders" do
+      expected_table = <<-TABLE.unindent
+      +---+---+
+      | 1 |   |
+      +---+---+
+      1 row in set
+      TABLE
+      table([{:a=>1, :b=>nil}], :headers=>false).should == expected_table
     end
 
     test "with string keys renders" do
@@ -66,6 +76,10 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([]).should == "0 rows in set"
     end
 
+    test "with invalid rows raises an argumenterror" do
+      assert_raises(ArgumentError) { table(:a=>1) }.message.should =~ /Table must/
+    end
+
     test "renders utf8" do
       expected_table = <<-TABLE.unindent
       +--------------------+
@@ -151,7 +165,7 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
 
     test "fields and number options copies fields option and does not modify it" do
       options = {:fields=>[:f1], :number=>true}
-      table({:f1=>1, :f2=>2}, options)
+      table([{:f1=>1, :f2=>2}], options)
       options[:fields].should == [:f1]
     end
   
@@ -439,8 +453,31 @@ class Hirb::Helpers::TableTest < Test::Unit::TestCase
       table([[1,2],[2,3]], :change_fields=>['name', 'value']).should == expected_table
     end
 
-    test "return_rows option returns rows" do
-      table([[1,2],[2,3]], :return_rows=>true).should == [{0=>"1", 1=>"2"}, {0=>"2", 1=>"3"}]
+    test "change_fields and fields option renders" do
+      expected_table = <<-TABLE.unindent
+      +------+
+      | name |
+      +------+
+      | 1    |
+      | 2    |
+      +------+
+      2 rows in set
+      TABLE
+      table([[1,2],[2,3]], :change_fields=>['name', 'value'], :fields=>['name']).should == expected_table
+    end
+
+    test "invalid fields in change_fields options are ignored" do
+      expected_table = <<-TABLE.unindent
+      +------+-------+
+      | name | value |
+      +------+-------+
+      | 1    | 2     |
+      | 2    | 3     |
+      +------+-------+
+      2 rows in set
+      TABLE
+      table([{:a=>1,:b=>2}, {:a=>2,:b=>3}], :change_fields=>{:a=>'name', :b=>'value', :c=>'time'}).should == expected_table
+      table([[1,2],[2,3]], :change_fields=>['name', 'value','time']).should == expected_table
     end
 
     test "filter_any option filters any value" do

data/test/tree_test.rb

@@ -107,6 +107,23 @@ class Hirb::Helpers::TreeTest < Test::Unit::TestCase
       TREE
       tree([[0,'0'],[1,'1'],[2,'2'],[2,'3'],[1,'4']], :type=>:number)
     end
+
+    test "with multi-line nodes option renders" do
+      expected_tree = <<-TREE.unindent
+      parent
+          +-------+
+          | value |
+          +-------+
+          | 1     |
+          | 2     |
+          | 3     |
+          +-------+
+              indented
+              stuff
+      TREE
+      node1 = "+-------+\n| value |\n+-------+\n| 1     |\n| 2     |\n| 3     |\n+-------+"
+      tree([ [0, 'parent'],[1, node1],[2, "indented\nstuff"]], :multi_line_nodes=>true)
+    end
   end
 
   def mock_node(value, value_method)

data/test/view_test.rb

@@ -49,6 +49,12 @@ module Hirb
         { :output=>{klass=>{:class=>:auto_table}} }
       end
 
+      test "sets formatter config" do
+        class_hash = {"Something::Base"=>{:class=>"BlahBlah"}}
+        Hirb.enable :output=>class_hash
+        View.formatter_config['Something::Base'].should == class_hash['Something::Base']
+      end
+
       test "when called multiple times merges configs" do
         Hirb.config = nil
         # default config + config_file

data/test/views_test.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Hirb::ViewsTest < Test::Unit::TestCase
+  context "activerecord table" do
+    test "with no select gets default options" do
+      pet = stub(:name=>'rufus', :age=>7, :attributes=>{"name"=>'rufus', 'age'=>7}, :class=>stub(:column_names=>%w{age name}))
+      Hirb::Helpers::AutoTable.active_record__base_view(pet).should == {:fields=>[:age, :name]}
+    end
+
+    test "with select gets default options" do
+      pet = stub(:name=>'rufus', :age=>7, :attributes=>{'name'=>'rufus'}, :class=>stub(:column_names=>%w{age name}))
+      Hirb::Helpers::AutoTable.active_record__base_view(pet).should == {:fields=>[:name]}
+    end
+  end
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: hirb
 version: !ruby/object:Gem::Version 
-  version: 0.2.10
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-16 00:00:00 -05:00
+date: 2010-03-11 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -27,13 +32,11 @@ files:
 - LICENSE.txt
 - README.rdoc
 - Rakefile
-- VERSION.yml
 - lib/hirb.rb
 - lib/hirb/console.rb
+- lib/hirb/dynamic_view.rb
 - lib/hirb/formatter.rb
-- lib/hirb/hash_struct.rb
 - lib/hirb/helpers.rb
-- lib/hirb/helpers/active_record_table.rb
 - lib/hirb/helpers/auto_table.rb
 - lib/hirb/helpers/object_table.rb
 - lib/hirb/helpers/parent_child_tree.rb
@@ -47,11 +50,17 @@ files:
 - lib/hirb/pager.rb
 - lib/hirb/string.rb
 - lib/hirb/util.rb
+- lib/hirb/version.rb
 - lib/hirb/view.rb
-- lib/hirb/views/activerecord_base.rb
-- test/active_record_table_test.rb
+- lib/hirb/views.rb
+- lib/hirb/views/couch_db.rb
+- lib/hirb/views/misc_db.rb
+- lib/hirb/views/mongo_db.rb
+- lib/hirb/views/orm.rb
+- lib/hirb/views/rails.rb
 - test/auto_table_test.rb
 - test/console_test.rb
+- test/dynamic_view_test.rb
 - test/formatter_test.rb
 - test/hirb_test.rb
 - test/import_test.rb
@@ -64,6 +73,7 @@ files:
 - test/tree_test.rb
 - test/util_test.rb
 - test/view_test.rb
+- test/views_test.rb
 has_rdoc: true
 homepage: http://tagaholic.me/hirb/
 licenses: []
@@ -77,25 +87,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: tagaholic
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A mini view framework for console/irb that's easy to use, even while under its influence.
 test_files: 
-- test/active_record_table_test.rb
 - test/auto_table_test.rb
 - test/console_test.rb
+- test/dynamic_view_test.rb
 - test/formatter_test.rb
 - test/hirb_test.rb
 - test/import_test.rb
@@ -108,3 +120,4 @@ test_files:
 - test/tree_test.rb
 - test/util_test.rb
 - test/view_test.rb
+- test/views_test.rb