Almirah 0.3.1 → 0.4.1

data/lib/almirah/doc_items/text_line.rb

@@ -1,3 +1,7 @@
+require 'cgi'
+require 'uri'
+require_relative '../relative_url'
+
 class TextLineToken
   attr_accessor :value
 
@@ -48,20 +52,47 @@ class SquareBracketRight < TextLineToken
   end
 end
 
+class DoubleSquareBracketLeft < TextLineToken
+  def initialize # rubocop:disable Lint/MissingSuper
+    @value = '[['
+  end
+end
+
+class DoubleSquareBracketRight < TextLineToken
+  def initialize # rubocop:disable Lint/MissingSuper
+    @value = ']]'
+  end
+end
+
 class SquareBracketRightAndParentheseLeft < TextLineToken
   def initialize
     @value = ']('
   end
 end
 
+class BacktickToken < TextLineToken
+  def initialize # rubocop:disable Lint/MissingSuper
+    @value = '`'
+  end
+end
+
+class InlineCodeToken < TextLineToken
+  def initialize(raw) # rubocop:disable Lint/MissingSuper
+    @value = raw
+  end
+end
+
 class TextLineParser
   attr_accessor :supported_tokens
 
-  def initialize # rubocop:disable Metrics/AbcSize
+  def initialize # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
     @supported_tokens = []
     @supported_tokens.append(BoldAndItalicToken.new)
     @supported_tokens.append(BoldToken.new)
     @supported_tokens.append(ItalicToken.new)
+    @supported_tokens.append(BacktickToken.new)
+    @supported_tokens.append(DoubleSquareBracketLeft.new)
+    @supported_tokens.append(DoubleSquareBracketRight.new)
     @supported_tokens.append(SquareBracketRightAndParentheseLeft.new)
     @supported_tokens.append(ParentheseLeft.new)
     @supported_tokens.append(ParentheseRight.new)
@@ -70,7 +101,7 @@ class TextLineParser
     @supported_tokens.append(TextLineToken.new)
   end
 
