sevgi-graphics 0.95.0 → 0.98.2

data/lib/sevgi/graphics/mixtures/inkscape.rb

@@ -5,6 +5,22 @@ module Sevgi
     module Mixtures
       # Inkscape-specific SVG DSL helpers.
       module Inkscape
+        # Normalizes callable wrapper attributes outside the DSL method surface.
+        # @api private
+        module Wrapper
+          # Returns owned wrapper attributes with a stable default id when the module is named.
+          # @param mod [Module] callable drawing module
+          # @param attributes [Hash] wrapper attributes
+          # @return [Hash{Symbol => Object}] normalized attributes
+          # @raise [Sevgi::ArgumentError] when attributes contains colliding names
+          def self.attributes(mod, attributes)
+            defaults = mod.name ? {id: F.demodulize(mod.name).to_sym} : {}
+            Attribute.defaults(attributes, **defaults)
+          end
+        end
+
+        private_constant :Wrapper
+
         # Adds Inkscape template metadata.
         # @param name [String] template name
         # @param desc [String, nil] short description
@@ -23,42 +39,60 @@ module Sevgi
         end
 
         # Renders a callable module inside a group.
-        # @param mod [Module] callable drawing module
+        # Named modules default the group id to their final constant name. Anonymous modules omit the id unless supplied.
+        # @example Supply a stable id for an anonymous callable
+        #   drawing = Module.new do
+        #     extend Sevgi::Graphics::Module
+        #     def call = circle r: 5
+        #   end
+        #   Sevgi::Graphics.SVG(:inkscape) { Group drawing, attributes: {id: "drawing"} }
+        # @param mod [Module] module extended with {Sevgi::Graphics::Module}
         # @param args [Array<Object>] callable arguments
-        # @param kwargs [Hash] group attributes
+        # @param attributes [Hash] group attributes; String and Symbol names are normalized and must not collide
+        # @param kwargs [Hash] callable keyword arguments
         # @yield forwards customization to the callable module
         # @yieldreturn [Object] callable customization result
         # @return [Sevgi::Graphics::Element] group element
-        # @raise [Sevgi::ArgumentError] when mod is not a plain module
-        def Group(mod, *args, **kwargs, &block)
-          kwargs = kwargs.merge(id: F.demodulize(mod).to_sym) unless kwargs.key?(:id)
-          g(**kwargs) { Call(mod, *args, &block) }
+        # @raise [Sevgi::ArgumentError] when mod is not a callable drawing module or attributes is not a Hash
+        def Group(mod, *args, attributes: {}, **kwargs, &block)
+          Graphics::Module.__send__(:callables, mod)
+          ArgumentError.("Group attributes must be a Hash") unless attributes.is_a?(::Hash)
+          attributes = Wrapper.attributes(mod, attributes)
+          g(**attributes) { Call(mod, *args, **kwargs, &block) }
         end
 
         # Renders a callable module inside an Inkscape layer.
-        # @param mod [Module] callable drawing module
+        # Named modules default the layer id to their final constant name. Anonymous modules omit the id unless supplied.
+        # @param mod [Module] module extended with {Sevgi::Graphics::Module}
         # @param args [Array<Object>] callable arguments
-        # @param kwargs [Hash] layer attributes
+        # @param attributes [Hash] layer attributes; String and Symbol names are normalized and must not collide
+        # @param kwargs [Hash] callable keyword arguments
         # @yield forwards customization to the callable module
         # @yieldreturn [Object] callable customization result
         # @return [Sevgi::Graphics::Element] layer element
