bitclust-core 1.6.1 → 1.8.0

data/test/test_search_index_generator.rb

@@ -511,3 +511,84 @@ HERE
     end
   end
 end
+
+class TestSearchIndexSnippet < Test::Unit::TestCase
+  # 検索結果の説明文(snippet)。meta description と同じ entry.description
+  # (最初の説明段落のプレーンテキスト)を、空でないときだけ持たせる。
+  #
+  # テストリスト:
+  # [x] class/method/special variable の各エントリが snippet を持つ
+  # [x] 説明が空のエントリは snippet キー自体を持たない
+  # [x] merge は複数版で同一エントリのとき最新版の snippet を採用する
+  # [x] 最新版に無いページは収録されている最終版の snippet を保つ
+  def setup
+    @prefix = 'db_snip'
+    @base = 'tree_snip'
+    @root = "#{@base}/refm/api/src"
+    FileUtils.mkdir_p("#{@root}")
+    File.open("#{@root}/LIBRARIES", 'w+') { |f| f.puts '_builtin' }
+    File.open("#{@root}/_builtin.rd", 'w+') do |f|
+      f.puts <<'HERE'
+description
+
+= class Foo < Object
+クラスの説明。
+== Instance Methods
+--- foo
+
+メソッドの説明。
+--- undocumented
+= module Kernel
+== Special Variables
+--- $; -> String | nil
+
+区切り文字。
+HERE
+    end
+    @db = BitClust::MethodDatabase.new(@prefix)
+    @db.init
+    @db.transaction do
+      [%w[version 3.4], %w[encoding utf-8]].each { |k, v| @db.propset(k, v) }
+    end
+    @db.transaction { @db.update_by_stdlibtree(@root) }
+    @gen = BitClust::SearchIndexGenerator.new
+  end
+
+  def teardown
+    FileUtils.rm_r([@prefix, @base], :force => true)
+  end
+
+  def find_entry(index, full_name)
+    index.find { |e| e[:full_name] == full_name }
+  end
+
+  def test_snippet_carries_entry_description
+    index = @gen.build_index(@db)
+    assert_equal 'クラスの説明。', find_entry(index, 'Foo')[:snippet]
+    assert_equal 'メソッドの説明。', find_entry(index, 'Foo#foo')[:snippet]
+    assert_equal '区切り文字。', find_entry(index, '$;')[:snippet]
+  end
+
+  def test_snippet_is_omitted_when_description_is_empty
+    index = @gen.build_index(@db)
+    e = find_entry(index, 'Foo#undocumented')
+    assert_not_nil e
+    assert_false e.key?(:snippet)
+  end
+
+  def test_merge_takes_snippet_from_newest_version
+    old_e = { name: 'X', full_name: 'X', type: 'class', path: 'class/-x.html', snippet: '古い説明' }
+    new_e = { name: 'X', full_name: 'X', type: 'class', path: 'class/-x.html', snippet: '新しい説明' }
+    merged = BitClust::SearchIndexGenerator.merge([['3.4', [new_e]], ['3.3', [old_e]]])
+    assert_equal 1, merged.size
+    assert_equal '新しい説明', merged.first[:snippet]
+    assert_equal %w[3.3 3.4], merged.first[:versions]
+  end
+
+  def test_merge_keeps_snippet_of_last_version_having_the_page
+    only_old = { name: 'Y', full_name: 'Y', type: 'class', path: 'class/-y.html', snippet: '最終収録版の説明' }
+    merged = BitClust::SearchIndexGenerator.merge([['3.4', []], ['3.3', [only_old]]])
+    assert_equal '最終収録版の説明', merged.first[:snippet]
+    assert_equal %w[3.3], merged.first[:versions]
+  end
+end

data/test/test_searcher.rb

@@ -1,8 +1,10 @@
 require "test/unit"
 require "bitclust"
 require "bitclust/searcher"
+require "bitclust/user_dirs"
 require "fileutils"
 require "tmpdir"
+require "yaml"
 
 class TestTerminalView < Test::Unit::TestCase
   include BitClust
