Module: Opencdd::StructuredValues

Defined in:
lib/opencdd/structured_values.rb

Overview

Single source of truth for parsing/serialising CDD's structured property-value wire forms: reference sets, synonym tuples, class references, data types.

Every format reader, writer, validator, and exporter that touches a {a,b,c} or (a,b) collection goes through this module. The brace/paren/comma convention lives here exactly once; a bug fixed here is fixed everywhere.

Defined Under Namespace

Classes: SynonymTupleScanner

Class Method Summary collapse

Class Method Details

.parse_class_ref(value) ⇒ Object 



68
69
70
71
 
# File 'lib/opencdd/structured_values.rb', line 68

def parse_class_ref(value)
  return nil if value.nil? || value.to_s.strip.empty?
  Opencdd::IRDI.parse(value.to_s.strip)
end

.parse_condition(value) ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/opencdd/structured_values.rb', line 115

def parse_condition(value)
  return nil if value.nil? || value.to_s.strip.empty?
  Opencdd::Condition.parse(value)
rescue ArgumentError
  nil
end

.parse_data_type(value) ⇒ Object 



78
79
80
81
 
# File 'lib/opencdd/structured_values.rb', line 78

def parse_data_type(value)
  return nil if value.nil? || value.to_s.strip.empty?
  Opencdd::DataType.parse_or_string(value)
end

.parse_ref_set(value) ⇒ Object 



57
58
59
60
 
# File 'lib/opencdd/structured_values.rb', line 57

def parse_ref_set(value)
  return [] if value.nil? || value.to_s.strip.empty?
  unwrap_and_split(value).filter_map { |t| Opencdd::IRDI.parse(t) }
end

.parse_synonyms(value) ⇒ Object 



43
44
45
46
 
# File 'lib/opencdd/structured_values.rb', line 43

def parse_synonyms(value)
  return [] if value.nil? || value.to_s.strip.empty?
  SynonymTupleScanner.new(value.to_s).scan
end

.parse_value_format(value) ⇒ Object 



127
128
129
130
 
# File 'lib/opencdd/structured_values.rb', line 127

def parse_value_format(value)
  return nil if value.nil? || value.to_s.strip.empty?
  Opencdd::ValueFormat.parse(value)
end

.rejoin(elements) ⇒ Object

Inverse of unwrap_and_split: join with , and wrap in {}. Empty input returns "".



37
38
39
40
41
 
# File 'lib/opencdd/structured_values.rb', line 37

def rejoin(elements)
  elements = Array(elements).map(&:to_s).reject { |e| e.nil? || e.strip.empty? }
  return "" if elements.empty?
  "{#{elements.join(",")}}"
end

.serialize_class_ref(irdi) ⇒ Object 



73
74
75
76
 
# File 'lib/opencdd/structured_values.rb', line 73

def serialize_class_ref(irdi)
  return "" if irdi.nil?
  irdi.is_a?(Opencdd::IRDI) ? irdi.to_s : irdi.to_s
end

.serialize_condition(condition) ⇒ Object 



122
123
124
125
 
# File 'lib/opencdd/structured_values.rb', line 122

def serialize_condition(condition)
  return "" if condition.nil?
  condition.to_s
end

.serialize_data_type(data_type) ⇒ Object 



110
111
112
113
 
# File 'lib/opencdd/structured_values.rb', line 110

def serialize_data_type(data_type)
  return "" if data_type.nil?
  data_type.to_s
end

.serialize_ref_set(irdis) ⇒ Object 



62
63
64
65
66
 
# File 'lib/opencdd/structured_values.rb', line 62

def serialize_ref_set(irdis)
  return "" if irdis.nil? || irdis.empty?
  elements = Array(irdis).map { |i| i.is_a?(Opencdd::IRDI) ? i.to_s : i.to_s }
  "{#{elements.join(",")}}"
end

.serialize_synonyms(pairs) ⇒ Object 



48
49
50
51
52
53
54
55
 
# File 'lib/opencdd/structured_values.rb', line 48

def serialize_synonyms(pairs)
  return "" if pairs.nil? || pairs.empty?
  tuples = Array(pairs).map do |pair|
    lang, name = Array(pair)
    "(#{name},#{lang})"
  end
  "{#{tuples.join(",")}}"
end

.serialize_value_format(format) ⇒ Object 



132
133
134
135
 
# File 'lib/opencdd/structured_values.rb', line 132

def serialize_value_format(format)
  return "" if format.nil?
  format.to_s
end

.unwrap_and_split(value) ⇒ Object

Split a {a,b,c} or (a,b,c) literal into [a, b, c]. Accepts unwrapped strings too (split directly). Empty/blank input returns []. Respects nested {}/() so {(a,b),(c,d)} yields two tuple strings, not four fragments.



27
28
29
30
31
32
33
 
# File 'lib/opencdd/structured_values.rb', line 27

def unwrap_and_split(value)
  return [] if value.nil? || value.to_s.strip.empty?
  s = value.to_s.strip
  s = s[1..-2] if (s.start_with?("{") && s.end_with?("}")) ||
                   (s.start_with?("(") && s.end_with?(")"))
  split_at_top_level_commas(s)
end