-        # @raise [Sevgi::ArgumentError] when mod is not a plain module
-        def Layer(mod, *args, **kwargs, &block)
-          kwargs = kwargs.merge(id: F.demodulize(mod).to_sym) unless kwargs.key?(:id)
-          layer(**kwargs) { Call(mod, *args, &block) }
+        # @raise [Sevgi::ArgumentError] when mod is not a callable drawing module or attributes is not a Hash
+        def Layer(mod, *args, attributes: {}, **kwargs, &block)
+          Graphics::Module.__send__(:callables, mod)
+          ArgumentError.("Layer attributes must be a Hash") unless attributes.is_a?(::Hash)
+          attributes = Wrapper.attributes(mod, attributes)
+          layer(**attributes) { Call(mod, *args, **kwargs, &block) }
         end
 
         # Renders a callable module inside an insensitive Inkscape layer.
-        # @param mod [Module] callable drawing module
+        # Named modules default the layer id to their final constant name. Anonymous modules omit the id unless supplied.
+        # @param mod [Module] module extended with {Sevgi::Graphics::Module}
         # @param args [Array<Object>] callable arguments
-        # @param kwargs [Hash] layer attributes
+        # @param attributes [Hash] layer attributes; String and Symbol names are normalized and must not collide
+        # @param kwargs [Hash] callable keyword arguments
         # @yield forwards customization to the callable module
         # @yieldreturn [Object] callable customization result
         # @return [Sevgi::Graphics::Element] layer element
-        # @raise [Sevgi::ArgumentError] when mod is not a plain module
-        def Layer!(mod, *args, **kwargs, &block)
-          kwargs = kwargs.merge(id: F.demodulize(mod).to_sym) unless kwargs.key?(:id)
-          layer!(**kwargs) { Call(mod, *args, &block) }
+        # @raise [Sevgi::ArgumentError] when mod is not a callable drawing module or attributes is not a Hash
+        def Layer!(mod, *args, attributes: {}, **kwargs, &block)
+          Graphics::Module.__send__(:callables, mod)
+          ArgumentError.("Layer attributes must be a Hash") unless attributes.is_a?(::Hash)
+          attributes = Wrapper.attributes(mod, attributes)
+          layer!(**attributes) { Call(mod, *args, **kwargs, &block) }
         end
 
         # @overload layer(**attributes)
@@ -81,46 +115,166 @@ module Sevgi
           layer("sodipodi:insensitive": "true", **, &block)
         end
 
