asciidoctor-diagram-layout 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f22dac919c2d693bff3278c5bf346b95f1c0e019e8778ab067d9cb24bbedc339
+  data.tar.gz: 153c7b5ee567acde3e3fec89caf1d99a7d7d721ebd2e93c5cc38e31dee31fc31
+SHA512:
+  metadata.gz: 3e240b340cfb7a98bb4a92e8488f3cc29f8b1f0346bdd6254bc9bd425ca86640b81d23260bd42cafb1adcb71345ed6e5004848421161998716e363891d3f9a03
+  data.tar.gz: ef99d52540a84f27354a62aa1170c69537e641921fe1fabf67f69d1f037a80fa72b124702cdc48bf0c6027c12989a306b1f650302e5191569cb5b25bee0d4c21

data/LICENSE

@@ -0,0 +1,192 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of developing and
+      coordinating the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contributions
+      with the Work to which such Contributions were submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that alongside or as an addendum to the NOTICE text
+          from the Work, provided that such additional attribution
+          notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Derivative Works, subject to the terms and conditions of this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (even if such Contributor has been advised of the possibility
+      of such damages).
+
+   9. Accepting Warranty or Liability. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a fee
+      for, acceptance of support, warranty, indemnity, or other liability
+      obligations and/or rights consistent with this License. However, in
+      accepting such obligations, You may offer only conditions that do not
+      conflict with the terms and conditions of this License, and for which
+      You may act only on Your own behalf and on Your sole responsibility,
+      not on behalf of any other Contributor. On such condition, you must
+      fully indemnify and hold harmless each Contributor for any liability
+      incurred by such Contributor as a result of warranties, liability
+      obligations assumed by You.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the syntax of your file format. Please also
+      include a brief description of how this work is licensed under
+      the Apache License, Version 2.0.
+
+   Copyright [2024] Qulix Systems
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,90 @@
+# asciidoctor-diagram-layout
+
+An Asciidoctor extension that adds a `[layout-rowcol]` block for
+rendering flex-based layout diagrams as HTML or SVG.
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem "asciidoctor-diagram-layout"
+```
+
+Or install directly:
+
+```
+gem install asciidoctor-diagram-layout
+```
+
+## Usage
+
+Register the extension and use the `[layout-rowcol]` block in your
+AsciiDoc documents:
+
+```ruby
+require "asciidoctor"
+require "asciidoctor-diagram-layout"
+
+Asciidoctor::Extensions.register do
+  block AsciidoctorDiagramLayout::Asciidoc::LayoutBlockProcessor
+end
+```
+
+### Basic example
+
+```asciidoc
+[layout-rowcol]
+----
+cols:
+    cell(30): Sidebar
+    rows:
+        cell: Header
+        cell: Content
+----
+```
+
+### DSL syntax
+
+Each line declares one node. Indentation (4 spaces or one tab) defines
+nesting.
+
+* `cols:` - container that arranges children horizontally
+* `rows:` - container that arranges children vertically
+* `cell: Name` - leaf cell with a visible label
+* `cell(30): Name` - leaf cell with a fixed size of 30% of its parent
+* Containers without an explicit size take equal shares of the remaining
+  space
+* Lines starting with `#` are comments
+
+### Block attributes
+
+* `direction` - implicit direction for top-level cells when no container
+  is declared: `rows` (default) or `cols`
+* `renderer` - force output format: `html` or `svg`; defaults to `html`
+  for HTML backends and `svg` for all others including PDF
+* `palette` - color scheme: `rainbow` (default), `pastel`, `warm`,
+  `cool`, `mono`
+* `width` - diagram width, e.g. `100%` (default) or `800px`
+* `height` - diagram height, e.g. `400px`; not set by default
+* `target` - SVG file name (without extension) when rendering to PDF
+
+### PDF output
+
+When converting to PDF, the extension writes the diagram as an SVG file
+and embeds it as an image block.
+Use the `target` attribute to control the output file name:
+
+```asciidoc
+[layout-rowcol, target="my-diagram"]
+----
+cols:
+    cell: Left
+    cell: Right
+----
+```
+
+## License
+
+Apache License 2.0.
+See [LICENSE](LICENSE).

