scout-gear 9.0.0 → 10.0.1

data/test/scout/simple_opt/test_setup.rb

@@ -1,77 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require 'scout/simple_opt'
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestSOPTSetup < Test::Unit::TestCase
-  def setup
-    SOPT.inputs = nil
-    SOPT.input_types = nil
-    SOPT.input_descriptions = nil
-    SOPT.input_shortcuts = nil
-  end
-
-  def test_setup
-    SOPT.setup <<-EOF
-Test application
-
-$ test cmd -arg 1
-
-It does some imaginary stuff
-
--a--arg* Argument
--a2--arg2* Argument
-
-    EOF
-
-    assert_equal "test cmd -arg 1", SOPT.synopsys
-    assert SOPT.inputs.include? "arg"
-    assert SOPT.inputs.include? "arg2"
-  end
-
-  def test_setup_alt
-    SOPT.setup <<-EOF
-Test application
-
-It does some imaginary stuff
-
--a--arg* Argument
--a2--arg2* Argument
-
-    EOF
-
-    assert SOPT.inputs.include? "arg"
-    assert SOPT.inputs.include? "arg2"
-  end
-
-  def test_setup_alt2
-    SOPT.setup <<-EOF
-Test application
-
--a--arg* Argument
--a2--arg2* Argument
-
-    EOF
-
-    assert SOPT.inputs.include? "arg"
-    assert SOPT.inputs.include? "arg2"
-  end
-
-  def test_setup_alt3
-    SOPT.setup <<-EOF
-Pulls the values from a tsv colum
-
-$ rbbt tsv values [options] <filename.tsv|->
-
-Use - to read from STDIN
-
--tch--tokyocabinet File is a tokyocabinet hash database
--tcb--tokyocabinet_bd File is a tokyocabinet B database
--h--help Print this help
-    EOF
-
-    assert SOPT.inputs.include? "tokyocabinet"
-  end
-
-end
-
-

data/test/scout/test_cmd.rb

@@ -1,85 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-require 'scout/open'
-
-class TestCmd < Test::Unit::TestCase
-
-  def test_cmd_option_string
-    assert_equal("--user-agent 'firefox'", CMD.process_cmd_options("--user-agent" => "firefox"))
-    assert_equal("--user-agent='firefox'", CMD.process_cmd_options("--user-agent=" => "firefox"))
-    assert_equal("-q", CMD.process_cmd_options("-q" => true))
-    assert_equal("", CMD.process_cmd_options("-q" => nil))
-    assert_equal("", CMD.process_cmd_options("-q" => false))
-
-    assert(CMD.process_cmd_options("--user-agent" => "firefox", "-q" => true) =~ /--user-agent 'firefox'/)
-    assert(CMD.process_cmd_options("--user-agent" => "firefox", "-q" => true) =~ /-q/)
-  end
-
-  def test_cmd
-    assert_equal("test\n", CMD.cmd("echo '{opt}' test").read)
-    assert_equal("test", CMD.cmd("echo '{opt}' test", "-n" => true).read)
-    assert_equal("test2\n", CMD.cmd("cut", "-f" => 2, "-d" => ' ', :in => "test1 test2").read)
-  end
-
-  def test_pipe
-    assert_equal("test\n", CMD.cmd("echo test", :pipe => true).read)
-    assert_equal("test\n", CMD.cmd("echo '{opt}' test", :pipe => true).read)
-    assert_equal("test", CMD.cmd("echo '{opt}' test", "-n" => true, :pipe => true).read)
-    assert_equal("test2\n", CMD.cmd("cut", "-f" => 2, "-d" => ' ', :in => "test1 test2", :pipe => true).read)
-  end
-
-  def test_error
-    Log.with_severity 6 do
-      assert_raise ProcessFailed do CMD.cmd('fake-command') end
-      assert_raise ProcessFailed do CMD.cmd('ls -fake_option') end
-
-      assert_raise ProcessFailed do CMD.cmd('fake-command', :stderr => true) end
-      assert_raise ProcessFailed do CMD.cmd('ls -fake_option', :stderr => true) end
-
-      assert_nothing_raised ProcessFailed do CMD.cmd('fake-command', :no_fail => true, :pipe => true) end
-      assert_nothing_raised ProcessFailed do CMD.cmd('ls -fake_option', :no_fail => true, :pipe => true) end
-
-      assert_raise ProcessFailed do CMD.cmd('fake-command', :stderr => true, :pipe => true).join end
-      assert_raise ConcurrentStreamProcessFailed do CMD.cmd('ls -fake_option', :stderr => true, :pipe => true).join end
-    end
-  end
-
-  def test_pipes
-    text = <<-EOF
-line1
-line2
-line3
-line11
-line22
-line33
-    EOF
-
-    TmpFile.with_file(text * 100) do |file|
-
-      Open.open(file) do |f|
-        io = CMD.cmd('tail -n 10', :in => f, :pipe => true)
-        io2 = CMD.cmd('head -n 10', :in => io, :pipe => true)
-        io3 = CMD.cmd('head -n 10', :in => io2, :pipe => true)
-        assert_equal 10, io3.read.split(/\n/).length
-      end
-    end
-  end
-
-  def test_STDIN_close
-    TmpFile.with_file("Hello") do |file|
-      STDIN.close
-      Open.open(file) do |f|
-        io = CMD.cmd("tr 'e' 'E'", :in => f, :pipe => true)
-        txt = io.read
-        io.join
-        assert_equal "HEllo", txt
-      end
-    end
-  end
-
-  def test_bash
-    assert_equal "TEST", CMD.bash("echo TEST").read.strip
-    assert_equal ENV["HOME"], CMD.bash("echo $HOME").read.strip
-  end
-end

