boson 0.2.0 → 0.2.1

data/lib/boson/view.rb

@@ -1,5 +1,51 @@
 module Boson
-  # Handles {Hirb}[http://tagaholic.me/hirb/]-based views.
+  # This module generates views for a command by handing it to {Hirb}[http://tagaholic.me/hirb/]. Since Hirb can be customized
+  # to generate any view, commands can have any views associated with them!
+  #
+  # === Views with Render Options
+  # To pass rendering options to a Hirb helper as command options, a command has to define the options with
+  # the render_options method attribute:
+  #
+  #   # @render_options :fields=>[:a,:b]
+  #   def list(options={})
+  #     [{:a=>1, :b=>2}, {:a=>10,:b=>11}]
+  #   end
+  #
+  #   # To see that the render_options method attribute actually passes the :fields option by default:
+  #   >> list '-p'   # or list '--pretend'
+  #   Arguments: []
+  #   Global options: {:pretend=>true, :fields=>[:a, :b]}
+  #
+  #   >> list
+  #   +----+----+
+  #   | a  | b  |
+  #   +----+----+
+  #   | 1  | 2  |
+  #   | 10 | 11 |
+  #   +----+----+
+  #   2 rows in set
+  #
+  #   # To create a vertical table, we can pass --vertical, one of the default global render options.
+  #   >> list '-V'   # or list '--vertical'
+  #   *** 1. row ***
+  #   a: 1
+  #   b: 2
+  #   ...
+  #
+  #   # To get the original return value use the global option --render
+  #   >> list '-r'  # or list '--render'
+  #   => [{:a=>1, :b=>2}, {:a=>10,:b=>11}]
+  #
+  # === Boson and Hirb
+  # Since Boson uses {Hirb's auto table helper}[http://tagaholic.me/hirb/doc/classes/Hirb/Helpers/AutoTable.html]
+  # by default, you may want to read up on its many options. To use any of them in commands, define them locally
+  # with render_options or globally by adding them under the :render_options key of the main config.
+  # What if you want to use your own helper class? No problem. Simply pass it with the global :class option.
+  #
+  # When using the default helper, one of the most important options to define is :fields. Aside from controlling what fields
+  # are displayed, it's used to set :values option attributes for related options i.e. :sort and :query. This provides handy option
+  # value aliasing via OptionParser. If you don't set :fields, Boson will try to set its :values with field-related options i.e.
+  # :change_fields, :filters and :headers.
   module View
     extend self
 
@@ -12,23 +58,13 @@ module Boson
     # Renders any object via Hirb. Options are passed directly to
     # {Hirb::Console.render_output}[http://tagaholic.me/hirb/doc/classes/Hirb/Console.html#M000011].
     def render(object, options={}, return_obj=false)
-      if silent_object?(object)
-        puts(object.inspect) unless options[:silence_booleans]
+      if options[:inspect]
+        puts(object.inspect)
       else
-        render_object(object, options, return_obj)
+        render_object(object, options, return_obj) unless silent_object?(object)
       end
     end
 
-    # Searches and sorts an array of objects or hashes using options :query, :sort and :reverse_sort.
-    # The :query option is a hash of fields mapped to their search terms. Searches are OR-ed.
-    def search_and_sort(object, options)
-      if object.is_a?(Array)
-        object = search_object(object, options[:query]) if options[:query]
-        object = sort_object(object, options[:sort], options[:reverse_sort]) if object.size > 0 && options[:sort]
-      end
-      object
-    end
-
     #:stopdoc:
     def toggle_pager
       Hirb::View.toggle_pager
@@ -43,56 +79,6 @@ module Boson
       render_result = Hirb::Console.render_output(object, options)
       return_obj ? object : render_result
     end