+        # Validates and constructs Inkscape page collections outside the DSL method surface.
+        # @api private
+        module Pagination
+          class << self
+            # Builds a namedview from normalized page attributes.
+            # @param context [Sevgi::Graphics::Element] DSL element receiving the namedview
+            # @param pages [Array<Hash>] page attributes
+            # @param namedview [Hash] namedview attributes
+            # @param page [Hash] shared page attributes
+            # @return [Sevgi::Graphics::Element] namedview element
+            # @raise [Sevgi::ArgumentError] when an attribute channel or page is invalid
+            def call(context, pages, namedview:, page:, &block)
+              namedview, page = channels(namedview, page)
+              pages = pages.each_with_index.map { |attributes, index| normalize(attributes, page, index) }
+
+              context.Element(:"sodipodi:namedview", **namedview) do
+                pages.each do |attributes|
+                  element = Element(:"inkscape:page", **attributes)
+                  block&.call(element)
+                end
+              end
+            end
+
+            # Generates validated attributes for a rectangular page grid.
+            # @return [Array<Hash{Symbol => Object}>] page attribute hashes
+            # @raise [Sevgi::ArgumentError] when a count, dimension, or gap is invalid
+            def tabular(rows:, cols:, width:, height:, gap:)
+              width, height, gap = normalize_grid(rows:, cols:, width:, height:, gap:)
+
+              rows.times.flat_map do |row|
+                cols.times.map do |col|
+                  x = col * (width + gap)
+                  y = row * (height + gap)
+                  label = "#{row + 1}x#{col + 1}"
+                  {id: "pageview-#{label}", x:, y:, width:, height:}
+                end
+              end
+            end
+
+            private
+
+            # Validates and normalizes the namedview and page-default channels.
+            # @return [Array<Hash>] normalized namedview attributes and page defaults
+            # @raise [Sevgi::ArgumentError] when either channel is not a Hash or has invalid attributes
+            # @api private
+            def channels(namedview, page)
+              ArgumentError.("Namedview attributes must be a Hash") unless namedview.is_a?(::Hash)
+              ArgumentError.("Page attributes must be a Hash") unless page.is_a?(::Hash)
+              [Attribute.defaults(namedview, id: "namedview"), Attribute.normalize(page)]
+            end
+
+            # Normalizes one explicit or generated page id.
+            # @return [Hash{String, Symbol => Object}] attributes beginning with a canonical id
+            # @raise [Sevgi::ArgumentError] when String and Symbol ids collide
+            # @api private
+            def identify(attributes, index)
+              id = attributes.key?(:id) ? attributes.delete(:id) : "page-#{index + 1}"
+              {id:}.merge(attributes)
+            end
+
+            # Normalizes and validates one page.
+            # @return [Hash{String, Symbol => Object}] independent page attributes
+            # @raise [Sevgi::ArgumentError] when attributes or dimensions are invalid
+            # @api private
+            def normalize(attributes, defaults, index)
+              ArgumentError.("Page #{index + 1} must be a Hash") unless attributes.is_a?(::Hash)
+              attributes = defaults.merge(Attribute.normalize(attributes))
+              %i[x y].each { number(attributes, it, index) }
+              %i[width height].each do |field|
+                number(attributes, field, index, positive: true)
+              end
+
+              identify(attributes, index)
+            end
+
+            # Validates and normalizes page-grid arguments.
+            # @return [Array<(Integer, Float)>] normalized width, height, and gap
+            # @raise [Sevgi::ArgumentError] when a count, dimension, or gap is invalid
+            # @api private
+            def normalize_grid(rows:, cols:, width:, height:, gap:)
+              {rows:, cols:}.each do |field, count|
+                unless count.is_a?(::Integer) && count.positive?
+                  ArgumentError.("Page #{field} must be a positive Integer")
+                end
+              end
+
+              [
+                Scalar.number(width, context: "page", field: :width, positive: true),
+                Scalar.number(height, context: "page", field: :height, positive: true),
+                Scalar.number(gap, context: "page", field: :gap, nonnegative: true)
+              ]
+            end
+
+            # Replaces one page field with its normalized SVG number.
+            # @return [Integer, Float] normalized number
+            # @api private
+            def number(attributes, field, index, **range)
+              key = attributes.key?(field) ? field : field.to_s
+              attributes[key] = Scalar.number(value(attributes, field, index), context: "page", field:, **range)
+            end
+
+            # Returns one required page field.
+            # @return [Object] page field value
+            # @raise [Sevgi::ArgumentError] when the field is absent
+            # @api private
+            def value(attributes, field, index)
+              attributes.fetch(field) do
+                attributes.fetch(field.to_s) { ArgumentError.("Page #{index + 1} requires #{field}") }
+              end
+            end
+          end
+        end
+
+        private_constant :Pagination
+
         # Builds an Inkscape namedview containing page elements.
-        # @param pages [Array<Hash>] page attribute hashes
-        # @param id [String] namedview id
+        # @example Build explicit pages with separate namedview and page attributes
+        #   Sevgi::Graphics.SVG(:inkscape) do
+        #     Pages(
+        #       {x: 0, y: 0, width: 100, height: 50, label: "front"},
+        #       namedview: {id: "views"},
+        #       page: {class: "print"}
+        #     )
+        #   end
+        # @param pages [Array<Hash>] page attribute hashes; numeric page fields are normalized to SVG numbers
+        # @param namedview [Hash] namedview attributes; String and Symbol names are normalized and must not collide
+        # @param page [Hash] page defaults; normalized page attributes override these defaults by name
         # @yield [page] customizes each generated page element
         # @yieldparam page [Sevgi::Graphics::Element] generated page element
         # @yieldreturn [Object] ignored customization result
         # @return [Sevgi::Graphics::Element] namedview element
