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

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

Constant Summary collapse

COMPUTE_KINDS = 
%w[projection external].freeze

Class Method Summary collapse

Class Method Details

.call(manifest, raw) ⇒ Object 



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
 
# File 'lib/textus/manifest/entry/parser.rb', line 7

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

  nested = raw["nested"] == true
  compute, projection, generator = parse_compute(raw, key)
  intake_handler, intake_config = parse_intake(raw["intake"])
  format = resolve_format(raw, path, nested)

  Textus::Manifest::Entry.new(
    manifest: manifest, raw: raw,
    key: key, path: path, zone: zone,
    schema: raw["schema"], owner: raw["owner"],
    nested: nested,
    template: raw["template"],
    publish_to: Array(raw["publish_to"]),
    publish_each: raw["publish_each"],
    events: raw["events"] || {},
    inject_intro: raw["inject_intro"] == true,
    index_filename: raw["index_filename"],
    format: format,
    compute: compute, projection: projection, generator: generator,
    intake_handler: intake_handler, intake_config: intake_config
  )
end

.parse_compute(raw, key) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/textus/manifest/entry/parser.rb', line 34

def self.parse_compute(raw, key)
  src = raw["compute"]
  return [nil, nil, nil] if src.nil?

  kind = src["kind"]
  unless COMPUTE_KINDS.include?(kind)
    raise BadManifest.new(
      "entry '#{key}': compute.kind must be one of #{COMPUTE_KINDS.join(", ")} (got #{kind.inspect})",
    )
  end

  frozen = src.freeze
  if kind == "projection"
    [frozen, frozen, nil]
  else
    [frozen, nil, frozen]
  end
end

.parse_intake(src) ⇒ Object 



53
54
55
56
 
# File 'lib/textus/manifest/entry/parser.rb', line 53

def self.parse_intake(src)
  src ||= {}
  [src["handler"], src["config"] || {}]
end

.resolve_format(raw, path, nested) ⇒ Object

Raises:



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/textus/manifest/entry/parser.rb', line 58

def self.resolve_format(raw, path, nested)
  declared = raw["format"]
  ext = File.extname(path)
  inferred = Textus::Entry.infer_from_extension(ext)

  if declared.nil?
    return inferred if inferred
    return "markdown" if ext == "" && nested
    return "markdown" if ext == ""

    return "markdown"
  end

  raise UsageError.new("entry '#{raw["key"]}': unknown format #{declared.inspect}") unless Textus::Entry.formats.include?(declared)

  if ext != "" && inferred && inferred != declared
    raise UsageError.new(
      "entry '#{raw["key"]}': path extension #{ext.inspect} does not match declared format #{declared.inspect}",
    )
  end

  declared
end