@@ -151,3 +153,64 @@ class TestSearcherModuleFunctionQuery < Test::Unit::TestCase
     assert_equal ["Foo", ".", "b?"], parse("Foo.b?")
   end
 end
+
+# refe/bitclust search が、環境変数指定が無いとき設定ファイル(UserDirs)
+# 経由で DB を見つけること。XDG の場所→従来の ~/.bitclust の順
+class TestSearcherDefaultDbpath < Test::Unit::TestCase
+  include BitClust
+
+  ENV_KEYS = %w[HOME XDG_CONFIG_HOME XDG_DATA_HOME XDG_CACHE_HOME
+                REFE2_SERVER BITCLUST_SERVER REFE2_DATADIR BITCLUST_DATADIR].freeze
+
+  def setup
+    @saved = ENV_KEYS.to_h {|k| [k, ENV[k]] }
+    @home = Dir.mktmpdir
+    ENV['HOME'] = @home
+    (ENV_KEYS - %w[HOME]).each {|k| ENV.delete(k) }
+  end
+
+  def teardown
+    @saved.each {|k, v| v ? ENV[k] = v : ENV.delete(k) }
+    FileUtils.rm_rf(@home)
+  end
+
+  def write_config(path, prefix)
+    FileUtils.mkdir_p(File.dirname(path))
+    File.write(path, { :default_version => '9.9', :database_prefix => prefix }.to_yaml)
+  end
+
+  def test_default_dbpath_via_xdg_config
+    prefix = File.join(@home, 'data', 'bitclust', 'db')
+    MethodDatabase.new("#{prefix}-9.9").init
+    write_config(File.join(@home, '.config', 'bitclust', 'config'), prefix)
+    searcher = Searcher.new
+    assert_equal("#{prefix}-9.9", searcher.send(:default_dbpath))
+    assert_true(searcher.local_database?)
+  end
+
+  def test_default_dbpath_via_legacy_config
+    prefix = File.join(@home, '.bitclust', 'db')
+    MethodDatabase.new("#{prefix}-9.9").init
+    write_config(File.join(@home, '.bitclust', 'config'), prefix)
+    searcher = Searcher.new
+    assert_equal("#{prefix}-9.9", searcher.send(:default_dbpath))
+    assert_true(searcher.local_database?)
+  end
+
+  def test_default_dbpath_prefers_xdg_over_legacy
+    legacy_prefix = File.join(@home, '.bitclust', 'db')
+    MethodDatabase.new("#{legacy_prefix}-9.9").init
+    write_config(File.join(@home, '.bitclust', 'config'), legacy_prefix)
+    xdg_prefix = File.join(@home, 'data', 'bitclust', 'db')
+    MethodDatabase.new("#{xdg_prefix}-9.9").init
+    write_config(File.join(@home, '.config', 'bitclust', 'config'), xdg_prefix)
+    searcher = Searcher.new
+    assert_equal("#{xdg_prefix}-9.9", searcher.send(:default_dbpath))
+  end
+
+  def test_default_dbpath_nil_without_config
+    searcher = Searcher.new
+    assert_nil(searcher.send(:default_dbpath))
+    assert_false(searcher.local_database?)
+  end
+end

