sevgi-graphics 0.95.0 → 1.0.0

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

@@ -3,22 +3,35 @@
 module Sevgi
   module Graphics
     module Mixtures
-      # rubocop:disable Metrics/MethodLength
-      # DSL helpers for repeated SVG use elements.
+      # DSL helpers for defining one SVG template and repeating it through `use` elements.
+      #
+      # Use {Sevgi::Sundries::Tile} instead when Ruby code needs inspectable repeated geometry or row/column bounds
+      # rather than SVG references.
+      # @see Sevgi::Sundries::Tile
+      # @see https://sevgi.roktas.dev/layout/#choose-a-layout-model Choosing a layout model
       module Tile
-        # Prefix used for generated tile CSS classes.
+        # Stable prefix used for generated tile CSS classes.
         PREFIX = "tile"
 
         # Builds a two-dimensional tile grid.
+        # Each use id has the form `id-row-column`, with one-based row and column numbers. Generated classes identify
+        # the one-based row and column and mark their first and last positions. A block defines the referenced template
+        # as a group under `defs` before the uses are added.
+        # @example Define and customize a tile grid
+        #   customize = proc { |use, x:, y:, nx:, ny:| use[:opacity] = (x + y + 1).fdiv(nx + ny) }
+        #   Sevgi::Graphics.SVG(:minimal) do
+        #     Tile("dot", nx: 2, dx: 10, ny: 2, dy: 10, proc: customize) { circle r: 2 }
+        #   end
         # @param id [String] referenced template id
         # @param nx [Integer] number of columns
-        # @param dx [Numeric] horizontal spacing
-        # @param ox [Numeric] horizontal offset
+        # @param dx [Numeric] finite horizontal spacing, normalized before coordinates are rendered
+        # @param ox [Numeric] finite horizontal offset, normalized before coordinates are rendered
         # @param ny [Integer] number of rows
-        # @param dy [Numeric] vertical spacing
-        # @param oy [Numeric] vertical offset
-        # @param proc [Proc, nil] optional coordinate/customization proc
-        # @yield evaluates the template drawing DSL in a generated group
+        # @param dy [Numeric] finite vertical spacing, normalized before coordinates are rendered
+        # @param oy [Numeric] finite vertical offset, normalized before coordinates are rendered
+        # @param proc [Proc, nil] optional callback invoked for each use as `(element, x:, y:, nx:, ny:)`, with
+        #   zero-based coordinates and total counts. The callback can mutate the element. Its return value is ignored
+        # @yield evaluates the template drawing DSL in a generated `defs` group named by id
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] self
         # @raise [Sevgi::ArgumentError] when a required tile argument is missing or invalid
@@ -33,14 +46,9 @@ module Sevgi
           proc: nil,
           &block
         )
-          Helper.assert(id:, nx:, dx:, ox:, ny:, dy:, oy:, proc:)
-
-          href, coords = id, proc do |x, y|
-            # rubocop:disable Style/NestedTernaryOperator
-            # for pretty kwargs handling
-            x.zero? ? (y.zero? ? {} : {y:}) : (y.zero? ? {x:} : {x:, y:})
-            # rubocop:enable Style/NestedTernaryOperator
-          end
+          id, nx, dx, ox, ny, dy, oy, callback = Helper
+            .normalize(id:, nx:, dx:, ox:, ny:, dy:, oy:, proc:)
+            .values_at(:id, :nx, :dx, :ox, :ny, :dy, :oy, :proc)
 
           defs { g(id:, &block) } if block
 
@@ -52,34 +60,36 @@ module Sevgi
                 cs = Helper.classify(as: "col", index: x, upper: nx)
 
                 element = use(
-                  id: [href, y + 1, x + 1].join("-"),
-                  href: "##{href}",
+                  id: [id, y + 1, x + 1].join("-"),
+                  href: "##{id}",
                   class: [*rs, *cs].join(" "),
-                  **coords.((x * dx) + ox, (y * dy) + oy)
+                  **Helper.coordinates(
+                    x: Scalar.number((x * dx) + ox, context: "tile", field: :x),
+                    y: Scalar.number((y * dy) + oy, context: "tile", field: :y)
+                  )
                 )
