sevgi-graphics 0.73.2 → 0.94.0

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

@@ -2,19 +2,43 @@
 
 module Sevgi
   module Graphics
+    # Callable drawing module support.
+    # Extend a plain Ruby module with this API to make its public instance methods callable drawing steps.
+    # @example Define and call a drawing module
+    #   Widget = Module.new do
+    #     extend Sevgi::Graphics::Module
+    #
+    #     def item(id)
+    #       rect(id:)
+    #     end
+    #   end
+    #
+    #   SVG { Call(Widget, "box") }
     module Module
+      # Tracks newly defined methods as callable drawing candidates.
+      # Invocation runs unique methods that are still public, preserving tracked definition order.
+      # @param method [Symbol] method name Ruby reports as added
+      # @return [Array<Symbol>, nil]
       def method_added(method)
         super
 
         _callables << method if public_method_defined?(method)
       end
 
+      # Class-level DSL for callable drawing modules.
+      # @api private
       module DSL
-        def call(after = false, &block) = ((after ? _after : _befores) << block)
+        # Registers a before or after hook.
+        # @param after [Boolean] true to register an after hook
+        # @return [Array<Proc>] hook list
+        def call(after = false, &block) = ((after ? _afters : _befores) << block)
       end
 
       private_constant :DSL
 
+      # Initializes callable module state.
+      # @param base [Module] extended module
+      # @return [void]
       def self.extended(base)
         base.instance_exec do
           @_callables = []
@@ -29,6 +53,14 @@ module Sevgi
         end
       end
 
+      # @overload call(mod, receiver, *args, **kwargs)
+      #   Runs module hooks and callables against a receiver.
+      #   @param mod [Module] callable module
+      #   @param receiver [Sevgi::Graphics::Element] receiver element
+      #   @param args [Array<Object>] callable arguments
+      #   @param kwargs [Hash] callable keyword arguments
+      #   @return [Object, nil] last callable return value
+      #   @raise [Sevgi::ArgumentError] when mod is not a plain module
       def self.call(mod, receiver, ...)
         mod._befores.each { receiver.Within(receiver, &it) } if mod.respond_to?(:_befores) && mod._befores
         # return last callable return value
@@ -37,15 +69,41 @@ module Sevgi
         end
       end
 
+      # Returns the methods that should be executed for a callable module.
+      # @param mod [Module] callable module
+      # @return [Array<UnboundMethod>]
+      # @raise [Sevgi::ArgumentError] when mod is not a plain module
       def self.callables(mod)
-        raise ArgumentError, "Must be a module: #{mod}" unless mod.instance_of?(::Module)
+        ArgumentError.("Must be a module: #{mod}") unless mod.instance_of?(::Module)
 
-        (mod.respond_to?(:_callables) ? mod._callables : mod.instance_methods).map { mod.instance_method(it) }
+        callable_names(mod).uniq.filter_map do |name|
+          mod.instance_method(name) if mod.public_method_defined?(name)
+        end
       end
+
+      def self.callable_names(mod)
+        tracked = mod.ancestors.reverse_each.filter_map do |ancestor|
+          ancestor._callables if ancestor.respond_to?(:_callables)
+        end
+
+        return tracked.flatten unless tracked.empty?
+
+        mod.public_instance_methods
+      end
+
+      private_class_method :callable_names
     end
 
     module Mixtures
+      # DSL helpers for invoking callable drawing modules.
       module Call
+        # @overload Call(mod, *args, **kwargs)
+        #   Runs a callable drawing module in the current element context.
+        #   @param mod [Module] callable module
+        #   @param args [Array<Object>] callable arguments
+        #   @param kwargs [Hash] callable keyword arguments
+        #   @return [Object, nil] last callable return value
+        #   @raise [Sevgi::ArgumentError] when mod is not a plain module
         def Call(mod, ...)
           Graphics::Module.call(mod, self, ...)
         end
@@ -54,7 +112,7 @@ module Sevgi
 
         # rubocop:disable Metrics/MethodLength
         def CallWithin(mod, container, element, *args, **kwargs, &block)
-          raise ArgumentError, "Must be a module: #{mod}" unless mod.instance_of?(::Module)
+          ArgumentError.("Must be a module: #{mod}") unless mod.instance_of?(::Module)
 
           kwargs = kwargs.merge(id: F.demodulize(mod).to_sym) unless kwargs.key?(:id)
 

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