data/test/test_server_command.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'stringio'
+require 'bitclust'
+require 'bitclust/subcommands/server_command'
+
+class TestServerCommand < Test::Unit::TestCase
+  def build(argv)
+    cmd = BitClust::Subcommands::ServerCommand.new
+    cmd.parse(argv)
+    cmd
+  end
+
+  def test_does_not_require_global_database
+    assert_false BitClust::Subcommands::ServerCommand.new.needs_database?
+  end
+
+  def test_parse_accepts_short_option
+    cmd = build(['--baseurl=', '-d', '/tmp/db-x'])
+    assert_equal '/tmp/db-x', cmd.__send__(:resolve_dbpath, {:prefix => nil, :capi => false})
+  end
+
+  def test_parse_accepts_long_option
+    cmd = build(['--baseurl=', '--database=/tmp/db-y'])
+    assert_equal '/tmp/db-y', cmd.__send__(:resolve_dbpath, {:prefix => '/tmp/global', :capi => false})
+  end
+
+  def test_global_database_is_used_as_fallback
+    cmd = build(['--baseurl='])
+    assert_equal '/tmp/global', cmd.__send__(:resolve_dbpath, {:prefix => '/tmp/global', :capi => false})
+  end
+
+  def test_missing_database_aborts_with_guidance
+    cmd = build(['--baseurl='])
+    err = StringIO.new
+    orig, $stderr = $stderr, err
+    assert_raise(SystemExit) { cmd.__send__(:resolve_dbpath, {:prefix => nil, :capi => false}) }
+    assert_match(/--database/, err.string)
+  ensure
+    $stderr = orig
+  end
+end