-                proc&.call(element, x:, y:, nx:, ny:)
+                callback&.call(element, x:, y:, nx:, ny:)
               end
             end
           end
         end
 
         # Builds a one-dimensional horizontal tile row.
+        # Each use id has the form `id-column`, with a one-based column number. Generated classes identify the column and
+        # mark its first and last positions. A block defines the referenced template as a group under `defs` before the
+        # uses are added.
         # @param id [String] referenced template id
         # @param n [Integer] number of instances
-        # @param d [Numeric] horizontal spacing
-        # @param o [Numeric] horizontal offset
-        # @param proc [Proc, nil] optional coordinate/customization proc
-        # @yield evaluates the template drawing DSL in a generated group
+        # @param d [Numeric] finite horizontal spacing, normalized before coordinates are rendered
+        # @param o [Numeric] finite horizontal offset, normalized before coordinates are rendered
+        # @param proc [Proc, nil] optional callback invoked for each use as `(element, x:, n:)`, with a zero-based column
+        #   and total count. The callback can mutate the element. Its return value is ignored
+        # @yield evaluates the template drawing DSL in a generated `defs` group named by id
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] self
         # @raise [Sevgi::ArgumentError] when a required tile argument is missing or invalid
         def TileX(id = Undefined, n: Undefined, d: Undefined, o: 0, proc: nil, &block)
-          Helper.assert(id:, n:, d:, o:, proc:)
-
-          href, coords = id, proc do |x|
-            # for pretty kwargs handling
-            x.zero? ? {} : {x:}
-          end
+          id, n, d, o, callback = Helper.normalize(id:, n:, d:, o:, proc:).values_at(:id, :n, :d, :o, :proc)
 
           defs { g(id:, &block) } if block
 
@@ -88,33 +98,32 @@ module Sevgi
               cs = Helper.classify(as: "col", index: x, upper: n)
 
               element = use(
-                id: [href, x + 1].join("-"),
-                href: "##{href}",
+                id: [id, x + 1].join("-"),
+                href: "##{id}",
                 class: cs.join(" "),
-                **coords.((x * d) + o)
+                **Helper.coordinates(x: Scalar.number((x * d) + o, context: "tile", field: :x))
               )
-              proc&.call(element, x:, n:)
+              callback&.call(element, x:, n:)
             end
           end
         end
 
         # Builds a one-dimensional vertical tile column.
+        # Each use id has the form `id-row`, with a one-based row number. Generated classes identify the row and mark its
+        # first and last positions. A block defines the referenced template as a group under `defs` before the uses are
+        # added.
         # @param id [String] referenced template id
         # @param n [Integer] number of instances
-        # @param d [Numeric] vertical spacing
-        # @param o [Numeric] vertical offset
-        # @param proc [Proc, nil] optional coordinate/customization proc
-        # @yield evaluates the template drawing DSL in a generated group
+        # @param d [Numeric] finite vertical spacing, normalized before coordinates are rendered
+        # @param o [Numeric] finite vertical offset, normalized before coordinates are rendered
+        # @param proc [Proc, nil] optional callback invoked for each use as `(element, y:, n:)`, with a zero-based row and
+        #   total count. The callback can mutate the element. Its return value is ignored
+        # @yield evaluates the template drawing DSL in a generated `defs` group named by id
         # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] self
         # @raise [Sevgi::ArgumentError] when a required tile argument is missing or invalid
         def TileY(id = Undefined, n: Undefined, d: Undefined, o: 0, proc: nil, &block)
-          Helper.assert(id:, n:, d:, o:, proc:)
-
-          href, coords = id, proc do |y|
-            # for pretty kwargs handling
-            y.zero? ? {} : {y:}
-          end
+          id, n, d, o, callback = Helper.normalize(id:, n:, d:, o:, proc:).values_at(:id, :n, :d, :o, :proc)
 
           defs { g(id:, &block) } if block
 