@@ -5,11 +5,54 @@ require "forwardable"
 module Sevgi
   module Graphics
     module Mixtures
+      # Traversal stop token returned by {Core#Stay}.
+      #
+      # @!attribute [r] value
+      #   @return [Object] value returned from traversal
+      Stop = Data.define(:value)
+
+      # Internal traversal engine.
+      # @api private
+      module Traversal
+        # Runs a depth-first traversal.
+        # @param element [Sevgi::Graphics::Element] starting element
+        # @param depth [Integer] starting depth
+        # @param leave [Proc, nil] optional leave callback
+        # @return [Sevgi::Graphics::Element, Object]
+        def self.call(element, depth, leave, &block)
+          catch(:traversal) do
+            visit(element, depth, leave, &block)
+            element
+          end
+        end
+
+        def self.stop(value)
+          throw(:traversal, value.value) if value.is_a?(Stop)
+        end
+
+        def self.visit(element, depth, leave, &block)
+          stop(block.call(element, depth))
+          element.children.each { |child| visit(child, depth + 1, leave, &block) }
+          stop(leave.call(element, depth)) if leave
+        end
+
+        private_class_method :stop, :visit
+      end
+
+      private_constant :Traversal
+
+      # Core SVG tree and attribute DSL helpers.
       module Core
         extend Forwardable
         def_delegators :@attributes, :[], :[]=, :has?
         def_delegators :@children, :first, :last, :at
 
+        # Moves this element under a new parent.
+        # @param new_parent [Sevgi::Graphics::Element, nil] target parent or current parent
+        # @param index [Integer] insertion index
+        # @return [Sevgi::Graphics::Element] self
+        # @raise [Sevgi::ArgumentError] when the target parent has a different element class
+        # @raise [Sevgi::ArgumentError] when the target parent is this element or one of its descendants
         def Adopt(new_parent = nil, index: -1)
           tap do
             if new_parent
@@ -20,101 +63,146 @@ module Sevgi
               new_parent = parent
             end
 
+            Adoption.validate(self, new_parent)
+
             self.Orphan()
             (@parent = new_parent).children.insert(index, self)
           end
         end
 
+        # @overload AdoptFirst(new_parent = nil)
+        #   Moves this element to the beginning of a parent.
+        #   @param new_parent [Sevgi::Graphics::Element, nil] target parent or current parent
+        #   @return [Sevgi::Graphics::Element] self
+        #   @raise [Sevgi::ArgumentError] when the target parent has a different element class
+        #   @raise [Sevgi::ArgumentError] when the target parent is this element or one of its descendants
         def AdoptFirst(*)
           Adopt(*, index: 0)
         end
 
+        # Appends existing elements as children.
+        # @param elements [Array<Sevgi::Graphics::Element>] elements to append
+        # @return [Sevgi::Graphics::Element] self
         def Append(*elements)
           tap { elements.each { it.Adopt(self) } }
         end
 
+        # Adds CSS classes without duplicating existing values.
+        # @param classes [Array<String, Symbol, Array>] class tokens; strings are split on whitespace
+        # @return [Sevgi::Graphics::Element] self
         def Classify(*classes)
           tap do
-            unless self[:class]
-              self[:class] = classes
-              next
+            tokens = proc do |value|
+              case value
+              when nil
+                []
+              when ::Array
+                value.flat_map { tokens.call(it) }
+              else
+                value.to_s.split
+              end
             end
 
-            case self[:class]
-            when ::Array
-              self[:class]
-            when ::String
-              self[:class].split
-            end => klasses
-
-            classes.each { klasses << it unless klasses.include?(it) }
+            self[:class] = [*tokens.call(self[:class]), *tokens.call(classes)].uniq
           end
         end
 
+        # Assigns default attributes only when they are absent.
+        # @param attributes [Hash] default attributes
+        # @return [Sevgi::Graphics::Element] self
         def Defaults(**attributes)
           tap do
             attributes.each do |key, value|
-              next if self[key]
+              next if has?(key)
 
               self[key] = value
             end
           end
         end
 
