Class: Jekyll::L10n::PoFileReader

Inherits:
Object
  • Object
show all
Defined in:
lib/jekyll-l10n/po_file/reader.rb

Overview

Parses GNU Gettext PO files into translation hashes.

PoFileReader reads and parses PO files in standard GNU Gettext format, supporting multiple parsing modes: simple (msgid -> msgstr), with references (for debugging), and with merge metadata (including fuzzy flags). It handles multi-line strings, comment extraction, and various escape sequences. Both instance-based and class-based APIs are supported for backward compatibility.

Key responsibilities:

  • Parse PO files into translation hashes
  • Handle msgid/msgstr pairs with continuation lines
  • Extract and preserve reference comments (file location references)
  • Extract and preserve fuzzy flags during merging
  • Parse multi-line strings with proper escaping
  • Support three modes: simple, with_references, and for_merge
  • Handle both file paths and inline content strings

rubocop:disable Metrics/ClassLength

Examples:

reader = PoFileReader.new('_locales/es.po')
simple = reader.parse  # { "msgid" => "msgstr" }
with_refs = reader.parse_with_references  # { "msgid" => { msgstr: "...", reference:
  "..." } }
for_merge = reader.parse_for_merge  # { "msgid" => { msgstr: "...", reference:
  "...", fuzzy: false } }

Constant Summary collapse

MSGID_PATTERN =

rubocop:enable Metrics/ClassLength