data/test/scout/test_concurrent_stream.rb

@@ -1,29 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-require 'scout/exceptions'
-require 'scout/cmd'
-
-class TestClass < Test::Unit::TestCase
-  def test_concurrent_stream_pipe
-    io = CMD.cmd("ls", :pipe => true, :autojoin => true)
-    io.read
-    io.close 
-  end
-
-  def test_concurrent_stream_process_failed
-    assert_raise ConcurrentStreamProcessFailed do 
-      io = CMD.cmd("grep . NONEXISTINGFILE", :pipe => true, :autojoin => true)
-      io.read
-      io.close 
-    end
-  end
-
-  def test_concurrent_stream_process_failed_autojoin
-    assert_raise ConcurrentStreamProcessFailed do 
-      io = CMD.cmd("grep . NONEXISTINGFILE", :pipe => true, :autojoin => true) 
-      io.read
-    end
-  end
-end
-

data/test/scout/test_config.rb

@@ -1,66 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestConfig < Test::Unit::TestCase
-  setup do
-    Scout::Config.set({:cpus => 30}, :test_config, :test)
-    Scout::Config.set(:cpus, 5, "slow::2", :test)
-    Scout::Config.set({:token => "token"}, "token")
-    Scout::Config.set(:notoken, "no_token")
-    Scout::Config.set({:emptytoken => "empty"})
-  end
-
-  def test_simple
-    assert_equal 30, Scout::Config.get(:cpus, :test_config)
-  end
-
-  def test_match
-    assert_equal({20 => ["token"]}, Scout::Config.match({["key:token"] => "token"}, "key:token"))
-  end
-
-  def test_simple_no_token
-    assert_equal "token", Scout::Config.get("token", "token")
-    assert_equal "no_token", Scout::Config.get("notoken", "key:notoken")
-    assert_equal 'token', Scout::Config.get("token", "key:token")
-    assert_equal 'token', Scout::Config.get("token")
-    assert_equal nil, Scout::Config.get("token", "someotherthing")
-    assert_equal "default_token", Scout::Config.get("token", 'unknown', :default => 'default_token')
-    assert_equal 'empty', Scout::Config.get("emptytoken", 'key:emptytoken')
-  end
-
-  def test_prio
-    assert_equal 5, Scout::Config.get(:cpus, :slow, :test)
-  end
-
-  def test_with_config
-    Scout::Config.add_entry 'key', 'valueA', 'token'
-    assert_equal "valueA", Scout::Config.get('key', 'token')
-    assert_equal "default", Scout::Config.get('key2', 'token', :default => 'default')
-
-    Scout::Config.with_config do 
-      Scout::Config.add_entry 'key', 'valueB', 'token'
-      Scout::Config.add_entry 'key2', 'valueB2', 'token'
-      assert_equal "valueB", Scout::Config.get('key', 'token')
-      assert_equal "valueB2", Scout::Config.get('key2', 'token', :default => 'default')
-    end
-
-    assert_equal "valueA", Scout::Config.get('key', 'token')
-    assert_equal "default", Scout::Config.get('key2', 'token', :default => 'default')
-  end
-
-  def test_order
-    Scout::Config.add_entry 'key', 'V1', 'token1'
-    Scout::Config.add_entry 'key', 'V2', 'token2'
-    Scout::Config.add_entry 'key', 'V3', 'token2'
-
-    assert_equal "V3", Scout::Config.get('key', 'token2')
-    assert_equal "V1", Scout::Config.get('key', 'token1')
-    assert_equal "V3", Scout::Config.get('key', 'token2', 'token1')
-    assert_equal "V1", Scout::Config.get('key', 'token1', 'token2')
-  end
-
-  def test_default
-    Scout::Config.add_entry 'key', 'V1', 'token1'
-    assert_equal "V3", Scout::Config.get('key', 'token2', :default => 'V3')
-  end
-end