@@ -123,12 +132,12 @@ module Sevgi
               rs = Helper.classify(as: "row", index: y, upper: n)
 
               element = use(
-                id: [href, y + 1].join("-"),
-                href: "##{href}",
+                id: [id, y + 1].join("-"),
+                href: "##{id}",
                 class: rs.join(" "),
-                **coords.((y * d) + o)
+                **Helper.coordinates(y: Scalar.number((y * d) + o, context: "tile", field: :y))
               )
-              proc&.call(element, y:, n:)
+              callback&.call(element, y:, n:)
             end
           end
         end
@@ -138,18 +147,14 @@ module Sevgi
         module Helper
           extend self
 
+          FINITE = %i[d dx dy o ox oy].freeze
+
           # Argument validators for tile helpers.
           ASSERTION = {
             id: proc { |name, value| "Argument '#{name}' must be a string" unless value.is_a?(::String) },
             n: proc { |name, value| positive_integer_issue(name, value) },
             nx: proc { |name, value| positive_integer_issue(name, value) },
             ny: proc { |name, value| positive_integer_issue(name, value) },
-            d: proc { |name, value| "Argument '#{name}' must be a number" unless value.is_a?(::Numeric) },
-            dx: proc { |name, value| "Argument '#{name}' must be a number" unless value.is_a?(::Numeric) },
-            dy: proc { |name, value| "Argument '#{name}' must be a number" unless value.is_a?(::Numeric) },
-            o: proc { |name, value| "Argument '#{name}' must be a number" unless value.is_a?(::Numeric) },
-            ox: proc { |name, value| "Argument '#{name}' must be a number" unless value.is_a?(::Numeric) },
-            oy: proc { |name, value| "Argument '#{name}' must be a number" unless value.is_a?(::Numeric) },
             proc: proc { |name, value| "Argument '#{name}' must be a proc" unless value.nil? || value.is_a?(::Proc) }
           }.freeze
 
@@ -161,22 +166,33 @@ module Sevgi
             "Argument '#{name}' must be a positive integer" unless value.is_a?(::Integer) && value.positive?
           end
 
-          # Validates tile arguments.
+          # Validates and normalizes tile arguments.
           # @param kwargs [Hash] tile arguments
-          # @return [nil]
+          # @return [Hash] independent arguments with spacing and offsets normalized to SVG numbers
           # @raise [Sevgi::ArgumentError] when an argument is missing or invalid
-          def assert(**kwargs)
-            kwargs.each do |name, value|
-              issue = "Argument '#{name}' required" if value == Undefined
+          def normalize(**kwargs)
+            kwargs.to_h do |name, value|
+              ArgumentError.("Argument '#{name}' required") if value == Undefined
+              [name, normalize_value(name, value)]
+            end
+          end
 
-              unless issue
-                next unless (assertion = ASSERTION[name])
-                next unless (issue = assertion.call(name, value))
-              end
+          def coordinates(**coordinates)
+            coordinates.reject { |_, value| value.zero? }
+          end
 
-              ArgumentError.(issue)
-            end
-            # rubocop:enable Metrics/MethodLength
+          def normalize_value(name, value)
+            return number(name, value) if FINITE.include?(name)
+            return value unless (assertion = ASSERTION[name])
+            return value unless (issue = assertion.call(name, value))
+
+            ArgumentError.(issue)
+          end
+
+          def number(name, value)
+            Scalar.number(value, context: "tile", field: name)
+          rescue ::Sevgi::ArgumentError
+            ArgumentError.("Argument '#{name}' must be a finite real number")
           end
 
           # Returns positional tile CSS classes.
@@ -191,6 +207,8 @@ module Sevgi
               classes << "#{PREFIX}-#{as}-last" if index + 1 == upper
             end
           end