+        # Builds a child element with an explicit tag name.
+        # @param tag [Symbol, String] SVG tag name
+        # @param contents [Array<Object>] text or content objects; non-content objects are stringified and XML-encoded
+        # @param attributes [Hash] SVG attributes
+        # @return [Sevgi::Graphics::Element] new child element
         def Element(tag, *contents, **attributes, &block)
           self.class.send(:new, tag.to_sym, contents: Content.contents(*contents), attributes:, parent: self, &block)
         end
 
+        # Forwards this element as the first argument to another receiver.
+        # @overload Forward(receiver, method, *args, **kwargs)
+        #   @param receiver [Object] target receiver
+        #   @param method [Symbol, String] method name
+        #   @param args [Array<Object>] additional arguments
+        #   @param kwargs [Hash] additional keyword arguments
+        #   @return [Object] forwarded call result
         def Forward(receiver, method, ...)
           receiver.public_send(method, self, ...)
         end
 
+        # Reports whether this element has the given SVG name.
+        # @param name [Symbol, String] SVG name
+        # @return [Boolean]
         def Is?(name)
           self.name() == name.to_sym
         end
 
+        # Removes this element from its parent.
+        # @return [Array<Sevgi::Graphics::Element>, nil] parent children after deletion, or nil for root elements
         def Orphan
           parent.children&.delete(self) unless Root?()
         end
 
+        # Prepends existing elements as children.
+        # @param elements [Array<Sevgi::Graphics::Element>] elements to prepend
+        # @return [Sevgi::Graphics::Element] self
         def Prepend(*elements)
           tap { elements.each { it.AdoptFirst(self) } }
         end
 
+        # Returns the root document element.
+        # @return [Sevgi::Graphics::Element]
         def Root
           element = self
-          element = element.parent while element.Root?()
+          element = element.parent until element.Root?()
 
           element
         end
 
+        # Reports whether this element is the root document element.
+        # @return [Boolean]
         def Root?
           self.class.root?(self)
         end
 
-        Traversal = Data.define(:value)
-
-        def Stay(...) = Traversal.new(...)
-
+        # @overload Stay(value)
+        #   Wraps a traversal return value as a stop token.
+        #   @param value [Object] value returned from traversal
+        #   @return [Sevgi::Graphics::Mixtures::Stop]
+        def Stay(...) = Stop.new(...)
+
+        # Traverses the subtree depth-first.
+        # @param depth [Integer] starting depth
+        # @param leave [Proc, nil] optional leave callback
+        # @return [Sevgi::Graphics::Element, Object] self or the value passed through Stay
+        # @raise [Sevgi::ArgumentError] when no block is given
         def Traverse(depth = 0, leave = nil, &block)
           ArgumentError.("Block required") unless block
 
-          tap do
-            yield(self, depth).tap { return it.value if it.is_a?(Traversal) }
-
-            children.each { |child| child.Traverse(depth + 1, leave, &block) }
-
-            leave&.call(self, depth).tap { return it.value if it.is_a?(Traversal) }
-          end
+          Traversal.call(self, depth, leave, &block)
         end
 
+        # Traverses ancestors from this element to the root.
+        # @param height [Integer] starting height
+        # @return [Object, nil] value passed through Stay, or nil
+        # @raise [Sevgi::ArgumentError] when no block is given
         def TraverseUp(height = 0, &block)
           ArgumentError.("Block required") unless block
 
           element = self
 
           loop do
-            yield(element, height).tap { return it.value if it.is_a?(Traversal) }
+            yield(element, height).tap { return it.value if it.is_a?(Stop) }
 
             break if element.Root?()
 
@@ -123,17 +211,50 @@ module Sevgi
           end
         end
 
+        # Evaluates a block in the parent element context.
+        # @param args [Array<Object>] optional receiver override followed by block arguments
+        # @param kwargs [Hash] keyword arguments passed to the block
+        # @return [Sevgi::Graphics::Element] self
         def With(*args, **kwargs, &block)
           tap { (args.shift || self).parent.instance_exec(*args, **kwargs, &block) }
         end
 
+        # Evaluates a block in this element context.
+        # @param args [Array<Object>] optional receiver override followed by block arguments
+        # @param kwargs [Hash] keyword arguments passed to the block
+        # @return [Sevgi::Graphics::Element] self
         def Within(*args, **kwargs, &block)
           tap { (args.shift || self).instance_exec(*args, **kwargs, &block) }
         end
 