-        def Pages(*pages, id: "namedview", **, &block)
-          Element(:"sodipodi:namedview", id:, **) do
-            pages.each_with_index do |page, i|
-              id = page[:id] || "page-#{i + 1}"
-              x, y, width, height = page.values_at(*%i[x y width height])
-              element = Element(:"inkscape:page", id:, x:, y:, width:, height:)
-              yield(element) if block
-            end
-          end
-        end
+        # @raise [Sevgi::ArgumentError] when an attribute channel, page, coordinate, or dimension is invalid
+        def Pages(*pages, namedview: {}, page: {}, &block) = Pagination.call(self, pages, namedview:, page:, &block)
 
         # Builds a tabular set of Inkscape pages.
+        # @example Build a page grid using the same attribute channels as {#Pages}
+        #   Sevgi::Graphics.SVG(:inkscape) do
+        #     PagesTabular(
+        #       rows: 2, cols: 3, width: 100, height: 50, gap: 5,
+        #       namedview: {id: "views"}, page: {class: "print"}
+        #     )
+        #   end
         # @param rows [Integer] number of rows
         # @param cols [Integer] number of columns
-        # @param width [Numeric] page width
-        # @param height [Numeric] page height
-        # @param gap [Numeric] gap between pages
-        # @param id [String] namedview id
-        # @return [Array<Array>] matrix entries as x, y, and label tuples
-        def PagesTabular(rows:, cols:, width:, height:, gap:, id: "namedview", **)
-          [].tap do |matrix|
-            Element(:"sodipodi:namedview", id:) do
-              rows.times do |row|
-                cols.times do |col|
-                  matrix << (x, y, label = col * (width + gap), row * (height + gap), "#{row + 1}x#{col + 1}")
-                  Element(:"inkscape:page", id: "pageview-#{label}", x:, y:, width:, height:, **)
-                end
-              end
-            end
-          end
+        # @param width [Numeric] finite positive page width, normalized to an SVG number
+        # @param height [Numeric] finite positive page height, normalized to an SVG number
+        # @param gap [Numeric] finite non-negative gap, normalized to an SVG number
+        # @param namedview [Hash] namedview attributes; String and Symbol names are normalized and must not collide
+        # @param page [Hash] page defaults; normalized page attributes override these defaults by name
+        # @yield [page] customizes each generated page element
+        # @yieldparam page [Sevgi::Graphics::Element] generated page element
+        # @yieldreturn [Object] ignored customization result
+        # @return [Sevgi::Graphics::Element] namedview element
+        # @raise [Sevgi::ArgumentError] when counts, dimensions, gap, or an attribute channel is invalid
+        # @see #Pages
+        def PagesTabular(rows:, cols:, width:, height:, gap:, namedview: {}, page: {}, &block)
+          pages = Pagination.tabular(rows:, cols:, width:, height:, gap:)
+          Pages(*pages, namedview:, page:, &block)
         end
 
-        # Internal symbol which does not show up Symbols Menu
         # @overload symbol!(**attributes)
         #   Builds an Inkscape symbol group hidden from the symbols menu.
         #   @param attributes [Hash] symbol attributes

data/lib/sevgi/graphics/mixtures/rdf.rb

@@ -4,21 +4,47 @@ module Sevgi
   module Graphics
     module Mixtures
       # DSL helpers for RDF and license metadata.
+      #
+      # @example Add Creative Commons metadata
+      #   Sevgi::Graphics.SVG :inkscape do
+      #     License_CC0 title: "Example", creator: "A. Creator"
+      #   end
       module RDF
