hatena_bookmark_client_for_ruby 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_invocation_chain.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeInvocationChain < Rake::TestCase
+  include Rake
+
+  def setup
+    super
+
+    @empty = InvocationChain.empty
+
+    @first_member = "A"
+    @second_member = "B"
+    @one = @empty.append(@first_member)
+    @two = @one.append(@second_member)
+  end
+
+  def test_conj_on_invocation_chains
+    list = InvocationChain.empty.conj("B").conj("A")
+    assert_equal InvocationChain.make("A", "B"), list
+    assert_equal InvocationChain, list.class
+  end
+
+  def test_make_on_invocation_chains
+    assert_equal @empty, InvocationChain.make()
+    assert_equal @one, InvocationChain.make(@first_member)
+    assert_equal @two, InvocationChain.make(@second_member, @first_member)
+  end
+
+  def test_append_with_one_argument
+    chain = @empty.append("A")
+
+    assert_equal 'TOP => A', chain.to_s # HACK
+  end
+
+  def test_append_one_circular
+    ex = assert_raises RuntimeError do
+      @one.append(@first_member)
+    end
+    assert_match(/circular +dependency/i, ex.message)
+    assert_match(/A.*=>.*A/, ex.message)
+  end
+
+  def test_append_two_circular
+    ex = assert_raises RuntimeError do
+      @two.append(@first_member)
+    end
+    assert_match(/A.*=>.*B.*=>.*A/, ex.message)
+  end
+
+  def test_member_eh_one
+    assert @one.member?(@first_member)
+  end
+
+  def test_member_eh_two
+    assert @two.member?(@first_member)
+    assert @two.member?(@second_member)
+  end
+
+  def test_to_s_empty
+    assert_equal "TOP", @empty.to_s
+    assert_equal "TOP => A", @one.to_s
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_late_time.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeLateTime < Rake::TestCase
+  def test_late_time_comparisons
+    late = Rake::LATE
+    assert_equal late, late
+    assert late >= Time.now
+    assert late > Time.now
+    assert late != Time.now
+    assert Time.now < late
+    assert Time.now <= late
+    assert Time.now != late
+  end
+
+  def test_to_s
+    assert_equal '<LATE TIME>', Rake::LATE.to_s
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_linked_list.rb