-  def tokenize(str)
+  def tokenize(str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
     result = []
     sl = str.length
     si = 0
@@ -79,29 +110,110 @@ class TextLineParser
         tl = t.value.length
         if tl != 0 # literal is the last supported token in the list
           projected_end_position = si + tl - 1
-          next if projected_end_position > sl
+          next if projected_end_position >= sl
 
           buf = str[si..projected_end_position]
-          if buf == t.value
+          next unless buf == t.value
+
+          if emphasis_token?(t) && !can_flank?(str, si, projected_end_position)
+            append_literal(result, buf)
+          else
             result.append(t)
-            si = projected_end_position + 1
-            break
           end
+          si = projected_end_position + 1
+          break
         else
-          if result.length.positive? && (result[-1].instance_of? TextLineToken)
-            literal = result[-1]
-            literal.value += str[si]
-          else
-            literal = TextLineToken.new
-            literal.value = str[si]
-            result.append(literal)
-          end
+          append_literal(result, str[si])
           si += 1
         end
       end
     end
+    fuse_backticks(result)
+  end
+
+  private
+
+  def fuse_backticks(tokens) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    result = []
+    i = 0
+    while i < tokens.length
+      if tokens[i].instance_of?(BacktickToken)
+        closer = next_backtick_index(tokens, i + 1)
+        if closer
+          raw = tokens[(i + 1)..(closer - 1)].map(&:value).join
+          result.append(InlineCodeToken.new(raw))
+          i = closer + 1
+        else
+          append_literal(result, '`')
+          i += 1
+        end
+      else
+        result.append(tokens[i])
+        i += 1
+      end
+    end
     result
   end
+
+  def next_backtick_index(tokens, start_idx)
+    idx = start_idx
+    while idx < tokens.length
+      return idx if tokens[idx].instance_of?(BacktickToken)
+
+      idx += 1
+    end
+    nil
+  end
+
+  def emphasis_token?(token)
+    token.is_a?(ItalicToken) || token.is_a?(BoldToken) || token.is_a?(BoldAndItalicToken)
+  end
+
+  def append_literal(result, text)
+    if !result.empty? && result[-1].instance_of?(TextLineToken)
+      result[-1].value += text
+    else
+      literal = TextLineToken.new
+      literal.value = text.dup
+      result.append(literal)
+    end
+  end
+
+  def can_flank?(str, start_idx, end_idx)
+    left_flanking?(str, start_idx, end_idx) || right_flanking?(str, start_idx, end_idx)
+  end
+
+  def left_flanking?(str, start_idx, end_idx)
+    after = char_at(str, end_idx + 1)
+    return false if after.nil? || whitespace?(after)
+    return true unless punctuation?(after)
+
+    before = char_at(str, start_idx - 1)
+    before.nil? || whitespace?(before)
+  end
+
+  def right_flanking?(str, start_idx, end_idx)
+    before = char_at(str, start_idx - 1)
+    return false if before.nil? || whitespace?(before)
+    return true unless punctuation?(before)
+
+    after = char_at(str, end_idx + 1)
+    after.nil? || whitespace?(after)
+  end
+
+  def char_at(str, idx)
+    return nil if idx.negative? || idx >= str.length
+
+    str[idx]
+  end
+
+  def whitespace?(char)
+    char.match?(/\s/)
+  end
+
+  def punctuation?(char)
+    char.match?(/[[:punct:]]/)
+  end
 end
 
 class TextLineBuilderContext
@@ -117,9 +229,17 @@ class TextLineBuilderContext
     str
   end
 
+  def inline_code(str)
+    str
+  end
+
   def link(_link_text, link_url)
     link_url
   end
+
+  def wiki_link(inner)
+    "[[#{inner}]]"
+  end
 end
 
 class TextLineBuilder
@@ -129,7 +249,7 @@ class TextLineBuilder
     @builder_context = builder_context
   end
 
-  def restore(token_list)
+  def restore(token_list) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
     result = ''
     return '' if token_list.nil?
 
@@ -196,6 +316,25 @@ class TextLineBuilder
           result += '***'
           ti = ti_starting_position + 1
         end
+      when 'DoubleSquareBracketLeft'
+        # wiki/Obsidian link: collect raw text up to the closing "]]"
+        is_found = false
+        ti_starting_position = ti
+        tii = ti + 1
+        while tii < tl
+          if token_list[tii].instance_of?(DoubleSquareBracketRight)
+            inner = token_list[(ti + 1)..(tii - 1)].map(&:value).join
+            result += @builder_context.wiki_link(inner)
+            ti = tii + 1
+            is_found = true
+            break
+          end
+          tii += 1
+        end
+        unless is_found
+          result += '[['
+          ti = ti_starting_position + 1
+        end
       when 'SquareBracketLeft'
         # try to find closing part
         is_found = false
@@ -230,7 +369,10 @@ class TextLineBuilder
           ti = ti_starting_position + 1
         end
 
-      when 'TextLineToken', 'ParentheseLeft', 'ParentheseRight', 'SquareBracketRight'
+      when 'InlineCodeToken'
+        result += @builder_context.inline_code(token_list[ti].value)
+        ti += 1
+      when 'TextLineToken', 'ParentheseLeft', 'ParentheseRight', 'SquareBracketRight', 'DoubleSquareBracketRight'
         result += token_list[ti].value
         ti += 1
       else
@@ -242,11 +384,37 @@ class TextLineBuilder
 end
 
 class TextLine < TextLineBuilderContext
-  @@lazy_doc_id_dict = {}
+  @@link_registry = nil # rubocop:disable Style/ClassVars
+  @@broken_links = [] # rubocop:disable Style/ClassVars
 
-  def self.add_lazy_doc_id(id)
-    doc_id = id.to_s.downcase
-    @@lazy_doc_id_dict[doc_id] = doc_id
+  class << self
+    def link_registry=(registry)
+      @@link_registry = registry # rubocop:disable Style/ClassVars
+    end
+
+    def link_registry
+      @@link_registry
+    end
+
+    # Cross-document links that could not be resolved to a managed document,
+    # collected during rendering for reporting (ADR-186, SRS-094).
+    def broken_links
+      @@broken_links
+    end
+
+    def reset_broken_links
+      @@broken_links = [] # rubocop:disable Style/ClassVars
+    end
+
+    def record_broken_link(document, target)
+      @@broken_links << { document: document&.id, target: target }
+    end
+  end
+
+  # The document that owns this text line. Used to resolve cross-document links
+  # relative to the current page. nil for stand-alone text (e.g. unit tests).
+  def owner_document
+    nil
   end
 
   def format_string(str)
@@ -267,30 +435,64 @@ class TextLine < TextLineBuilderContext
     "<b><i>#{str}</i></b>"
   end
 
-  def link(link_text, link_url)
-    # define default result first
-    result = "<a target=\"_blank\" rel=\"noopener\" href=\"#{link_url}\" class=\"external\">#{link_text}</a>"
-
-    lazy_doc_id = nil
-    anchor = nil
-
-    if res = /(\w+)[.]md$/.match(link_url)          # link
-      lazy_doc_id = res[1].to_s.downcase
+  def inline_code(str)
+    "<code class=\"inline\">#{CGI.escapeHTML(str)}</code>"
+  end
 
-    elsif res = /(\w*)[.]md(#.*)$/.match(link_url)  # link with anchor
-      if res && res.length > 2
-        lazy_doc_id = res[1]
-        anchor = res[2]
-      end
+  def link(link_text, link_url) # rubocop:disable Metrics/MethodLength
+    raw = link_url.to_s
+    kind, target, fragment = classify_markdown_link(raw)
+    case kind
+    when :internal
+      href = RelativeUrl.between(owner_document.output_rel_path, target.output_rel_path, fragment: fragment)
+      "<a href=\"#{href}\" class=\"external\">#{link_text}</a>"
+    when :broken
+      TextLine.record_broken_link(owner_document, raw)
+      "<a href=\"#{raw}\" class=\"broken_link\" title=\"Unresolved cross-document link\">#{link_text}</a>"
+    else
+      "<a target=\"_blank\" rel=\"noopener\" href=\"#{raw}\" class=\"external\">#{link_text}</a>"
     end
+  end
 
-    if lazy_doc_id && @@lazy_doc_id_dict.key?(lazy_doc_id)
-      result = if anchor
-                 "<a href=\".\\..\\#{lazy_doc_id}\\#{lazy_doc_id}.html#{anchor}\" class=\"external\">#{link_text}</a>"
-               else
-                 "<a href=\".\\..\\#{lazy_doc_id}\\#{lazy_doc_id}.html\" class=\"external\">#{link_text}</a>"
-               end
+  # Resolves an Obsidian/wiki link "[[target#fragment|alias]]" to a managed
+  # document by its unique id/filename, independent of folder (ADR-186).
+  def wiki_link(inner) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize,Metrics/MethodLength
+    link_part, sep, alias_text = inner.partition('|')
+    target, _hash, fragment = link_part.partition('#')
+    display = (sep.empty? ? link_part : alias_text).strip
+    display = link_part.strip if display.empty?
+
+    doc = TextLine.link_registry&.find_by_id(target.strip)
+    if doc && owner_document&.output_rel_path
+      href = RelativeUrl.between(owner_document.output_rel_path, doc.output_rel_path,
+                                 fragment: fragment.strip.empty? ? nil : fragment.strip)
+      "<a href=\"#{href}\" class=\"external\">#{CGI.escapeHTML(display)}</a>"
+    elsif owner_document&.output_rel_path
+      TextLine.record_broken_link(owner_document, "[[#{inner}]]")
+      "<span class=\"broken_link\" title=\"Unresolved wiki link\">#{CGI.escapeHTML(display)}</span>"
+    else
+      "[[#{inner}]]"
     end
-    result
+  end
+
+  private
+
+  # Classifies a Markdown link target as :internal (a managed document, resolved
+  # against the owning document's source directory), :broken (a local .md path
+  # that does not resolve), or :external (everything else). ADR-186.
+  def classify_markdown_link(raw) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    path_part, _sep, fragment = raw.partition('#')
+    path_part = URI::DEFAULT_PARSER.unescape(path_part) # decode %20 etc. to match the real file path
+    return [:external] unless local_markdown_path?(path_part)
+
+    doc = owner_document
+    return [:external] unless doc&.output_rel_path && doc.respond_to?(:path) && doc.path && TextLine.link_registry
+
+    target = TextLine.link_registry.find_by_source(File.expand_path(path_part, File.dirname(doc.path)))
+    target ? [:internal, target, fragment.empty? ? nil : fragment] : [:broken]
+  end
+
+  def local_markdown_path?(path_part)
+    path_part.match?(/\.(md|markdown)\z/i) && !path_part.match?(%r{\A[a-z][a-z0-9+.\-]*://}i)
   end
 end

data/lib/almirah/doc_parser.rb

@@ -174,7 +174,7 @@ class DocParser # rubocop:disable Metrics/ClassLength,Style/Documentation
 
           doc.items.append(item)
 
-        elsif res = /^(\*\s+)(.*)/.match(s) # check if unordered list start
+        elsif res = /^([*\-]\s+)(.*)/.match(s) # check if unordered list start
 
           if doc.title == ''
             # dummy section if root is not a Document Title (level 0)
@@ -248,8 +248,9 @@ class DocParser # rubocop:disable Metrics/ClassLength,Style/Documentation
 
             if temp_md_table
               if temp_md_table.is_separator_detected # if there is a separator
-                # check if parent doc is a Protocol
-                if doc.instance_of? Protocol
+                # check if parent doc is a Protocol, or a Decision Record inside an "Affected Documents" section
+                if doc.instance_of?(Protocol) ||
+                   (doc.instance_of?(Decision) && in_section?(doc, 'Affected Documents'))
                   # check if it is a controlled table
                   tmp = /(.*)\s+>\[(\S*)\]/.match(row)
                   if tmp && (temp_md_table.instance_of? MarkdownTable)
@@ -379,4 +380,20 @@ class DocParser # rubocop:disable Metrics/ClassLength,Style/Documentation
     end
     temp_md_table
   end
+
+  # Returns true when the most recently parsed heading is inside (or equal to) a section
+  # whose heading text matches `section_name`. Walks back through the heading list
+  # accumulating the ancestor chain (strictly decreasing levels).
+  def self.in_section?(doc, section_name)
+    return false if doc.headings.empty?
+
+    last_level = doc.headings[-1].level + 1
+    doc.headings.reverse_each do |h|
+      next if h.level >= last_level
+
+      last_level = h.level
+      return true if h.text.strip == section_name
+    end
+    false
+  end
 end

data/lib/almirah/doc_types/base_document.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
+require_relative '../relative_url'
+
 class BaseDocument # rubocop:disable Style/Documentation
-  attr_accessor :title, :id, :dom, :headings
+  attr_accessor :title, :id, :dom, :headings, :output_rel_path
+
+  class << self
+    attr_accessor :show_decisions_link
+  end
 
   def initialize
     @items = []
@@ -21,9 +27,14 @@ class BaseDocument # rubocop:disable Style/Documentation
 
     output_file_path += if @id == 'index'
                           "#{@id}.html"
+                        elsif instance_of? DecisionsOverview
+                          'overview.html'
+                        elsif instance_of? Decision
+                          "#{@id}.html"
                         else
                           "#{@id}/#{@id}.html"
                         end
+    @output_rel_path = output_file_path.split('/build/', 2).last
     file = File.open(output_file_path, 'w')
     file_data.each do |s| # rubocop:disable Metrics/BlockLength
       if s.include?('{{CONTENT}}')
@@ -35,35 +46,21 @@ class BaseDocument # rubocop:disable Style/Documentation
       elsif s.include?('{{DOCUMENT_TITLE}}')
         file.puts s.gsub! '{{DOCUMENT_TITLE}}', @title
       elsif s.include?('{{STYLES_AND_SCRIPTS}}')
+        file.puts "<link rel=\"stylesheet\" href=\"#{rel_to('css/main.css')}\">"
+        file.puts "<script src=\"#{rel_to('scripts/main.js')}\"></script>"
         if @id == 'index'
-          file.puts '<script type="module" src="./scripts/orama_search.js"></script>'
-          file.puts '<link rel="stylesheet" href="./css/search.css">'
-          file.puts '<link rel="stylesheet" href="./css/main.css">'
-          file.puts '<script src="./scripts/main.js"></script>'
-        elsif instance_of? Specification
-          file.puts '<link rel="stylesheet" href="../../css/main.css">'
-          file.puts '<script src="../../scripts/main.js"></script>'
-        elsif instance_of? Traceability
-          file.puts '<link rel="stylesheet" href="../../css/main.css">'
-          file.puts '<script src="../../scripts/main.js"></script>'
-        elsif instance_of? Coverage
-          file.puts '<link rel="stylesheet" href="../../css/main.css">'
-          file.puts '<script src="../../scripts/main.js"></script>'
-        elsif instance_of? Implementation
-          file.puts '<link rel="stylesheet" href="../../css/main.css">'
-          file.puts '<script src="../../scripts/main.js"></script>'
-        elsif instance_of? Protocol
-          file.puts '<link rel="stylesheet" href="../../../css/main.css">'
-          file.puts '<script src="../../../scripts/main.js"></script>'
+          file.puts "<script type=\"module\" src=\"#{rel_to('scripts/orama_search.js')}\"></script>"
+          file.puts "<link rel=\"stylesheet\" href=\"#{rel_to('css/search.css')}\">"
+        elsif instance_of? DecisionsOverview
+          file.puts '<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>'
         end
       elsif s.include?('{{HOME_BUTTON}}')
         if @id == 'index'
-          file.puts '<a id="home_menu_item" href="./index.html"><span><i class="fa fa-home" aria-hidden="true"></i></span>&nbsp;Home</a>'
-        elsif instance_of? Protocol
-          file.puts '<a id="index_menu_item" href="./../../../index.html"><span><i class="fa fa-info" aria-hidden="true"></i></span>&nbsp;Index</a>'
+          file.puts home_link(rel_to('index.html'))
         else
-           file.puts '<a id="index_menu_item" href="./../../index.html"><span><i class="fa fa-info" aria-hidden="true"></i></span>&nbsp;Index</a>'
+          file.puts index_link(rel_to('index.html'))
         end
+        file.puts decisions_link(rel_to('decisions/overview.html')) if BaseDocument.show_decisions_link
       elsif s.include?('{{GEM_VERSION}}')
         file.puts "(#{Gem.loaded_specs['Almirah'].version.version})"
       else
@@ -72,4 +69,24 @@ class BaseDocument # rubocop:disable Style/Documentation
     end
     file.close
   end
+
+  def decisions_link(href)
+    icon = '<span><i class="fa fa-gavel" aria-hidden="true"></i></span>'
+    %(<a id="decisions_menu_item" href="#{href}">#{icon}&nbsp;Decision Records</a>)
+  end
+
+  def index_link(href)
+    icon = '<span><i class="fa fa-info" aria-hidden="true"></i></span>'
+    %(<a id="index_menu_item" href="#{href}">#{icon}&nbsp;Index</a>)
+  end
+
+  def home_link(href)
+    icon = '<span><i class="fa fa-home" aria-hidden="true"></i></span>'
+    %(<a id="home_menu_item" href="#{href}">#{icon}&nbsp;Home</a>)
+  end
+
+  # Relative URL from this page to a target path under the build root.
+  def rel_to(target)
+    RelativeUrl.between(@output_rel_path, target)
+  end
 end

data/lib/almirah/doc_types/decision.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'date'
+require_relative 'persistent_document'
+require_relative '../doc_items/heading'
+require_relative '../doc_items/markdown_table'
+
+class Decision < PersistentDocument # rubocop:disable Style/Documentation,Metrics/ClassLength
+  attr_accessor :path, :sequence_number, :record_type, :html_rel_path, :root_prefix, :current_status,
+                :start_date, :target_release_version, :specifications_path, :wrong_links_hash
+
+  def initialize(file_path)
+    super
+    @path = file_path
+    stem = File.basename(file_path, File.extname(file_path))
+    assign_id_parts(stem)
+    @current_status = nil
+    @start_date = nil
+    @target_release_version = nil
+    @wrong_links_hash = {}
+  end
+
+  def to_console
+    puts "\e[36mDecision: #{@id}\e[0m"
+  end
+
+  def to_html(nav_pane, output_file_path)
+    html_rows = []
+    html_rows.append('')
+
+    @items.each do |item|
+      html_rows.append item.to_html
+    end
+
+    save_html_to_file(html_rows, nav_pane, output_file_path)
+  end
+
+  def extract_current_status
+    status_table = find_section_table('Status')
+    return if status_table.nil?
+
+    status_table.is_decision_status_table = true
+    marker_rows = status_table.rows.select { |row| row[0].to_s.strip == '*' }
+    @current_status = marker_rows.length == 1 ? marker_rows[0][-1].to_s.strip : nil
+  end
+
+  def extract_start_date
+    dates = collect_dates('Status', 'Date') + collect_dates('Scope', 'Start Date')
+    @start_date = dates.min
+  end
+
+  def extract_target_release_version
+    @target_release_version = lookup_cell(
+      section_name: 'Software Versions',
+      key_column: 'Software Version Category',
+      value_column: 'Software Version ID',
+      key: 'Target Release Version'
+    )
+  end
+
+  def effective_status_on(date) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    table = find_section_table('Status')
+    return nil if table.nil?
+
+    date_idx = column_index(table, 'Date')
+    status_idx = column_index(table, 'Status')
+    return nil if date_idx.nil? || status_idx.nil?
+
+    best_idx = nil
+    best_date = nil
+    table.rows.each_with_index do |row, i|
+      parsed = parse_dd_mm_yyyy(row[date_idx])
+      next if parsed.nil? || parsed > date
+
+      if best_date.nil? || parsed > best_date || (parsed == best_date && i > best_idx)
+        best_date = parsed
+        best_idx = i
+      end
+    end
+    return nil if best_idx.nil?
+
+    status = table.rows[best_idx][status_idx].to_s.strip
+    status.empty? ? nil : status
+  end
+
+  private
+
+  def lookup_cell(section_name:, key_column:, value_column:, key:) # rubocop:disable Metrics/AbcSize
+    table = find_section_table(section_name)
+    return nil if table.nil?
+
+    key_idx = column_index(table, key_column)
+    value_idx = column_index(table, value_column)
+    return nil if key_idx.nil? || value_idx.nil?
+
+    row = table.rows.find { |r| r[key_idx].to_s.strip == key }
+    return nil if row.nil?
+
+    cell = row[value_idx].to_s.strip
+    cell.empty? ? nil : cell
+  end
+
+  def find_section_table(section_name) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    in_section = false
+    section_level = nil
+    @items.each do |item|
+      if item.is_a?(Heading)
+        if !in_section && item.text.strip == section_name
+          in_section = true
+          section_level = item.level
+        elsif in_section && item.level <= section_level
+          return nil
+        end
+      elsif in_section && item.is_a?(MarkdownTable)
+        return item
+      end
+    end
+    nil
+  end
+
+  def collect_dates(section_name, column_name)
+    table = find_section_table(section_name)
+    return [] if table.nil?
+
+    col_index = column_index(table, column_name)
+    return [] if col_index.nil?
+
+    table.rows.filter_map { |row| parse_dd_mm_yyyy(row[col_index]) }
+  end
+
+  def column_index(table, column_name)
+    table.column_names.each_with_index do |name, idx|
+      return idx if name.to_s.strip == column_name
+    end
+    nil
+  end
+
+  def parse_dd_mm_yyyy(value)
+    return nil if value.nil?
+
+    match = /\A(\d{2})-(\d{2})-(\d{4})\z/.match(value.to_s.strip)
+    return nil unless match
+
+    Date.new(match[3].to_i, match[2].to_i, match[1].to_i)
+  rescue ArgumentError
+    nil
+  end
+
+  def assign_id_parts(stem)
+    match = stem.match(/\A([A-Za-z]+)-(\d+)/)
+    if match
+      @id = "#{match[1]}-#{match[2]}".downcase
+      @record_type = match[1].upcase
+      @sequence_number = match[2]
+    else
+      @id = stem.downcase
+      @record_type = nil
+      @sequence_number = nil
+    end
+  end
+end