sevgi-graphics 0.94.0 → 0.98.2

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

@@ -6,27 +6,42 @@ module Sevgi
       # DSL wrappers for common SVG shapes and content patterns.
       module Wrappers
         # Builds a line path ending at an absolute point.
-        # @param x2 [Numeric] ending x coordinate
-        # @param y2 [Numeric] ending y coordinate
-        # @param x1 [Numeric] starting x coordinate
-        # @param y1 [Numeric] starting y coordinate
+        # @example Render a rational coordinate as an SVG number
+        #   Sevgi::Graphics.SVG { LineTo(x2: Rational(1, 2), y2: 1) }
+        # @param x2 [Numeric] finite ending x coordinate
+        # @param y2 [Numeric] finite ending y coordinate
+        # @param x1 [Numeric] finite starting x coordinate
+        # @param y1 [Numeric] finite starting y coordinate
         # @return [Sevgi::Graphics::Element] path element
+        # @raise [Sevgi::ArgumentError] when a coordinate is not a finite real number
         def LineTo(x2:, y2:, x1: 0, y1: 0, **)
+          x1 = Scalar.number(x1, context: "absolute line", field: :x1)
+          y1 = Scalar.number(y1, context: "absolute line", field: :y1)
+          x2 = Scalar.number(x2, context: "absolute line", field: :x2)
+          y2 = Scalar.number(y2, context: "absolute line", field: :y2)
+
           path(d: "M #{x1} #{y1} L #{x2} #{y2}", **)
         end
 
         # Builds a horizontal line path ending at an absolute x coordinate.
-        # @param x2 [Numeric] ending x coordinate
-        # @param x1 [Numeric] starting x coordinate
-        # @param y1 [Numeric] starting y coordinate
+        # @param x2 [Numeric] finite ending x coordinate
+        # @param x1 [Numeric] finite starting x coordinate
+        # @param y1 [Numeric] finite starting y coordinate
         # @return [Sevgi::Graphics::Element] path element
+        # @raise [Sevgi::ArgumentError] when a coordinate is not a finite real number
         def HLineTo(x2:, x1: 0, y1: 0, **)
+          x1 = Scalar.number(x1, context: "horizontal line", field: :x1)
+          y1 = Scalar.number(y1, context: "horizontal line", field: :y1)
+          x2 = Scalar.number(x2, context: "horizontal line", field: :x2)
+
           path(d: "M #{x1} #{y1} H #{x2}", **)
         end
 
         # Builds a titled SVG symbol.
         # @param name [String] human-readable symbol name
         # @param kwargs [Hash] symbol attributes
+        # @yield evaluates the drawing DSL in the symbol element
+        # @yieldreturn [Object] ignored block result
         # @return [Sevgi::Graphics::Element] symbol element
         def Symbol(name, **kwargs, &block)
           id = (words = name.split).map(&:downcase).join("-")
@@ -39,23 +54,36 @@ module Sevgi
         end
 
         # Builds a vertical line path ending at an absolute y coordinate.
-        # @param y2 [Numeric] ending y coordinate
-        # @param x1 [Numeric] starting x coordinate
-        # @param y1 [Numeric] starting y coordinate
+        # @param y2 [Numeric] finite ending y coordinate
+        # @param x1 [Numeric] finite starting x coordinate
+        # @param y1 [Numeric] finite starting y coordinate
         # @return [Sevgi::Graphics::Element] path element
+        # @raise [Sevgi::ArgumentError] when a coordinate is not a finite real number
         def VLineTo(y2:, x1: 0, y1: 0, **)
+          x1 = Scalar.number(x1, context: "vertical line", field: :x1)
+          y1 = Scalar.number(y1, context: "vertical line", field: :y1)
+          y2 = Scalar.number(y2, context: "vertical line", field: :y2)
+
           path(d: "M #{x1} #{y1} V #{y2}", **)
         end
 
         # Builds a relative line path from angle and length.
