Module: Textus::Builder::Pipeline

Defined in:
lib/textus/builder/pipeline.rb

Class Method Summary collapse

Class Method Details

.renderers ⇒ Object 



52
53
54
55
56
57
58
59
 
# File 'lib/textus/builder/pipeline.rb', line 52

def self.renderers
  @renderers ||= {
    "markdown" => Renderer::Markdown,
    "text" => Renderer::Text,
    "json" => Renderer::Json,
    "yaml" => Renderer::Yaml,
  }
end

.run(store:, mentry:, template_loader:) ⇒ Object 



61
62
63
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
 
# File 'lib/textus/builder/pipeline.rb', line 61

def self.run(store:, mentry:, template_loader:)
  # 1. Load sources + project + reduce
  data =
    if mentry.projection
      ops = Operations.for(store)
      Projection.new(
        reader: ops.reads.get.method(:call),
        spec: mentry.projection,
        lister: ops.reads.list.method(:call),
        transform_resolver: ->(name) { store.registry.rpc_callable(:transform_rows, name) },
        transform_context: Application::Context.system(store),
      ).run
    else
      { "entries" => [], "count" => 0, "generated_at" => Time.now.utc.iso8601 }
    end
  data = data.merge("intro" => Intro.run(store)) if mentry.inject_intro

  # 2. Render
  klass = renderers[mentry.format] or
    raise UsageError.new("builder: unsupported format #{mentry.format.inspect} for '#{mentry.key}'")
  bytes = klass.new(template_loader: template_loader).call(mentry: mentry, data: data)

  # 3. Write (idempotent: skip if only generated_at would differ)
  target_path = Key::Path.resolve(store.manifest, mentry)
  FileUtils.mkdir_p(File.dirname(target_path))
  write_if_changed(target_path, bytes, mentry.format)

  target_path
end

.write_if_changed(target_path, bytes, format) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/textus/builder/pipeline.rb', line 91

def self.write_if_changed(target_path, bytes, format)
  if File.exist?(target_path)
    old_bytes = File.binread(target_path)
    if format == "text"
      return if old_bytes == bytes
    else
      rewritten = IdempotentWrite.rewrite_with_prior_timestamp(
        new_bytes: bytes, old_bytes: old_bytes, format: format,
      )
      return if rewritten && rewritten == old_bytes
    end
  end
  File.binwrite(target_path, bytes)
end