+        # Appends an element as a child.
+        # @param element [Sevgi::Graphics::Element] element to append
+        # @return [Sevgi::Graphics::Element] self
         def <<(element)
           Append(element)
         end
+
+        # Adoption target validation that keeps tree mutation atomic.
+        # @api private
+        module Adoption
+          # Rejects target parents that would create a cycle.
+          # @param element [Sevgi::Graphics::Element] element being moved
+          # @param parent [Sevgi::Graphics::Element, Object] target parent
+          # @return [void]
+          # @raise [Sevgi::ArgumentError] when the target parent is this element or one of its descendants
+          def self.validate(element, parent)
+            ArgumentError.("Element cannot be adopted under itself") if parent.equal?(element)
+
+            while parent.respond_to?(:Root?)
+              ArgumentError.("Element cannot be adopted under its descendant") if parent.equal?(element)
+              break if parent.Root?()
+
+              parent = parent.parent
+            end
+          end
+        end
+
+        private_constant :Adoption
       end
     end
   end

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

@@ -3,13 +3,24 @@
 module Sevgi
   module Graphics
     module Mixtures
+      # DSL helpers for duplicating independent element subtrees.
       module Duplicate
+        # Duplicates an element subtree as an independent tree and optionally translates it.
+        # Copied elements receive new child arrays, attribute stores, and content arrays. Public `id` attributes are
+        # moved to an internal `-id` attribute before the optional block runs, allowing the block to derive replacement
+        # ids without rendering duplicate public ids.
+        # @param dx [Numeric, nil] x translation
+        # @param dy [Numeric, nil] y translation
+        # @param parent [Sevgi::Graphics::Element, nil] parent for the duplicated subtree
+        # @yield [element] optional customization hook for each copied element
+        # @yieldparam element [Sevgi::Graphics::Element] copied element
+        # @return [Sevgi::Graphics::Element] duplicated element
+        # @raise [Sevgi::ArgumentError] when the target parent has a different element class
         def Duplicate(dx: nil, dy: nil, parent: nil, &block)
-          duplicated = dup
+          duplicated = Subtree.copy(self)
 
           duplicated.Traverse() do |element|
-            element.children = element.children.map(&:dup)
-            id = (element.attributes = element.attributes.dup).delete(:id)
+            id = element.attributes.delete(:id)
             element[:"#{ATTRIBUTE_INTERNAL_PREFIX}id"] = id if id
             block&.call(element)
           end
@@ -21,9 +32,42 @@ module Sevgi
           duplicated
         end
 
+        # Duplicates an element subtree along the x-axis.
+        # @param dx [Numeric] x translation
+        # @param parent [Sevgi::Graphics::Element, nil] parent for the duplicated subtree
+        # @yield [element] optional customization hook for each copied element
+        # @yieldparam element [Sevgi::Graphics::Element] copied element
+        # @return [Sevgi::Graphics::Element] duplicated element
+        # @raise [Sevgi::ArgumentError] when the target parent has a different element class
         def DuplicateX(dx, parent: nil, &block) = Duplicate(dx:, dy: 0, parent:, &block)
 
+        # Duplicates an element subtree along the y-axis.
+        # @param dy [Numeric] y translation
+        # @param parent [Sevgi::Graphics::Element, nil] parent for the duplicated subtree
+        # @yield [element] optional customization hook for each copied element
+        # @yieldparam element [Sevgi::Graphics::Element] copied element
+        # @return [Sevgi::Graphics::Element] duplicated element
+        # @raise [Sevgi::ArgumentError] when the target parent has a different element class
         def DuplicateY(dy, parent: nil, &block) = Duplicate(dx: 0, dy:, parent:, &block)
+
+        # Recursive subtree copier that keeps duplicate implementation state out of the DSL surface.
+        # @api private
+        module Subtree
+          # Builds an independent copy of an element subtree.
+          # @param element [Sevgi::Graphics::Element] source subtree root
+          # @param parent [Sevgi::Graphics::Element, Object] parent for the copied root
+          # @return [Sevgi::Graphics::Element] copied subtree root
+          def self.copy(element, parent = element.parent)
+            element.dup.tap do |duplicated|
+              duplicated.send(:parent=, parent)
+              duplicated.send(:attributes=, element.attributes.dup)
+              duplicated.send(:contents=, element.contents.dup)
+              duplicated.send(:children=, element.children.map { |child| copy(child, duplicated) })
+            end
+          end
+        end
+
+        private_constant :Subtree
       end
     end
   end

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