data/test/test_setup_command.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+require 'test/unit'
+require 'bitclust'
+require 'bitclust/subcommands/setup_command'
+require 'bitclust/user_dirs'
+require 'tmpdir'
+require 'fileutils'
+require 'yaml'
+
+# setup サブコマンドの既定バージョン。
+#
+# テストリスト:
+# [x] 既定の対象バージョンに teeny が付いていない
+#     (#%if (version == "V") や #%version V の等値ゲートは文字列一致なので、
+#     teeny 付きの版名で DB を作ると doctree CI・生成済みドキュメントと
+#     ゲートの判定がずれる)
+class TestSetupCommand < Test::Unit::TestCase
+  def test_default_versions_have_no_teeny
+    versions = BitClust::Subcommands::SetupCommand.new.instance_variable_get(:@versions)
+    assert_false(versions.empty?)
+    versions.each do |version|
+      assert_match(/\A\d+\.\d+\z/, version)
+    end
+  end
+end
+
+# setup サブコマンドが選ぶ、設定・DB・doctree checkout の置き場所。
+#
+# テストリスト:
+# [x] 何も無ければ XDG の場所(~/.config/bitclust, ~/.local/share/bitclust)を使う
+# [x] 従来の ~/.bitclust/config だけあれば、そのレイアウトを維持する
+# [x] 両方あれば XDG を使う
+class TestSetupCommandLayout < Test::Unit::TestCase
+  ENV_KEYS = %w[HOME XDG_CONFIG_HOME XDG_DATA_HOME XDG_CACHE_HOME].freeze
+
+  def setup
+    @saved = ENV_KEYS.to_h {|k| [k, ENV[k]] }
+    @home = Dir.mktmpdir
+    ENV['HOME'] = @home
+    (ENV_KEYS - %w[HOME]).each {|k| ENV.delete(k) }
+    @cmd = BitClust::Subcommands::SetupCommand.new
+  end
+
+  def teardown
+    @saved.each {|k, v| v ? ENV[k] = v : ENV.delete(k) }
+    FileUtils.rm_rf(@home)
+  end
+
+  def touch_config(path)
+    FileUtils.mkdir_p(File.dirname(path))
+    FileUtils.touch(path)
+  end
+
+  def test_layout_uses_xdg_when_nothing_exists
+    config_path, database_prefix, rubydoc_dir = @cmd.send(:layout)
+    assert_equal(File.join(@home, '.config', 'bitclust', 'config'), config_path.to_s)
+    assert_equal(File.join(@home, '.local', 'share', 'bitclust', 'db'), database_prefix)
+    assert_equal(File.join(@home, '.local', 'share', 'bitclust', 'rubydoc'), rubydoc_dir.to_s)
+  end
+
+  def test_layout_keeps_legacy_when_only_legacy_config_exists
+    touch_config(File.join(@home, '.bitclust', 'config'))
+    config_path, database_prefix, rubydoc_dir = @cmd.send(:layout)
+    assert_equal(File.join(@home, '.bitclust', 'config'), config_path.to_s)
+    assert_equal(File.join(@home, '.bitclust', 'db'), database_prefix)
+    assert_equal(File.join(@home, '.bitclust', 'rubydoc'), rubydoc_dir.to_s)
+  end
+
+  def test_layout_uses_xdg_when_both_exist
+    touch_config(File.join(@home, '.bitclust', 'config'))
+    touch_config(File.join(@home, '.config', 'bitclust', 'config'))
+    config_path, database_prefix, _rubydoc_dir = @cmd.send(:layout)
+    assert_equal(File.join(@home, '.config', 'bitclust', 'config'), config_path.to_s)
+    assert_equal(File.join(@home, '.local', 'share', 'bitclust', 'db'), database_prefix)
+  end
+end
+
+# setup --prepare が layout の選択どおりに設定ファイルを書くこと
+# (checkout はネットワークに出るのでスタブする)
+class TestSetupCommandPrepare < Test::Unit::TestCase
+  ENV_KEYS = %w[HOME XDG_CONFIG_HOME XDG_DATA_HOME XDG_CACHE_HOME].freeze
+
+  def setup
+    @saved = ENV_KEYS.to_h {|k| [k, ENV[k]] }
+    @home = Dir.mktmpdir
+    ENV['HOME'] = @home
+    (ENV_KEYS - %w[HOME]).each {|k| ENV.delete(k) }
+    @cmd = BitClust::Subcommands::SetupCommand.new
+    stub(@cmd).checkout {|_dir| nil }
+  end
+
+  def teardown
+    @saved.each {|k, v| v ? ENV[k] = v : ENV.delete(k) }
+    FileUtils.rm_rf(@home)
+  end
+
+  def test_prepare_writes_config_under_xdg_config_home
+    @cmd.send(:prepare)
+    config_path = File.join(@home, '.config', 'bitclust', 'config')
+    assert_true(File.exist?(config_path))
+    config = YAML.load_file(config_path)
+    assert_equal(File.join(@home, '.local', 'share', 'bitclust', 'db'), config[:database_prefix])
+  end
+
+  def test_prepare_keeps_legacy_layout_when_legacy_config_exists
+    legacy_config = File.join(@home, '.bitclust', 'config')
+    FileUtils.mkdir_p(File.dirname(legacy_config))
+    versions = @cmd.instance_variable_get(:@versions)
+    File.write(legacy_config, {
+      :database_prefix => File.join(@home, '.bitclust', 'db'),
+      :encoding        => 'utf-8',
+      :versions        => versions,
+      :default_version => versions.max,
+      :mdtree          => File.join(@home, '.bitclust', 'rubydoc', 'manual', 'api'),
+      :capi_mdtree     => File.join(@home, '.bitclust', 'rubydoc', 'manual', 'capi'),
+      :baseurl         => 'http://localhost:10080',
+      :port            => '10080',
+      :pid_file        => '/tmp/bitclust.pid',
+    }.to_yaml)
+    @cmd.send(:prepare)
+    assert_false(File.exist?(File.join(@home, '.config', 'bitclust', 'config')))
+    config = YAML.load_file(legacy_config)
+    assert_equal(File.join(@home, '.bitclust', 'db'), config[:database_prefix])
+  end
+end
+
+# setup --purge が新旧すべての置き場所を消すこと
+class TestSetupCommandPurge < Test::Unit::TestCase
+  ENV_KEYS = %w[HOME XDG_CONFIG_HOME XDG_DATA_HOME XDG_CACHE_HOME].freeze
+
+  def setup
+    @saved = ENV_KEYS.to_h {|k| [k, ENV[k]] }
+    @home = Dir.mktmpdir
+    ENV['HOME'] = @home
+    (ENV_KEYS - %w[HOME]).each {|k| ENV.delete(k) }
+    @cmd = BitClust::Subcommands::SetupCommand.new
+  end
+
+  def teardown
+    @saved.each {|k, v| v ? ENV[k] = v : ENV.delete(k) }
+    FileUtils.rm_rf(@home)
+  end
+
+  def test_purge_removes_legacy_xdg_config_data_and_cache_dirs
+    dirs = [
+      File.join(@home, '.bitclust'),
+      File.join(@home, '.config', 'bitclust'),
+      File.join(@home, '.local', 'share', 'bitclust'),
+      File.join(@home, '.cache', 'bitclust'),
+    ]
+    dirs.each {|dir| FileUtils.mkdir_p(dir) }
+    out, _err = capture_output do
+      assert_raise(SystemExit) { @cmd.send(:purge) }
+    end
+    dirs.each do |dir|
+      assert_false(File.exist?(dir), dir)
+      assert_include(out, dir)
+    end
+  end
+
+  def test_purge_is_fine_when_nothing_exists
+    assert_raise(SystemExit) { capture_output { @cmd.send(:purge) } }
+  end
+end