-
-    def search_object(object, query_hash)
-      if object[0].is_a?(Hash)
-        TableCallbacks.search_callback(object, :query=>query_hash)
-      else
-        query_hash.map {|field,query| object.select {|e| e.send(field).to_s =~ /#{query}/i } }.flatten.uniq
-      end
-    rescue NoMethodError
-      $stderr.puts "Query failed with nonexistant method '#{$!.message[/`(.*)'/,1]}'"
-    end
-
-    def sort_object(object, sort, reverse_sort=false)
-      if object[0].is_a?(Hash)
-        TableCallbacks.sort_callback(object, :sort=>sort, :reverse_sort=>reverse_sort)
-      else
-        sort_lambda = object.all? {|e| e.send(sort).respond_to?(:<=>) } ? lambda {|e| e.send(sort) || ''} :
-          lambda {|e| e.send(sort).to_s }
-        object = object.sort_by &sort_lambda
-        object = object.reverse if reverse_sort
-        object
-      end
-    rescue NoMethodError, ArgumentError
-      $stderr.puts "Sort failed with nonexistant method '#{sort}'"
-    end
     #:startdoc:
-
-    # Callbacks used by Hirb::Helpers::Table to search and sort arrays of hashes.
-    module TableCallbacks
-      extend self
-      # Case-insensitive searches an array of hashes using the option :query. Numerical string keys
-      # in :query are converted to actual numbers to interface with Hirb. See View.search_and_sort for more
-      # about :query.
-      def search_callback(obj, options)
-        !options[:query] ? obj : begin
-          options[:query].map {|field,query|
-            field = field.to_i if field.to_s[/^\d+$/]
-            obj.select {|e| e[field].to_s =~ /#{query}/i }
-          }.flatten.uniq
-        end
-      end
-
-      # Sorts an array of hashes using :sort option and reverses the sort with :reverse_sort option.
-      def sort_callback(obj, options)
-        sort =  options[:sort].to_s[/^\d+$/] ? options[:sort].to_i : options[:sort]
-        sort_lambda = (obj.all? {|e| e[sort].respond_to?(:<=>) } ? lambda {|e| e[sort] } : lambda {|e| e[sort].to_s })
-        obj = obj.sort_by &sort_lambda
-        obj = obj.reverse if options[:reverse_sort]
-        obj
-      end
-    end
   end
 end
-Hirb::Helpers::Table.send :include, Boson::View::TableCallbacks

data/test/bin_runner_test.rb

@@ -109,24 +109,24 @@ module Boson
       def index(options={})
         Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0] == options[:load]
           }.at_least(1).returns(!options[:fails])
-          Index.expects(:write)
+        Index.indexes[0].expects(:write)
       end
 
       test "with index option, no existing index and core command updates index and prints index message" do
         index :load=>Runner.all_libraries
-        Index.stubs(:exists?).returns(false)
+        Index.indexes[0].stubs(:exists?).returns(false)
         capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
       end
 
       test "with index option, existing index and core command updates incremental index" do
         index :load=>['changed']
-        Index.stubs(:exists?).returns(true)
+        Index.indexes[0].stubs(:exists?).returns(true)
         capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
       end
 
       test "with index option, failed indexing prints error" do
         index :load=>['changed'], :fails=>true
-        Index.stubs(:exists?).returns(true)
+        Index.indexes[0].stubs(:exists?).returns(true)
         Manager.stubs(:failed_libraries).returns(['changed'])
         capture_stderr {
           capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
@@ -134,7 +134,7 @@ module Boson
       end
 
       test "with core command updates index and doesn't print index message" do
-        Index.expects(:write)
+        Index.indexes[0].expects(:write)
         Boson.main_object.expects(:send).with('libraries')
         capture_stdout { start 'libraries'}.should_not =~ /index/i
       end
@@ -142,18 +142,59 @@ module Boson
       test "with non-core command finding library doesn't update index" do
         Index.expects(:find_library).returns('sweet_lib')
         Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
-        Index.expects(:update).never
+        Index.indexes[0].expects(:update).never
         capture_stderr { start("sweet") }.should =~ /sweet/
       end
 
       test "with non-core command not finding library, does update index" do
         Index.expects(:find_library).returns(nil, 'sweet_lib').times(2)
         Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
-        Index.expects(:update).returns(true)
+        Index.indexes[0].expects(:update).returns(true)
         capture_stderr { start("sweet") }.should =~ /sweet/
       end
     end
 
+    context "render_output" do
+      before(:each) { Scientist.rendered = false; BinRunner.instance_eval "@options = {}" }
+
+      test "doesn't render when nil, false or true" do
+        View.expects(:render).never
+        [nil, false, true].each do |e|
+          BinRunner.render_output e
+        end
+      end
+
+      test "doesn't render when rendered with Scientist" do
+        Scientist.rendered = true
+        View.expects(:render).never
+        BinRunner.render_output 'blah'
+      end
+
+      test "render with puts when non-string" do
+        View.expects(:render).with('dude', {:method => 'puts'})
+        BinRunner.render_output 'dude'
+      end
+
+      test "renders with inspect when non-array and non-string" do
+        [{:a=>true}, :ok].each do |e|
+          View.expects(:puts).with(e.inspect)
+          BinRunner.render_output e
+        end
+      end
+
+      test "renders with inspect when Scientist rendering toggled off with :render" do
+        Scientist.global_options = {:render=>true}
+        View.expects(:puts).with([1,2].inspect)
+        BinRunner.render_output [1,2]
+        Scientist.global_options = nil
+      end
+
+      test "renders with hirb when array" do
+        View.expects(:render_object)
+        BinRunner.render_output [1,2,3]
+      end
+    end
+
     test "parse_args only translates options before command" do
       BinRunner.parse_args(['-v', 'com', '-v']).should == ["com", {:verbose=>true}, ['-v']]
       BinRunner.parse_args(['com', '-v']).should == ["com", {}, ['-v']]

data/test/comment_inspector_test.rb

@@ -84,16 +84,17 @@ module Boson
     end
 
     test "scrape all comment types with implicit desc" do
-      @lines = ["module Foo", '# @render_options :b=>1', '  # @options {:a=>true}', '#blah', "  def foo", "  end", "end"]
-      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}}
-      CommentInspector.scrape(@lines.join("\n"), 5, Optional).should == expected
+      @lines = ["module Foo", '# @config :a=>true', '# @render_options :b=>1', '  # @options {:a=>true}',
+        '#blah', "  def foo", "  end", "end"]
+      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}, :config=>{:a=>true}}
+      CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
     end
 
     test "scrape all comment types with explicit desc" do
       @lines = ["module Foo",  '#@desc blah', '# @render_options :b=>1,', '# :c=>2',
-        '  # @options {:a=>true}', "  def foo", "  end", "end"]
-      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}}
-      CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
+        '  # @options {:a=>true}', '  # @config :a=>true', "  def foo", "  end", "end"]
+      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}, :config=>{:a=>true}}
+      CommentInspector.scrape(@lines.join("\n"), 7, Optional).should == expected
     end
   end
 end

