boson-more 0.1.0

data/test/pipes_test.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Pipes" do
+  before_all { ::Ab = Struct.new(:a, :b) }
+  describe "query_pipe" do
+    before_all {
+      @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
+      @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
+    }
+
+    it "searches one query" do
+      [@hashes, @objects].each {|e|
+        Pipes.query_pipe(e, :a=>'some').should == e[0,1]
+      }
+    end
+
+    it "searches non-string values" do
+      [@hashes, @objects].each {|e|
+        Pipes.query_pipe(e, :a=>'more').should == e[1,1]
+      }
+    end
+
+    it "searches multiple search terms" do
+      [@hashes, @objects].each {|e|
+        Pipes.query_pipe(e, :a=>'some', :b=>'yep').size.should == 2
+      }
+    end
+
+    it "prints error for invalid search field" do
+      capture_stderr { Pipes.query_pipe(@objects, :blah=>'blah') }.should =~ /failed.*'blah'/
+    end
+  end
+
+  describe "sort_pipe" do
+    before_all {
+      @hashes = [{:a=>'some', :b=>'thing'}, {:a=>:more, :b=>:yep}]
+      @objects = [Ab.new('some', 'thing'), Ab.new(:more, :yep)]
+    }
+    it "sorts objects with values of different types" do
+      Pipes.sort_pipe(@objects, :a).should == @objects.reverse
+    end
+
+    it "sorts hashes with values of different types" do
+      Pipes.sort_pipe(@hashes, :a).should == @hashes.reverse
+    end
+
+    it "sorts numeric values" do
+      hashes = [{:a=>10, :b=>4}, {:a=>5, :b=>3}]
+      Pipes.sort_pipe(hashes, :a).should == hashes.reverse
+    end
+
+    it "sorts numeric hash keys by string" do
+      hashes = [{2=>'thing'}, {2=>'some'}]
+      Pipes.sort_pipe(hashes, '2').should == hashes.reverse
+    end
+
+    it "sorts numeric hash keys by string" do
+      Pipes.sort_pipe(@hashes, 'a').should == @hashes.reverse
+    end
+
+    it "prints error for invalid sort field" do
+      capture_stderr { Pipes.sort_pipe(@objects, :blah)}.should =~ /failed.*'blah'/
+    end
+  end
+end

data/test/repo_index_test.rb

@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "RepoIndex" do
+  # since we're defining our own @commands, @libraries, @lib_hashes
+  def index
+    @index ||= begin
+      ind = RepoIndex.new(Boson.repo)
+      ind.instance_variable_set "@read", true
+      ind
+    end
+  end
+
+  describe "read_and_transfer" do
+    before { reset_boson; index.instance_eval "@libraries = @commands = nil" }
+
+    def transfers(options={})
+      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] || []
+      Boson.libraries.map {|e| e.name}.should == options[:libraries]
+      Boson.commands.map {|e| e.name}.should == options[:commands]
+    end
+
+    it "transfers libraries with no libraries to ignore" do
+      transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}, :ignored=>[]
+    end
+
+    it "transfers libraries and commands except for ignored libraries and its commands" do
+      transfers :libraries=>%w{bling}, :commands=>[], :ignored=>%w{blah}
+    end
+
+    it "doesn't replace existing libraries" do
+      lib = Library.new(:name=>'blah')
+      cmd = Command.new(:name=>'blurb', :lib=>'blah')
+      Boson.libraries << lib
+      Boson.commands << cmd
+      transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}
+      Boson.libraries.include?(lib).should == true
+      Boson.commands.include?(cmd).should == true
+    end
+  end
+
+  describe "find_library" do
+    before_all {
+      reset_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')]
+    }
+
+    it "finds command aliased or not" do
+      index.find_library('blurb').should == 'blah'
+      index.find_library('bb').should == 'blah'
+    end
+
+    it "doesn't find command" do
+      index.find_library('blah').should == nil
+    end
+
+    it "finds a subcommand aliased or not" do
+      index.find_library('bling.sub').should == 'bling'
+      # @index.find_library('bl.s').should == 'bling'
+    end
+
+    it "finds namespace command aliased or not without a subcommand" do
+      index.find_library('bling').should == 'bling'
+      # @index.find_library('bl').should == 'bling'
+    end
+
+    it "doesn't find a subcommand" do
+      index.find_library('d.d').should == nil
+    end
+  end
+
+  # enable once this is moved
+  xdescribe "changed_libraries" do
+    before_all { index.instance_eval "@lib_hashes = nil" }
+
+    def changed(string, all_libs=['file1'])
+      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
+    end
+
+    it "detects changed libraries" do
+      changed("state2").should == %w{file1}
+    end
+
+    it "detects new libraries" do
+      changed("state1", ['file2']).should == %w{file2}
+    end
+
+    it "detects no changed libraries" do
+      changed("state1").should == []
+    end
+  end
+
+  describe "write" do
+    before_all {
+      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)
+      libraries = commands = []
+      index.expects(:save_marshal_index).with {|str| libraries, commands, hashes = Marshal.load(str) ; true}
+      index.write
+      @index_hash = {:libraries=>libraries, :commands=>commands}
+    }
+
+    it "saves library module constants as strings" do
+      @index_hash[:libraries][0].module.class.should == String
+    end
+
+    it "save commands with arg values as strings" do
+      @index_hash[:commands][0].args.each {|e| e[1].class.should == String}
+    end
+  end
+end