+        WORK_OPTIONS = %i[title description creator publisher date language license].freeze
+        private_constant :WORK_OPTIONS
+
         # Adds RDF license metadata inside a metadata element.
         # @param kwargs [Hash] RDF work options
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
-        def License(**kwargs, &block) = metadata { RDFWork(**kwargs, &block) }
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
+        def License(**kwargs, &block)
+          unknown = kwargs.keys - WORK_OPTIONS
+          ArgumentError.("Unknown license options: #{unknown.join(", ")}") unless unknown.empty?
+
+          metadata { RDFWork(**kwargs, &block) }
+        end
+
+        # Adds Creative Commons BY license metadata.
+        # @param kwargs [Hash] RDF work options
+        # @yield evaluates additional RDF work metadata
+        # @yieldreturn [Object] ignored block result
+        # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
+        def License_CC_BY(**kwargs, &block)
+          License(**kwargs, license: "https://creativecommons.org/licenses/by/4.0/", &block)
+        end
 
-        # Use SPDX license codes in underscored form: https://spdx.org/licenses/
-        #
         # Adds Creative Commons BY-SA license metadata.
         # @param kwargs [Hash] RDF work options
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_CC_BY_SA(**kwargs, &block)
           License(**kwargs, license: "https://creativecommons.org/licenses/by-sa/4.0/", &block)
         end
@@ -28,6 +54,8 @@ module Sevgi
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_CC_BY_NC(**kwargs, &block)
           License(**kwargs, license: "https://creativecommons.org/licenses/by-nc/4.0/", &block)
         end
@@ -37,6 +65,8 @@ module Sevgi
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_CC_BY_NC_SA(**kwargs, &block)
           License(**kwargs, license: "https://creativecommons.org/licenses/by-nc-sa/4.0/", &block)
         end
@@ -46,6 +76,8 @@ module Sevgi
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_CC_BY_ND(**kwargs, &block)
           License(**kwargs, license: "https://creativecommons.org/licenses/by-nd/4.0/", &block)
         end
@@ -55,6 +87,8 @@ module Sevgi
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_CC_BY_NC_ND(**kwargs, &block)
           License(**kwargs, license: "https://creativecommons.org/licenses/by-nc-nd/4.0/", &block)
         end
@@ -64,6 +98,8 @@ module Sevgi
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_CC0(**kwargs, &block)
           License(**kwargs, license: "https://creativecommons.org/publicdomain/zero/1.0/", &block)
         end
@@ -73,15 +109,19 @@ module Sevgi
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] metadata element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
+        # @see #RDFWork
         def License_LAL(**kwargs, &block) = License(**kwargs, license: "https://artlibre.org/licence/lal/en/", &block)
 
         # Builds an RDF root element.
-        # @param _kwargs [Hash] currently unused options
+        # @param kwargs [Hash] options; RDF currently accepts none
         # @yield evaluates the RDF drawing DSL
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] RDF element
         # @raise [Sevgi::ArgumentError] when no block is given
-        def RDF(**_kwargs, &block)
+        # @raise [Sevgi::ArgumentError] when an option is given
+        def RDF(**kwargs, &block)
+          ArgumentError.("Unknown RDF options: #{kwargs.keys.join(", ")}") unless kwargs.empty?
           ArgumentError.("Block required") unless block
 
           Element(
@@ -94,7 +134,6 @@ module Sevgi
           end
         end
 
-        # rubocop:disable Metrics/MethodLength
         # Builds a Creative Commons RDF Work element.
         # @param kwargs [Hash] RDF work options
         # @option kwargs [String] :title work title
@@ -104,10 +143,24 @@ module Sevgi
         # @option kwargs [String] :date date
         # @option kwargs [String] :language language
         # @option kwargs [String] :license license URL
+        #
+        # | Option | RDF element |
+        # | --- | --- |
+        # | `title` | `dc:title` |
+        # | `description` | `dc:description` |
+        # | `creator` | `dc:creator` |
+        # | `publisher` | `dc:publisher` |
+        # | `date` | `dc:date` |
+        # | `language` | `dc:language` |
+        # | `license` | `cc:license` resource |
         # @yield evaluates additional RDF work metadata
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] RDF element
+        # @raise [Sevgi::ArgumentError] when an option is unknown
         def RDFWork(**kwargs, &block)