data/test/file_library_test.rb

@@ -37,27 +37,6 @@ module Boson
       test "prints error for file library with multiple modules" do
         capture_stderr { load(:blah, :file_string=>"module Doo; end; module Daa; end") }.should =~ /Can't.*config/
       end
-
-      test "with same module reloads" do
-        load(:blah, :file_string=>"module Blah; def blah; end; end")
-        File.stubs(:exists?).returns(true)
-        File.stubs(:read).returns("module Blah; def bling; end; end")
-        Manager.reload('blah').should == true
-        command_exists?('bling')
-        library('blah').commands.size.should == 2
-      end
-
-      test "with different module reloads" do
-        load(:blah, :file_string=>"module Blah; def blah; end; end")
-        File.stubs(:exists?).returns(true)
-        File.stubs(:read).returns("module Bling; def bling; end; end")
-        Manager.reload('blah').should == true
-        library_has_module('blah', "Boson::Commands::Bling")
-        command_exists?('bling')
-        command_exists?('blah', false)
-        library('blah').commands.size.should == 1
-      end
-      
     end
   end
-end
+end

data/test/loader_test.rb

@@ -35,6 +35,11 @@ module Boson
         end
       end
 
+      test "from inspector attribute config sets command's config" do
+        load :blah, :file_string=>"module Blah; config :alias=>'ok'\n; def bling; end; end"
+        library('blah').command_object('bling').alias.should == 'ok'
+      end
+
       test "hash from inspector recursively merged with user's config" do
         with_config(:libraries=>{'blah'=>{:commands=>{'blung'=>{:args=>[], :render_options=>{:sort=>'this'}}}}}) do
           CommentInspector.expects(:scrape).returns({:render_options=>{:fields=>['this']}})
@@ -227,18 +232,5 @@ module Boson
         end
       end
     end
-
-    context "reload" do
-      before(:each) { reset }
-      test "loads currently unloaded library" do
-        create_library('blah')
-        Manager.expects(:load).with('blah', anything)
-        Manager.reload('blah')
-      end
-
-      test "doesn't load nonexistent library" do
-        capture_stdout { Manager.reload('bling', :verbose=>true) }.should =~ /bling doesn't/
-      end
-    end
   end
 end

data/test/manager_test.rb

@@ -74,14 +74,14 @@ module Boson
       }
 
       test "are deleted" do
-        Scientist.expects(:create_option_command).with(anything, @foo)
-        Manager.create_option_commands(@library, @library.commands)
+        Scientist.expects(:redefine_command).with(anything, @foo)
+        Manager.redefine_commands(@library, @library.commands)
       end
 
       test "are deleted and printed when verbose" do