data/test/repo_test.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "config" do
+  before_all { reset }
+  before { @repo = Repo.new(File.dirname(__FILE__)) }
+
+  it "reloads config when passed true" do
+    @repo.config.object_id.should.not == @repo.config(true).object_id
+  end
+
+  it "reads existing config correctly" do
+    expected_hash = {:commands=>{'c1'=>{}}, :libraries=>{}}
+    File.expects(:exists?).returns(true)
+    YAML.expects(:load_file).returns(expected_hash)
+    @repo.config[:commands]['c1'].should == {}
+  end
+
+  it "ignores nonexistent file and sets config defaults" do
+    @repo.config[:command_aliases].class.should == Hash
+    @repo.config[:libraries].class.should == Hash
+  end
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/config', :force=>true }
+end

data/test/runner_options_test.rb

@@ -0,0 +1,29 @@
+describe "BinRunner" do
+  describe "at commandline" do
+    def start(*args)
+      Hirb.stubs(:enable)
+      BinRunner.start(args)
+    end
+
+    before {|e|
+      BinRunner.instance_variables.each {|e| BinRunner.instance_variable_set(e, nil)}
+    }
+
+    before_all { reset }
+
+    it "invalid option value prints error" do
+      aborts_with(/Error: no value/) { start("-l") }
+    end
+
+    it "load option loads libraries" do
+      Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0][0] == 'blah'}.times(2)
+      BinRunner.stubs(:execute_command)
+      start('-l', 'blah', 'libraries')
+    end
+
+    it "with backtrace option prints backtrace" do
+      BinRunner.expects(:autoload_command).returns(false)
+      aborts_with(/not found\nOriginal.*runner\.rb:/m) { start("--backtrace", "blah") }
+    end
+  end
+end

data/test/save_test.rb

@@ -0,0 +1,86 @@
+describe "BinRunner" do
+  # TODO: moar acceptance tests
+  xit "basic command executes" do
+    BinRunner.expects(:init).returns(true)
+    BinRunner.stubs(:render_output)
+    Boson.main_object.expects(:send).with('kick','it')
+    start 'kick','it'
+  end
+  xit "bin_defaults config loads by default"
+
+  def start(*args)
+    BinRunner.start(args)
+  end
+
+  before {|e|
+    BinRunner.instance_variables.each {|e| BinRunner.instance_variable_set(e, nil)}
+  }
+
+  # TODO: fix missing libraries command
+  xdescribe "autoload_command" do
+    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.indexes[0].expects(:write)
+    end
+
+    it "with index option, no existing index and core command updates index and prints index message" do
+      index :load=>BareRunner.all_libraries
+      Index.indexes[0].stubs(:exists?).returns(false)
+      capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
+    end
+
+    it "with index option, existing index and core command updates incremental index" do
+      index :load=>['changed']
+      Index.indexes[0].stubs(:exists?).returns(true)
+      capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+    end
+
+    it "with index option, failed indexing prints error" do
+      index :load=>['changed'], :fails=>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/
+      }.should =~ /Error:.*failed.*changed/
+    end
+
+    it "with core command updates index and doesn't print index message" do
+      Index.indexes[0].expects(:write)
+      Boson.main_object.expects(:send).with('libraries')
+      capture_stdout { start 'libraries'}.should.not =~ /index/i
+    end
+
+    it "with non-core command not finding library, does update index" do
+      Index.expects(:find_library).returns(nil, 'sweet_lib')
+      Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
+      Index.indexes[0].expects(:update).returns(true)
+      aborts_with(/sweet/) { start 'sweet' }
+    end
+  end
+
+end
+
+__END__
+describe "BinRunner" do
+  describe "at commandline" do
+    before_all { reset }
+
+    it "failed subcommand prints error and not command not found" do
+      BinRunner.expects(:execute_command).raises("bling")
+      aborts_with(/Error: bling/) { start("commands.to_s") }
+    end
+
+    it "nonexistant subcommand prints command not found" do
+      aborts_with(/'to_s.bling' not found/) { start("to_s.bling") }
+    end
+
+    it "sub command executes" do
+      obj = Object.new
+      Boson.main_object.extend Module.new { def phone; Struct.new(:home).new('done'); end }
+      BinRunner.expects(:init).returns(true)
+      start 'phone.home'
+    end
+  end
+end
+end