data/lib/asciidoctor-diagram-layout.rb

@@ -0,0 +1,11 @@
+require_relative "asciidoctor_diagram_layout/version"
+require_relative "asciidoctor_diagram_layout/parser"
+require_relative "asciidoctor_diagram_layout/renderer/color_palette"
+require_relative "asciidoctor_diagram_layout/renderer/scheme/golden_ratio_scheme"
+require_relative "asciidoctor_diagram_layout/renderer/scheme/analogous_scheme"
+require_relative "asciidoctor_diagram_layout/renderer/scheme/monochromatic_scheme"
+require_relative "asciidoctor_diagram_layout/renderer/scheme/cell_color_scheme_factory"
+require_relative "asciidoctor_diagram_layout/renderer/render_options"
+require_relative "asciidoctor_diagram_layout/renderer/html_renderer"
+require_relative "asciidoctor_diagram_layout/renderer/svg_renderer"
+require_relative "asciidoctor_diagram_layout/asciidoc/layout_block_processor"

data/lib/asciidoctor_diagram_layout/asciidoc/layout_block_processor.rb

@@ -0,0 +1,83 @@
+require "asciidoctor"
+require "asciidoctor/extensions"
+
+module AsciidoctorDiagramLayout
+  module Asciidoc
+    class LayoutBlockProcessor < Asciidoctor::Extensions::BlockProcessor
+      use_dsl
+      named :"layout-rowcol"
+      on_contexts :listing, :literal
+
+      def process(parent, reader, attrs)
+        dsl               = reader.read
+        implicit_dir      = attrs["direction"] == "cols" ? :cols : :rows
+        root              = Parser.new.parse(dsl, implicit_dir)
+        backend           = parent.document.attr("backend").to_s
+        renderer_attr     = attrs["renderer"]
+        strategy          = resolve_strategy(renderer_attr, backend)
+        palette           = attrs.fetch("palette", "rainbow")
+        pdf               = backend == "pdf"
+        options           = Renderer::RenderOptions.new(
+          width:          attrs.fetch("width", "100%"),
+          height:         attrs["height"],
+          palette:        palette,
+          pdf:            pdf,
+          name_converter: method(:identity)
+        )
+        case strategy
+        when :html then render_html(parent, root, options)
+        when :svg  then render_svg(parent, root, backend, options, attrs)
+        end
+      end
+
+      private
+
+      def resolve_strategy(renderer_attr, backend)
+        case renderer_attr.to_s.downcase
+        when "html" then :html
+        when "svg"  then :svg
+        else
+          case backend.downcase
+          when "html", "html5" then :html
+          else :svg
+          end
+        end
+      end
+
+      def render_html(parent, root, options)
+        html = Renderer::HtmlRenderer.new.render(root, options)
+        create_pass_block(parent, html, {}, subs: nil)
+      end
+
+      def render_svg(parent, root, backend, options, attrs)
+        svg = Renderer::SvgRenderer.new.render(root, options)
+        if backend == "pdf"
+          target = attrs["target"]
+          outdir = parent.document.attr("outdir").to_s
+          path   = write_svg(svg, target, outdir)
+          create_image_block(parent, { "target" => path, "format" => "svg" })
+        else
+          create_pass_block(parent, svg, {}, subs: nil)
+        end
+      end
+
+      def write_svg(svg, name, outdir)
+        has_outdir = outdir && outdir != "null" && !outdir.empty?
+        has_name   = name && !name.empty?
+        if has_outdir && has_name
+          path = File.join(outdir, "#{name}.svg")
+        elsif has_name
+          path = File.join(Dir.tmpdir, "#{name}-#{SecureRandom.hex(4)}.svg")
+        else
+          path = File.join(Dir.tmpdir, "layout-#{SecureRandom.hex(4)}.svg")
+        end
+        File.write(path, svg, encoding: "UTF-8")
+        path
+      end
+
+      def identity(text)
+        text
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/parser.rb

