bbcloud 0.6.2 → 0.7

data/lib/bbcloud/vendor/hirb/test/formatter_test.rb

@@ -1,171 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "Formatter" do
-  def set_formatter(hash={})
-    @formatter = Formatter.new(hash)
-  end
-
-  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
-
-    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
-
-    it "returns hash when nothing found" do
-      set_formatter.klass_config(::String).should == {}
-    end
-
-    describe "with dynamic_config" do
-      def set_formatter(hash={})
-        @formatter = Formatter.new(hash)
-      end
-      after { Formatter.dynamic_config = {}}
-
-      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
-
-      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
-
-      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}
-      end
-    end
-  end
-
-  describe "formatter methods:" do
-    before_all { eval "module ::Dooda; end" }
-
-    it "add_view sets formatter config" do
-      @formatter = set_formatter
-      @formatter.add_view ::Dooda, :class=>"DoodaView"
-      @formatter.klass_config(::Dooda).should == {:class=>"DoodaView"}
-    end
-
-    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
-
-    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
-
-  describe "format_output" do
-    def view_output(*args, &block); View.view_output(*args, &block); end
-    def render_method(*args); View.render_method(*args); end
-
-    def enable_with_output(value)
-      Hirb.enable :output=>value
-    end
-
-    before_all {
-      eval %[module ::Commify
-        def self.render(strings)
-          strings = Array(strings)
-          strings.map {|e| e.split('').join(',')}.join("\n")
-        end
-      end]
-      reset_config
-    }
-    before { View.formatter = nil; reset_config }
-    after { Hirb.disable }
-    
-    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
-    
-    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
-    
-    it "formats with class option as symbol" do
-      enable_with_output "String"=>{:class=>:auto_table}
-      Helpers::AutoTable.expects(:render)
-      view_output('dude')
-    end
-
-    it "formats arrays" do
-      enable_with_output "String"=>{:class=>"Commify"}
-      render_method.expects(:call).with('d,u,d,e')
-      view_output(['dude'])
-    end
-
-    it "formats array-like objects" do
-      enable_with_output "String"=>{:class=>"Commify"}
-      render_method.expects(:call).with('d,u,d,e')
-      require 'set'
-      view_output Set.new(['dude'])
-    end
-    
-    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
-    
-    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
-    
-    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
-
-    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
-
-    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
-
-    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
-    
-    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

data/lib/bbcloud/vendor/hirb/test/hirb_test.rb

@@ -1,39 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "Hirb" do
-  before_all { Hirb.config_files = nil }
-  before { Hirb.config = nil }
-
-  it "config converts yaml when config file exists" do
-    yaml_data = {:blah=>'blah'}
-    File.stubs('exists?').returns(true)
-    Hirb.config_files = ['ok']
-    YAML::expects(:load_file).returns(yaml_data)
-    Hirb.config.should == yaml_data
-  end
-  
-  it "config defaults to hash when no config file" do
-    File.stubs('exists?').returns(false)
-    Hirb.config.should == {}
-  end
-  
-  it "config reloads if given explicit reload" do
-    Hirb.config
-    Hirb.expects(:read_config_file).returns({})
-    Hirb.config(true)
-  end
-
-  it "config reads multiple config files and merges them" do
-    Hirb.config_files = %w{one two}
-    Hirb.expects(:read_config_file).times(2).returns({:output=>{"String"=>:auto_table}}, {:output=>{"Array"=>:auto_table}})
-    Hirb.config.should == {:output=>{"Array"=>:auto_table, "String"=>:auto_table}}
-    Hirb.config_files = nil
-  end
-
-  it "config_file sets correctly when no ENV['HOME']" do
-    Hirb.config_files = nil
-    home = ENV.delete('HOME')
-    Hirb.config_files[0].class.should == String
-    ENV["HOME"] = home
-  end
-end

data/lib/bbcloud/vendor/hirb/test/import_test.rb