-        # @param angle [Numeric] angle in degrees
-        # @param length [Numeric] line length
-        # @param x [Numeric] starting x coordinate
-        # @param y [Numeric] starting y coordinate
+        # @param angle [Numeric] finite angle in degrees, normalized before calculation
+        # @param length [Numeric] finite line length, normalized before calculation
+        # @param x [Numeric] finite starting x coordinate, normalized to an SVG number
+        # @param y [Numeric] finite starting y coordinate, normalized to an SVG number
         # @return [Sevgi::Graphics::Element] path element
+        # @raise [Sevgi::ArgumentError] when an operand is not a finite real number
         def LineBy(angle:, length:, x: 0, y: 0, **)
-          dx = length * ::Math.cos(angle.to_f / 180 * ::Math::PI)
-          dy = length * ::Math.sin(angle.to_f / 180 * ::Math::PI)
+          angle, length, x, y = Scalar.numbers([angle, length, x, y], context: "relative line")
+          dx, dy = Scalar.numbers(
+            [
+              length * ::Math.cos(angle.to_f / 180 * ::Math::PI),
+              length * ::Math.sin(angle.to_f / 180 * ::Math::PI)
+            ],
+            context: "relative line result"
+          )
+
           path(d: "M #{x} #{y} l #{dx} #{dy}", **)
         end
 
@@ -63,7 +91,8 @@ module Sevgi
         # @param hash [Hash, nil] CSS rules
         # @param attributes [Hash] style attributes or CSS rules when hash is nil
         # @return [Sevgi::Graphics::Element] style element
-        # @raise [Sevgi::ArgumentError] when CSS content is not a hash
+        # @raise [Sevgi::ArgumentError] when CSS rules are malformed, cyclic, cannot be stringified, or contain invalid
+        #   encoding or illegal XML 1.0 characters
         def css(hash = nil, **attributes)
           hash, attributes = attributes, {} unless hash
 
@@ -71,27 +100,40 @@ module Sevgi
         end
 
         # Builds a relative horizontal line path.
-        # @param length [Numeric] line length
-        # @param x [Numeric] starting x coordinate
-        # @param y [Numeric] starting y coordinate
+        # @param length [Numeric] finite line length
+        # @param x [Numeric] finite starting x coordinate
+        # @param y [Numeric] finite starting y coordinate
         # @return [Sevgi::Graphics::Element] path element
+        # @raise [Sevgi::ArgumentError] when an operand is not a finite real number
         def HLineBy(length:, x: 0, y: 0, **)
+          length = Scalar.number(length, context: "horizontal line", field: :length)
+          x = Scalar.number(x, context: "horizontal line", field: :x)
+          y = Scalar.number(y, context: "horizontal line", field: :y)
+
           path(d: "M #{x} #{y} h #{length}", **)
         end
 
         # Builds a square rect.
-        # @param length [Numeric] side length
+        # @param length [Numeric] finite side length
         # @return [Sevgi::Graphics::Element] rect element
+        # @raise [Sevgi::ArgumentError] when length is not a finite real number
         def square(length:, **)
+          length = Scalar.number(length, context: "square", field: :length)
+
           rect(width: length, height: length, **)
         end
 
         # Builds a relative vertical line path.
-        # @param length [Numeric] line length
-        # @param x [Numeric] starting x coordinate
-        # @param y [Numeric] starting y coordinate
+        # @param length [Numeric] finite line length
+        # @param x [Numeric] finite starting x coordinate
+        # @param y [Numeric] finite starting y coordinate
         # @return [Sevgi::Graphics::Element] path element
+        # @raise [Sevgi::ArgumentError] when an operand is not a finite real number
         def VLineBy(length:, x: 0, y: 0, **)
+          length = Scalar.number(length, context: "vertical line", field: :length)
+          x = Scalar.number(x, context: "vertical line", field: :x)
+          y = Scalar.number(y, context: "vertical line", field: :y)
+
           path(d: "M #{x} #{y} v #{length}", **)
         end
       end