data/test/science_test.rb

@@ -0,0 +1,58 @@
+describe "BinRunner" do
+  it "help option and command prints help" do
+    capture_stdout { start('-h', 'commands') }.should =~ /^commands/
+  end
+
+  it "global option takes value with whitespace" do
+    View.expects(:render).with {|*args| args[1][:fields] = %w{f1 f2} }
+    start('commands', '-f', 'f1, f2')
+  end
+
+  describe "render_output" do
+    before { Scientist.rendered = false; BinRunner.instance_eval "@options = {}" }
+
+    it "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
+
+    it "doesn't render when rendered with Scientist" do
+      Scientist.rendered = true
+      View.expects(:render).never
+      BinRunner.render_output 'blah'
+    end
+
+    it "render with puts when non-string" do
+      View.expects(:render).with('dude', {:method => 'puts'})
+      BinRunner.render_output 'dude'
+    end
+
+    it "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
+
+    it "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
+
+    it "renders with hirb when array" do
+      View.expects(:render_object)
+      BinRunner.render_output [1,2,3]
+    end
+  end
+
+end
+
+describe "MethodInspector" do
+  it "render_options sets render_options" do
+    parse("render_options :z=>true; def zee; end")[:render_options].should == {"zee"=>{:z=>true}}
+  end
+end

data/test/scientist_test.rb

