wp2txt 2.3.4 → 2.4.0

data/lib/wp2txt/metadata_index.rb

@@ -39,9 +39,10 @@ module Wp2txt
 
     # Normalize a page title the way MediaWiki treats titles:
     # underscores to spaces, trimmed, first letter capitalized
-    def self.normalize_title(name)
+    def self.normalize_title(name, case_rule: "first-letter")
       n = name.to_s.tr("_", " ").strip.squeeze(" ")
       return n if n.empty?
+      return n if case_rule == "case-sensitive"
 
       n[0].upcase + n[1..].to_s
     end
@@ -161,6 +162,69 @@ module Wp2txt
         skipped_invalid: meta[:langlinks_skipped_invalid].to_i }
     end
 
+    # Provenance and counts of imported page properties, or nil
+    def page_props_provenance
+      return nil unless File.exist?(@db_path)
+
+      meta = read_metadata
+      return nil unless meta && meta[:page_props_imported_at] && page_properties_imported?
+
+      { source: meta[:page_props_source],
+        source_size: meta[:page_props_source_size].to_i,
+        source_sha256: meta[:page_props_source_sha256],
+        imported_at: meta[:page_props_imported_at],
+        imported_with: meta[:page_props_wp2txt_version],
+        page_count: meta[:page_props_page_count].to_i,
+        qid_count: meta[:page_props_qid_count].to_i,
+        disambiguation_count: meta[:page_props_disambiguation_count].to_i,
+        sort_key_count: meta[:page_props_sort_key_count].to_i,
+        skipped_invalid_sort_keys: meta[:page_props_skipped_invalid_sort_keys].to_i }
+    end
+
+    # How incoming links were counted (wp2txt --count-links), or nil
+    def links_provenance
+      return nil unless File.exist?(@db_path)
+
+      meta = read_metadata
+      return nil unless meta && meta[:links_counted_at]
+
+      { counted_at: meta[:links_counted_at],
+        rule_version: meta[:links_rule_version],
+        counted_with: meta[:links_wp2txt_version],
+        article_count: meta[:links_article_count].to_i,
+        with_inlinks: meta[:links_with_inlinks].to_i }
+    end
+
+    # An incomplete import must not be reported as an absent property.
+    def self.page_properties_imported?(db)
+      !!db.get_first_value(<<~SQL)
+        SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'page_properties'
+        AND EXISTS (SELECT 1 FROM metadata WHERE key = 'page_props_imported_at')
+      SQL
+    end
+
+    def page_properties_imported?
+      File.exist?(@db_path) && self.class.page_properties_imported?(open_db)
+    rescue SQLite3::Exception
+      false
+    end
+
+    def self.property_values(row = nil)
+      qid, sort_key, disambiguation = row
+      { qid: qid, sort_key: sort_key, disambiguation: disambiguation == 1 }
+    end
+
+    # nil means not imported; null/false values mean imported but absent.
+    def properties_for(page_id)
+      return nil unless page_properties_imported?
+
+      self.class.property_values(open_db.get_first_row(
+        "SELECT qid, sort_key, disambiguation FROM page_properties WHERE page_id = ?", [page_id]
+      ))
+    rescue SQLite3::Exception
+      nil
+    end
+
     def close
       @db&.close
       @db = nil
@@ -230,7 +294,7 @@ module Wp2txt
       end
     end
 
-    def finalize_build!(source_path)
+    def finalize_build!(source_path, case_rule: "first-letter")
       db = open_db
       db.execute("CREATE INDEX IF NOT EXISTS idx_pages_title ON pages(title)")
       db.execute("CREATE INDEX IF NOT EXISTS idx_pc_category ON page_categories(category)")
@@ -248,6 +312,7 @@ module Wp2txt
         source_size: stat.size,
         source_mtime: stat.mtime.to_i,
         dump_name: dump_name,
+        case_rule: case_rule,
         built_at: Time.now.utc.iso8601
       )
       db.execute("ANALYZE")
@@ -629,6 +694,7 @@ module Wp2txt
     # Build the index. Yields (batches_done, batches_total) after each batch.
     # @return [MetadataIndex] the built index
     def build(&progress)
+      case_rule = case_rule_from_header
       index = MetadataIndex.new(@db_path)
       index.prepare_build!
       # Close before Parallel forks workers so children do not inherit a