data/lib/sevgi/graphics/mixtures.rb

@@ -8,37 +8,43 @@ module Sevgi
       #   Includes a named mixture and optional anonymous extension into a document class.
       #   @param mod [Symbol, String] mixture constant name
       #   @param document [Class] document class receiving the mixture
+      #   @yield defines methods in the anonymous mixture
+      #   @yieldreturn [Object] ignored module-definition result
       #   @return [Module, nil] optional anonymous mixture when a block is given
       #   @raise [NameError] when the mixture does not exist
       # @overload mixin(document = Graphics::Document::Base, &block)
       #   Includes only an anonymous extension into a document class.
       #   @param document [Class] document class receiving the mixture
+      #   @yield defines methods in the anonymous mixture
+      #   @yieldreturn [Object] ignored module-definition result
       #   @return [Module] anonymous mixture
       #   @raise [Sevgi::ArgumentError] when no named mixture or block is given
       def self.mixin(mod = Undefined, document = Graphics::Document::Base, &block)
         mod, document = normalize(mod, document, block)
         ArgumentError.("Mixture name or block required") if mod == Undefined && !block
 
-        document.mixture(mod) unless mod == Undefined
+        document.send(:mixture, mod) unless mod == Undefined
         include_anonymous(document, &block) if block
       end
 
-      def self.anonymous_document?(mod, block)
-        block && mod.is_a?(::Class) && mod <= Graphics::Document::Proto
-      end
+      class << self
+        private
 
-      def self.include_anonymous(document, &block)
-        ::Module.new(&block).tap do |anonymous|
-          document.send(:include, anonymous)
-          document.extend(anonymous.const_get(:ClassMethods)) if anonymous.const_defined?(:ClassMethods, false)
+        def anonymous_document?(mod, block)
+          block && mod.is_a?(::Class) && mod <= Graphics::Document::Proto
         end
-      end
 
-      def self.normalize(mod, document, block)
-        anonymous_document?(mod, block) ? [Undefined, mod] : [mod, document]
-      end
+        def include_anonymous(document, &block)
+          ::Module.new(&block).tap do |anonymous|
+            document.send(:include, anonymous)
+            document.extend(anonymous.const_get(:ClassMethods)) if anonymous.const_defined?(:ClassMethods, false)
+          end
+        end
 
-      private_class_method :anonymous_document?, :include_anonymous, :normalize
+        def normalize(mod, document, block)
+          anonymous_document?(mod, block) ? [Undefined, mod] : [mod, document]
+        end
+      end
     end
   end
 end

data/lib/sevgi/graphics/version.rb

@@ -3,6 +3,6 @@
 module Sevgi
   module Graphics
     # Current graphics component version.
-    VERSION = "0.94.0"
+    VERSION = "0.98.2"
   end
 end

