Module: Textus::Protocol::Manifest::Entry::Parser

Defined in:
lib/textus/protocol/manifest/entry/parser.rb

Class Method Summary collapse

Class Method Details

.call(raw, root: nil) ⇒ Object

Raises:



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/textus/protocol/manifest/entry/parser.rb', line 6

def self.call(raw, root: nil)
  key = raw["key"] or raise UsageError.new("manifest entry missing key")
  lane = raw["lane"] or raise UsageError.new("manifest entry '#{key}' missing lane")

  naming = raw["naming"]
  if naming && !Textus::Protocol::V4::NAMING_PATTERNS.key?(naming)
    known_aliases = Textus::Protocol::V4::NAMING_PATTERNS.keys.join(", ")
    raise BadManifest.new(
      "entry '#{key}': unknown naming alias '#{naming}' (known: #{known_aliases})",
    )
  end

  kind = infer_kind(key, raw, root:)
  format = resolve_format(key, kind, root, raw["format"])
  path = derive_path(key, kind, format)

  common = {
    raw: raw,
    key: key, path: path, lane: lane,
    format: format, naming: naming,
    schema: raw["schema"]
  }

  klass = Entry::REGISTRY[kind]
  raise BadManifest.new("entry '#{key}': unknown inferred kind: #{kind.inspect}") unless klass

  klass.from_raw(common, raw)
end

.resolve_format(key, kind, root, declared) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/textus/protocol/manifest/entry/parser.rb', line 46

def self.resolve_format(key, kind, root, declared)
  return declared || "markdown" if kind == :nested

  dir = root ? File.join(root, "data", key.split(".").join("/")) : nil
  if dir
    existing = Dir.glob("#{dir}.*").find { |p| File.file?(p) }
    return Textus::Protocol::Format.infer_from_extension(File.extname(existing)) if existing
  end

  declared || "markdown"
end