+
+          private :normalize_value, :number
         end
 
         private_constant :Helper

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

@@ -4,29 +4,57 @@ module Sevgi
   module Graphics
     module Mixtures
       # DSL helpers for SVG transform attributes.
+      #
+      # Transform calls are appended in call order and return the element, so they can be composed.
+      # @example Compose transforms on one element
+      #   Sevgi::Graphics.SVG(:minimal) do
+      #     rect(width: 8, height: 4).Translate(12, 6).Rotate(15, 4, 2)
+      #   end
       module Transform
+        # Keep box validation here: mixture helper methods would also enter the SVG DSL namespace.
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
         # Aligns an inner box inside an outer box.
         # @param position [Symbol, String, nil] alignment name
-        # @param inner [#width, #height, nil] inner box
-        # @param outer [#width, #height, nil] outer box
+        # @param inner [#width, #height, nil] inner box, with optional position exposing x and y
+        # @param outer [#width, #height, nil] outer box, with optional position exposing x and y
         # @return [Sevgi::Graphics::Element] self
         # @raise [Sevgi::ArgumentError] when alignment is unsupported
+        # @raise [Sevgi::ArgumentError] when a box dimension is not a finite real number
+        # @raise [Sevgi::ArgumentError] when a supplied box position does not expose finite real x and y coordinates
+        # @note Size-only boxes have origin (0, 0). Positions describe known box geometry, not renderer-computed bounds.
         def Align(position, inner:, outer:)
           return self unless position && inner && outer
 
           case position.to_sym
           when :center
-            Translate((outer.width - inner.width) / 2.0, (outer.height - inner.height) / 2.0)
+            dimensions = [inner.width, inner.height, outer.width, outer.height]
+            iw, ih, ow, oh = dimensions.map { Scalar.number(it, context: "alignment", field: :dimension) }
+            origins = [inner, outer].map do |box|
+              next [0, 0] unless box.respond_to?(:position)
+
+              origin = box.position
+              unless origin.respond_to?(:x) && origin.respond_to?(:y)
+                ArgumentError.("Alignment box position must expose x and y")
+              end
+
+              [origin.x, origin.y].map { Scalar.number(it, context: "alignment", field: :position) }
+            end
+
+            (ix, iy), (ox, oy) = origins
+            Translate(ox - ix + ((ow - iw) / 2.0), oy - iy + ((oh - ih) / 2.0))
           else
             ArgumentError.("Unsupported alignment: #{position}")
           end
         end
 
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
         # Appends a scale(-1, -1) transform.
         # @return [Sevgi::Graphics::Element] self
         def Flip
           tap do
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "scale(-1, -1)"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "scale(-1, -1)"
           end
         end
 
@@ -34,7 +62,7 @@ module Sevgi
         # @return [Sevgi::Graphics::Element] self
         def FlipX
           tap do
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "scale(-1, 1)"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "scale(-1, 1)"
           end
         end
 
@@ -42,36 +70,40 @@ module Sevgi
         # @return [Sevgi::Graphics::Element] self
         def FlipY
           tap do
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "scale(1, -1)"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "scale(1, -1)"
           end
         end
 
         # Appends a six-value SVG matrix transform.
-        # @param values [Array<Numeric>] matrix values
+        # @param values [Array<Numeric>] finite matrix values, normalized to SVG numbers
         # @return [Sevgi::Graphics::Element] self
-        # @raise [Sevgi::ArgumentError] when exactly six values are not supplied
+        # @raise [Sevgi::ArgumentError] when six finite real values are not supplied
         def Matrix(*values)
           tap do
             ArgumentError.("Incorrect transform matrix (six values required): #{values}") if values.size != 6
+            values = Scalar.numbers(values, context: "matrix")
 
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "matrix(#{values.join(" ")})"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "matrix(#{values.join(" ")})"
           end
         end
 
         # Appends an SVG rotate transform.