@@ -0,0 +1,124 @@
+module AsciidoctorDiagramLayout
+  class ParseError < StandardError; end
+
+  # Parses flex layout DSL text into a node tree.
+  #
+  # Format: one directive per line. Containers (cols, rows) declare
+  # a nested block via indentation. Leaf zones use cell.
+  # An optional size in parentheses sets a fixed percentage:
+  #   cell(30): Name  or  cols(40):
+  class Parser
+    LINE_PATTERN = /\A(?<keyword>cols|rows|cell)(?:\((?<size>\d+)\))?:(?<rest>.*)\z/i
+    TAB_WIDTH    = 4
+
+    def parse(dsl, implicit_direction = :rows)
+      lines = dsl.split("\n", -1)
+      state = ParseState.new(lines)
+      roots = parse_children(state, 0)
+      raise ParseError, "Empty input: expected at least one cell, rows, or cols" if roots.empty?
+      if roots.size == 1 && roots.first.is_a?(ContainerNode)
+        roots.first
+      else
+        ContainerNode.new(implicit_direction, :auto, roots)
+      end
+    end
+
+    private
+
+    def parse_children(state, indent)
+      nodes = []
+      while state.more?
+        line   = state.peek
+        trimmed = strip_comment(line).rstrip
+        if trimmed.strip.empty?
+          state.advance
+          next
+        end
+        line_indent = count_indent(line)
+        break if line_indent < indent
+        if line_indent > indent
+          raise ParseError, "Unexpected indentation at line #{state.index + 1}: #{line.inspect}"
+        end
+        state.advance
+        content = trimmed.strip
+        m = LINE_PATTERN.match(content)
+        raise ParseError, "Invalid syntax at line #{state.index}: #{line.inspect}" unless m
+        keyword   = m[:keyword].downcase
+        size      = m[:size] ? m[:size].to_i : :auto
+        rest      = m[:rest].strip
+        nodes << build_node(keyword, size, rest, state, indent, state.index, line)
+      end
+      nodes
+    end
+
+    def build_node(keyword, size, rest, state, indent, line_number, original_line)
+      if keyword == "cell"
+        raise ParseError, "cell requires a name at line #{line_number}: #{original_line.inspect}" if rest.empty?
+        return CellNode.new(size, rest)
+      end
+      unless rest.empty?
+        raise ParseError, "#{keyword} is a container and must not have a value at line #{line_number}: #{original_line.inspect}"
+      end
+      direction     = keyword == "cols" ? :cols : :rows
+      nested_indent = detect_nested_indent(state, indent, line_number)
+      children      = parse_children(state, nested_indent)
+      ContainerNode.new(direction, size, children)
+    end
+
+    def detect_nested_indent(state, current_indent, line_number)
+      while state.more?
+        line    = state.peek
+        trimmed = strip_comment(line).rstrip
+        unless trimmed.strip.empty?
+          indent = count_indent(line)
+          if indent <= current_indent
+            raise ParseError, "Expected indented block after line #{line_number} but found: #{line.inspect}"
+          end
+          return indent
+        end
+        state.advance
+      end
+      raise ParseError, "Expected indented block after line #{line_number} but reached end of input"
+    end
+
+    def count_indent(line)
+      count = 0
+      line.each_char do |c|
+        if c == ' '
+          count += 1
+        elsif c == "\t"
+          count += TAB_WIDTH
+        else
+          break
+        end
+      end
+      count
+    end
+
+    def strip_comment(line)
+      i = line.index('#')
+      i ? line[0, i] : line
+    end
+  end
+
+  ParseState = Struct.new(:lines, :index) do
+    def initialize(lines)
+      super(lines, 0)
+    end
+
+    def more?
+      index < lines.size
+    end
+
+    def peek
+      lines[index]
+    end
+
+    def advance
+      self.index += 1
+    end
+  end
+
+  ContainerNode = Struct.new(:direction, :size, :children)
+  CellNode      = Struct.new(:size, :name)
+end

data/lib/asciidoctor_diagram_layout/renderer/color_palette.rb

