Class: Pubid::Ieee::Components::Code

Inherits:
Lutaml::Model::Serializable
  • Object
show all
Defined in:
lib/pubid/ieee/components/code.rb

Overview

IEEE document code (number with parts/subparts) Handles formats like:

802          - simple numbers
802.15.4     - dotted parts
C57.12.00    - prefix with parts
11073-10404  - dashed parts

Stays independent of Pubid::Components::Code because IEEE tracks original_separator to round-trip dot vs dash notation, and uses number rather than value.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(prefix: nil, number: nil, parts: nil, original_separator: nil) ⇒ Code

Returns a new instance of Code.



24
25
26
27
28
29
30
31
 
# File 'lib/pubid/ieee/components/code.rb', line 24

def initialize(prefix: nil, number: nil, parts: nil,
original_separator: nil)
  super()
  self.prefix = prefix
  self.number = number
  self.parts = parts || []
  self.original_separator = original_separator
end

Class Method Details

.parse(code_str) ⇒ Object

Parse code string into components



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/pubid/ieee/components/code.rb', line 34

def self.parse(code_str)
  return nil if code_str.nil? || code_str.empty?

  # Extract prefix if present (C, P)
  prefix_match = code_str.match(/^([A-Z])/)
  prefix = prefix_match ? prefix_match[1] : nil

  # Remove prefix for number parsing
  remainder = prefix ? code_str[prefix.length..] : code_str

  # Detect the separator used
  separator = nil
  if remainder.include?(".")
    separator = "."
  elsif remainder.include?("-")
    separator = "-"
  end

  # Split by dots or dashes to get number and parts
  components = remainder.split(/[.-]/)
  number = components.shift

  new(
    prefix: prefix,
    number: number,
    parts: components.empty? ? nil : components,
    original_separator: separator,
  )
end

Instance Method Details

#render(context: nil) ⇒ Object 



104
105
106
 
# File 'lib/pubid/ieee/components/code.rb', line 104

def render(context: nil)
  to_s
end

#to_s ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/pubid/ieee/components/code.rb', line 64

def to_s
  result = ""
  result += prefix if prefix
  result += number if number # Guard against nil number (e.g., "ANSI X")

  if parts && !parts.empty?
    # Use original separator if available
    if original_separator
      separator = original_separator
    elsif prefix == "P" || (!prefix && parts.first && parts.first.length > 3)
      # Fallback to heuristics when original separator unknown
      # Determine separator based on prefix and pattern:
      # - Letter prefix (C, etc.) codes use dots: C37.111
      # - P-prefix codes typically use dashes: P11073-10404
      # - Pure numeric codes with 5+ digits use dashes: 61523-4 (IEC style)
      # - Traditional IEEE codes like 802.11 use dots
      #
      # Heuristic:
      # 1. P-prefix or long part (>3 chars) → dash
      # 2. Letter prefix (except P) → dot
      # 3. Long number (5+ digits) → dash (IEC pattern)
      # 4. Default → dot (traditional IEEE)
      separator = "-"
    elsif prefix && prefix != "P"
      separator = "."
    elsif !prefix && number && number.length >= 5
      separator = "-"
    else
      # Default to dot for traditional IEEE codes like 802.11
      separator = "."
    end

    parts.each do |part|
      result += separator + part
    end
  end

  result
end