@@ -3,21 +3,46 @@
 module Sevgi
   module Graphics
     module Mixtures
+      # DSL helpers for native SVG export formats.
       module Export
+        # Exports the document as PDF.
+        # @param path [String, nil] output path or directory
+        # @param kwargs [Hash] export options
+        # @return [String] output path
+        # @raise [Sevgi::MissingComponentError] when sevgi/sundries is unavailable
+        # @raise [Sevgi::MissingComponentError] when native export gems are unavailable
+        # @raise [Sevgi::Sundries::Export::ExportError] when native export fails
         def PDF(path = nil, **kwargs, &block)
-          require "sevgi/sundries"
+          begin
+            require "sevgi/sundries"
+
+          rescue ::LoadError => e
+            raise unless e.path == "sevgi/sundries"
+
+            MissingComponentError.("sevgi/sundries")
+          end
 
           Export(path, **kwargs, format: :pdf, &block)
-        rescue ::LoadError
-          raise NoMethodError, "\"sevgi/sundries\" required"
         end
 
+        # Exports the document as PNG.
+        # @param path [String, nil] output path or directory
+        # @param kwargs [Hash] export options
+        # @return [String] output path
+        # @raise [Sevgi::MissingComponentError] when sevgi/sundries is unavailable
+        # @raise [Sevgi::MissingComponentError] when native export gems are unavailable
+        # @raise [Sevgi::Sundries::Export::ExportError] when native export fails
         def PNG(path = nil, **kwargs, &block)
-          require "sevgi/sundries"
+          begin
+            require "sevgi/sundries"
+
+          rescue ::LoadError => e
+            raise unless e.path == "sevgi/sundries"
+
+            MissingComponentError.("sevgi/sundries")
+          end
 
           Export(path, **kwargs, format: :png, &block)
-        rescue ::LoadError
-          raise NoMethodError, "\"sevgi/sundries\" required"
         end
 
         private

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

@@ -3,14 +3,35 @@
 module Sevgi
   module Graphics
     module Mixtures
+      # DSL helpers for drawing geometry-derived hatch lines.
       module Hatch
+        # Draws one or more geometry line-like objects into this element.
+        # @param lines [Object, Array<Object>] drawable geometry objects
+        # @param kwargs [Hash] SVG attributes passed to each draw call
+        # @return [Array<Sevgi::Graphics::Element>] rendered line elements
         def Draw(lines, **kwargs)
           Array(lines).map { it.draw(self, **kwargs) }
         end
 
-        # TODO: angle vs direction
-        def Hatch(element, direction:, step:, initial: nil, **kwargs)
-          Draw(Geometry::Operation.sweep!(element, initial: initial || element.position, direction:, step:), **kwargs)
+        # Draws hatch lines swept through a geometry element.
+        # @param element [Object] geometry element responding to position
+        # @param angle [Numeric] hatch angle in degrees
+        # @param step [Numeric] distance between hatch lines
+        # @param initial [Object, nil] initial point for the sweep
+        # @param kwargs [Hash] SVG attributes passed to each draw call
+        # @return [Array<Sevgi::Graphics::Element>] rendered line elements
+        # @raise [Sevgi::MissingComponentError] when sevgi/geometry is unavailable
+        def Hatch(element, angle:, step:, initial: nil, **kwargs)
+          begin
+            require "sevgi/geometry"
+
+          rescue ::LoadError => e
+            raise unless e.path == "sevgi/geometry"
+
+            MissingComponentError.("sevgi/geometry")
+          end
+
+          Draw(Geometry::Operation.sweep!(element, initial: initial || element.position, angle:, step:), **kwargs)
         end
       end
     end

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

@@ -3,10 +3,22 @@
 module Sevgi
   module Graphics
     module Mixtures
+      # DSL helpers for collecting and hiding SVG ids.
       module Identify
+        # Index of element ids under a subtree.
         class Identifiers
-          attr_reader :element, :namespace, :collision
+          # @return [Sevgi::Graphics::Element] indexed root element
+          attr_reader :element
 