@@ -0,0 +1,84 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestLinkedList < Rake::TestCase
+  include Rake
+
+  def test_empty_list
+    empty = LinkedList::EMPTY
+    assert empty.empty?, "should be empty"
+  end
+
+  def test_list_with_one_item
+    list = LinkedList.make(:one)
+    assert ! list.empty?, "should not be empty"
+    assert_equal :one, list.head
+    assert_equal LinkedList::EMPTY, list.tail
+  end
+
+  def test_make_with_no_arguments
+    empty = LinkedList.make()
+    assert_equal LinkedList::EMPTY, empty
+  end
+
+  def test_make_with_one_argument
+    list = LinkedList.make(:one)
+    assert ! list.empty?
+    assert_equal :one, list.head
+    assert_equal LinkedList::EMPTY, list.tail
+  end
+
+  def test_make_with_two_arguments
+    list = LinkedList.make(:one, :two)
+    assert ! list.empty?
+    assert_equal :one, list.head
+    assert_equal :two, list.tail.head
+    assert_equal LinkedList::EMPTY, list.tail.tail
+  end
+
+  def test_list_with_several_items
+    list = LinkedList.make(:one, :two, :three)
+
+    assert ! list.empty?, "should not be empty"
+    assert_equal :one, list.head
+    assert_equal :two, list.tail.head
+    assert_equal :three, list.tail.tail.head
+    assert_equal LinkedList::EMPTY, list.tail.tail.tail
+  end
+
+  def test_lists_are_structurally_equivalent
+    list = LinkedList.make(1, 2, 3)
+    same = LinkedList.make(1, 2, 3)
+    diff = LinkedList.make(1, 2, 4)
+    short = LinkedList.make(1, 2)
+
+    assert_equal list, same
+    refute_equal list, diff
+    refute_equal list, short
+    refute_equal short, list
+  end
+
+  def test_conversion_to_string
+    list = LinkedList.make(:one, :two, :three)
+    assert_equal "LL(one, two, three)", list.to_s
+    assert_equal "LL()", LinkedList.make().to_s
+  end
+
+  def test_conversion_with_inspect
+    list = LinkedList.make(:one, :two, :three)
+    assert_equal "LL(:one, :two, :three)", list.inspect
+    assert_equal "LL()", LinkedList.make().inspect
+  end
+
+  def test_lists_are_enumerable
+    list = LinkedList.make(1, 2, 3)
+    new_list = list.map { |item| item + 10 }
+    expected = [11, 12, 13]
+    assert_equal expected, new_list
+  end
+
+  def test_conjunction
+    list = LinkedList.make.conj("C").conj("B").conj("A")
+    assert_equal LinkedList.make("A", "B", "C"), list
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_makefile_loader.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/loaders/makefile'
+
+class TestRakeMakefileLoader < Rake::TestCase
+  include Rake
+
+  def test_parse
+    Dir.chdir @tempdir
+
+    open 'sample.mf', 'w' do |io|
+      io << <<-'SAMPLE_MF'
+# Comments
+a: a1 a2 a3 a4
+b: b1 b2 b3 \
+   b4 b5 b6\
+# Mid: Comment
+b7
+
+ a : a5 a6 a7
+c: c1
+d: d1 d2 \
+
+e f : e1 f1
+
+g\ 0: g1 g\ 2 g\ 3 g4
+      SAMPLE_MF
+    end
+
+    Task.clear
+    loader = Rake::MakefileLoader.new
+    loader.load 'sample.mf'
+    %w(a b c d).each do |t|
+      assert Task.task_defined?(t), "#{t} should be a defined task"
+    end
+    assert_equal %w(a1 a2 a3 a4 a5 a6 a7).sort, Task['a'].prerequisites.sort
+    assert_equal %w(b1 b2 b3 b4 b5 b6 b7).sort, Task['b'].prerequisites.sort
+    assert_equal %w(c1).sort, Task['c'].prerequisites.sort
+    assert_equal %w(d1 d2).sort, Task['d'].prerequisites.sort
+    assert_equal %w(e1 f1).sort, Task['e'].prerequisites.sort
+    assert_equal %w(e1 f1).sort, Task['f'].prerequisites.sort
+    assert_equal(
+      ["g1", "g 2", "g 3", "g4"].sort,
+      Task['g 0'].prerequisites.sort)
+    assert_equal 7, Task.tasks.size
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_multi_task.rb