data/test/scout/test_indiferent_hash.rb

@@ -1,26 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestClass < Test::Unit::TestCase
-  def test_indiferent_hash
-    a = {:a => 1, "b" => 2}
-    a.extend IndiferentHash
-
-    assert_equal 1, a[:a]
-    assert_equal 1, a["a"]
-    assert_equal 2, a["b"]
-    assert_equal 2, a[:b]
-  end
-
-  def test_case_insensitive_hash
-    a = {:a => 1, "b" => 2}
-    a.extend CaseInsensitiveHash
-
-    assert_equal 1, a[:a]
-    assert_equal 1, a["A"]
-    assert_equal 1, a[:A]
-    assert_equal 2, a["B"]
-    assert_equal 2, a[:b]
-  end
-end
-

data/test/scout/test_log.rb

@@ -1,32 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestLog < Test::Unit::TestCase
-  def test_get_level
-    assert_equal 0, Log.get_level(:debug)
-    assert_equal 1, Log.get_level(:low)
-    assert_equal 1, Log.get_level("LOW")
-    assert_equal 1, Log.get_level(1)
-    assert_equal 0, Log.get_level(nil)
-  end
-
-  def test_color
-    assert Log.color(:green, "green")
-  end
-
-  def test_iif
-    TmpFile.with_file do |tmp|
-      Log.logfile(tmp)
-      iif :foo
-      assert File.read(tmp).include? ":foo"
-      assert File.read(tmp).include? "INFO"
-    end
-  end
-
-  def test_tty_size
-    assert Integer === Log.tty_size
-  end
-
-end
-
-

data/test/scout/test_meta_extension.rb

@@ -1,80 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestMetaExtension < Test::Unit::TestCase
-  module ExtensionClass
-    extend MetaExtension
-
-    extension_attr :code, :code2
-  end
-
-  module ExtensionClass2
-    extend MetaExtension
-
-    extension_attr :code3, :code4
-  end
-
-
-  def test_setup_annotate
-    str = "String"
-    ExtensionClass.setup(str, :code)
-    assert ExtensionClass === str
-    assert_equal :code, str.code
-
-    str2 = "String2"
-    str.annotate(str2)
-    assert_equal :code, str2.code
-  end
-
-  def test_marshal
-    str = "String"
-    ExtensionClass.setup(str, :code)
-    assert ExtensionClass === str
-    assert_equal :code, str.code
-
-    str2 = Marshal.load(Marshal.dump(str))
-    assert_equal :code, str2.code
-  end
-
-  def test_setup_alternatives
-    str = "String"
-
-    ExtensionClass.setup(str, :code2 => :code)
-    assert_equal :code, str.code2
-
-    ExtensionClass.setup(str, code2: :code)
-    assert_equal :code, str.code2
-
-    ExtensionClass.setup(str, "code2" => :code)
-    assert_equal :code, str.code2
-
-  end
-
-  def test_setup_block
-    o = ExtensionClass.setup nil, :code => :c, :code2 => :c2 do
-      puts 1
-    end
-
-    assert o.extension_attr_hash.include?(:code)
-    assert o.extension_attr_hash.include?(:code2)
-  end
-
-  def test_twice
-    str = "String"
-
-    ExtensionClass.setup(str, :code2 => :code)
-    assert_equal :code, str.code2
-    assert_include str.instance_variable_get(:@extension_attrs), :code
-
-    str.extend ExtensionClass2
-    str.code3 = :code_alt
-    assert_equal :code, str.code2
-    assert_equal :code_alt, str.code3
-    assert_include str.instance_variable_get(:@extension_attrs), :code
-    assert_include str.instance_variable_get(:@extension_attrs), :code3
-
-    assert_include str.extension_attr_hash, :code
-    assert_include str.extension_attr_hash, :code3
-  end
-end
-