data/lib/sevgi/graphics/xml.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    # XML 1.0 text and qualified-name validation shared by renderer boundaries.
+    # @api private
+    module XML
+      NCNAME_START = "A-Z_a-z\u{C0}-\u{D6}\u{D8}-\u{F6}\u{F8}-\u{2FF}\u{370}-\u{37D}\u{37F}-\u{1FFF}" \
+        "\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}" \
+        "\u{FDF0}-\u{FFFD}\u{10000}-\u{EFFFF}"
+      NCNAME_CHAR = "#{NCNAME_START}\\-.0-9\u{B7}\u{300}-\u{36F}\u{203F}-\u{2040}".freeze
+      NCNAME = "[#{NCNAME_START}][#{NCNAME_CHAR}]*".freeze
+      QNAME = /\A#{NCNAME}(?::#{NCNAME})?\z/u
+
+      private_constant :NCNAME, :NCNAME_CHAR, :NCNAME_START, :QNAME
+
+      class << self
+        # Validates an XML 1.0 string representation.
+        # @param value [Object] value to stringify and validate
+        # @param context [String] error-message subject
+        # @return [String] UTF-8 text
+        # @raise [Sevgi::ArgumentError] when stringification, encoding, or XML character validation fails
+        def text(value, context: "XML content")
+          value = stringify(value, context:) unless value.is_a?(::String)
+          validate_string(value, context:)
+        end
+
+        # Validates and snapshots a nested XML-bound value.
+        # @param value [Object] scalar or nested container
+        # @param context [String] error-message subject
+        # @param seen [Hash] container identities on the current traversal path
+        # @return [Object] validated caller-owned snapshot
+        # @raise [Sevgi::ArgumentError] when the value is cyclic, collides after stringification, or has invalid XML text
+        def snapshot(value, context:, seen: {}.compare_by_identity)
+          case value
+          when ::Hash
+            nested(value, context:, seen:) { snapshot_hash(value, context:, seen:) }
+          when ::Array
+            nested(value, context:, seen:) { value.map { snapshot(it, context:, seen:) } }
+          else
+            text(value, context:)
+          end
+        end
+
+        # Validates an XML qualified name.
+        # @param value [Object] candidate name
+        # @param context [String] error-message subject
+        # @return [String] validated qualified name
+        # @raise [Sevgi::ArgumentError] when text conversion or QName validation fails
+        def name(value, context: "XML name")
+          text(value, context:).tap do |candidate|
+            ArgumentError.("#{context} is invalid: #{candidate.inspect}") unless QNAME.match?(candidate)
+          end
+        end
+
+        # Validates a nested XML value without retaining its snapshot.
+        # @param value [Object] scalar or nested container
+        # @param context [String] error-message subject
+        # @return [Object] original value
+        # @raise [Sevgi::ArgumentError] when nested content is cyclic or contains invalid XML text
+        def validate(value, context: "XML content")
+          snapshot(value, context:)
+          value
+        end
+
+        # Escapes embedded CDATA terminators after validating text.
+        # @param value [Object] CDATA value
+        # @return [String] safe CDATA body
+        # @raise [Sevgi::ArgumentError] when value is not valid XML text
+        def cdata(value) = text(value).gsub("]]>", "]]]]><![CDATA[>")
+
+        private
+
+        def nested(value, context:, seen:)
+          ArgumentError.("Cyclic #{context} is not supported") if seen.key?(value)
+
+          seen[value] = true
+          yield
+        ensure
+          seen.delete(value)
+        end
+
+        def snapshot_hash(value, context:, seen:)
+          value.each_with_object({}) do |(key, item), captured|
+            key = snapshot(key, context:, seen:)
+            ArgumentError.("#{context} keys collide after stringification") if captured.key?(key)
+
+            captured[key] = snapshot(item, context:, seen:)
+          end
+        end
+
+        def stringify(value, context:)
+          text = value.to_s
+          ArgumentError.("#{context} stringification must return a String") unless text.is_a?(::String)
+
+          text
+        rescue Sevgi::ArgumentError
+          raise
+        rescue ::StandardError => e
+          ArgumentError.("#{context} cannot be stringified: #{e.class}: #{e.message}")
+        end
+
+        def validate_string(value, context:)
+          ArgumentError.("#{context} must be valid UTF-8") unless value.valid_encoding?
+
+          text = value.encode("UTF-8")
+          if (codepoint = text.each_codepoint.find { !legal_codepoint?(it) })
+            ArgumentError.("#{context} contains illegal character U+#{format("%04X", codepoint)}")
+          end
+
+          text
+        rescue ::EncodingError => e
+          ArgumentError.("#{context} must be valid UTF-8: #{e.message}")
+        end
+
+        def legal_codepoint?(codepoint)
+          [0x9, 0xA, 0xD].include?(codepoint) ||
+            (0x20..0xD7FF).cover?(codepoint) ||
+            (0xE000..0xFFFD).cover?(codepoint) ||
+            (0x10000..0x10FFFF).cover?(codepoint)
+        end
+      end
+    end
+
+    private_constant :XML
+  end
+end