+          unknown = kwargs.keys - WORK_OPTIONS
+          ArgumentError.("Unknown RDF work options: #{unknown.join(", ")}") unless unknown.empty?
+
           RDF do
             Element(:"cc:Work", "rdf:about": "") do
               Element(:"dc:format", "image/svg+xml")
@@ -124,7 +177,6 @@ module Sevgi
             end
           end
         end
-        # rubocop:enable Metrics/MethodLength
       end
     end
   end

data/lib/sevgi/graphics/mixtures/render.rb

@@ -10,6 +10,7 @@ module Sevgi
         class Renderer
           # Default renderer options.
           DEFAULTS = {indent: "  ", linelength: 140, style: :hybrid}.freeze
+          STYLES = %i[hybrid inline block].freeze
           SVG_NAMESPACE = "http://www.w3.org/2000/svg"
 
           # Attribute rendering strategies.
@@ -23,7 +24,7 @@ module Sevgi
               # @param depth [Integer] element depth
               # @return [void]
               def attributes(element, depth)
-                attributes_block(element, depth, element.attributes.to_xml_lines)
+                attributes_block(element, depth, element.attributes.send(:xml_lines))
               end
             end
 
@@ -35,7 +36,7 @@ module Sevgi
               # @param depth [Integer] element depth
               # @return [void]
               def attributes(element, depth)
-                if attributes_as_block?(lines = element.attributes.to_xml_lines, depth)
+                if attributes_as_block?(lines = element.attributes.send(:xml_lines), depth)
                   attributes_block(element, depth, lines)
                 else
                   attributes_inline(element, depth, lines)
@@ -67,7 +68,7 @@ module Sevgi
               # @param depth [Integer] element depth
               # @return [void]
               def attributes(element, depth)
-                attributes_inline(element, depth, element.attributes.to_xml_lines)
+                attributes_inline(element, depth, element.attributes.send(:xml_lines))
               end
             end
           end
@@ -78,7 +79,13 @@ module Sevgi
           ELEMENTS_WITH_BLOCK_CONTENT = %i[style].freeze
           SEPARATOR = "\n"
 
-          private_constant :ELEMENTS_WITH_INLINE_CONTENT, :ELEMENTS_WITH_BLOCK_CONTENT, :SEPARATOR, :SVG_NAMESPACE
+          private_constant(
+            :ELEMENTS_WITH_INLINE_CONTENT,
+            :ELEMENTS_WITH_BLOCK_CONTENT,
+            :SEPARATOR,
+            :STYLES,
+            :SVG_NAMESPACE
+          )
 
           # @return [Sevgi::Graphics::Element] root element
           attr_reader :root
@@ -165,7 +172,7 @@ module Sevgi
           #   @raise [Sevgi::ArgumentError] when an option is unknown, malformed, missing, or unsupported
           def initialize(root, **)
             @root = root
-            @options = DEFAULTS.merge(**)
+            @options = self.class.send(:validate, **)
             @output = []
             @inlines = Inlines.new
 
@@ -187,6 +194,29 @@ module Sevgi
           # @raise [Sevgi::ArgumentError] when options, names, attributes, or content are invalid XML
           def self.fragment(root, **options) = new(root, **options).call
 
+          def self.validate(**options)
+            options = DEFAULTS.merge(options)
+            unknown = options.keys - DEFAULTS.keys
+            ArgumentError.("Unknown renderer options: #{unknown.join(", ")}") unless unknown.empty?
+
+            indent = options[:indent]
+            unless indent.is_a?(::String) && /\A[\t\n\r ]*\z/.match?(indent)
+              ArgumentError.("Renderer indent must contain only XML whitespace")
+            end
+
+            options[:indent] = XML.text(indent, context: "Renderer indent")
+            linelength = options[:linelength]
+            unless linelength.is_a?(::Integer) && linelength >= 0
+              ArgumentError.("Renderer linelength must be a non-negative Integer")
+            end
+
+            ArgumentError.("Unrecognized style: #{options[:style]}") unless STYLES.include?(options[:style])
+
+            options.freeze
+          end
+
+          private_class_method :validate
+
           # Appends rendered lines to the output buffer.
           # @param depth [Integer, nil] indentation depth
           # @param lines [Array<String>] rendered lines