@@ -1,9 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "import" do
-  it "require import_object extends Object" do
-    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should == false
-    require 'hirb/import_object'
-    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should == true
-  end
-end

data/lib/bbcloud/vendor/hirb/test/menu_test.rb

@@ -1,239 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "Menu" do
-  before_all { View.instance_variable_set("@config", :width=>Hirb::View::DEFAULT_WIDTH) }
-
-  def menu(*args, &block)
-    # testing via menu's main use case (through console) instead of Menu.render
-    @console ||= Object.new.extend(Hirb::Console)
-    @console.menu(*args, &block)
-  end
-
-  def basic_menu(*args, &block)
-    menu_input('1')
-    capture_stdout { menu(*args, &block).should == [1] }
-  end
-
-  def menu_input(input='')
-    $stdin.expects(:gets).returns(input)
-  end
-
-  describe "menu" do
-    it "by default renders table menu" do
-      expected_menu = <<-MENU.unindent
-      +--------+-------+
-      | number | value |
-      +--------+-------+
-      | 1      | 1     |
-      | 2      | 2     |
-      | 3      | 3     |
-      +--------+-------+
-      3 rows in set
-      MENU
-      basic_menu([1,2,3]).include?(expected_menu).should == true
-    end
-
-    it "with block renders" do
-      menu_input "1,2"
-      expected_result = [1,2]
-      capture_stdout { 
-        menu([1,2,3]) {|e| e.should == expected_result }.should == expected_result
-      }
-    end
-
-    it "with block and no chosen doesn't call block" do
-      menu_input ""
-      block = lambda {|e| @called = true }
-      capture_stdout {
-        menu([1,2,3], &block).should == []
-      }
-      assert !@called
-    end
-
-    it "with valid helper_class option renders" do
-      Helpers::Table.expects(:render)
-      basic_menu [1,2,3], :helper_class=>"Hirb::Helpers::Table"
-    end
-
-    it "with invalid helper_class option renders default menu" do
-      expected_menu = <<-MENU.unindent
-      1: 1
-      2: 2
-      3: 3
-      MENU
-      basic_menu([1,2,3], :helper_class=>"SomeHelper").include?(expected_menu).should == true
-    end
-
-    it "with false helper_class option renders default menu" do
-      expected_menu = <<-MENU.unindent
-      1: 1
-      2: 2
-      3: 3
-      MENU
-      basic_menu([1,2,3], :helper_class=>false).include?(expected_menu).should == true
-    end
-
-    it "prints prompt option" do
-      prompt = "Input or else ..."
-      basic_menu([1,2,3], :prompt=>prompt).include?(prompt).should == true
-    end
-
-    it "converts non-array inputs to array" do
-      Helpers::AutoTable.expects(:render).with([1], anything)
-      basic_menu 1
-    end
-
-    it "with false ask option returns one choice without asking" do
-      $stdin.expects(:gets).never
-      menu([1], :ask=>false).should == [1]
-    end
-
-    it "with no items to choose from always return without asking" do
-      $stdin.expects(:gets).never
-      menu([], :ask=>false).should == []
-      menu([], :ask=>true).should == []
-    end
-
-    it "with directions option turns off directions" do
-      menu_input('blah')
-      capture_stdout { menu([1], :directions=>false) }.should.not =~ /range.*all/
-    end
-
-    it "with true reopen option reopens" do
-      $stdin.expects(:reopen).with('/dev/tty')
-      basic_menu [1], :reopen=>true
-    end
-
-    it "with string reopen option reopens" do
-      $stdin.expects(:reopen).with('/dev/blah')
-      basic_menu [1], :reopen=>'/dev/blah'
-    end
-  end
-
-  def two_d_menu(options={})
-    if options[:invokes] || options[:invoke]
-      cmd = options[:command] || 'p'
-      (options[:invokes] || [options[:invoke]]).each {|e|
-        Menu.any_instance.expects(:invoke).with(cmd, e)
-      }
-    end
-
-    capture_stdout {
-      return menu(options[:output] || [{:a=>1, :bro=>2}, {:a=>3, :bro=>4}],
-       {:two_d=>true}.merge(options))
-    }
-  end
-
-  describe "2d menu" do
-    it "with default field from last_table renders" do
-      menu_input "1"
-      two_d_menu.should == [1]
-    end
-
-    it "with default field from fields option renders" do
-      menu_input "1"
-      two_d_menu(:fields=>[:bro, :a]).should == [2]
-    end
-
-    it "with default field option renders" do
-      menu_input "1"
-      two_d_menu(:default_field=>:bro).should == [2]
-    end
-
-    it "with non-table helper class renders" do
-      menu_input "1"
-      two_d_menu(:helper_class=>false, :fields=>[:a,:bro]).should == [1]
-    end
-
-    it "with no default field prints error" do
-      menu_input "1"
-      capture_stderr { two_d_menu(:fields=>[]) }.should =~ /No default.*found/
-    end
-
-    it "with invalid field prints error" do
-      menu_input "1:z"
-      capture_stderr { two_d_menu }.should =~ /Invalid.*'z'/
-    end
-
-    it "with choice from abbreviated field" do
-      menu_input "2:b"
-      two_d_menu.should == [4]
-    end
-
-    it "with choices from multiple fields renders" do
-      menu_input "1 2:bro"
-      two_d_menu.should == [1,4]
-    end
-  end
-
-  describe "action menu" do
-    it "invokes" do
-      menu_input "p 1 2:bro"
-      two_d_menu(:action=>true, :invoke=>[[1,4]])
-    end
-
-    it "with 1d invokes" do
-      menu_input "p 1"
-      two_d_menu(:action=>true, :two_d=>nil, :invoke=>[[{:a=>1, :bro=>2}]])
-    end
-
-    it "with non-choice arguments invokes" do
-      menu_input "p arg1 1"
-      two_d_menu :action=>true, :invoke=>['arg1', [1]]
-    end
-
-    it "with multiple choice arguments flattens them into arg" do
-      menu_input "p arg1 1 2:bro arg2"
-      two_d_menu :action=>true, :invoke=>['arg1', [1,4], 'arg2']
-    end
-
-    it "with nothing chosen prints error" do
-      menu_input "cmd"
-      capture_stderr { two_d_menu(:action=>true) }.should =~ /No rows chosen/
-    end
-
-    it "with no command given prints error" do
-      menu_input "1"
-      capture_stderr { two_d_menu(:action=>true) }.should =~ /No command given/
-    end
-
-    it "with array menu items" do
-      menu_input "p 1"
-      two_d_menu :action=>true, :output=>[['some', 'choice'], ['and', 'another']],
-        :invokes=>[[['some']]]
-    end
-
-    it "with multi_action option invokes" do
-      menu_input "p 1 2:bro"
-      two_d_menu(:action=>true, :multi_action=>true, :invokes=>[[1], [4]])
-    end
-
-    it "with command option invokes" do
-      menu_input "1"
-      two_d_menu(:action=>true, :command=>'p', :invoke=>[[1]])
-    end
-
-    it "with command option and empty input doesn't invoke action and exists silently" do
-      Menu.any_instance.expects(:invoke).never
-      menu_input ""
-      two_d_menu(:action=>true, :command=>'p').should == nil
-    end
-
-    it "with action_object option invokes" do
-      obj = mock(:blah=>true)
-      menu_input "blah 1"
-      two_d_menu(:action=>true, :action_object=>obj)
-    end
-
-    it "with ask false and defaults invokes" do
-      two_d_menu(:output=>[{:a=>1, :bro=>2}], :action=>true, :ask=>false, :default_field=>:a,
-        :command=>'p', :invoke=>[[1]])
-    end
-
-    it "with ask false and no defaults prints error" do
-      capture_stderr {
-        two_d_menu(:output=>[{:a=>1, :bro=>2}], :action=>true, :ask=>false, :command=>'p')
-      }.should =~ /Default.*required/
-    end
-  end
-end

