windows-pr 1.2.4 → 1.2.5

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_task_argument_parsing.rb

@@ -0,0 +1,119 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskArgumentParsing < Rake::TestCase
+  def setup
+    super
+
+    @app = Rake::Application.new
+  end
+
+  def test_name_only
+    name, args = @app.parse_task_string("name")
+    assert_equal "name", name
+    assert_equal [], args
+  end
+
+  def test_empty_args
+    name, args = @app.parse_task_string("name[]")
+    assert_equal "name", name
+    assert_equal [], args
+  end
+
+  def test_one_argument
+    name, args = @app.parse_task_string("name[one]")
+    assert_equal "name", name
+    assert_equal ["one"], args
+  end
+
+  def test_two_arguments
+    name, args = @app.parse_task_string("name[one,two]")
+    assert_equal "name", name
+    assert_equal ["one", "two"], args
+  end
+
+  def test_can_handle_spaces_between_args
+    name, args = @app.parse_task_string("name[one, two,\tthree , \tfour]")
+    assert_equal "name", name
+    assert_equal ["one", "two", "three", "four"], args
+  end
+
+  def test_keeps_embedded_spaces
+    name, args = @app.parse_task_string("name[a one ana, two]")
+    assert_equal "name", name
+    assert_equal ["a one ana", "two"], args
+  end
+
+  def test_can_handle_commas_in_args
+    name, args = @app.parse_task_string("name[one, two, three_a\\, three_b, four]")
+    assert_equal "name", name
+    assert_equal ["one", "two", "three_a, three_b", "four"], args
+  end
+
+  def test_treat_blank_arg_as_empty_string
+    name, args = @app.parse_task_string("name[one,]")
+    assert_equal "name", name
+    assert_equal ["one", ""], args
+
+    name, args = @app.parse_task_string("name[one,,two]")
+    assert_equal "name", name
+    assert_equal ["one", "", "two"], args
+  end
+
+  def test_terminal_width_using_env
+    app = Rake::Application.new
+    app.terminal_columns = 1234
+
+    assert_equal 1234, app.terminal_width
+  end
+
+  def test_terminal_width_using_stty
+    def @app.unix?() true end
+    def @app.dynamic_width_stty() 1235 end
+    def @app.dynamic_width_tput() 0 end
+
+    assert_equal 1235, @app.terminal_width
+  end
+
+  def test_terminal_width_using_tput
+    def @app.unix?() true end
+    def @app.dynamic_width_stty() 0 end
+    def @app.dynamic_width_tput() 1236 end
+
+    assert_equal 1236, @app.terminal_width
+  end
+
+  def test_terminal_width_using_hardcoded_80
+    def @app.unix?() false end
+
+    assert_equal 80, @app.terminal_width
+  end
+
+  def test_terminal_width_with_failure
+    def @app.unix?() raise end
+
+    assert_equal 80, @app.terminal_width
+  end
+
+  def test_no_rakeopt
+    ARGV << '--trace'
+    app = Rake::Application.new
+    app.init
+    assert !app.options.silent
+  end
+
+  def test_rakeopt_with_blank_options
+    ARGV << '--trace'
+    app = Rake::Application.new
+    app.init
+    assert !app.options.silent
+  end
+
+  def test_rakeopt_with_silent_options
+    ENV['RAKEOPT'] = '-s'
+    app = Rake::Application.new
+
+    app.init
+
+    assert app.options.silent
+  end
+end

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_task_arguments.rb