@@ -236,9 +266,6 @@ module Sevgi
           end
 
           def build
-            validate_options!
-            ArgumentError.("Missing style") unless options[:style]
-
             case options[:style]
             when :hybrid
               extend(Attributes::Hybrid)
@@ -246,8 +273,6 @@ module Sevgi
               extend(Attributes::Inline)
             when :block
               extend(Attributes::Block)
-            else
-              ArgumentError.("Unrecognized style: #{options[:style]}")
             end
 
             unclosed
@@ -330,21 +355,6 @@ module Sevgi
 
           def unclosed = @closed = false
 
-          def validate_options!
-            unknown = options.keys - DEFAULTS.keys
-            ArgumentError.("Unknown renderer options: #{unknown.join(", ")}") unless unknown.empty?
-
-            indent = options[:indent]
-            unless indent.is_a?(::String) && /\A[\t\n\r ]*\z/.match?(indent)
-              ArgumentError.("Renderer indent must contain only XML whitespace")
-            end
-
-            options[:indent] = XML.text(indent, context: "Renderer indent")
-            linelength = options[:linelength]
-            return if linelength.is_a?(::Integer) && linelength >= 0
-
-            ArgumentError.("Renderer linelength must be a non-negative Integer")
-          end
         end
 
         private_constant :Renderer
@@ -355,7 +365,13 @@ module Sevgi
         #   descendants in the same text line. Whitespace inside content objects is preserved as given, and encoded
         #   content is XML-escaped unless a verbatim content object is used. SVG `style` elements use block content;
         #   same-named elements under a foreign default namespace retain ordinary inline text formatting.
+        #   @example Keep every attribute on the element's opening line
+        #     SVG(:minimal) { rect id: "card", width: 80, height: 40 }.Render(style: :inline)
         #   @param options [Hash] renderer options
+        #   @option options [String] :indent ("  ") XML-whitespace indentation unit
+        #   @option options [Integer] :linelength (140) non-negative line length that switches hybrid attributes to block
+        #     style
+        #   @option options [Symbol] :style (:hybrid) attribute layout: `:hybrid`, `:inline`, or `:block`
         #   @return [String] SVG source
         #   @raise [Sevgi::ArgumentError] when options, preambles, names, attributes, or content are invalid XML
         def Render(**) = Renderer.(self, **)
@@ -363,14 +379,22 @@ module Sevgi
         # Renders only this element's children.
         # Child render output omits document preambles and preserves each child's text whitespace and inline
         # mixed-content formatting.
+        # @example Render child fragments with block-style attributes
+        #   Sevgi::Graphics.SVG(:minimal) { rect id: "one" }.RenderChildren(style: :block, indent: "\t")
         # @param separator [String] separator between child documents
+        # @param options [Hash] renderer options applied to every child fragment
+        # @option options [String] :indent ("  ") XML-whitespace indentation unit
+        # @option options [Integer] :linelength (140) non-negative line length that switches hybrid attributes to block
+        #   style
+        # @option options [Symbol] :style (:hybrid) attribute layout: `:hybrid`, `:inline`, or `:block`
         # @return [String] rendered child fragments
-        # @raise [Sevgi::ArgumentError] when separator or rendered child data is not valid XML text
-        def RenderChildren(separator = "\n\n")
+        # @raise [Sevgi::ArgumentError] when separator, options, or rendered child data is invalid
+        def RenderChildren(separator = "\n\n", **options)
           ArgumentError.("SVG fragment separator must be a String") unless separator.is_a?(::String)
 
           separator = XML.text(separator, context: "SVG fragment separator")
-          children.map { Renderer.fragment(it) }.join(separator)
+          Renderer.send(:validate, **options)
+          children.map { Renderer.fragment(it, **options) }.join(separator)
         end
       end
     end