data/lib/sevgi/graphics.rb

@@ -2,6 +2,7 @@
 
 require "sevgi/function"
 
+require_relative "graphics/xml"
 require_relative "graphics/attribute"
 require_relative "graphics/auxiliary"
 require_relative "graphics/element"
@@ -13,15 +14,44 @@ require_relative "graphics/version"
 
 module Sevgi
   # SVG document builder and DSL namespace.
+  #
+  # A document profile controls root metadata and preambles; a {Canvas} controls
+  # physical size, margins, viewport, and viewBox. {Graphics.SVG} combines them
+  # into an element tree. Library code keeps that tree as an object until it
+  # explicitly renders, validates, saves, or exports it.
+  #
+  # @example Build and render a minimal SVG document
+  #   drawing = Sevgi::Graphics.SVG :minimal, width: 10, height: 10 do
+  #     circle cx: 5, cy: 5, r: 4
+  #   end
+  #   drawing.Render #=> "<svg width=\"10\" height=\"10\">\n  <circle cx=\"5\" cy=\"5\" r=\"4\"/>\n</svg>"
+  # @see https://sevgi.roktas.dev/svg/ SVG construction and profile guide
+  # @see https://sevgi.roktas.dev/library-mode/ Library composition guide
+  # @see https://sevgi.roktas.dev/showcase/ Runnable drawing examples
+  # @see Sevgi::Graphics::Document
+  # @see Sevgi::Graphics::Canvas
   module Graphics
-    # @overload canvas(arg = Undefined, **kwargs)
-    #   Builds a canvas from a paper profile or explicit size.
-    #   @param arg [Sevgi::Graphics::Paper, Symbol, String, Sevgi::Undefined] paper profile or paper object
-    #   @param kwargs [Hash] canvas keyword arguments
+    # @overload canvas(paper, **overrides)
+    #   Builds a canvas from a paper profile with optional field overrides.
+    #   @param paper [Sevgi::Graphics::Paper, Symbol, String] paper object or registered profile
+    #   @param overrides [Hash] canvas field overrides
     #   @return [Sevgi::Graphics::Canvas]
-    #   @raise [Sevgi::ArgumentError] when the paper profile is unknown
+    #   @raise [Sevgi::ArgumentError] when the paper or an override is invalid
+    # @overload canvas(width:, height:, unit: "mm", name: :custom, margins: [])
+    #   Builds a canvas from an explicit size.
+    #   @param width [Numeric] canvas width
+    #   @param height [Numeric] canvas height
+    #   @param unit [Symbol, String] SVG unit
+    #   @param name [Symbol, String] paper name
+    #   @param margins [Array<Numeric>] margin shorthand values
+    #   @return [Sevgi::Graphics::Canvas]
+    #   @raise [Sevgi::ArgumentError] when a required field is omitted or a value is invalid
+    # @example Use the component constructor in library code
+    #   page = Sevgi::Graphics.canvas(:a4, margins: [12, 10])
+    #   icon = Sevgi::Graphics.canvas(width: 24, height: 24, unit: :px)
+    #   [page.name, icon.viewport] # => [:a4, {width: "24.0px", height: "24.0px"}]
     def canvas(...)
-      Graphics::Canvas.from_paper(...)
+      Graphics::Canvas.call(...)
     end
 
     # @overload document(name)
@@ -30,35 +60,55 @@ module Sevgi
     #   @return [Class] document class
     #   @raise [Sevgi::ArgumentError] when the profile is unknown
     # @overload document(name, preambles: Undefined, attributes: Undefined)