data/test/test_statichtml_command.rb

@@ -202,3 +202,140 @@ class TestStatichtmlSitemap < Test::Unit::TestCase
     end
   end
 end
+
+class TestStatichtmlMarkdownOutput < Test::Unit::TestCase
+  def build_command(markdown_output: true)
+    cmd = BitClust::Subcommands::StatichtmlCommand.new
+    argv = ["--fs-casesensitive"]
+    argv.unshift("--markdown-output") if markdown_output
+    cmd.parse(argv)
+    cmd.instance_variable_set(:@verbose, false)
+    cmd.send(:create_manager_config)
+    urlmapper = cmd.instance_variable_get(:@urlmapper)
+    urlmapper.bitclust_html_base = '..'
+    cmd.instance_variable_set(:@markdown_exporter,
+                              BitClust::MarkdownExporter.new(urlmapper, '.html'))
+    cmd
+  end
+
+  def markdown_db
+    db = BitClust::MethodDatabase.dummy({ "version" => "3.4" })
+    def db.properties = { 'source_format' => 'markdown' }
+    db
+  end
+
+  def test_option_defaults_to_false
+    cmd = BitClust::Subcommands::StatichtmlCommand.new
+    assert_false(cmd.instance_variable_get(:@markdown_output))
+  end
+
+  def test_option_is_parsed
+    cmd = BitClust::Subcommands::StatichtmlCommand.new
+    cmd.parse(["--markdown-output"])
+    assert_true(cmd.instance_variable_get(:@markdown_output))
+  end
+
+  def test_markdown_path_replaces_html_suffix
+    cmd = BitClust::Subcommands::StatichtmlCommand.new
+    assert_equal("out/class/ARGF.class.md",
+                 cmd.send(:markdown_path, Pathname.new("out/class/ARGF.class.html")).to_s)
+  end
+
+  def test_writes_md_next_to_html_for_markdown_db
+    Dir.mktmpdir do |dir|
+      cmd = build_command
+      db = markdown_db
+      entry = BitClust::DocEntry.new(db, "help")
+      entry.title = "ヘルプ"
+      entry.source = "\n[c:String] を参照。\n"
+      path = Pathname.new(dir) + "doc/help.html"
+      FileUtils.mkdir_p(path.dirname)
+      cmd.send(:create_markdown_file_p, entry, path, db)
+      md = File.read(File.join(dir, "doc", "help.md"))
+      assert_equal("# ヘルプ\n\n[String](../class/String.md) を参照。\n", md)
+    end
+  end
+
+  def test_skips_md_for_non_markdown_db
+    Dir.mktmpdir do |dir|
+      cmd = build_command
+      db = BitClust::MethodDatabase.dummy({ "version" => "3.4" })
+      def db.properties = {}
+      entry = BitClust::DocEntry.new(db, "help")
+      entry.title = "ヘルプ"
+      entry.source = "\n本文\n"
+      path = Pathname.new(dir) + "doc/help.html"
+      FileUtils.mkdir_p(path.dirname)
+      cmd.send(:create_markdown_file_p, entry, path, db)
+      assert_false(File.exist?(File.join(dir, "doc", "help.md")))
+    end
+  end
+
+  def test_warns_when_db_is_not_markdown
+    cmd = build_command
+    db = BitClust::MethodDatabase.dummy({ "version" => "3.4" })
+    def db.properties = {}
+    orig_stderr, $stderr = $stderr, StringIO.new
+    begin
+      cmd.send(:warn_markdown_output_skipped, db, "the method database")
+      assert_match(/--markdown-output is ignored/, $stderr.string)
+    ensure
+      $stderr = orig_stderr
+    end
+  end
+
+  def test_no_warning_without_option
+    cmd = build_command(markdown_output: false)
+    db = BitClust::MethodDatabase.dummy({ "version" => "3.4" })
+    def db.properties = {}
+    orig_stderr, $stderr = $stderr, StringIO.new
+    begin
+      cmd.send(:warn_markdown_output_skipped, db, "the method database")
+      assert_equal("", $stderr.string)
+    ensure
+      $stderr = orig_stderr
+    end
+  end
+end
+
+class TestStatichtmlVersionSwitcher < Test::Unit::TestCase
+  def build_command(themedir, outputdir)
+    cmd = BitClust::Subcommands::StatichtmlCommand.new
+    cmd.instance_variable_set(:@manager_config, { :themedir => Pathname.new(themedir) })
+    cmd.instance_variable_set(:@outputdir, Pathname.new(outputdir))
+    cmd.instance_variable_set(:@verbose, false)
+    cmd
+  end
+
+  def test_version_switcher_js_is_copied
+    Dir.mktmpdir do |dir|
+      themedir = File.join(dir, 'theme')
+      outputdir = File.join(dir, 'out')
+      FileUtils.mkdir_p(File.join(themedir, 'js'))
+      FileUtils.mkdir_p(outputdir)
+      File.write(File.join(themedir, 'js', 'version_switcher.js'), "// vs\n")
+      cmd = build_command(themedir, outputdir)
+      cmd.send(:copy_version_switcher_script)
+      assert_true(File.file?(File.join(outputdir, 'js', 'version_switcher.js')))
+    end
+  end
+
+  # An older themedir without the file must not abort the whole build.
+  def test_theme_without_version_switcher_js_is_tolerated
+    Dir.mktmpdir do |dir|
+      themedir = File.join(dir, 'theme')
+      outputdir = File.join(dir, 'out')
+      FileUtils.mkdir_p(themedir)
+      FileUtils.mkdir_p(outputdir)
+      cmd = build_command(themedir, outputdir)
+      orig_stderr, $stderr = $stderr, StringIO.new
+      begin
+        assert_nothing_raised { cmd.send(:copy_version_switcher_script) }
+        assert_match(/version_switcher\.js not found/, $stderr.string)
+      ensure
+        $stderr = orig_stderr
+      end
+      assert_false(File.exist?(File.join(outputdir, 'js', 'version_switcher.js')))
+    end
+  end
+end