@@ -0,0 +1,47 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    module ColorPalette
+      STROKE_COLOR = "#d0d0d0"
+      GOLDEN_RATIO = 0.618033988749895
+      HUE_RANGE    = 360
+
+      # Converts HSL to a hex color string, identical to Java ColorPalette.hslToHex.
+      def self.hsl_to_hex(hue, saturation, lightness)
+        s = saturation / 100.0
+        l = lightness  / 100.0
+        c = (1 - (2 * l - 1).abs) * s
+        x = c * (1 - ((hue / 60.0) % 2 - 1).abs)
+        m = l - c / 2.0
+        if hue < 60
+          r, g, b = c, x, 0
+        elsif hue < 120
+          r, g, b = x, c, 0
+        elsif hue < 180
+          r, g, b = 0, c, x
+        elsif hue < 240
+          r, g, b = 0, x, c
+        elsif hue < 300
+          r, g, b = x, 0, c
+        else
+          r, g, b = c, 0, x
+        end
+        ri = (r + m) * 255
+        gi = (g + m) * 255
+        bi = (b + m) * 255
+        format("#%02x%02x%02x", ri.round, gi.round, bi.round)
+      end
+
+      # Java String.hashCode: s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
+      # using 32-bit signed integer overflow semantics.
+      def self.java_hash(str)
+        return 0 if str.nil? || str.empty?
+        h = 0
+        str.each_char do |c|
+          h = (31 * h + c.ord) & 0xffffffff
+        end
+        # convert to signed 32-bit
+        h >= 0x80000000 ? h - 0x100000000 : h
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/html_renderer.rb

@@ -0,0 +1,60 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    class HtmlRenderer
+      CELL_BASE = "display:flex; align-items:center; justify-content:center;" \
+                  " padding:8px; font-weight:bold; font-family:sans-serif;" \
+                  " min-height:60px; box-sizing:border-box; color:#333;"
+
+      def render(root, options = RenderOptions.new)
+        sb = +""
+        height_style = options.height ? " min-height:#{options.height};" : ""
+        wrapper_style = "display:flex; width:#{options.width};#{height_style}" \
+                        " box-sizing:border-box; font-family:sans-serif; overflow:hidden;"
+        sb << "<div style=\"#{wrapper_style}\">\n"
+        render_node(root, sb, 1, options)
+        sb << "</div>\n"
+        sb
+      end
+
+      private
+
+      def render_node(node, sb, depth, options)
+        case node
+        when ContainerNode then render_container(node, sb, depth, options)
+        when CellNode      then render_cell(node, sb, depth, options)
+        end
+      end
+
+      def render_container(container, sb, depth, options)
+        flex_dir = container.direction == :cols ? "row" : "column"
+        style = "display:flex; flex-direction:#{flex_dir}; #{size_style(container.size)}" \
+                " align-items:stretch; box-sizing:border-box;"
+        indent(sb, depth)
+        sb << "<div style=\"#{style}\">\n"
+        container.children.each { |child| render_node(child, sb, depth + 1, options) }
+        indent(sb, depth)
+        sb << "</div>\n"
+      end
+
+      def render_cell(cell, sb, depth, options)
+        scheme   = options.color_scheme
+        color    = scheme.fill_color(cell.name)
+        grad_end = scheme.gradient_end(cell.name)
+        stroke   = scheme.stroke_color(cell.name)
+        gradient = "linear-gradient(135deg,#{color},#{grad_end})"
+        style    = "#{CELL_BASE} #{size_style(cell.size)}" \
+                   " background:#{gradient}; border:1px solid #{stroke};"
+        indent(sb, depth)
+        sb << "<div style=\"#{style}\">#{options.name_converter.call(cell.name)}</div>\n"
+      end
+
+      def size_style(size)
+        size == :auto ? "flex:1;" : "flex:0 0 #{size}%; box-sizing:border-box;"
+      end
+
+      def indent(sb, depth)
+        sb << "  " * depth
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/render_options.rb