-        Scientist.expects(:create_option_command).with(anything, @foo)
+        Scientist.expects(:redefine_command).with(anything, @foo)
         @library.instance_eval("@options = {:verbose=>true}")
-        capture_stdout { Manager.create_option_commands(@library, @library.commands) } =~ /options.*blah/
+        capture_stdout { Manager.redefine_commands(@library, @library.commands) } =~ /options.*blah/
       end
     end
 

data/test/method_inspector_test.rb

@@ -36,9 +36,14 @@ module Boson
         parse("render_options :z=>true; def zee; end")[:render_options].should == {"zee"=>{:z=>true}}
       end
 
-      test "neither options or desc set, sets method_locations" do
+      test "config sets config" do
+        parse("config :z=>true; def zee; end")[:config].should == {"zee"=>{:z=>true}}
+      end
+
+      test "not all method attributes set causes method_locations to be set" do
         MethodInspector.stubs(:find_method_locations).returns(["/some/path", 10])
-        parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; render_options :a=>1; desc 'z'; options :a=>1; def az; end"
+        parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; " +
+          "render_options :a=>1; config :a=>1; desc 'z'; options :a=>1; def az; end"
         parsed[:method_locations].key?('yo').should == true
         parsed[:method_locations].key?('yep').should == true
         parsed[:method_locations].key?('az').should == false

data/test/{view_test.rb → pipe_test.rb}

@@ -1,57 +1,57 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 module Boson
-  class ViewTest < Test::Unit::TestCase
+  class PipeTest < Test::Unit::TestCase
     before(:all) {
       @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
-      Ab = Struct.new(:a, :b) unless ViewTest.const_defined?(:Ab)
+      Ab = Struct.new(:a, :b) unless PipeTest.const_defined?(:Ab)
       @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
     }
     context "search_object" do
 
       test "searches one query" do
         [@hashes, @objects].each {|e|
-          View.search_object(e, :a=>'some').should == e[0,1]
+          Pipe.search_object(e, :a=>'some').should == e[0,1]
         }
       end
 
       test "searches non-string values" do
         [@hashes, @objects].each {|e|
-          View.search_object(e, :a=>'more').should == e[1,1]
+          Pipe.search_object(e, :a=>'more').should == e[1,1]
         }
       end
 
       test "searches multiple search terms" do
         [@hashes, @objects].each {|e|
-          View.search_object(e, :a=>'some', :b=>'yep').size.should == 2
+          Pipe.search_object(e, :a=>'some', :b=>'yep').size.should == 2
         }
       end
 
       test "prints error for invalid search field" do
-        capture_stderr { View.search_object(@objects, :blah=>'blah') }.should =~ /failed.*'blah'/
+        capture_stderr { Pipe.search_object(@objects, :blah=>'blah') }.should =~ /failed.*'blah'/
       end
     end
 
     context "sort_object" do
       test "sorts objects with values of different types" do
-        View.sort_object(@objects, :a).should == @objects.reverse
+        Pipe.sort_object(@objects, :a).should == @objects.reverse
       end
 
       test "sorts hashes with values of different types" do
-        View.sort_object(@hashes, :a).should == @hashes.reverse
+        Pipe.sort_object(@hashes, :a).should == @hashes.reverse
       end
 
       test "sorts numeric values" do
         hashes = [{:a=>10, :b=>4}, {:a=>5, :b=>3}]
-        View.sort_object(hashes, :a).should == hashes.reverse
+        Pipe.sort_object(hashes, :a).should == hashes.reverse
       end
 
       test "sorts and reverses sort" do
-        View.sort_object(@hashes, :a, true).should == @hashes
+        Pipe.sort_object(@hashes, :a, true).should == @hashes
       end
 
       test "prints error for invalid sort field" do
-        capture_stderr { View.sort_object(@objects, :blah)}.should =~ /failed.*'blah'/
+        capture_stderr { Pipe.sort_object(@objects, :blah)}.should =~ /failed.*'blah'/
       end
     end
   end

data/test/{index_test.rb → repo_index_test.rb}

@@ -1,18 +1,18 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 module Boson
-  class IndexTest < Test::Unit::TestCase
+  class RepoIndexTest < Test::Unit::TestCase
     # since we're defining our own @commands, @libraries, @lib_hashes
-    before(:all) { Index.instance_variable_set "@read", true }
+    before(:all) { @index = RepoIndex.new(Boson.repo); @index.instance_variable_set "@read", true }
 
     context "read_and_transfer" do
-      before(:each) { reset_boson; Index.instance_eval "@libraries = @commands = nil" }
+      before(:each) { reset_boson; @index.instance_eval "@libraries = @commands = nil" }
 
       def transfers(options={})