data/test/test_syntax_highlighter.rb

@@ -123,6 +123,98 @@ class TestSyntaxHighlighter < Test::Unit::TestCase
     assert_equal(expected, highlight(source))
   end
 
+  sub_test_case "symbol span" do
+    test 'ivar symbol' do
+      source = "x = :@records\n"
+      expected = "x <span class=\"o\">=</span> <span class=\"ss\">:@records</span>\n"
+      assert_equal(expected, highlight(source))
+    end
+
+    test 'cvar symbol' do
+      source = "x = :@@cv\n"
+      expected = "x <span class=\"o\">=</span> <span class=\"ss\">:@@cv</span>\n"
+      assert_equal(expected, highlight(source))
+    end
+
+    test 'gvar symbol' do
+      source = "x = :$stdout\n"
+      expected = "x <span class=\"o\">=</span> <span class=\"ss\">:$stdout</span>\n"
+      assert_equal(expected, highlight(source))
+    end
+
+    test 'operator symbols' do
+      source = <<~END
+        a = :+
+        b = :<<
+        c = :[]
+        d = :[]=
+        e = :<=>
+        f = :!
+      END
+      expected = <<~END
+        a <span class="o">=</span> <span class="ss">:+</span>
+        b <span class="o">=</span> <span class="ss">:&lt;&lt;</span>
+        c <span class="o">=</span> <span class="ss">:[]</span>
+        d <span class="o">=</span> <span class="ss">:[]=</span>
+        e <span class="o">=</span> <span class="ss">:&lt;=&gt;</span>
+        f <span class="o">=</span> <span class="ss">:!</span>
+      END
+      assert_equal(expected, highlight(source))
+    end
+
+    test '%s dynamic symbol literal' do
+      source = "x = %s!sym!\n"
+      expected = "x <span class=\"o\">=</span> <span class=\"ss\">%s!sym!</span>\n"
+      assert_equal(expected, highlight(source))
+    end
+
+    test 'double-quoted dynamic symbol' do
+      source = "x = :\"dyn\"\n"
+      expected = "x <span class=\"o\">=</span> <span class=\"ss\">:&quot;dyn&quot;</span>\n"
+      assert_equal(expected, highlight(source))
+    end
+
+    test 'well-formedness of mixed symbol spans' do
+      source = <<~END
+        x = :@records
+        y = :@@cv
+        z = :$stdout
+        a = :+
+        b = :<<
+        c = :[]
+        s = %s!sym!
+        d = :"dyn"
+      END
+      result = highlight(source)
+      assert_equal(result.scan('<span').size, result.scan('</span>').size)
+    end
+
+    test 'symbol does not leak the stack into later tokens' do
+      source = <<~END
+        x = :@records
+        def foo
+        end
+      END
+      baseline = highlight("def foo\nend\n")
+      result = highlight(source)
+      assert(
+        result.end_with?(baseline),
+        "expected result to end with unaffected `def foo/end` rendering:\n" \
+        "  baseline: #{baseline.inspect}\n" \
+        "  result:   #{result.inspect}"
+      )
+    end
+
+    test 'label is not treated as a symbol' do
+      source = "h = { a: 1 }\nfoo(:x, k: 2)\n"
+      result = highlight(source)
+      assert_equal(result.scan('<span').size, result.scan('</span>').size)
+      assert_match(%r{<span class="ss">a:</span>}, result)
+      assert_match(%r{<span class="ss">k:</span>}, result)
+      assert_match(%r{<span class="ss">:x</span>}, result)
+    end
+  end
+
   test 'one liner module' do
     source = <<~END
       module Foo; end