@@ -0,0 +1,22 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    class RenderOptions
+      attr_reader :width, :height, :color_scheme, :name_converter
+
+      def initialize(width: "100%", height: nil, palette: "rainbow", pdf: false,
+                     color_scheme: nil, name_converter: nil)
+        @width          = width
+        @height         = height
+        @color_scheme   = color_scheme || Scheme::CellColorSchemeFactory.resolve(palette, pdf: pdf)
+        @name_converter = name_converter || method(:escape)
+      end
+
+      private
+
+      def escape(text)
+        return "" if text.nil?
+        text.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/scheme/analogous_scheme.rb

@@ -0,0 +1,39 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    module Scheme
+      class AnalogousScheme
+        GRADIENT_HUE_SHIFT = 15
+        STROKE_LIGHTNESS   = 65
+        STROKE_SATURATION  = 25
+
+        def initialize(base_hue, hue_range, saturation, lightness)
+          @base_hue   = base_hue
+          @hue_range  = hue_range
+          @saturation = saturation
+          @lightness  = lightness
+        end
+
+        def fill_color(name)
+          ColorPalette.hsl_to_hex(hue(name), @saturation, @lightness)
+        end
+
+        def gradient_end(name)
+          ColorPalette.hsl_to_hex((hue(name) + GRADIENT_HUE_SHIFT) % ColorPalette::HUE_RANGE,
+                                  @saturation, @lightness)
+        end
+
+        def stroke_color(name)
+          ColorPalette.hsl_to_hex(hue(name), STROKE_SATURATION, STROKE_LIGHTNESS)
+        end
+
+        private
+
+        def hue(name)
+          hash = ColorPalette.java_hash(name).abs
+          offset = (hash * ColorPalette::GOLDEN_RATIO % 1.0) * @hue_range
+          (@base_hue + offset.to_i) % ColorPalette::HUE_RANGE
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/scheme/cell_color_scheme_factory.rb

@@ -0,0 +1,38 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    module Scheme
+      module CellColorSchemeFactory
+        WARM_BASE_HUE        = 30
+        COOL_BASE_HUE        = 210
+        ANALOGOUS_HUE_RANGE  = 60
+        ANALOGOUS_SATURATION = 25
+        ANALOGOUS_LIGHTNESS  = 86
+        MONO_HUE             = 210
+        MONO_SATURATION      = 20
+        DEFAULT_SATURATION   = 22
+        DEFAULT_LIGHTNESS    = 88
+        PDF_SATURATION       = 15
+        PDF_LIGHTNESS        = 90
+        PASTEL_SATURATION    = 18
+        PASTEL_LIGHTNESS     = 93
+
+        def self.resolve(name, pdf: false)
+          key = name.to_s.downcase
+          case key
+          when "pastel"
+            GoldenRatioScheme.new(PASTEL_SATURATION, PASTEL_LIGHTNESS)
+          when "warm"
+            AnalogousScheme.new(WARM_BASE_HUE, ANALOGOUS_HUE_RANGE, ANALOGOUS_SATURATION, ANALOGOUS_LIGHTNESS)
+          when "cool"
+            AnalogousScheme.new(COOL_BASE_HUE, ANALOGOUS_HUE_RANGE, ANALOGOUS_SATURATION, ANALOGOUS_LIGHTNESS)
+          when "mono"
+            MonochromaticScheme.new(MONO_HUE, MONO_SATURATION)
+          else
+            pdf ? GoldenRatioScheme.new(PDF_SATURATION, PDF_LIGHTNESS)
+                : GoldenRatioScheme.new(DEFAULT_SATURATION, DEFAULT_LIGHTNESS)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/scheme/golden_ratio_scheme.rb

@@ -0,0 +1,36 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    module Scheme
+      class GoldenRatioScheme
+        GRADIENT_HUE_SHIFT = 20
+        STROKE_LIGHTNESS   = 65
+        STROKE_SATURATION  = 30
+
+        def initialize(saturation, lightness)
+          @saturation = saturation
+          @lightness  = lightness
+        end
+
+        def fill_color(name)
+          ColorPalette.hsl_to_hex(hue(name), @saturation, @lightness)
+        end
+
+        def gradient_end(name)
+          ColorPalette.hsl_to_hex((hue(name) + GRADIENT_HUE_SHIFT) % ColorPalette::HUE_RANGE,
+                                  @saturation, @lightness)
+        end
+
+        def stroke_color(name)
+          ColorPalette.hsl_to_hex(hue(name), STROKE_SATURATION, STROKE_LIGHTNESS)
+        end
+
+        private
+
+        def hue(name)
+          hash = ColorPalette.java_hash(name).abs
+          ((hash * ColorPalette::GOLDEN_RATIO % 1.0) * ColorPalette::HUE_RANGE).to_i
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/scheme/monochromatic_scheme.rb