data/lib/bbcloud/vendor/hirb/test/object_table_test.rb

@@ -1,79 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "object table" do
-  def table(*args)
-    Helpers::ObjectTable.render(*args)
-  end
-
-  before_all {
-    @pets = [stub(:name=>'rufus', :age=>7, :to_s=>'rufus'), stub(:name=>'alf', :age=>101, :to_s=>'alf')]
-  }
-  it "renders" do
-    expected_table = <<-TABLE.unindent
-    +-------+-----+
-    | name  | age |
-    +-------+-----+
-    | rufus | 7   |
-    | alf   | 101 |
-    +-------+-----+
-    2 rows in set
-    TABLE
-    table(@pets, :fields=>[:name, :age]).should == expected_table
-  end
-  
-  it "with no options defaults to to_s field" do
-    expected_table = <<-TABLE.unindent
-    +-------+
-    | value |
-    +-------+
-    | rufus |
-    | alf   |
-    +-------+
-    2 rows in set
-    TABLE
-    table(@pets).should == expected_table
-  end
-
-  it "renders simple arrays" do
-    expected_table = <<-TABLE.unindent
-    +-------+
-    | value |
-    +-------+
-    | 1     |
-    | 2     |
-    | 3     |
-    | 4     |
-    +-------+
-    4 rows in set
-    TABLE
-    table([1,2,3,4]).should == expected_table
-  end
-
-  it "renders simple arrays with custom header" do
-    expected_table = <<-TABLE.unindent
-    +-----+
-    | num |
-    +-----+
-    | 1   |
-    | 2   |
-    | 3   |
-    | 4   |
-    +-----+
-    4 rows in set
-    TABLE
-    table([1,2,3,4], :headers=>{:to_s=>'num'}).should == expected_table
-  end
-
-  it "with empty fields" do
-    expected_table = <<-TABLE.unindent
-    0 rows in set
-    TABLE
-    table(@pets, :fields => []).should == expected_table
-  end
-
-  it "doesn't raise error for objects that don't have :send defined" do
-    object = Object.new
-    class<<object; self; end.send :undef_method, :send
-    should.not.raise(NoMethodError) { table([object], :fields=>[:to_s]) }
-  end
-end