data/test/scout/test_misc.rb

@@ -1,6 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestMisc < Test::Unit::TestCase
-end
-

data/test/scout/test_named_array.rb

@@ -1,43 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestNamedArray < Test::Unit::TestCase
-  def test_identify_names
-    names =<<-EOF.split("\n")
-ValueA
-ValueB (Entity type)
-15
-    EOF
-    assert_equal 0, NamedArray.identify_name(names, "ValueA")
-    assert_equal :key, NamedArray.identify_name(names, :key)
-    assert_equal 0, NamedArray.identify_name(names, nil)
-    assert_equal 1, NamedArray.identify_name(names, "ValueB (Entity type)")
-    assert_equal 1, NamedArray.identify_name(names, "ValueB")
-    assert_equal 1, NamedArray.identify_name(names, 1)
-  end
-
-  def test_missing_field
-    a = NamedArray.setup([1,2], [:a, :b])
-    assert_equal 1, a[:a]
-    assert_equal nil, a[:c]
-  end
-
-  def test_zip_fields
-    a = [%w(a b), %w(1 1)]
-    assert_equal [%w(a 1), %w(b 1)], NamedArray.zip_fields(a)
-  end
-
-  def test_add_zipped
-    a = [%w(a b), %w(1 1)]
-    NamedArray.add_zipped a, [%w(c), %w(1)]
-    NamedArray.add_zipped a, [%w(d), %w(1)]
-    assert_equal [%w(a b c d), %w(1 1 1 1)], a
-  end
-
-  def test_method_missing
-    a = NamedArray.setup([1,2], [:a, :b])
-    assert_equal 1, a.a
-    assert_equal 2, a.b
-  end
-end
-

data/test/scout/test_open.rb