-    #   Defines a named document profile, or returns an existing profile when every explicitly supplied field matches.
-    #   Omitted fields are ignored during existing-profile comparison. Profile inputs are copied into the registry.
+    #   Looks up a named profile when both definition keywords are omitted. Supplying `preambles:` or `attributes:`
+    #   defines a named profile, or returns an existing profile when every explicitly supplied field matches. Omitted
+    #   fields are ignored during existing-profile comparison. Profile containers and strings are copied into the
+    #   process-global, thread-atomic registry; attribute names and nested Hash keys are normalized, nil attributes are
+    #   omitted, update suffixes are retained for document-class inheritance, and mutable non-container values are
+    #   stringified once before registration. Concurrent identical definitions return the same canonical registered
+    #   class.
     #   @param name [Symbol, String] profile name
     #   @param preambles [Array<String>, nil, Sevgi::Undefined] document preamble lines
-    #   @param attributes [Hash, Sevgi::Undefined] default root attributes
+    #   @param attributes [Hash, nil, Sevgi::Undefined] default root attributes; nil means an empty Hash
     #   @return [Class] document class
-    #   @raise [Sevgi::ArgumentError] when a named profile conflicts with an existing profile
+    #   @raise [Sevgi::ArgumentError] when a profile conflicts or metadata is invalid XML, cyclic, or cannot be stringified
     # @overload document(preambles: Undefined, attributes: Undefined)
     #   Defines an anonymous document profile without registering it globally.
     #   @param preambles [Array<String>, nil, Sevgi::Undefined] document preamble lines
-    #   @param attributes [Hash, Sevgi::Undefined] default root attributes
+    #   @param attributes [Hash, nil, Sevgi::Undefined] default root attributes; nil means an empty Hash
     #   @return [Class] anonymous document class
-    #   @raise [Sevgi::ArgumentError] when profile input is invalid
+    #   @raise [Sevgi::ArgumentError] when metadata is invalid XML, cyclic, or cannot be stringified
     # @return [Class] document class
+    # @example Define, look up, and inspect a named document
+    #   Sevgi::Graphics.document(:card, attributes: {viewBox: "0 0 100 60"})
+    #   Sevgi::Graphics::Document.fetch(:card)              # => the registered document class
+    #   Sevgi::Graphics::Document.profile(:card).attributes # => {viewBox: "0 0 100 60"}
+    # @example Define an anonymous document without changing the registry
+    #   klass = Sevgi::Graphics.document(attributes: {viewBox: "0 0 10 10"})
+    #   klass.profile.name # => nil
+    # @example Define and use a named profile from library code
+    #   Sevgi::Graphics.document(:badge, attributes: {viewBox: "0 0 24 24"})
+    #   drawing = Sevgi::Graphics.SVG(:badge) { circle cx: 12, cy: 12, r: 10 }
+    #   drawing[:viewBox] # => "0 0 24 24"
     def document(name = Undefined, preambles: Undefined, attributes: Undefined)
       Graphics::Document.define(name, preambles:, attributes:)
     end
 
     # Defines or replaces a document profile class.
+    # Validation and snapshot capture complete before an existing registration is atomically replaced.
+    # Use the non-bang {#document} for ordinary idempotent definitions; this
+    # bang form is an explicit process-global replacement.
     # @param name [Symbol, String] profile name
     # @param preambles [Array<String>, nil] document preamble lines
-    # @param attributes [Hash] default root attributes
+    # @param attributes [Hash, nil] default root attributes; nil means an empty Hash
     # @return [Class] document class
-    # @raise [Sevgi::ArgumentError] when the profile name is invalid
+    # @raise [Sevgi::ArgumentError] when the name or metadata is invalid XML, cyclic, or cannot be stringified
     def document!(name, preambles: [], attributes: {})
       Graphics::Document.define(name, preambles:, attributes:, overwrite: true)
     end
 
-    # Defines a paper profile unless the same profile already exists.
+    # Defines a paper profile unless the same profile already exists. Registration is process-global and thread-atomic;
+    # an identical concurrent definition is idempotent and a conflicting definition is rejected.
     # @param width [Numeric] paper width
     # @param height [Numeric] paper height
     # @param name [Symbol, String] profile name
@@ -66,18 +116,13 @@ module Sevgi
     # @return [Symbol, String] original profile name
     # @raise [Sevgi::ArgumentError] when the profile is invalid or an existing profile has different dimensions
     def paper(width, height, name = :custom, unit: "mm")