@@ -0,0 +1,134 @@
+require File.expand_path('../helper', __FILE__)
+
+######################################################################
+class TestRakeTaskArguments < Rake::TestCase
+  def teardown
+    ENV.delete('rev')
+    ENV.delete('VER')
+
+    super
+  end
+
+  def test_empty_arg_list_is_empty
+    ta = Rake::TaskArguments.new([], [])
+    assert_equal({}, ta.to_hash)
+  end
+
+  def test_multiple_values_in_args
+    ta = Rake::TaskArguments.new([:a, :b, :c], [:one, :two, :three])
+    assert_equal({:a => :one, :b => :two, :c => :three}, ta.to_hash)
+  end
+
+  def test_has_key
+    ta = Rake::TaskArguments.new([:a], [:one])
+    assert(ta.has_key?(:a))
+    refute(ta.has_key?(:b))
+  end
+
+  def test_fetch
+    ta = Rake::TaskArguments.new([:one], [1])
+    assert_equal 1, ta.fetch(:one)
+    assert_equal 2, ta.fetch(:two) { 2 }
+    assert_raises(KeyError) { ta.fetch(:three) }
+  end
+
+  def test_to_s
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
+    assert_equal ta.to_hash.inspect, ta.to_s
+    assert_equal ta.to_hash.inspect, ta.inspect
+  end
+
+  def test_enumerable_behavior
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
+    assert_equal [10, 20, 30], ta.map { |k, v| v * 10 }.sort
+  end
+
+  def test_named_args
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal 1, ta.aa
+    assert_equal 1, ta[:aa]
+    assert_equal 1, ta["aa"]
+    assert_equal 2, ta.bb
+    assert_nil ta.cc
+  end
+
+  def test_args_knows_its_names
+    ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2])
+    assert_equal ["aa", "bb"], ta.names
+  end
+
+  def test_extra_names_are_nil
+    ta = Rake::TaskArguments.new(["aa", "bb", "cc"], [1, 2])
+    assert_nil ta.cc
+  end
+
+  def test_args_do_not_reference_env_values
+    ta = Rake::TaskArguments.new(["aa"], [1])
+    ENV['rev'] = "1.2"
+    ENV['VER'] = "2.3"
+    assert_nil ta.rev
+    assert_nil ta.ver
+  end
+
+  def test_creating_new_argument_scopes
+    parent = Rake::TaskArguments.new(['p'], [1])
+    child = parent.new_scope(['c', 'p'])
+    assert_equal({:p=>1}, child.to_hash)
+    assert_equal 1, child.p
+    assert_equal 1, child["p"]
+    assert_equal 1, child[:p]
+    assert_nil child.c
+  end
+
+  def test_child_hides_parent_arg_names
+    parent = Rake::TaskArguments.new(['aa'], [1])
+    child = Rake::TaskArguments.new(['aa'], [2], parent)
+    assert_equal 2, child.aa
+  end
+
+  def test_default_arguments_values_can_be_merged
+    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
+    ta.with_defaults({ :aa => 'default_val' })
+    assert_equal 'default_val', ta[:aa]
+    assert_equal 'original_val', ta[:bb]
+  end
+
+  def test_default_arguments_that_dont_match_names_are_ignored
+    ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"])
+    ta.with_defaults({ "cc" => "default_val" })
+    assert_nil ta[:cc]
+  end
+
+  def test_all_and_extra_arguments_without_named_arguments
+    app = Rake::Application.new
+    _, args = app.parse_task_string("task[1,two,more]")
+    ta = Rake::TaskArguments.new([], args)
+    assert_equal [], ta.names
+    assert_equal ['1', 'two', 'more'], ta.to_a
+    assert_equal ['1', 'two', 'more'], ta.extras
+  end
+
+  def test_all_and_extra_arguments_with_named_arguments
+    app = Rake::Application.new
+    _, args = app.parse_task_string("task[1,two,more,still more]")
+    ta = Rake::TaskArguments.new([:first, :second], args)
+    assert_equal [:first, :second], ta.names
+    assert_equal "1", ta[:first]
+    assert_equal "two", ta[:second]
+    assert_equal ['1', 'two', 'more', 'still more'], ta.to_a
+    assert_equal ['more', 'still more'], ta.extras
+  end
+
+  def test_extra_args_with_less_than_named_arguments
+    app = Rake::Application.new
+    _, args = app.parse_task_string("task[1,two]")
+    ta = Rake::TaskArguments.new([:first, :second, :third], args)
+    assert_equal [:first, :second, :third], ta.names
+    assert_equal "1", ta[:first]
+    assert_equal "two", ta[:second]
+    assert_equal nil, ta[:third]
+    assert_equal ['1', 'two'], ta.to_a
+    assert_equal [], ta.extras
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_task_manager.rb