@@ -1,146 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestOpen < Test::Unit::TestCase
-
-  def test_read
-    content =<<-EOF
-1
-2
-3
-4
-    EOF
-    TmpFile.with_file(content) do |file|
-      sum = 0
-      Open.read file do |line| sum += line.to_i end
-      assert_equal(1 + 2 + 3 + 4, sum)
-      assert_equal(content, Open.read(file))
-    end
-  end
-
-  def test_gzip
-    content =<<-EOF
-1
-2
-3
-4
-    EOF
-    TmpFile.with_file(content) do |file|
-      `gzip #{file}`
-      assert_equal(content, Open.read(file + '.gz'))
-      FileUtils.rm file + '.gz'
-    end
-  end
-
-
-
-  #def test_wget
-  #  assert(Misc.fixutf8(Open.wget('http://google.com', :quiet => true).read) =~ /html/)
-  #end
-
-  #def test_nice
-  #  nice =  0.5
-
-  #  t = Time.now
-  #  Open.wget('http://google.com', :quiet => true, :nice => nice).read
-  #  assert(Time.now - t + 0.5 >= nice)
-
-  #  Open.wget('http://google.com', :quiet => true, :nice => nice, :nice_key => 1).read
-  #  t = Time.now
-  #  Open.wget('http://google.com', :quiet => true, :nice => nice, :nice_key => 1).read
-  #  assert(Time.now - t + 0.5 >= nice)
-  #end
-
-  #def test_remote?
-  #  assert(Open.remote?('http://google.com'))
-  #  assert(! Open.remote?('~/.bashrc'))
-  #end
-
-  #def test_open
-  #  assert(Open.read('http://google.com', :quiet => true, :nocache => :update) =~ /html/)
-  #end
-
-  #def test_repo_dir
-  #  file1 = "TEST"
-  #  file2 = "TEST" * 1000
-  #  TmpFile.with_file do |tmpdir|
-  #    tmpdir = Rbbt.tmp.repo_dir.find
-  #    normal = File.join(tmpdir, 'normal')
-  #    repo = File.join(tmpdir, 'repo')
-
-  #    Open.repository_dirs.push(repo)
-
-  #    Misc.benchmark(100) do
-  #      filename = "file" << (rand * 100).to_i.to_s
-  #      Open.write(File.join(normal, filename), file2)
-  #      100.times do 
-  #        Open.read(File.join(normal,  filename))
-  #      end
-  #    end
-
-  #    Misc.benchmark(100) do
-  #      filename = "file" << (rand * 100).to_i.to_s
-  #      Open.write(File.join(repo, filename), file2)
-  #      100.times do 
-  #        Open.read(File.join(repo, filename))
-  #      end
-  #    end
-  #  end
-  #end
-  #
-  #def test_repo_dir2
-  #  TmpFile.with_file do |tmpdir|
-  #    tmpdir = Rbbt.tmp.repo_dir.find
-  #    repo = File.join(tmpdir, 'repo')
-
-  #    Open.repository_dirs.push(repo)
-
-  #    obj = { :a => "???a"}
-  #    filename = "file" << (rand * 100).to_i.to_s
-  #    Open.write(File.join(repo, filename), Marshal.dump(obj))
-  #    dump = Open.read(File.join(repo, filename))
-  #    obj_cp = Marshal.load(dump)
-  #    assert_equal obj, obj_cp
-  #  end
-  #end
-
-  #def test_repo_marshal
-  #  TmpFile.with_file do |tmpdir|
-  #    tmpdir = Rbbt.tmp.repo_dir.find
-  #    repo = File.join(tmpdir, 'repo')
-
-  #    filename = 'file'
-  #    Open.repository_dirs.push(repo)
-
-  #    obj = {:a => "string", :pid => nil, :num => 1000, :p  => Rbbt.tmp.foo}
-  #    Open.write(File.join(repo, filename), Marshal.dump(obj))
-  #    new =Open.open(File.join(repo, filename)) do |f|
-  #      Marshal.load(f)
-  #    end
-
-  #    assert_equal new, obj
-  #  end
-
-  #end
-
-  #def test_write_stream_repo
-  #  TmpFile.with_file do |tmpdir|
-  #    tmpdir = Rbbt.tmp.repo_dir.find
-  #    repo = File.join(tmpdir, 'repo')
-
-  #    file = File.join(repo, 'file')
-  #    Open.repository_dirs.push(repo)
-
-  #    text = (["text"] * 5) * "\n"
-
-  #    Misc.consume_stream(StringIO.new(text), false, file)
-
-  #    assert_equal text, Open.read(file)
-  #    assert !File.exist?(file)
-  #    assert Open.exists? file
-  #  end
-
-  #end
-
-end
-

data/test/scout/test_path.rb

@@ -1,54 +0,0 @@
-require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
-require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-
-class TestPath < Test::Unit::TestCase
-  def test_join
-    path = '/tmp'
-    path.extend Path
-    assert_equal '/tmp/foo', path.join(:foo)
-    assert_equal '/tmp/foo/bar', path.join(:bar, :foo)
-  end
-
-  def test_get
-    path = '/tmp'
-    path.extend Path
-    assert_equal '/tmp/foo', path[:foo]
-    assert_equal '/tmp/foo/bar', path.foo[:bar]
-    assert_equal '/tmp/foo/bar', path[:bar, :foo]
-  end
-
-  def test_slash
-    path = '/tmp'
-    path.extend Path
-    assert_equal '/tmp/foo', path/:foo
-    assert_equal '/tmp/foo/bar', path/:foo/:bar
-    assert_equal '/tmp/foo/bar', path.foo/:bar
-    assert_equal '/tmp/foo/bar', path./(:bar, :foo)
-  end
-
-  def test_setup
-    path = 'tmp'
-    Path.setup(path)
-    assert_equal 'scout', path.pkgdir
-    assert path.libdir.end_with?("scout-gear")
-  end
-
-  def test_lib_dir
-    TmpFile.with_file do |tmpdir|
-      Path.setup tmpdir
-      FileUtils.mkdir_p tmpdir.lib
-      lib_path = File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
-      lib_path = File.join(Path.caller_lib_dir, 'lib', lib_path)
-      File.write tmpdir.lib.file, <<-EOR 
-require '#{lib_path}'
-a = "1"
-Path.setup(a)
-print a.libdir
-      EOR
-      Misc.in_dir tmpdir.tmp do
-        assert_equal tmpdir, `ruby #{tmpdir.lib.file}`
-      end
-    end
-  end
-end
-