@@ -652,10 +718,20 @@ module Wp2txt
         self.class.scan_batch(@multistream_path, batch)
       end
 
-      index.finalize_build!(@multistream_path)
+      index.finalize_build!(@multistream_path, case_rule: case_rule)
       index
     end
 
+    # The siteinfo may occupy its own stream before the first page offset.
+    def case_rule_from_header
+      return "first-letter" if @stream_offsets.empty?
+
+      header_end = @stream_offsets.first.positive? ? @stream_offsets.first : @stream_offsets[1]
+      xml = self.class.decompress_bz2(File.binread(@multistream_path, header_end))
+      siteinfo = xml[%r{<siteinfo\b[^>]*>(.*?)</siteinfo>}m, 1].to_s
+      siteinfo[%r{<case>\s*(first-letter|case-sensitive)\s*</case>}, 1] || "first-letter"
+    end
+
     # Scan a batch of [offset, next_offset] stream pairs.
     # Runs inside worker processes: must not touch SQLite.
     def self.scan_batch(multistream_path, offset_pairs)

data/lib/wp2txt/multistream.rb

@@ -866,6 +866,27 @@ module Wp2txt
       File.join(@cache_dir, "#{@lang}wiki-#{date}-langlinks.sql.gz")
     end
 
+    def page_props_url(date)
+      wiki = "#{@lang}wiki"
+      "#{DUMP_BASE_URL}/#{wiki}/#{date}/#{wiki}-#{date}-page_props.sql.gz"
+    end
+
+    def cached_page_props_path(date)
+      File.join(@cache_dir, "#{@lang}wiki-#{date}-page_props.sql.gz")
+    end
+
+    # Download the page_props dump for an explicit dump date (must match the index)
+    def download_page_props(date:, force: false)
+      path = cached_page_props_path(date)
+      return path if File.exist?(path) && !force
+
+      url = page_props_url(date)
+      puts "Downloading page_props: #{url}"
+      $stdout.flush
+      download_file(url, path)
+      path
+    end
+
     # Download the langlinks dump for an explicit dump date. The date MUST
     # come from the built metadata index (not latest_dump_date) so the
     # imported links stay pinned to the indexed dump version.