@@ -0,0 +1,39 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    module Scheme
+      class MonochromaticScheme
+        LIGHTNESS_MIN      = 75
+        LIGHTNESS_MAX      = 95
+        GRADIENT_SHIFT     = 5
+        STROKE_LIGHTNESS   = 60
+        STROKE_SATURATION  = 20
+
+        def initialize(hue, saturation)
+          @hue        = hue
+          @saturation = saturation
+        end
+
+        def fill_color(name)
+          ColorPalette.hsl_to_hex(@hue, @saturation, lightness(name))
+        end
+
+        def gradient_end(name)
+          l = [lightness(name) + GRADIENT_SHIFT, 98].min
+          ColorPalette.hsl_to_hex(@hue, @saturation, l)
+        end
+
+        def stroke_color(name)
+          ColorPalette.hsl_to_hex(@hue, STROKE_SATURATION, STROKE_LIGHTNESS)
+        end
+
+        private
+
+        def lightness(name)
+          hash = ColorPalette.java_hash(name).abs
+          range = LIGHTNESS_MAX - LIGHTNESS_MIN
+          LIGHTNESS_MIN + (hash % (range + 1))
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/renderer/svg_renderer.rb

@@ -0,0 +1,137 @@
+module AsciidoctorDiagramLayout
+  module Renderer
+    class SvgRenderer
+      DEFAULT_WIDTH  = 600
+      DEFAULT_HEIGHT = 300
+      FONT_SIZE      = 14
+
+      def render(root, options = RenderOptions.new)
+        w = parse_px(options.width,  DEFAULT_WIDTH)
+        h = parse_px(options.height, DEFAULT_HEIGHT)
+        defs = +""
+        body = +""
+        render_node(root, defs, body, options.color_scheme, 0, 0, w, h)
+        sb = +""
+        sb << "<svg xmlns=\"http://www.w3.org/2000/svg\""
+        sb << " width=\"#{w}\""
+        sb << " height=\"#{h}\""
+        sb << " style=\"font-family:sans-serif;\""
+        sb << ">\n"
+        if defs.length > 0
+          sb << "  <defs>\n" << defs << "  </defs>\n"
+        end
+        sb << body
+        sb << "</svg>\n"
+        sb
+      end
+
+      private
+
+      def parse_px(value, default_value)
+        return default_value if value.nil?
+        trimmed = value.end_with?("px") ? value[0..-3] : value
+        Integer(trimmed.strip)
+      rescue ArgumentError
+        default_value
+      end
+
+      def render_node(node, defs, body, scheme, x, y, w, h)
+        case node
+        when ContainerNode then render_container(node, defs, body, scheme, x, y, w, h)
+        when CellNode      then render_cell(node, defs, body, scheme, x, y, w, h)
+        end
+      end
+
+      def render_container(container, defs, body, scheme, x, y, w, h)
+        children = container.children
+        total    = container.direction == :cols ? w : h
+        sizes    = distribute_pixels(children, total)
+        offset   = 0
+        children.each_with_index do |child, i|
+          cx = container.direction == :cols ? x + offset : x
+          cy = container.direction == :cols ? y : y + offset
+          cw = container.direction == :cols ? sizes[i] : w
+          ch = container.direction == :cols ? h : sizes[i]
+          render_node(child, defs, body, scheme, cx, cy, cw, ch)
+          offset += sizes[i]
+        end
+      end
+
+      def render_cell(cell, defs, body, scheme, x, y, w, h)
+        label  = extract_label(cell.name)
+        color  = scheme.fill_color(cell.name)
+        light  = scheme.gradient_end(cell.name)
+        stroke = scheme.stroke_color(cell.name)
+        grad_id = "g#{x}-#{y}"
+        defs << "    <linearGradient id=\"#{grad_id}\""
+        defs << " gradientUnits=\"userSpaceOnUse\""
+        defs << " x1=\"#{x}\" y1=\"#{y}\""
+        defs << " x2=\"#{x + w}\" y2=\"#{y + h}\">\n"
+        defs << "      <stop offset=\"0%\" stop-color=\"#{color}\"/>\n"
+        defs << "      <stop offset=\"100%\" stop-color=\"#{light}\"/>\n"
+        defs << "    </linearGradient>\n"
+        body << "  <rect"
+        body << " x=\"#{x}\""
+        body << " y=\"#{y}\""
+        body << " width=\"#{w}\""
+        body << " height=\"#{h}\""
+        body << " fill=\"url(##{grad_id})\""
+        body << " stroke=\"#{stroke}\""
+        body << " stroke-width=\"1\""
+        body << "/>\n"
+        tx = x + w / 2
+        ty = y + h / 2
+        body << "  <text"
+        body << " x=\"#{tx}\""
+        body << " y=\"#{ty}\""
+        body << " text-anchor=\"middle\""
+        body << " dominant-baseline=\"middle\""
+        body << " font-size=\"#{FONT_SIZE}\""
+        body << " font-weight=\"bold\""
+        body << " fill=\"#333\""
+        body << ">#{escape_xml(label)}</text>\n"
+      end
+
+      def distribute_pixels(children, total_pixels)
+        fixed_sum  = 0
+        auto_count = 0
+        children.each do |child|
+          s = child.size
+          s == :auto ? auto_count += 1 : fixed_sum += s
+        end
+        remaining_percent = [0, 100 - fixed_sum].max
+        auto_percent      = auto_count > 0 ? remaining_percent / auto_count : 0
+        pixels = children.map do |child|
+          pct = child.size == :auto ? auto_percent : child.size
+          total_pixels * pct / 100
+        end
+        used      = pixels.sum
+        remainder = total_pixels - used
+        if remainder != 0
+          (children.size - 1).downto(0) do |i|
+            if children[i].size == :auto
+              pixels[i] += remainder
+              break
+            end
+          end
+        end
+        pixels
+      end
+
+      def extract_label(name)
+        return "" if name.nil?
+        name.gsub(/xref:[^\[]*\[([^\]]*)\]/, '\1')
+            .gsub(/\{[^}]*\}/, "")
+            .strip
+      end
+
+      def escape_xml(text)
+        return "" if text.nil?
+        text.gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+      end
+    end
+  end
+end