@@ -0,0 +1,64 @@
+require File.expand_path('../helper', __FILE__)
+require 'thread'
+
+class TestRakeMultiTask < Rake::TestCase
+  include Rake
+  include Rake::DSL
+
+  def setup
+    super
+
+    Task.clear
+    @runs = Array.new
+    @mutex = Mutex.new
+  end
+
+  def teardown
+    Rake.application.thread_pool.join
+
+    super
+  end
+
+  def add_run(obj)
+    @mutex.synchronize do
+      @runs << obj
+    end
+  end
+
+  def test_running_multitasks
+    task :a do 3.times do |i| add_run("A#{i}"); sleep 0.01; end end
+    task :b do 3.times do |i| add_run("B#{i}"); sleep 0.01;  end end
+    multitask :both => [:a, :b]
+    Task[:both].invoke
+    assert_equal 6, @runs.size
+    assert @runs.index("A0") < @runs.index("A1")
+    assert @runs.index("A1") < @runs.index("A2")
+    assert @runs.index("B0") < @runs.index("B1")
+    assert @runs.index("B1") < @runs.index("B2")
+  end
+
+  def test_all_multitasks_wait_on_slow_prerequisites
+    task :slow do 3.times do |i| add_run("S#{i}"); sleep 0.05 end end
+    task :a => [:slow] do 3.times do |i| add_run("A#{i}"); sleep 0.01 end end
+    task :b => [:slow] do 3.times do |i| add_run("B#{i}"); sleep 0.01 end end
+    multitask :both => [:a, :b]
+    Task[:both].invoke
+    assert_equal 9, @runs.size
+    assert @runs.index("S0") < @runs.index("S1")
+    assert @runs.index("S1") < @runs.index("S2")
+    assert @runs.index("S2") < @runs.index("A0")
+    assert @runs.index("S2") < @runs.index("B0")
+    assert @runs.index("A0") < @runs.index("A1")
+    assert @runs.index("A1") < @runs.index("A2")
+    assert @runs.index("B0") < @runs.index("B1")
+    assert @runs.index("B1") < @runs.index("B2")
+  end
+
+  def test_multitasks_with_parameters
+    task :a, [:arg] do |t, args| add_run(args[:arg]) end
+    multitask :b, [:arg] => [:a] do |t, args| add_run(args[:arg] + 'mt') end
+    Task[:b].invoke "b"
+    assert @runs[0] == "b"
+    assert @runs[1] == "bmt"
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_name_space.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakeNameSpace < Rake::TestCase
+
+  class TM
+    include Rake::TaskManager
+  end
+
+  def test_namespace_creation
+    mgr = TM.new
+    ns = Rake::NameSpace.new(mgr, [])
+    refute_nil ns
+  end
+
+  def test_namespace_lookup
+    mgr = TM.new
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, "t")
+    end
+
+    refute_nil ns["t"]
+    assert_equal mgr["n:t"], ns["t"]
+  end
+
+  def test_namespace_reports_tasks_it_owns
+    mgr = TM.new
+    nns = nil
+    ns = mgr.in_namespace("n") do
+      mgr.define_task(Rake::Task, :x)
+      mgr.define_task(Rake::Task, :y)
+      nns = mgr.in_namespace("nn") do
+        mgr.define_task(Rake::Task, :z)
+      end
+    end
+    mgr.in_namespace("m") do
+      mgr.define_task(Rake::Task, :x)
+    end
+
+    assert_equal ["n:nn:z", "n:x", "n:y"],
+      ns.tasks.map { |tsk| tsk.name }
+    assert_equal ["n:nn:z"], nns.tasks.map { |t| t.name }
+  end
+
+  def test_scope
+    mgr = TM.new
+
+    scope = Rake::LinkedList.new 'b'
+    scope = scope.conj 'a'
+
+    ns = Rake::NameSpace.new mgr, scope
+
+    assert_equal scope, ns.scope
+
+    refute_same scope, ns.scope
+  end
+
+end

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_package_task.rb

@@ -0,0 +1,79 @@
+require File.expand_path('../helper', __FILE__)
+require 'rake/packagetask'
+
+class TestRakePackageTask < Rake::TestCase
+
+  def test_initialize
+    touch 'install.rb'
+    touch 'a.c'
+    touch 'b.c'
+    mkdir 'CVS'
+    touch 'a.rb~'
+
+    pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p|
+      p.package_files << "install.rb"
+      p.package_files.include '*.c'
+      p.package_files.exclude(/\bCVS\b/)
+      p.package_files.exclude(/~$/)
+      p.package_dir = 'pkg'
+      p.need_tar = true
+      p.need_tar_gz = true
+      p.need_tar_bz2 = true
+      p.need_zip = true
+    }
+
+    assert_equal "pkg", pkg.package_dir
+
+    assert_includes pkg.package_files, 'a.c'
+
+    assert_equal 'pkgr', pkg.name
+    assert_equal '1.2.3', pkg.version
+    assert Rake::Task[:package]
+    assert Rake::Task['pkg/pkgr-1.2.3.tgz']
+    assert Rake::Task['pkg/pkgr-1.2.3.tar.gz']
+    assert Rake::Task['pkg/pkgr-1.2.3.tar.bz2']
+    assert Rake::Task['pkg/pkgr-1.2.3.zip']
+    assert Rake::Task['pkg/pkgr-1.2.3']
+    assert Rake::Task[:clobber_package]
+    assert Rake::Task[:repackage]
+  end
+
+  def test_initialize_no_version
+    e = assert_raises RuntimeError do
+      Rake::PackageTask.new 'pkgr'
+    end
+
+    assert_equal 'Version required (or :noversion)', e.message
+  end
+
+  def test_initialize_noversion
+    pkg = Rake::PackageTask.new 'pkgr', :noversion
+
+    assert_equal 'pkg',  pkg.package_dir
+    assert_equal 'pkgr', pkg.name
+    assert_equal nil,    pkg.version
+  end
+
+  def test_clone
+    pkg = Rake::PackageTask.new("x", :noversion)
+    p2 = pkg.clone
+    pkg.package_files << "y"
+    p2.package_files << "x"
+    assert_equal ["y"], pkg.package_files
+    assert_equal ["x"], p2.package_files
+  end
+
+  def test_package_name
+    pkg = Rake::PackageTask.new 'a', '1'
+
+    assert_equal 'a-1', pkg.package_name
+  end
+
+  def test_package_name_noversion
+    pkg = Rake::PackageTask.new 'a', :noversion
+
+    assert_equal 'a', pkg.package_name
+  end
+
+end
+