+          # @return [Hash<String, Sevgi::Graphics::Element>] id namespace
+          attr_reader :namespace
+
+          # @return [Hash<String, Array<Sevgi::Graphics::Element>>] duplicate id groups
+          attr_reader :collision
+
+          # Builds an id index for an element subtree.
+          # @param element [Sevgi::Graphics::Element] root element
+          # @return [void]
           def initialize(element)
             @element = element
             @namespace = {}
@@ -15,10 +27,16 @@ module Sevgi
             build
           end
 
+          # Reports whether duplicate ids were found.
+          # @return [Boolean]
           def conflict?
             !@collision.empty?
           end
 
+          # @overload [](id)
+          #   Returns the element registered for an id.
+          #   @param id [String] SVG id
+          #   @return [Sevgi::Graphics::Element, nil]
           def [](*)
             @namespace[*]
           end
@@ -27,7 +45,9 @@ module Sevgi
 
           def build
             element.Traverse() do |element|
-              next unless (id = element[:id])
+              next unless (value = element[:id])
+
+              id = Attribute.xml_text(value)
 
               if @namespace.key?(id)
                 (@collision[id] ||= [@namespace[id]]) << element
@@ -38,6 +58,8 @@ module Sevgi
           end
         end
 
+        # Moves visible id attributes to Sevgi-internal id storage.
+        # @return [Sevgi::Graphics::Element] self
         def Disidentify
           Traverse do |element|
             next unless element[:id]
@@ -46,6 +68,8 @@ module Sevgi
           end
         end
 
+        # Builds an id index for this element subtree.
+        # @return [Sevgi::Graphics::Mixtures::Identify::Identifiers]
         def Identifiers = Identifiers.new(self)
       end
     end

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

@@ -3,14 +3,50 @@
 module Sevgi
   module Graphics
     module Mixtures
+      # DSL helpers for including derendered SVG/XML fragments.
       module Include
         require "sevgi/derender"
 
+        # Includes a derendered node matching an id.
+        #
+        # SVG/XML file content is treated as data and is not evaluated as Ruby source.
+        # @param file [String] source SVG/XML file
+        # @param id [String, Symbol] source node id
+        # @return [Sevgi::Graphics::Element, nil] included element, or nil when the selected node produces no graphics
+        #   output
+        # @raise [Sevgi::ArgumentError] when the file cannot be found, file content is malformed or rootless, or the id is
+        #   absent
+        # @raise [Sevgi::MissingComponentError] when sevgi/derender is unavailable
         def Include(file, id) = Derender.evaluate_file(file, self, id:)
-        def Include!(file, id) = Derender.evaluate_file!(file, self, id:)
-      rescue ::LoadError
-        def Include(...) = raise NoMethodError, "\"sevgi/derender\" required"
-        def Include!(...) = raise NoMethodError, "\"sevgi/derender\" required"
+
+        # Includes the children of a derendered node matching an id.
+        #
+        # SVG/XML file content is treated as data and is not evaluated as Ruby source.
+        # @param file [String] source SVG/XML file
+        # @param id [String, Symbol] source node id
+        # @return [Array<Sevgi::Graphics::Element>] included children
+        # @raise [Sevgi::ArgumentError] when the file cannot be found, file content is malformed or rootless, or the id is
+        #   absent
+        # @raise [Sevgi::MissingComponentError] when sevgi/derender is unavailable
+        def IncludeChildren(file, id) = Derender.evaluate_file_children(file, self, id:)
+      rescue ::LoadError => e
+        raise unless e.path == "sevgi/derender"
+
+        # @overload IncludeChildren(file, id)
+        #   Raises because sevgi/derender is unavailable.
+        #   @param file [String] source SVG/XML file
+        #   @param id [String, Symbol] source node id
+        #   @return [void]
+        #   @raise [Sevgi::MissingComponentError] always
+        def IncludeChildren(...) = MissingComponentError.("sevgi/derender")
+
+        # @overload Include(file, id)
+        #   Raises because sevgi/derender is unavailable.
+        #   @param file [String] source SVG/XML file
+        #   @param id [String, Symbol] source node id
+        #   @return [void]
+        #   @raise [Sevgi::MissingComponentError] always
+        def Include(...) = MissingComponentError.("sevgi/derender")
       end
     end
   end