data/lib/wp2txt/page_props_importer.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require "time"
+require "digest"
+require_relative "sql_dump_reader"
+require_relative "version"
+
+module Wp2txt
+  # Imports Wikidata IDs, disambiguation flags, and default sort keys
+  # from the official page_props dump into the metadata index, as
+  # page_properties. Like langlinks, the dump must carry the same
+  # date as the index: IDs are only meaningful for the pages they came with.
+  class PagePropsImporter
+    BATCH_SIZE = 50_000
+
+    # (pp_page,'pp_propname','pp_value',pp_sortkey) — string classes accept
+    # escaped quotes and backslashes; sortkey is NULL or a number
+    TUPLE_REGEX = /\((\d+),'((?:[^'\\]|\\.)*)','((?:[^'\\]|\\.)*)',(?:NULL|[-+.\deE]+)\)/
+    QID_REGEX = /\AQ\d+\z/
+
+    def initialize(db_path)
+      @db_path = db_path
+    end
+
+    # "jawiki-20260901-page_props.sql.gz" => "jawiki-20260901"
+    def self.dump_name_of(path)
+      File.basename(path)[/\A[a-z0-9_\-]+?-\d{8}/]
+    end
+
+    # @return [Hash] { status: :imported | :already_imported, row_count:, provenance: }
+    def import!(source_path, force: false)
+      raise ArgumentError, "page_props file not found: #{source_path}" unless File.exist?(source_path)
+
+      db = SQLite3::Database.new(@db_path)
+      db.busy_timeout = 5000
+      dump_name = metadata_value(db, "dump_name")
+      raise ArgumentError, "metadata index is not built: #{@db_path}" unless dump_name
+
+      source_dump = self.class.dump_name_of(source_path)
+      unless source_dump && source_dump == dump_name
+        raise ArgumentError,
+              "dump version mismatch: the metadata index is #{dump_name} but the page_props file is " \
+              "#{source_dump || File.basename(source_path)} (versions must match; there is no override)"
+      end
+
+      if !force && (existing = imported_at(db))
+        return { status: :already_imported, imported_at: existing,
+                 row_count: db.get_first_value("SELECT COUNT(*) FROM page_properties").to_i, provenance: read_provenance(db) }
+      end
+
+      db.execute("DROP TABLE IF EXISTS page_qids") # replace the unreleased QID-only schema
+      db.execute("DROP TABLE IF EXISTS page_properties")
+      # A failed load must leave the index looking "not imported"
+      db.execute("DELETE FROM metadata WHERE key LIKE 'page\\_props\\_%' ESCAPE '\\'")
+      db.execute(<<~SQL)
+        CREATE TABLE page_properties (
+          page_id INTEGER PRIMARY KEY,
+          qid TEXT,
+          disambiguation INTEGER NOT NULL DEFAULT 0,
+          sort_key TEXT
+        )
+      SQL
+
+      rows_seen = 0
+      skipped_invalid = 0
+      batch = []
+      flush = lambda do
+        db.transaction do
+          stmt = db.prepare(<<~SQL)
+            INSERT INTO page_properties (page_id, qid, disambiguation, sort_key) VALUES (?, ?, ?, ?)
+            ON CONFLICT(page_id) DO UPDATE SET
+              qid = COALESCE(excluded.qid, page_properties.qid),
+              disambiguation = MAX(excluded.disambiguation, page_properties.disambiguation),
+              sort_key = COALESCE(excluded.sort_key, page_properties.sort_key)
+          SQL
+          batch.each { |row| stmt.execute(row) }
+          stmt.close
+        end
+        batch.clear
+      end
+
+      SqlDumpReader.each_insert_line(source_path, "page_props") do |line|
+        line.scan(TUPLE_REGEX) do |page, name, value|
+          rows_seen += 1
+          row = [page.to_i, nil, 0, nil]
+          case name
+          when "wikibase_item"
+            qid = SqlDumpReader.unescape(value)
+            next unless QID_REGEX.match?(qid)
+
+            row[1] = qid.force_encoding(Encoding::UTF_8)
+          when "disambiguation"
+            row[2] = 1
+          when "defaultsort"
+            key = SqlDumpReader.unescape(value).force_encoding(Encoding::UTF_8)
+            unless key.valid_encoding?
+              skipped_invalid += 1
+              next
+            end
+            row[3] = key
+          else
+            next
+          end
+          batch << row
+          flush.call if batch.size >= BATCH_SIZE
+        end
+      end
+      flush.call unless batch.empty?
+
+      if rows_seen.zero?
+        raise Wp2txt::Error, "no page_props rows found in #{File.basename(source_path)}; " \
+                             "the file may be empty or in an unrecognized format"
+      end
+
+      counts = db.get_first_row("SELECT COUNT(*), COUNT(qid), SUM(disambiguation), COUNT(sort_key) FROM page_properties")
+      row_count = counts[0]
+      stamp_provenance(db, source_path, counts, skipped_invalid)
+      { status: :imported, row_count: row_count, provenance: read_provenance(db) }
+    ensure
+      db&.close
+    end
+
+    private
+
+    def metadata_value(db, key)
+      db.get_first_value("SELECT value FROM metadata WHERE key = ?", [key])
+    rescue SQLite3::Exception
+      nil
+    end
+
+    def imported_at(db)
+      table = db.get_first_value("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'page_properties'")
+      table && metadata_value(db, "page_props_imported_at")
+    end
+
+    def stamp_provenance(db, source_path, counts, skipped_invalid)
+      values = {
+        page_props_source: File.basename(source_path),
+        page_props_source_size: File.size(source_path),
+        page_props_source_sha256: Digest::SHA256.file(source_path).hexdigest,
+        page_props_imported_at: Time.now.utc.iso8601,
+        page_props_wp2txt_version: Wp2txt::VERSION,
+        page_props_page_count: counts[0],
+        page_props_qid_count: counts[1],
+        page_props_disambiguation_count: counts[2].to_i,
+        page_props_sort_key_count: counts[3],
+        page_props_skipped_invalid_sort_keys: skipped_invalid
+      }
+      stmt = db.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)")
+      values.each { |k, v| stmt.execute([k.to_s, v.to_s]) }
+      stmt.close
+    end
+
+    def read_provenance(db)
+      {
+        source: metadata_value(db, "page_props_source"),
+        source_size: metadata_value(db, "page_props_source_size").to_i,
+        source_sha256: metadata_value(db, "page_props_source_sha256"),
+        imported_at: metadata_value(db, "page_props_imported_at"),
+        imported_with: metadata_value(db, "page_props_wp2txt_version"),
+        page_count: metadata_value(db, "page_props_page_count").to_i,
+        qid_count: metadata_value(db, "page_props_qid_count").to_i,
+        disambiguation_count: metadata_value(db, "page_props_disambiguation_count").to_i,
+        sort_key_count: metadata_value(db, "page_props_sort_key_count").to_i,
+        skipped_invalid_sort_keys: metadata_value(db, "page_props_skipped_invalid_sort_keys").to_i
+      }
+    end
+  end
+end

data/lib/wp2txt/sql_dump_reader.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Wp2txt
+  # Streams the rows of one table's INSERT statements out of an official
+  # MySQL table dump (.sql or .sql.gz), without loading the file whole.
+  #
+  # Dumps write each INSERT either on one line or with the header on its own
+  # line and one tuple per following line (current dumps do the latter), so
+  # every line of a statement is read up to its terminating semicolon.
+  # Statements for other tables are skipped.
+  #
+  # Lines are read as BINARY: string columns are VARBINARY and real dumps
+  # contain historically corrupted bytes. Callers match tuples with ASCII-only
+  # patterns and validate the captures themselves.
+  module SqlDumpReader
+    STATEMENT_START = /\A\s*INSERT\s+INTO\s/i
+
+    module_function
+
+    # @yield [String] each line (BINARY) that belongs to an INSERT statement for table
+    def each_insert_line(source_path, table)
+      header = /\A\s*INSERT\s+INTO\s+`#{Regexp.escape(table)}`\s+VALUES\b/i
+      io = if source_path.end_with?(".gz")
+             # GzipReader ignores set_encoding; the encoding must be given at open time
+             Zlib::GzipReader.open(source_path, encoding: Encoding::BINARY.to_s)
+           else
+             File.open(source_path, "rb")
+           end
+      inside = false
+      begin
+        io.each_line do |line|
+          inside = header.match?(line) if STATEMENT_START.match?(line)
+          next unless inside
+
+          inside = false if line.rstrip.end_with?(";")
+          yield line
+        end
+      ensure
+        io.close
+      end
+    end
+
+    UNESCAPE_REGEX = /\\(.)/m
+    # MySQL backslash escapes inside mysqldump string literals
+    UNESCAPES = {
+      "0" => "\0", "'" => "'", '"' => '"', "b" => "\b", "n" => "\n",
+      "r" => "\r", "t" => "\t", "Z" => "\x1A", "\\" => "\\"
+    }.freeze
+
+    # Undo MySQL string escaping (\' \\ \n ...) in a captured value
+    def unescape(value)
+      value.gsub(UNESCAPE_REGEX) { UNESCAPES.fetch(Regexp.last_match(1), Regexp.last_match(1)) }
+    end
+  end
+end

data/lib/wp2txt/stream_processor.rb

@@ -19,8 +19,12 @@ module Wp2txt
 
     attr_reader :buffer_size, :pages_processed, :bytes_read, :redirects_skipped
 
-    def initialize(input_path, bz2_gem: false, adaptive_buffer: true, validate_bz2: true, skip_redirects: true)
+    # keep_raw_text: also hand back each article's wikitext as stored in the
+    # dump (before comment removal), as :raw_text among the with_ids values
+    def initialize(input_path, bz2_gem: false, adaptive_buffer: true, validate_bz2: true, skip_redirects: true,
+                   keep_raw_text: false)
       @input_path = input_path
+      @keep_raw_text = keep_raw_text
       @bz2_gem = bz2_gem
       @buffer = +""
       @pending_bytes = +"".b
@@ -257,6 +261,7 @@ module Wp2txt
       return nil unless Wp2txt.namespace_id(namespace).zero?
 
       text = text_node.content
+      raw_text = text if @keep_raw_text
 
       # Early redirect detection and skip (before expensive processing)
       # Redirects start with # or ＃ followed by redirect keyword and [[target]]
@@ -272,7 +277,9 @@ module Wp2txt
       end
 
       @pages_processed += 1
-      [title, text, Wp2txt.page_ids(page_xml)]
+      meta = Wp2txt.page_ids(page_xml)
+      meta[:raw_text] = raw_text if @keep_raw_text
+      [title, text, meta]
     rescue Nokogiri::XML::SyntaxError
       # Skip malformed XML
       nil

data/lib/wp2txt/template_expander.rb

@@ -171,6 +171,19 @@ module Wp2txt
       nil
     end
 
+    # Templates whose rendering the text-cleaning stage defines (see
+    # Wp2txt#correct_inline_template), keyed by normalized name. Limited to
+    # kinds whose output does not depend on marker settings.
+    def rendered_by_cleaner?(template_name)
+      @rendered_by_cleaner ||= [Wp2txt::RUBY_TEXT_TEMPLATES, Wp2txt::INTERWIKI_LINK_TEMPLATES]
+                               .flatten.to_set { |name| name.to_s.tr("_", " ").strip.downcase }
+      @rendered_by_cleaner.include?(template_name.tr("_", " "))
+    end
+
+    def text_renderer
+      @text_renderer ||= Object.new.extend(Wp2txt)
+    end
+
     def expand_single_template(content)
       parts = split_template_parts(content)
       return "" if parts.empty?
@@ -263,6 +276,12 @@ module Wp2txt
         # Handle lang-xx templates (e.g., lang-fr, lang-de, lang-ja)
         if template_name.start_with?("lang-")
           expand_lang_xx(template_name, params)
+        elsif rendered_by_cleaner?(template_name)
+          # These carry words the article needs (a reading, a link's display
+          # text). Deleting them dropped those words; leaving the raw template
+          # for later confused links that contain it (an image caption with a
+          # "|" inside). Render them now, with the cleaner's own rules.
+          text_renderer.correct_inline_template("{{#{expand(content)}}}")
         else
           @preserve_unknown ? "{{#{content}}}" : ""
         end

data/lib/wp2txt/utils.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "strscan"
+require_relative "wikitext_regions"
 require_relative "constants"
 require_relative "regex"
 require_relative "text_processing"
@@ -574,8 +575,9 @@ module Wp2txt
   # Helper to check if template name matches any in a list (case-insensitive)
   def template_matches?(name, template_list)
     return false if template_list.nil? || template_list.empty?
-    normalized_name = name.to_s.strip.downcase
-    template_list.any? { |t| t.downcase == normalized_name }
+    # MediaWiki treats "_" and " " in template names as the same character
+    normalized_name = name.to_s.tr("_", " ").strip.downcase
+    template_list.any? { |t| t.tr("_", " ").downcase == normalized_name }
   end
 
   def correct_inline_template(str, enabled_markers = [], extract_citations = false)
@@ -583,7 +585,7 @@ module Wp2txt
     return str unless str.include?("{{")
 
     process_nested_single_pass(str, "{{", "}}") do |contents|
-      parts = contents.split("|")
+      parts = WikitextRegions.split_pipes(contents)
       template_name = (parts[0] || "").strip
       template_name_lower = template_name.downcase
 

data/lib/wp2txt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wp2txt
-  VERSION = "2.3.4"
+  VERSION = "2.4.0"
 end

data/lib/wp2txt/wikitext_regions.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Wp2txt
+  # Literal regions suppress wikitext parsing. Galleries and timelines can
+  # contain links, but their contents are not the article's lead prose.
+  module WikitextRegions
+    LITERAL_TAGS = %w[nowiki pre math chem ce score syntaxhighlight source graph mapframe templatedata].freeze
+    NON_PROSE_TAGS = %w[gallery timeline].freeze
+    COMMENT = /<!--.*?(?:-->|\z)/m
+
+    def self.region_pattern(tags)
+      /<!--.*?(?:-->|\z)|<(?<tag>#{tags.join('|')})(?=[\s\/>])(?:"[^"]*"|'[^']*'|[^'">])*?(?:\/>|>.*?(?:<\/\k<tag>\s*>|\z))/mi
+    end
+
+    LITERAL_REGION = region_pattern(LITERAL_TAGS)
+    LEAD_REGION = region_pattern(LITERAL_TAGS + NON_PROSE_TAGS)
+    LITERAL_REGION_AT = /\G(?:#{LITERAL_REGION})/
+    LEAD_REGION_AT = /\G(?:#{LEAD_REGION})/
+
+    module_function
+
+    def end_at(text, offset, lead: false)
+      match = (lead ? LEAD_REGION_AT : LITERAL_REGION_AT).match(text, offset)
+      match.end(0) if match
+    end
+
+    def remove_literal(text)
+      text.gsub(LITERAL_REGION, "")
+    end
+
+    # One space per codepoint, including internal newlines: an excluded
+    # region must not introduce a paragraph or heading boundary.
+    def mask_lead(text)
+      text.gsub(LEAD_REGION) { |region| " " * region.length }
+    end
+
+    def split_pipes(text)
+      parts = [+""]
+      stack = []
+      i = 0
+      while i < text.length
+        two = text[i, 2]
+        if text[i] == "<" && (stop = end_at(text, i))
+          parts.last << text[i...stop]
+          i = stop
+        elsif ["{{", "[["].include?(two)
+          stack << (two == "{{" ? "}}" : "]]")
+          parts.last << two
+          i += 2
+        elsif !stack.empty? && two == stack.last
+          stack.pop
+          parts.last << two
+          i += 2
+        else
+          if text[i] == "|" && stack.empty?
+            parts << +""
+          else
+            parts.last << text[i]
+          end
+          i += 1
+        end
+      end
+      parts
+    end
+  end
+end

data/spec/docs_sync_spec.rb

@@ -37,14 +37,14 @@ RSpec.describe "documentation surface sync" do
     expect(phantom).to be_empty, "documented tools that do not exist: #{phantom.join(', ')}"
   end
 
-  # Tripwire: tracked files must not contain tokens listed in .private-doc-tokens,
+  # Tripwire: tracked files must not contain tokens listed in .local/doc-tokens,
   # an untracked, machine-local file (one substring per line; # starts a comment).
   # The file exists only on machines that maintain such a list; everywhere else
   # (CI, other contributors) this example skips — loudly, so a silently dead
   # check cannot be mistaken for a passing one.
   it "keeps machine-local private tokens out of tracked files" do
-    token_file = File.join(repo_root, ".private-doc-tokens")
-    skip "SKIPPED: no .private-doc-tokens on this machine — tripwire not checked" unless File.exist?(token_file)
+    token_file = File.join(repo_root, ".local", "doc-tokens")
+    skip "SKIPPED: no .local/doc-tokens on this machine — tripwire not checked" unless File.exist?(token_file)
 
     tokens = File.readlines(token_file, encoding: "UTF-8")
                  .map(&:strip).reject { |t| t.empty? || t.start_with?("#") }

data/spec/langlinks_importer_spec.rb

@@ -65,6 +65,33 @@ RSpec.describe Wp2txt::LanglinksImporter do
     rows
   end
 
+  # Current dumps put the INSERT header on its own line and one tuple per line
+  MULTILINE_SQL = <<~MSQL
+    INSERT INTO `langlinks` VALUES
+    (1,'en','Film A'),
+    (1,'ja','映画A'),
+    (2,'en','It\\'s a Film; Really');
+    INSERT INTO `pagelinks` VALUES
+    (9,'Ignored',0);
+    INSERT INTO `langlinks` VALUES
+    (3,'fr','Film B');
+  MSQL
+
+  describe "dumps with one tuple per line" do
+    it "imports every tuple of every langlinks statement, and nothing else" do
+      path = write_langlinks("testwiki-20260101-langlinks.sql.gz", MULTILINE_SQL, gzip: true)
+      expect(import(path)[:row_count]).to eq(4)
+      expect(langlinks_rows).to contain_exactly(
+        [1, "en", "Film A"], [1, "ja", "映画A"], [2, "en", "It's a Film; Really"], [3, "fr", "Film B"]
+      )
+    end
+
+    it "refuses to report success when no rows could be read" do
+      path = write_langlinks("testwiki-20260101-langlinks.sql", "-- nothing here\nUNLOCK TABLES;\n")
+      expect { import(path) }.to raise_error(Wp2txt::Error, /no langlinks rows found/)
+    end
+  end
+
   describe "parsing and normalization" do
     it "imports tuples with escapes, commas, parens, and multiple INSERT statements" do
       path = write_langlinks("testwiki-20260101-langlinks.sql")