data/lib/bbcloud/vendor/hirb/test/pager_test.rb

@@ -1,162 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-describe "Pager" do
-  def pager; View.pager; end
-
-  def create_pageable_string(inspect_mode=false, size={})
-    size = {:width=>pager.width, :height=>pager.height}.merge(size)
-    seed = inspect_mode ? "a" : "a\n"
-    if inspect_mode
-      seed * (size[:width] * size[:height] + 1)
-    else
-      seed * (size[:height] + 1)
-    end
-  end
-
-  it "command_pager sets pager_command when command exists" do
-    Util.expects(:command_exists?).returns(true)
-    Pager.expects(:basic_pager)
-    Pager.command_pager 'blah', :pager_command=>'less'
-  end
-
-  it "command_pager doesn't set pager_command when command doesn't exist" do
-    Util.expects(:command_exists?).returns(false)
-    Pager.expects(:basic_pager).never
-    Pager.command_pager 'blah', :pager_command=>'moreless'
-  end
-
-  describe "default_pager" do
-    before_all { reset_config; Hirb.enable :pager=>true }
-    before { View.pager = nil; Pager.stubs(:pager_command).returns(nil) }
-
-    it "pages once in normal mode" do
-      $stdin.expects(:gets).returns("\n")
-      output = capture_stdout { pager.page(create_pageable_string, false) }
-      output.include?('quit').should == true
-      output.include?('finished').should == true
-    end
-
-    it "doesn't page in normal mode" do
-      $stdin.expects(:gets).never
-      output = capture_stdout { pager.page("a\n", false) }
-      output.include?("a\n=== Pager finished. ===\n").should == true
-    end
-
-    it "pages once in inspect mode" do
-      $stdin.expects(:gets).returns("\n")
-      output = capture_stdout { pager.page(create_pageable_string(true), true) }
-      output.include?('quit').should == true
-      output.include?('finished').should == true
-    end
-
-    it "doesn't page in inspect mode" do
-      $stdin.expects(:gets).never
-      output = capture_stdout { pager.page("a", true) }
-      output.include?("a\n=== Pager finished. ===\n").should == true
-    end
-    after_all { Hirb.disable }
-  end
-
-  describe "pager" do
-    before_all { reset_config; Hirb.enable }
-    before { View.pager = nil; View.formatter = nil }
-
-    def irb_eval(string)
-      context_stub = stub(:last_value=>string)
-      ::IRB::Irb.new(context_stub).output_value
-    end
-
-    # this mode is called within @irb.output_value
-    describe "in inspect_mode" do
-      it "activates when output is wide enough" do
-        output = create_pageable_string(true)
-        pager.expects(:page).with(output.inspect, true)
-        View.expects(:render_output).returns(false)
-        irb_eval output
-      end
-
-      it "doesn't activate when output isn't wide enough" do
-        pager.expects(:page).never
-        View.expects(:render_output).returns(false)
-        irb_eval("a")
-      end
-
-      it "activates with an explicit width" do
-        View.config[:width] = 10
-        output = create_pageable_string true, :width=>10
-        pager.expects(:page).with(output.inspect, true)
-        View.expects(:render_output).returns(false)
-        irb_eval output
-      end
-
-      it "activates default_pager when pager command is invalid" do
-        Pager.expects(:pager_command).returns(nil)
-        output = create_pageable_string(true)
-        Pager.expects(:default_pager).with(output.inspect, anything)
-        View.expects(:render_output).returns(false)
-        capture_stdout { irb_eval output }
-      end
-    end
-
-    # this mode is called within View.render_output
-    describe "in normal mode" do
-      it "activates when output is long enough" do
-        output = create_pageable_string
-        View.formatter.expects(:format_output).returns(output)
-        pager.expects(:page).with(output, false)
-        irb_eval(output)
-      end
-
-      it "doesn't activate when output isn't long enough" do
-        output = "a\n"
-        View.formatter.expects(:format_output).returns(output)
-        pager.expects(:page).never
-        capture_stdout { irb_eval(output) }
-      end
-
-      it "activates with an explicit height" do
-        View.config[:height] = 100
-        output = create_pageable_string false, :height=>100
-        View.formatter.expects(:format_output).returns(output)
-        pager.expects(:page).with(output, false)
-        irb_eval(output)
-      end
-
-      it "activates default_pager when pager_command is invalid" do
-        Pager.expects(:pager_command).returns(nil)
-        output = create_pageable_string
-        Pager.expects(:default_pager).with(output, anything)
-        View.formatter.expects(:format_output).returns(output)
-        capture_stdout { irb_eval output }
-      end
-    end
-
-    it "activates pager_command with valid pager_command option" do
-      View.config[:pager_command] = "less"
-      View.expects(:render_output).returns(false)
-      Util.expects(:command_exists?).returns(true)
-      Pager.expects(:command_pager)
-      irb_eval create_pageable_string(true)
-      View.config[:pager_command] = nil
-    end
-
-    it "activates pager_command with pager_command option that has command options" do
-      View.config[:pager_command] = "less -r"
-      View.expects(:render_output).returns(false)
-      Util.expects(:command_exists?).with('less').returns(true)
-      Pager.expects(:command_pager)
-      irb_eval create_pageable_string(true)
-      View.config[:pager_command] = nil
-    end
-
-    it "doesn't activate pager_command with invalid pager_command option" do
-      View.config[:pager_command] = "moreless"
-      View.expects(:render_output).returns(false)
-      Util.expects(:command_exists?).returns(false)
-      Pager.expects(:default_pager)
-      irb_eval create_pageable_string(true)
-      View.config[:pager_command] = nil
-    end
-  end
-  after_all { Hirb.disable }
-end