/^msgid ['"](.*)['"] *$/.freeze
MSGSTR_PATTERN = 
/^msgstr ['"](.*)['"] *$/.freeze
NO_REFERENCE = 
nil

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(po_path_or_content = nil) ⇒ PoFileReader

Initialize a new PoFileReader.

Accepts either a file path (if file exists) or inline PO content. Determines which based on whether the path exists in the filesystem. Defaults to nil, which initializes the reader with empty content.

Parameters:

  • po_path_or_content (String, nil) (defaults to: nil) —

    File path to PO file or inline content string (defaults to nil)



49
50
51
52
53
54
55
56
57
58
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 49

def initialize(po_path_or_content = nil)
  # Support both file path and content string
  if po_path_or_content && File.exist?(po_path_or_content.to_s)
    @po_path = po_path_or_content
    @content = nil
  else
    @content = po_path_or_content
    @po_path = nil
  end
end

Instance Attribute Details

#po_path ⇒ Object (readonly)

Returns the value of attribute po_path.



39
40
41
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 39

def po_path
  @po_path
end

Class Method Details

.build_translation_entry(msgstr, reference, fuzzy, previous_msgid = nil, with_metadata: false) ⇒ Object

rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity



460
461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 460

def self.build_translation_entry(msgstr, reference, fuzzy, previous_msgid = nil,
                                 with_metadata: false)
  # Simple format when no metadata requested and none provided
  return msgstr if !with_metadata && reference.nil? && fuzzy.nil? && previous_msgid.nil?

  # Build metadata hash based on what's provided
  entry = { msgstr: msgstr }
  entry[:reference]      = reference      unless reference.nil?
  entry[:fuzzy]          = fuzzy          unless fuzzy.nil?
  entry[:previous_msgid] = previous_msgid unless previous_msgid.nil?
  entry[:comment]        = nil if !fuzzy.nil? || !reference.nil?
  entry
end

.collect_continuation_lines(lines, start_idx, values, delimiter) ⇒ Object 



377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 377

def self.collect_continuation_lines(lines, start_idx, values, delimiter)
  idx = start_idx

  while idx < lines.length
    cont_line = lines[idx].strip

    break if stop_collecting?(cont_line)

    break unless continuation_line?(cont_line)

    unescaped = unescape_string(cont_line[1...-1], delimiter)
    values << unescaped
    idx += 1

  end

  combined_value = values.join

  { value: combined_value, next_line: idx }
end

.continuation_line?(line) ⇒ Boolean

Returns:

  • (Boolean) 


398
399
400
401
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 398

def self.continuation_line?(line)
  (line.start_with?('"') && line.end_with?('"')) ||
    (line.start_with?("'") && line.end_with?("'"))
end

.extract_metadata_before_msgid(lines, msgid_idx, include_fuzzy: false) ⇒ Object

Unified metadata extraction: extracts reference, fuzzy flag, and previous msgid. rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 301

def self.extract_metadata_before_msgid(lines, msgid_idx, include_fuzzy: false)
  reference      = nil
  fuzzy          = false
  previous_msgid = nil
  comments_end   = msgid_idx - 1

  while comments_end >= 0
    comment_line = lines[comments_end].strip
    break unless comment_line.start_with?('#') || comment_line.empty?

    reference      = extract_reference_from_line(comment_line) || reference
    previous_msgid = extract_previous_msgid_from_line(comment_line) || previous_msgid if include_fuzzy
    fuzzy          = true if include_fuzzy && fuzzy_line?(comment_line)

    comments_end -= 1
  end

  include_fuzzy ? [reference, fuzzy, previous_msgid] : reference
end

.extract_msgid_and_continuation(lines, start_idx) ⇒ Object 



354
355
356
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 354

def self.extract_msgid_and_continuation(lines, start_idx)
  extract_po_field(lines, start_idx, MSGID_PATTERN)
end

.extract_msgstr_and_continuation(lines, start_idx) ⇒ Object 



358
359
360
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 358

def self.extract_msgstr_and_continuation(lines, start_idx)
  extract_po_field(lines, start_idx, MSGSTR_PATTERN)
end

.extract_po_field(lines, start_idx, pattern) ⇒ Object 



362
363
364
365
366
367
368
369
370
371
372
373
374
375
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 362

def self.extract_po_field(lines, start_idx, pattern)
  line = lines[start_idx].strip

  match = line.match(pattern)
  if match
    delimiter = line[match.begin(1) - 1]
    values = [unescape_string(match[1], delimiter)]
  else
    values = []
    delimiter = '"'
  end

  collect_continuation_lines(lines, start_idx + 1, values, delimiter)
end

.extract_previous_msgid_from_line(comment_line) ⇒ Object

Parse a #| msgid "..." previous-msgid comment line.



326
327
328
329
330
331
332
333
334
335
336
337
338
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 326

def self.extract_previous_msgid_from_line(comment_line)
  return nil unless comment_line.start_with?('#|') && comment_line.include?('msgid')

  raw = comment_line.sub(/^#\|\s*msgid\s*/, '').strip
  # Strip surrounding quotes and unescape
  if raw.start_with?('"') && raw.end_with?('"')
    unescape_string(raw[1...-1], '"')
  elsif raw.start_with?("'") && raw.end_with?("'")
    unescape_string(raw[1...-1], "'")
  else
    raw
  end
end

.extract_reference_and_fuzzy_before_msgid(lines, msgid_idx) ⇒ Object

Backward compatibility wrapper — now returns [reference, fuzzy, previous_msgid]



350
351
352
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 350

def self.extract_reference_and_fuzzy_before_msgid(lines, msgid_idx)
  extract_metadata_before_msgid(lines, msgid_idx, include_fuzzy: true)
end

.extract_reference_before_msgid(lines, msgid_idx) ⇒ Object

Backward compatibility wrapper



345
346
347
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 345

def self.extract_reference_before_msgid(lines, msgid_idx)
  extract_metadata_before_msgid(lines, msgid_idx, include_fuzzy: false)
end

.extract_reference_from_line(comment_line) ⇒ Object 



321
322
323
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 321

def self.extract_reference_from_line(comment_line)
  comment_line.sub(/^#:\s*/, '').strip if comment_line.start_with?('#:')
end

.fuzzy_line?(comment_line) ⇒ Boolean

Returns:

  • (Boolean) 


340
341
342
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 340

def self.fuzzy_line?(comment_line)
  comment_line.start_with?('#,') && comment_line.include?('fuzzy')
end

.msgid_line?(line) ⇒ Boolean

Returns:

  • (Boolean) 


150
151
152
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 150

def self.msgid_line?(line)
  line.start_with?('msgid ')
end

.parse(po_path) ⇒ Hash

Parse a PO file (class method, for backward compatibility).

Parameters:

  • po_path (String) —

    Path to PO file

Returns:

  • (Hash) —

    Simple translation hash



112
113
114
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 112

def self.parse(po_path)
  new(po_path).parse
end

.parse_for_merge(po_path) ⇒ Hash

Parse a PO file for merging (class method, for backward compatibility).

Parameters:

  • po_path (String) —

    Path to PO file

Returns:

  • (Hash) —

    Translation hash with merge metadata



128
129
130
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 128

def self.parse_for_merge(po_path)
  new(po_path).parse_for_merge
end

.parse_for_translation(po_path) ⇒ Hash

Parse a PO file for translation injection, excluding fuzzy entries (class method).

Parameters:

  • po_path (String) —

    Path to PO file

Returns:

  • (Hash) —

    Simple translation hash { msgid => msgstr }, fuzzy entries omitted



136
137
138
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 136

def self.parse_for_translation(po_path)
  new(po_path).parse_for_translation
end

.parse_with_references(po_path) ⇒ Hash

Parse a PO file with references (class method, for backward compatibility).

Parameters:

  • po_path (String) —

    Path to PO file

Returns:

  • (Hash) —

    Translation hash with references



120
121
122
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 120

def self.parse_with_references(po_path)
  new(po_path).parse_with_references
end

.process_line(lines, idx, translations) ⇒ Object

Backward compatibility wrapper



146
147
148
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 146

def self.process_line(lines, idx, translations)
  process_line_internal(lines, idx, translations, false)
end

.process_line_for_merge(lines, idx, translations) ⇒ Object 



260
261
262
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 260

def self.process_line_for_merge(lines, idx, translations)
  process_line_internal(lines, idx, translations, :merge)
end

.process_line_internal(lines, idx, translations, with_references) ⇒ Object 



264
265
266
267
268
269
270
271
272
273
274
275
276
277
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 264

def self.process_line_internal(lines, idx, translations, with_references)
  return idx + 1 if idx >= lines.length

  idx = skip_blank_and_comments(lines, idx)
  return idx if idx >= lines.length

  line = lines[idx].strip

  if msgid_line?(line)
    process_msgid_with_references(lines, idx, translations, with_references)
  else
    idx + 1
  end
end

.process_line_with_reference(lines, idx, translations) ⇒ Object

Backward compatibility wrappers



256
257
258
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 256

def self.process_line_with_reference(lines, idx, translations)
  process_line_internal(lines, idx, translations, true)
end

.process_msgid_msgstr_pair(lines, start_idx, translations, reference: nil, fuzzy: nil, previous_msgid: nil, with_mode: false) ⇒ Object

Unified method for processing msgid/msgstr pairs with optional reference and fuzzy metadata with_mode: false (default, simple format), true (with reference), :merge (with both) rubocop:disable Metrics/ParameterLists, Metrics/AbcSize, Metrics/PerceivedComplexity



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 175

def self.process_msgid_msgstr_pair(lines, start_idx, translations,
                                   reference: nil, fuzzy: nil, previous_msgid: nil,
                                   with_mode: false)
  # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize, Metrics/PerceivedComplexity
  # Handle nil sentinel values (from NO_REFERENCE constant)
  reference = nil if reference == NO_REFERENCE
  fuzzy = nil if fuzzy == NO_REFERENCE

  msgid = extract_msgid_and_continuation(lines, start_idx)
  msgid_value = msgid[:value]
  i = msgid[:next_line]

  if i < lines.length && lines[i].strip.start_with?('msgstr ')
    msgstr = extract_msgstr_and_continuation(lines, i)
    msgstr_value = msgstr[:value]
    i = msgstr[:next_line]

    # Always use metadata format if in reference or merge mode
    with_metadata = with_mode == true || with_mode == :merge || !reference.nil? || !fuzzy.nil?
    store_translation(
      translations, msgid_value, msgstr_value,
      reference: reference, fuzzy: fuzzy, previous_msgid: previous_msgid,
      with_metadata: with_metadata
    )
  else
    i += 1
  end

  i
end

.process_msgid_msgstr_pair_internal(lines, start_idx, translations, reference = nil, fuzzy = nil) ⇒ Object

Backward compatibility alias



222
223
224
225
226
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 222

def self.process_msgid_msgstr_pair_internal(lines, start_idx, translations,
                                            reference = nil, fuzzy = nil)
  process_msgid_msgstr_pair(lines, start_idx, translations, reference: reference,
                                                            fuzzy: fuzzy)
end

.process_msgid_msgstr_pair_with_metadata(lines, start_idx, translations, reference: nil, fuzzy: nil) ⇒ Object

Backward compatibility alias



207
208
209
210
211
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 207

def self.process_msgid_msgstr_pair_with_metadata(lines, start_idx, translations,
                                                 reference: nil, fuzzy: nil)
  process_msgid_msgstr_pair(lines, start_idx, translations, reference: reference,
                                                            fuzzy: fuzzy, with_mode: :merge)
end

.process_msgid_msgstr_pair_with_reference(lines, start_idx, translations, reference) ⇒ Object

Backward compatibility alias



214
215
216
217
218
219
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 214

def self.process_msgid_msgstr_pair_with_reference(lines, start_idx, translations, reference)
  process_msgid_msgstr_pair(
    lines, start_idx, translations,
    reference: reference, fuzzy: nil, with_mode: true
  )
end

.process_msgid_with_references(lines, idx, translations, with_references) ⇒ Object 



279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 279

def self.process_msgid_with_references(lines, idx, translations, with_references)
  case with_references
  when true
    reference = extract_reference_before_msgid(lines, idx)
    process_msgid_msgstr_pair(
      lines, idx, translations,
      reference: reference, fuzzy: nil, with_mode: true
    )
  when :merge
    reference, fuzzy, previous_msgid = extract_reference_and_fuzzy_before_msgid(lines, idx)
    process_msgid_msgstr_pair(
      lines, idx, translations,
      reference: reference, fuzzy: fuzzy, previous_msgid: previous_msgid, with_mode: :merge
    )
  else
    process_msgid_msgstr_pair(lines, idx, translations, reference: nil, fuzzy: nil,
                                                        with_mode: false)
  end
end

.process_po_lines(content) ⇒ Object

Backward compatibility wrapper



141
142
143
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 141

def self.process_po_lines(content)
  process_po_lines_internal(content, false)
end

.process_po_lines_for_merge(content) ⇒ Object 



232
233
234
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 232

def self.process_po_lines_for_merge(content)
  process_po_lines_internal(content, :merge)
end

.process_po_lines_internal(content, with_references) ⇒ Object 



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 236

def self.process_po_lines_internal(content, with_references)
  translations = {}
  lines = split_lines(content)
  i = 0

  while i < lines.length
    i = case with_references
        when true
          process_line_internal(lines, i, translations, true)
        when :merge
          process_line_internal(lines, i, translations, :merge)
        else
          process_line_internal(lines, i, translations, false)
        end
  end

  translations
end

.process_po_lines_with_references(content) ⇒ Object 



228
229
230
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 228

def self.process_po_lines_with_references(content)
  process_po_lines_internal(content, true)
end

.read_po_file(po_path) ⇒ Object 



429
430
431
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 429

def self.read_po_file(po_path)
  FileOperations.read_utf8(po_path)
end

.skip_blank_and_comments(lines, idx) ⇒ Object

Skips blank lines and comments before processing entries



160
161
162
163
164
165
166
167
168
169
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 160

def self.skip_blank_and_comments(lines, idx)
  return idx if idx >= lines.length

  line = lines[idx].strip
  if line.empty? || line.start_with?('#')
    idx + 1
  else
    idx
  end
end

.split_lines(content) ⇒ Object

Splits PO file content into individual lines



155
156
157
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 155

def self.split_lines(content)
  content.split("\n")
end

.stop_collecting?(line) ⇒ Boolean

Determines if we should stop collecting continuation lines

Returns:

  • (Boolean) 


501
502
503
504
505
506
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 501

def self.stop_collecting?(line)
  line.empty? ||
    line.start_with?('#') ||
    line.start_with?('msgid') ||
    line.start_with?('msgstr')
end

.store_translation(translations, msgid, msgstr, reference: nil, fuzzy: nil, previous_msgid: nil, with_metadata: false) ⇒ Object

Store translation with optional metadata (reference location and fuzzy flag).

Three Storage Formats ===

  1. Simple: { msgid => msgstr } Used during translation lookup - minimal memory, fastest access

  2. With Reference: { msgid => { msgstr: "...", reference: "file.html:10" } } Used during extraction - preserves source location for debugging

  3. With Merge Metadata: { msgid => { msgstr: "...", reference: "...", fuzzy: false } } Used during merging - tracks fuzzy flag for incomplete translations

Why three formats instead of one?

  • Memory efficiency: Simple format used most often (translation lookup)
  • Flexibility: Can handle different parsing modes without wasting storage
  • Backward compatibility: Supports legacy calling conventions rubocop:disable Metrics/ParameterLists


450
451
452
453
454
455
456
457
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 450

def self.store_translation(translations, msgid, msgstr, reference: nil, fuzzy: nil,
                           previous_msgid: nil, with_metadata: false)
  # rubocop:enable Metrics/ParameterLists
  return if msgid.nil? || msgstr.nil? || msgid.empty?

  translations[msgid] = build_translation_entry(msgstr, reference, fuzzy,
                                                previous_msgid, with_metadata: with_metadata)
end

.store_translation_internal(translations, msgid, msgstr, reference: nil, fuzzy: nil) ⇒ Object

Kept for backward compatibility with existing tests Supports both positional and keyword argument calling styles



476
477
478
479
480
481
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 476

def self.store_translation_internal(translations, msgid, msgstr, reference: nil, fuzzy: nil)
  # Handle nil sentinel values (from NO_REFERENCE constant)
  reference = nil if reference == NO_REFERENCE
  fuzzy = nil if fuzzy == NO_REFERENCE
  store_translation(translations, msgid, msgstr, reference: reference, fuzzy: fuzzy)
end

.store_translation_with_fuzzy(translations, msgid, msgstr, fuzzy:) ⇒ Object 



489
490
491
492
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 489

def self.store_translation_with_fuzzy(translations, msgid, msgstr, fuzzy:)
  store_translation(translations, msgid, msgstr, reference: nil, fuzzy: fuzzy,
                                                 with_metadata: true)
end

.store_translation_with_reference(translations, msgid, msgstr, reference:) ⇒ Object

Backward compatibility wrappers for old method signatures



484
485
486
487
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 484

def self.store_translation_with_reference(translations, msgid, msgstr, reference:)
  store_translation(translations, msgid, msgstr, reference: reference, fuzzy: nil,
                                                 with_metadata: true)
end

.store_translation_with_reference_and_fuzzy(translations, msgid, msgstr, reference:, fuzzy:) ⇒ Object 



494
495
496
497
498
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 494

def self.store_translation_with_reference_and_fuzzy(translations, msgid, msgstr,
                                                    reference:, fuzzy:)
  store_translation(translations, msgid, msgstr, reference: reference, fuzzy: fuzzy,
                                                 with_metadata: true)
end

.unescape_string(str, delimiter) ⇒ Object

Unescape PO file string values containing escape sequences.

IMPORTANT: Order Matters for Correctness ===

Must unescape escaped quotes BEFORE unescaping backslashes. Why: If we unescape backslashes first, we lose information about which backslashes were part of escape sequences vs. literal text.

Example with wrong order (backslash first):

Input: "Say \\" Hello"  (should be: Say \ Hello with closing quote)
Wrong: "\\\\" -> "\\" -> Remove quotes -> "Say \" Hello" (quote not closed!)

Correct order (quote first):

Input: "Say \\" Hello"
Right: "\\" -> " " (two backslashes become one literal backslash) -> "Say \ Hello"

Single vs Double quotes matter:

  • Single quotes: Use \' and \\
  • Double quotes: Use \" and \\


421
422
423
424
425
426
427
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 421

def self.unescape_string(str, delimiter)
  if delimiter == "'"
    str.gsub("\\'", "'").gsub('\\\\', '\\')
  else
    str.gsub('\\"', '"').gsub('\\\\', '\\')
  end
end

Instance Method Details

#parse ⇒ Hash

Parse PO file into simple translation hash.

Returns hash mapping msgid strings to msgstr strings (no metadata).

Returns:

  • (Hash) —

    Simple translation hash { msgid => msgstr }



65
66
67
68
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 65

def parse
  content = load_content
  process_po_lines_instance(content, false)
end

#parse_for_merge ⇒ Hash

Parse PO file with all metadata for merging.

Returns hash mapping msgid strings to metadata hashes containing msgstr, reference, and fuzzy flag. Used when merging with existing translations.

Returns:

  • (Hash) —

    Translation hash with merge metadata { msgid => { msgstr: "...", reference: "...", fuzzy: false } }



89
90
91
92
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 89

def parse_for_merge
  content = load_content
  process_po_lines_instance(content, :merge)
end

#parse_for_translation ⇒ Hash

Parse a PO file for translation injection, excluding fuzzy entries.

Parses with full merge metadata (including fuzzy flags), then strips fuzzy entries and returns a simple msgid → msgstr hash. Fuzzy entries are treated as untranslated per the GNU Gettext standard: msgfmt skips them by default and they should fall through to the active fallback mode.

Returns:

  • (Hash) —

    Simple translation hash { msgid => msgstr }, fuzzy entries omitted



102
103
104
105
106
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 102

def parse_for_translation
  parse_for_merge
    .reject { |_msgid, v| v.is_a?(Hash) && v[:fuzzy] }
    .transform_values { |v| v.is_a?(Hash) ? v[:msgstr] : v }
end

#parse_with_references ⇒ Hash

Parse PO file with reference comments preserved.

Returns hash mapping msgid strings to metadata hashes containing msgstr and reference (file location for debugging).

Returns:

  • (Hash) —

    Translation hash with references { msgid => { msgstr: "...", reference: "..." } }



77
78
79
80
 
# File 'lib/jekyll-l10n/po_file/reader.rb', line 77

def parse_with_references
  content = load_content
  process_po_lines_instance(content, true)
end