-        Index.instance_variable_set "@libraries", [Library.new(:name=>'blah', :commands=>['blurb']),
+        @index.instance_variable_set "@libraries", [Library.new(:name=>'blah', :commands=>['blurb']),
           Library.new(:name=>'bling')]
-        Index.instance_variable_set "@commands", [Command.new(:name=>'blurb', :lib=>'blah')]
-        Index.read_and_transfer options[:ignored] || []
+        @index.instance_variable_set "@commands", [Command.new(:name=>'blurb', :lib=>'blah')]
+        @index.read_and_transfer options[:ignored] || []
         Boson.libraries.map {|e| e.name}.should == options[:libraries]
         Boson.commands.map {|e| e.name}.should == options[:commands]
       end
@@ -42,43 +42,43 @@ module Boson
         commands = [Command.new(:name=>'blurb', :lib=>'blah', :alias=>'bb'), 
           Command.new(:name=>'sub', :lib=>'bling', :alias=>'s')
         ]
-        Index.instance_variable_set "@commands", commands
-        Index.instance_variable_set "@libraries", [Library.new(:name=>'blah'), Library.new(:name=>'bling', :namespace=>'bling')]
+        @index.instance_variable_set "@commands", commands
+        @index.instance_variable_set "@libraries", [Library.new(:name=>'blah'), Library.new(:name=>'bling', :namespace=>'bling')]
       }
 
       test "finds command aliased or not" do
-        Index.find_library('blurb').should == 'blah'
-        Index.find_library('bb').should == 'blah'
+        @index.find_library('blurb').should == 'blah'
+        @index.find_library('bb').should == 'blah'
       end
 
       test "doesn't find command" do
-        Index.find_library('blah').should == nil
+        @index.find_library('blah').should == nil
       end
 
       test "finds a subcommand aliased or not" do
-        Index.find_library('bling.sub').should == 'bling'
-        # Index.find_library('bl.s').should == 'bling'
+        @index.find_library('bling.sub').should == 'bling'
+        # @index.find_library('bl.s').should == 'bling'
       end
 
       test "finds namespace command aliased or not without a subcommand" do
-        Index.find_library('bling').should == 'bling'
-        # Index.find_library('bl').should == 'bling'
+        @index.find_library('bling').should == 'bling'
+        # @index.find_library('bl').should == 'bling'
       end
 
       test "doesn't find a subcommand" do
-        Index.find_library('d.d').should == nil
+        @index.find_library('d.d').should == nil
       end
     end
 
     context "changed_libraries" do
-      before(:all) { Index.instance_eval "@lib_hashes = nil" }
+      before(:all) { @index.instance_eval "@lib_hashes = nil" }
 
       def changed(string, all_libs=['file1'])
-        Runner.expects(:all_libraries).returns(all_libs)
-        Index.instance_variable_set "@lib_hashes", {"file1"=>Digest::MD5.hexdigest("state1")}
+        @index.repo.expects(:all_libraries).returns(all_libs)
+        @index.instance_variable_set "@lib_hashes", {"file1"=>Digest::MD5.hexdigest("state1")}
         File.stubs(:exists?).returns(true)
         File.expects(:read).returns(string)
-        Index.changed_libraries
+        @index.changed_libraries
       end
 
       test "detects changed libraries" do
@@ -99,19 +99,19 @@ module Boson
         reset_boson
         Boson.commands << Command.new(:name=>'blah', :lib=>'blah', :args=>[['arg1', {}], ['arg2', self.class]])
         Boson.libraries << Library.new(:name=>'blah', :module=>self.class)
-        Index.expects(:latest_hashes)
+        @index.expects(:latest_hashes)
         libraries = commands = []
-        Index.expects(:save_marshal_index).with {|str| libraries, commands, hashes = Marshal.load(str) ; true}
-        Index.write
-        @index = {:libraries=>libraries, :commands=>commands}
+        @index.expects(:save_marshal_index).with {|str| libraries, commands, hashes = Marshal.load(str) ; true}
+        @index.write
+        @index_hash = {:libraries=>libraries, :commands=>commands}
       }
 
       test "saves library module constants as strings" do
-        @index[:libraries][0].module.class.should == String
+        @index_hash[:libraries][0].module.class.should == String
       end
 
       test "save commands with arg values as strings" do
-        @index[:commands][0].args.each {|e| e[1].class.should == String}
+        @index_hash[:commands][0].args.each {|e| e[1].class.should == String}
       end
     end
   end