-      profile = Graphics::Paper[width, height, unit, name]
-
-      if Graphics::Paper.exist?(name)
-        ArgumentError.("Paper already defined differently: #{name}") unless Graphics::Paper.public_send(name) == profile
-      else
-        Graphics::Paper.define(name, width:, height:, unit:)
-      end
+      Graphics::Paper.define(name, width:, height:, unit:, overwrite: false)
 
       name
     end
 
     # Defines or replaces a paper profile.
+    # Use this only when replacing the process-global meaning of a name is intentional.
     # @param width [Numeric] paper width
     # @param height [Numeric] paper height
     # @param name [Symbol, String] profile name
@@ -85,15 +130,19 @@ module Sevgi
     # @return [Symbol, String] original profile name
     # @raise [Sevgi::ArgumentError] when the profile is invalid or the profile name is reserved
     def paper!(width, height, name = :custom, unit: "mm")
-      name.tap { Graphics::Paper.define(name, width:, height:, unit:) }
+      name.tap { Graphics::Paper.define(name, width:, height:, unit:, overwrite: true) }
     end
 
-    # Builds an SVG root document.
+    # Builds an SVG root element tree without rendering it.
+    #
+    # The first argument selects root metadata; the second supplies physical
+    # canvas attributes. Keyword attributes are applied to the root after both.
     # @param document [Symbol, String, Class] document profile name or document class
     # @param canvas [Sevgi::Graphics::Canvas, Sevgi::Graphics::Paper, Symbol, String, Sevgi::Undefined, nil] canvas input
-    # @param block [Proc, nil] DSL block evaluated in the root element
+    # @yield evaluates the drawing DSL in the root element
+    # @yieldreturn [Object] ignored block result
     # @return [Sevgi::Graphics::Document::Proto] SVG root element
-    # @raise [Sevgi::ArgumentError] when the document or canvas profile is unknown
+    # @raise [Sevgi::ArgumentError] when the document/canvas profile or root XML attributes are invalid
     def SVG(document = :default, canvas = Undefined, **, &block)
       Graphics::Document.(document, canvas, **, &block)
     end
@@ -101,6 +150,4 @@ module Sevgi
     extend self
   end
 
-  # Top-level alias for the graphics DSL namespace.
-  SVG = Graphics
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sevgi-graphics
 version: !ruby/object:Gem::Version
-  version: 0.94.0
+  version: 0.98.2
 platform: ruby
 authors:
 - Recai Oktaş
@@ -15,15 +15,15 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.94.0
+        version: 0.98.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.94.0
-description: Provides an extensible DSL for creating SVG content.
+        version: 0.98.2
+description: Builds and renders SVG document trees from Ruby.
 email: roktas@gmail.com
 executables: []
 extensions: []
@@ -39,6 +39,9 @@ files:
 - lib/sevgi/graphics/auxiliary/content.rb
 - lib/sevgi/graphics/auxiliary/margin.rb
 - lib/sevgi/graphics/auxiliary/paper.rb
+- lib/sevgi/graphics/auxiliary/path.rb
+- lib/sevgi/graphics/auxiliary/scalar.rb
+- lib/sevgi/graphics/auxiliary/sizes.rb
 - lib/sevgi/graphics/document.rb
 - lib/sevgi/graphics/document/base.rb
 - lib/sevgi/graphics/document/default.rb
@@ -67,6 +70,7 @@ files:
 - lib/sevgi/graphics/mixtures/validate.rb
 - lib/sevgi/graphics/mixtures/wrappers.rb
 - lib/sevgi/graphics/version.rb
+- lib/sevgi/graphics/xml.rb
 homepage: https://sevgi.roktas.dev
 licenses:
 - GPL-3.0-or-later
@@ -89,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
-summary: Core DSL for the Sevgi toolkit.
+summary: Core SVG DSL for Sevgi.
 test_files: []