@@ -142,4 +234,36 @@ class TestSyntaxHighlighter < Test::Unit::TestCase
     END
     assert_equal(expected, highlight(source))
   end
+
+  sub_test_case "heredoc argument and quoted label" do
+    def assert_balanced(html)
+      assert_equal html.scan(/<span\b/).size, html.scan(%r{</span>}).size, html
+    end
+
+    test 'identifier after a heredoc argument is rendered normally' do
+      html = highlight("method(arg1, <<LABEL, arg2)\n    x\nLABEL\n")
+      assert_include(html, ', arg2<span class="p">)</span>')
+      assert_balanced(html)
+    end
+
+    test 'block argument after a heredoc argument' do
+      html = highlight("ERB.new(<<~'END_PRODUCT', eoutvar: \"@product\").result b\n  x\nEND_PRODUCT\n")
+      assert_balanced(html)
+      assert_not_include(html, '<span class="no">b')
+    end
+
+    test 'quoted symbol keys close the string span' do
+      html = highlight(%q({ "a":"A", 'b':"B" }) + "\n")
+      assert_balanced(html)
+      assert_include(html, %q(<span class="s1">'b':</span>))
+      assert_include(html, %q(<span class="s2">a</span><span class="s2">&quot;:</span>))
+    end
+
+    test 'quoted symbol key does not leak the stack' do
+      with = highlight(%q({ "a":"A" }) + "\ndef foo\nend\n")
+      without = highlight("def foo\nend\n")
+      assert_include(with, without.lines[0].chomp)
+      assert_balanced(with)
+    end
+  end
 end