@@ -0,0 +1,195 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+# Now in science.rb
+describe "Scientist" do
+  before_all {
+    Boson.in_shell = nil
+    eval <<-EOF
+    module Blah
+      def blah(arg1, options={})
+        [arg1, options]
+      end
+      def splat_blah(*args)
+        args
+      end
+      def default_blah(arg1, arg2=default, options={})
+        [arg1, arg2, options]
+      end
+      def default; 'some default'; end
+      def default_option(options={})
+        options
+      end
+    end
+    EOF
+    @opt_cmd = Object.new.extend Blah
+  }
+
+  def command(hash, args)
+    hash = {:name=>'blah', :lib=>'bling', :options=>{:force=>:boolean, :level=>2}}.merge(hash)
+    @cmd = Command.new hash
+    @cmd.instance_variable_set("@file_parsed_args", true) if hash[:file_parsed_args]
+    Scientist.redefine_command(@opt_cmd, @cmd)
+    @opt_cmd.send(hash[:name], *args)
+  end
+
+  def command_with_arg_size(*args)
+    command({:args=>2}, args)
+  end
+
+  def command_with_args(*args)
+    command({:args=>[['arg1'],['options', {}]]}, args)
+  end
+
+  def basic_command(hash, args)
+    command({:name=>'splat_blah', :args=>'*'}.merge(hash), args)
+  end
+
+  def command_with_splat_args(*args)
+    command({:name=>'splat_blah', :args=>'*'}, args)
+  end
+
+  def command_with_arg_defaults(*args)
+    arg_defaults = [%w{arg1}, %w{arg2 default}, %w{options {}}]
+    command({:name=>'default_blah', :file_parsed_args=>true, :args=>arg_defaults}, args)
+  end
+
+  def args_are_equal(args, array)
+    command_with_args(*args).should == array
+    command_with_arg_size(*args).should == array
+    command_with_splat_args(*args).should == array
+  end
+
+  def all_commands
+    [:command_with_args, :command_with_arg_size, :command_with_splat_args]
+  end
+
+  describe "command" do
+    describe "prints error" do
+      it "with unexpected error in render" do
+        Scientist.expects(:can_render?).raises("unexpected")
+        capture_stderr { command_with_args('a1') }.should =~ /Error.*unexpected/
+      end
+    end
+  end
+
+  def command_with_render(*args)
+    basic_command({:render_options=>{:fields=>{:values=>['f1', 'f2']}} }, args)
+  end
+
+  def render_expected(options=nil)
+    View.expects(:render).with(anything, options || anything, false)
+  end
+
+  describe "render" do
+    it "called for command with render_options" do
+      render_expected
+      command_with_render('1')
+    end
+
+    it "called for command without render_options and --render" do
+      render_expected
+      command_with_args('--render 1')
+    end
+
+    it "not called for command with render_options and --render" do
+      Boson.expects(:invoke).never
+      command_with_render('--render 1')
+    end
+
+    it "not called for command without render_options" do
+      Boson.expects(:invoke).never
+      command_with_args('1')
+    end
+  end
+
+  describe "command renders" do
+    it "with basic render options" do
+      render_expected :fields => ['f1', 'f2']
+      command_with_render("--fields f1,f2 ab")
+    end
+
+    it "without non-render options" do
+      render_expected :fields=>['f1']
+      Scientist.expects(:can_render?).returns(true)
+      args = ["--render --fields f1 ab"]
+      basic_command({:render_options=>{:fields=>{:values=>['f1', 'f2']}} }, args)
+    end
+
+    it "with user-defined render options" do
+      render_expected :fields=>['f1'], :foo=>true
+      args = ["--foo --fields f1 ab"]
+      basic_command({:render_options=>{:foo=>:boolean, :fields=>{:values=>['f1', 'f2']}} }, args)
+    end
+
+    it "with non-hash user-defined render options" do
+      render_expected :fields=>['f1'], :foo=>true
+      args = ["--foo --fields f1 ab"]
+      basic_command({:render_options=>{:foo=>:boolean, :fields=>%w{f1 f2 f3}} }, args)
+    end
+  end
+
+  it "optionless command renders" do
+    render_expected :fields=>['f1']
+    command({:args=>2, :options=>nil, :render_options=>{:fields=>:array}}, ["--fields f1 ab ok"])
+  end
+
+  describe "global options:" do
+    def local_and_global(*args)
+      Scientist.stubs(:can_render?).returns(false) # turn off rendering caused by :render_options
+      @non_opts = basic_command(@command_options, args)
+      @non_opts.slice!(-1,1) << Scientist.global_options
+    end
+
+    before_all {
+      @command_options = {:options=>{:do=>:boolean, :foo=>:boolean},
+      :render_options=>{:dude=>:boolean}}
+      @expected_non_opts = [[], ['doh'], ['doh'], [:doh]]
+    }
+
+    it "local option overrides global one" do
+      ['-d', 'doh -d','-d doh', [:doh, '-d']].each_with_index do |args, i|
+        local_and_global(*args).should == [{:do=>true}, {}]
+        @non_opts.should == @expected_non_opts[i]
+      end
+    end
+
+    it "global option before local one is valid" do
+      args_arr = ['--dude -f', '--dude doh -f', '--dude -f doh', [:doh, '--dude -f']]
+      args_arr.each_with_index do |args, i|
+        local_and_global(*args).should == [{:foo=>true}, {:dude=>true}]
+        @non_opts.should == @expected_non_opts[i]
+      end
+    end
+
+    it "delete_options deletes global options" do
+      local_and_global('--delete_options=r,p -rp -f').should ==
+        [{:foo=>true}, {:delete_options=>["r", "p"]}]
+    end
+
+    it "global option after local one is invalid" do
+      args_arr = ['-f --dude', '-f doh --dude', '-f --dude doh', [:doh, '-f --dude'] ]
+      args_arr.each_with_index do |args, i|
+        capture_stderr {
+          local_and_global(*args).should == [{:foo=>true}, {}]
+          @non_opts.should == @expected_non_opts[i]
+        }.should =~ /invalid.*dude/
+      end
+    end
+
+    it "global option after local one and -" do
+      local_and_global("doh -r -f - --dude").should == [{:foo=>true}, {:dude=>true, :render=>true}]
+    end
+
+    it "conflicting global option after -" do
+      local_and_global('doh - -f=1,2').should == [{}, {:fields=>["1", "2"]}]
+    end
+
+    it "no options parsed after --" do
+      local_and_global('doh -f -- -r').should == [{:foo=>true}, {}]
+      local_and_global('doh -- -r -f').should == [{}, {}]
+      local_and_global('-- -r -f').should == [{}, {}]
+      local_and_global('doh -r -- -f').should == [{}, {:render=>true}]
+    end
+  end
+  after_all { Boson.in_shell = false }
+end