data/vendor/bundle/ruby/2.6.0/gems/rake-10.5.0/test/test_rake_path_map.rb

@@ -0,0 +1,168 @@
+require File.expand_path('../helper', __FILE__)
+
+class TestRakePathMap < Rake::TestCase
+
+  def test_returns_self_with_no_args
+    assert_equal "abc.rb", "abc.rb".pathmap
+  end
+
+  def test_s_returns_file_separator
+    sep = File::ALT_SEPARATOR || File::SEPARATOR
+    assert_equal sep, "abc.rb".pathmap("%s")
+    assert_equal sep, "".pathmap("%s")
+    assert_equal "a#{sep}b", "a/b".pathmap("%d%s%f")
+  end
+
+  def test_f_returns_basename
+    assert_equal "abc.rb", "abc.rb".pathmap("%f")
+    assert_equal "abc.rb", "this/is/a/dir/abc.rb".pathmap("%f")
+    assert_equal "abc.rb", "/this/is/a/dir/abc.rb".pathmap("%f")
+  end
+
+  def test_n_returns_basename_without_extension
+    assert_equal "abc", "abc.rb".pathmap("%n")
+    assert_equal "abc", "abc".pathmap("%n")
+    assert_equal "abc", "this/is/a/dir/abc.rb".pathmap("%n")
+    assert_equal "abc", "/this/is/a/dir/abc.rb".pathmap("%n")
+    assert_equal "abc", "/this/is/a/dir/abc".pathmap("%n")
+  end
+
+  def test_d_returns_dirname
+    assert_equal ".", "abc.rb".pathmap("%d")
+    assert_equal "/", "/abc".pathmap("%d")
+    assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%d")
+    assert_equal "/this/is/a/dir", "/this/is/a/dir/abc.rb".pathmap("%d")
+  end
+
+  def test_9d_returns_partial_dirname
+    assert_equal "this/is", "this/is/a/dir/abc.rb".pathmap("%2d")
+    assert_equal "this", "this/is/a/dir/abc.rb".pathmap("%1d")
+    assert_equal ".", "this/is/a/dir/abc.rb".pathmap("%0d")
+    assert_equal "dir", "this/is/a/dir/abc.rb".pathmap("%-1d")
+    assert_equal "a/dir", "this/is/a/dir/abc.rb".pathmap("%-2d")
+    assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%100d")
+    assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%-100d")
+  end
+
+  def test_x_returns_extension
+    assert_equal "", "abc".pathmap("%x")
+    assert_equal ".rb", "abc.rb".pathmap("%x")
+    assert_equal ".rb", "abc.xyz.rb".pathmap("%x")
+    assert_equal "", ".depends".pathmap("%x")
+    assert_equal "", "dir/.depends".pathmap("%x")
+  end
+
+  def test_x_returns_everything_but_extension
+    assert_equal "abc", "abc".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X")
+    assert_equal "ab.xyz", "ab.xyz.rb".pathmap("%X")
+    assert_equal "a.xyz", "a.xyz.rb".pathmap("%X")
+    assert_equal "abc", "abc.rb".pathmap("%X")
+    assert_equal "ab", "ab.rb".pathmap("%X")
+    assert_equal "a", "a.rb".pathmap("%X")
+    assert_equal ".depends", ".depends".pathmap("%X")
+    assert_equal "a/dir/.depends", "a/dir/.depends".pathmap("%X")
+    assert_equal "/.depends", "/.depends".pathmap("%X")
+  end
+
+  def test_p_returns_entire_pathname
+    assert_equal "abc.rb", "abc.rb".pathmap("%p")
+    assert_equal "this/is/a/dir/abc.rb", "this/is/a/dir/abc.rb".pathmap("%p")
+    assert_equal "/this/is/a/dir/abc.rb", "/this/is/a/dir/abc.rb".pathmap("%p")
+  end
+
+  def test_dash_returns_empty_string
+    assert_equal "", "abc.rb".pathmap("%-")
+    assert_equal "abc.rb", "abc.rb".pathmap("%X%-%x")
+  end
+
+  def test_percent_percent_returns_percent
+    assert_equal "a%b", "".pathmap("a%%b")
+  end
+
+  def test_undefined_percent_causes_error
+    assert_raises(ArgumentError) {
+      "dir/abc.rb".pathmap("%z")
+    }
+  end
+
+  def test_pattern_returns_substitutions
+    assert_equal "bin/org/osb",
+      "src/org/osb/Xyz.java".pathmap("%{src,bin}d")
+  end
+
+  def test_pattern_can_use_backreferences
+    assert_equal "dir/hi/is", "dir/this/is".pathmap("%{t(hi)s,\\1}p")
+  end
+
+  def test_pattern_with_star_replacement_string_uses_block
+    assert_equal "src/ORG/osb",
+      "src/org/osb/Xyz.java".pathmap("%{/org,*}d") { |d| d.upcase }
+    assert_equal "Xyz.java",
+      "src/org/osb/Xyz.java".pathmap("%{.*,*}f") { |f| f.capitalize }
+  end
+
+  def test_pattern_with_no_replacement_nor_block_substitutes_empty_string
+    assert_equal "bc.rb", "abc.rb".pathmap("%{a}f")
+  end
+
+  def test_pattern_works_with_certain_valid_operators
+    assert_equal "dir/xbc.rb", "dir/abc.rb".pathmap("%{a,x}p")
+    assert_equal "d1r", "dir/abc.rb".pathmap("%{i,1}d")
+    assert_equal "xbc.rb", "dir/abc.rb".pathmap("%{a,x}f")
+    assert_equal ".Rb", "dir/abc.rb".pathmap("%{r,R}x")
+    assert_equal "xbc", "dir/abc.rb".pathmap("%{a,x}n")
+  end
+
+  def test_multiple_patterns
+    assert_equal "this/is/b/directory/abc.rb",
+      "this/is/a/dir/abc.rb".pathmap("%{a,b;dir,\\0ectory}p")
+  end
+
+  def test_partial_directory_selection_works_with_patterns
+    assert_equal "this/is/a/long",
+      "this/is/a/really/long/path/ok.rb".pathmap("%{/really/,/}5d")
+  end
+
+  def test_pattern_with_invalid_operator
+    ex = assert_raises(ArgumentError) do
+      "abc.xyz".pathmap("%{src,bin}z")
+    end
+    assert_match(/unknown.*pathmap.*spec.*z/i, ex.message)
+  end
+
+  def test_works_with_windows_separators
+    if File::ALT_SEPARATOR
+      assert_equal "abc", 'dir\abc.rb'.pathmap("%n")
+      assert_equal 'this\is\a\dir',
+        'this\is\a\dir\abc.rb'.pathmap("%d")
+    end
+  end
+
+  def test_complex_patterns
+    sep = "".pathmap("%s")
+    assert_equal(
+      "dir/abc.rb",
+      "dir/abc.rb".pathmap("%d/%n%x"))
+    assert_equal(
+      "./abc.rb",
+      "abc.rb".pathmap("%d/%n%x"))
+    assert_equal(
+      "Your file extension is '.rb'",
+      "dir/abc.rb".pathmap("Your file extension is '%x'"))
+    assert_equal(
+      "bin/org/onestepback/proj/A.class",
+      "src/org/onestepback/proj/A.java".pathmap("%{src,bin}d/%n.class"))
+    assert_equal(
+      "src_work/bin/org/onestepback/proj/A.class",
+      "src_work/src/org/onestepback/proj/A.java".
+        pathmap('%{\bsrc\b,bin}X.class'))
+    assert_equal(
+      ".depends.bak",
+      ".depends".pathmap("%X.bak"))
+    assert_equal(
+      "d#{sep}a/b/c#{sep}file.txt",
+      "a/b/c/d/file.txt".pathmap("%-1d%s%3d%s%f"))
+  end
+end