data/lib/asciidoctor_diagram_layout/version.rb

@@ -0,0 +1,3 @@
+module AsciidoctorDiagramLayout
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: asciidoctor-diagram-layout
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Anton Pechinsky
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: asciidoctor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Provides a [layout] block for Asciidoctor that renders layout diagrams
+  as HTML or SVG.
+email: anton@pechinsky.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/asciidoctor-diagram-layout.rb
+- lib/asciidoctor_diagram_layout/asciidoc/layout_block_processor.rb
+- lib/asciidoctor_diagram_layout/parser.rb
+- lib/asciidoctor_diagram_layout/renderer/color_palette.rb
+- lib/asciidoctor_diagram_layout/renderer/html_renderer.rb
+- lib/asciidoctor_diagram_layout/renderer/render_options.rb
+- lib/asciidoctor_diagram_layout/renderer/scheme/analogous_scheme.rb
+- lib/asciidoctor_diagram_layout/renderer/scheme/cell_color_scheme_factory.rb
+- lib/asciidoctor_diagram_layout/renderer/scheme/golden_ratio_scheme.rb
+- lib/asciidoctor_diagram_layout/renderer/scheme/monochromatic_scheme.rb
+- lib/asciidoctor_diagram_layout/renderer/svg_renderer.rb
+- lib/asciidoctor_diagram_layout/version.rb
+homepage: https://github.com/apechinsky/asciidoctor-diagram-layout
+licenses:
+- Apache-2.0
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Asciidoctor extension for rendering flex layout diagrams
+test_files: []