-        # @param a [Numeric] angle in degrees
-        # @param origin [Array<Numeric>] optional x and y origin
+        # @param a [Numeric] finite angle in degrees, normalized to an SVG number
+        # @param origin [Array<Numeric>] optional finite x and y origin, normalized to SVG numbers
         # @return [Sevgi::Graphics::Element] self
-        # @raise [Sevgi::ArgumentError] when origin is not two coordinates
+        # @raise [Sevgi::ArgumentError] when angle or origin is not finite real, or origin is not two coordinates
         def Rotate(a, *origin)
           tap do
             if !origin.empty? && origin.size != 2
               ArgumentError.("Incorrect origin (two coordinates required): #{origin}")
             end
 
-            next if a.to_f == 0.0
+            angle = Scalar.number(a, context: "rotation", field: :angle)
+            origin = Scalar.numbers(origin, context: "rotation")
 
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "rotate(#{[a, *origin].join(", ")})"
+            next if angle.zero?
+
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "rotate(#{[angle, *origin].join(", ")})"
           end
         end
 
@@ -88,56 +120,83 @@ module Sevgi
         def RotateLeft(...) = Rotate(-90, ...)
 
         # Appends an SVG scale transform.
-        # @param x [Numeric] x scale, or uniform scale when y is nil
-        # @param y [Numeric, nil] y scale
+        # @param x [Numeric] finite x scale, or uniform scale when y is nil
+        # @param y [Numeric, nil] finite y scale
         # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when a scale is not a finite real number
         def Scale(x, y = nil)
           tap do
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "scale(#{(y ? [x, y] : [x]).join(", ")})"
+            x = Scalar.number(x, context: "scale", field: :x)
+            y = Scalar.number(y, context: "scale", field: :y) unless y.nil?
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "scale(#{(y.nil? ? [x] : [x, y]).join(", ")})"
           end
         end
 
         # Appends a skew transform through an SVG matrix.
-        # @param ax [Numeric] x skew angle in degrees
-        # @param ay [Numeric] y skew angle in degrees
+        # @param ax [Numeric] finite x skew angle in degrees, normalized before calculation
+        # @param ay [Numeric] finite y skew angle in degrees, normalized before calculation
         # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when an angle is not a finite real number
         def Skew(ax, ay)
+          ax = Scalar.number(ax, context: "skew", field: :x)
+          ay = Scalar.number(ay, context: "skew", field: :y)
           Matrix(1.0, ::Math.tan(ay / 180.0 * ::Math::PI), ::Math.tan(ax / 180.0 * ::Math::PI), 1.0, 0.0, 0.0)
         end
 
         # Appends an SVG skewX transform.
-        # @param a [Numeric] angle in degrees
+        # @param a [Numeric] finite angle in degrees, normalized to an SVG number
         # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when angle is not a finite real number
         def SkewX(a)
           tap do
-            next if a.to_f == 0.0
+            angle = Scalar.number(a, context: "skew", field: :x)
+            next if angle.zero?
 
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "skewX(#{a})"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "skewX(#{angle})"
           end
         end
 
         # Appends an SVG skewY transform.
-        # @param a [Numeric] angle in degrees
+        # @param a [Numeric] finite angle in degrees, normalized to an SVG number
         # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when angle is not a finite real number
         def SkewY(a)
           tap do
-            next if a.to_f == 0.0
+            angle = Scalar.number(a, context: "skew", field: :y)
+            next if angle.zero?
 
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "skewY(#{a})"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "skewY(#{angle})"
           end
         end
 
-        # Appends an SVG translate transform.
-        # @param x [Numeric] x translation
-        # @param y [Numeric, nil] y translation
+        # Appends an SVG translate transform. One argument translates only the x axis.
+        # @param x [Numeric] finite x translation, normalized to an SVG number
+        # @param y [Numeric, nil] finite y translation, normalized to an SVG number
         # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when a coordinate is not a finite real number
         def Translate(x, y = nil)
           tap do