@@ -0,0 +1,178 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskManager < Rake::TestCase
+
+  def setup
+    super
+
+    @tm = Rake::TestCase::TaskManager.new
+  end
+
+  def test_create_task_manager
+    refute_nil @tm
+    assert_equal [], @tm.tasks
+  end
+
+  def test_define_task
+    t = @tm.define_task(Rake::Task, :t)
+    assert_equal "t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_index
+    e = assert_raises RuntimeError do
+      @tm['bad']
+    end
+
+    assert_equal "Don't know how to build task 'bad' (see --tasks)", e.message
+  end
+
+  def test_name_lookup
+    t = @tm.define_task(Rake::Task, :t)
+    assert_equal t, @tm[:t]
+  end
+
+  def test_namespace_task_create
+    @tm.in_namespace("x") do
+      t = @tm.define_task(Rake::Task, :t)
+      assert_equal "x:t", t.name
+    end
+    assert_equal ["x:t"], @tm.tasks.map { |t| t.name }
+  end
+
+  def test_define_namespaced_task
+    t = @tm.define_task(Rake::Task, 'n:a:m:e:t')
+    assert_equal Rake::Scope.make("e", "m", "a", "n"), t.scope
+    assert_equal "n:a:m:e:t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_define_namespace_in_namespace
+    t = nil
+    @tm.in_namespace("n") do
+      t = @tm.define_task(Rake::Task, 'a:m:e:t')
+    end
+    assert_equal Rake::Scope.make("e", "m", "a", "n"), t.scope
+    assert_equal "n:a:m:e:t", t.name
+    assert_equal @tm, t.application
+  end
+
+  def test_anonymous_namespace
+    anon_ns = @tm.in_namespace(nil) do
+      t = @tm.define_task(Rake::Task, :t)
+      assert_equal "_anon_1:t", t.name
+    end
+    task = anon_ns[:t]
+    assert_equal "_anon_1:t", task.name
+  end
+
+  def test_create_filetask_in_namespace
+    @tm.in_namespace("x") do
+      t = @tm.define_task(Rake::FileTask, "fn")
+      assert_equal "fn", t.name
+    end
+
+    assert_equal ["fn"], @tm.tasks.map { |t| t.name }
+  end
+
+  def test_namespace_yields_same_namespace_as_returned
+    yielded_namespace = nil
+    returned_namespace = @tm.in_namespace("x") do |ns|
+      yielded_namespace = ns
+    end
+    assert_equal returned_namespace, yielded_namespace
+  end
+
+  def test_name_lookup_with_implicit_file_tasks
+    FileUtils.touch 'README.rdoc'
+
+    t = @tm["README.rdoc"]
+
+    assert_equal "README.rdoc", t.name
+    assert Rake::FileTask === t
+  end
+
+  def test_name_lookup_with_nonexistent_task
+    assert_raises(RuntimeError) {
+      @tm["DOES NOT EXIST"]
+    }
+  end
+
+  def test_name_lookup_in_multiple_scopes
+    aa = nil
+    bb = nil
+    xx = @tm.define_task(Rake::Task, :xx)
+    top_z = @tm.define_task(Rake::Task, :z)
+    @tm.in_namespace("a") do
+      aa = @tm.define_task(Rake::Task, :aa)
+      mid_z = @tm.define_task(Rake::Task, :z)
+      ns_d = @tm.define_task(Rake::Task, "n:t")
+      @tm.in_namespace("b") do
+        bb = @tm.define_task(Rake::Task, :bb)
+        bot_z = @tm.define_task(Rake::Task, :z)
+
+        assert_equal Rake::Scope.make("b", "a"), @tm.current_scope
+
+        assert_equal bb, @tm["a:b:bb"]
+        assert_equal aa, @tm["a:aa"]
+        assert_equal xx, @tm["xx"]
+        assert_equal bot_z, @tm["z"]
+        assert_equal mid_z, @tm["^z"]
+        assert_equal top_z, @tm["^^z"]
+        assert_equal top_z, @tm["^^^z"] # Over the top
+        assert_equal top_z, @tm["rake:z"]
+      end
+
+      assert_equal Rake::Scope.make("a"), @tm.current_scope
+
+      assert_equal bb, @tm["a:b:bb"]
+      assert_equal aa, @tm["a:aa"]
+      assert_equal xx, @tm["xx"]
+      assert_equal bb, @tm["b:bb"]
+      assert_equal aa, @tm["aa"]
+      assert_equal mid_z, @tm["z"]
+      assert_equal top_z, @tm["^z"]
+      assert_equal top_z, @tm["^^z"] # Over the top
+      assert_equal top_z, @tm["rake:z"]
+      assert_equal ns_d, @tm["n:t"]
+      assert_equal ns_d, @tm["a:n:t"]
+    end
+
+    assert_equal Rake::Scope.make, @tm.current_scope
+
+    assert_equal Rake::Scope.make, xx.scope
+    assert_equal Rake::Scope.make('a'), aa.scope
+    assert_equal Rake::Scope.make('b', 'a'), bb.scope
+  end
+
+  def test_lookup_with_explicit_scopes
+    t1, t2, t3, s = (0...4).map { nil }
+    t1 = @tm.define_task(Rake::Task, :t)
+    @tm.in_namespace("a") do
+      t2 = @tm.define_task(Rake::Task, :t)
+      s =  @tm.define_task(Rake::Task, :s)
+      @tm.in_namespace("b") do
+        t3 = @tm.define_task(Rake::Task, :t)
+      end
+    end
+    assert_equal t1, @tm[:t, Rake::Scope.make]
+    assert_equal t2, @tm[:t, Rake::Scope.make("a")]
+    assert_equal t3, @tm[:t, Rake::Scope.make("b", "a")]
+    assert_equal s,  @tm[:s, Rake::Scope.make("b", "a")]
+    assert_equal s,  @tm[:s, Rake::Scope.make("a")]
+  end
+
+  def test_correctly_scoped_prerequisites_are_invoked
+    values = []
+    @tm = Rake::Application.new
+    @tm.define_task(Rake::Task, :z) do values << "top z" end
+    @tm.in_namespace("a") do
+      @tm.define_task(Rake::Task, :z) do values << "next z" end
+      @tm.define_task(Rake::Task, :x => :z)
+    end
+
+    @tm["a:x"].invoke
+    assert_equal ["next z"], values
+  end
+
+end

data/vendor/bundle/ruby/2.2.0/gems/win32-api-1.6.0-universal-mingw32/vendor/bundle/ruby/2.2.0/gems/rake-11.1.2/test/test_rake_task_manager_argument_resolution.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeTaskManagerArgumentResolution < Rake::TestCase
+
+  def test_good_arg_patterns
+    assert_equal [:t, [], []],       task(:t)
+    assert_equal [:t, [], [:x]],     task(:t => :x)
+    assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y])
+
+    assert_equal [:t, [:a, :b], []],       task(:t, [:a, :b])
+    assert_equal [:t, [:a, :b], [:x]],     task(:t, [:a, :b] => :x)
+    assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y])
+  end
+
+  def task(*args)
+    tm = Rake::TestCase::TaskManager.new
+    tm.resolve_args(args)
+  end
+end