-            next if x.to_f == 0.0 && (y.nil? || y.to_f == 0.0)
+            dx = Scalar.number(x, context: "translation", field: :x)
+            dy = Scalar.number(y, context: "translation", field: :y) unless y.nil?
+            next if dx.zero? && (dy.nil? || dy.zero?)
 
-            attributes[:"transform#{ATTRIBUTE_UPDATE_SUFFIX}"] = "translate(#{(y ? [x, y] : [x]).join(" ")})"
+            attributes[:"transform#{Attributes::UPDATE_SUFFIX}"] = "translate(#{(dy.nil? ? [dx] : [dx, dy]).join(" ")})"
           end
         end
+
+        # Appends an x-axis SVG translate transform.
+        # @param x [Numeric] finite x translation
+        # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when x is not a finite real number
+        # @see #Translate
+        def TranslateX(x) = Translate(x)
+
+        # Appends a y-axis SVG translate transform.
+        # @param y [Numeric] finite y translation
+        # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when y is not a finite real number
+        # @see #Translate
+        def TranslateY(y) = Translate(0, y)
       end
     end
   end

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

@@ -3,8 +3,11 @@
 module Sevgi
   module Graphics
     module Mixtures
-      # DSL helpers for floating text, comments, and inherited internal attributes.
+      # DSL helpers for floating text, comments, and inherited non-rendering context.
       module Underscore
+        CONTEXT = :"#{Attributes::META_PREFIX}context"
+        private_constant :CONTEXT
+
         # Creates a floating content element.
         # @param contents [Array<Object>] text or content objects
         # @return [Sevgi::Graphics::Element] floating element
@@ -15,7 +18,7 @@ module Sevgi
         # Adds an XML comment.
         # @param comment [Object] comment text
         # @return [Sevgi::Graphics::Element] floating comment element
-        # @raise [Sevgi::ArgumentError] when comment cannot be stringified as valid XML or would form malformed markup
+        # @raise [Sevgi::ArgumentError] when comment cannot be stringified as valid XML or forms malformed markup
         def Comment(comment)
           comment = XML.text(comment, context: "XML comment")
 
@@ -25,16 +28,22 @@ module Sevgi
           _(Content.verbatim("<!-- #{comment} -->"))
         end
 
-        # Merges internal attributes from the document root, ancestors, and this element.
-        # Only the direct root-to-self ancestor chain participates; sibling subtrees are ignored. When the same key is
-        # present on multiple chain elements, the nearest element to the receiver wins.
-        # @return [Hash] merged internal attributes
+        # Merges `-context` metadata from the document root, ancestors, and this element.
+        # Only the direct root-to-self ancestor chain participates. Sibling subtrees are ignored. When the same key is
+        # present on multiple chain elements, the nearest element to the receiver wins. Context remains available in
+        # memory but is omitted from rendered SVG. It is unrelated to the `_:` XML namespace syntax preserved by
+        # Derender.
+        # @return [Hash] merged context
+        # @example Inherit drawing context without rendering it
+        #   Sevgi::Graphics.SVG "-context": {tone: "tomato"} do
+        #     rect fill: Ancestral()[:tone]
+        #   end
         def Ancestral
           chain = []
           TraverseUp { |element| chain.unshift(element) }
 
           {}.tap do |result|
-            chain.each { |element| result.merge!(element[:_]) if element.has?(:_) }
+            chain.each { |element| result.merge!(element[CONTEXT]) if element.has?(CONTEXT) }
           end
         end
       end

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

@@ -22,7 +22,7 @@ module Sevgi
         def CData
           return if !contents || contents.empty?
 
-          Content.text(contents)
+          contents.join("\n")
         end
 
         # Reports whether a namespace is available on this element or an ancestor.
@@ -41,7 +41,7 @@ module Sevgi
           Traverse do |element|
             Standard.conform(
               element.name,
-              attributes: element.attributes.list,
+              attributes: element.attributes.keys,
               cdata: element.CData(),
               elements: element.children.map(&:name)
             )