sevgi 0.0.0

data/lib/sevgi/graphics/element.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "sevgi/standard"
+
+module Sevgi
+  module Graphics
+    class Element
+      private_class_method :new
+
+      RootParent = Object.new.tap { |this| def this.inspect = "RootParent" }.freeze
+
+      module Ident
+        def id(given) = (@id ||= {})[given] ||= given.to_s.tr("_", "-").to_sym
+      end
+
+      extend Ident
+
+      attr_reader :name, :attributes, :children, :contents, :parent
+
+      def initialize(name, attributes: {}, contents: [], parent:, &block)
+        @name       = name
+        @attributes = Attributes.new(attributes)
+        @contents   = contents
+        @parent     = parent
+        @children   = []
+
+        parent.children << self unless self.class.root?(self)
+
+        instance_exec(&block) if block
+      end
+
+      def method_missing(name, *, &block)
+        Element.valid?(id = Element.id(name)) ? Dispatch.(self, id, *, &block) : super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        Element.valid?(Element.id(name)) || super
+      end
+
+      protected
+
+      attr_writer :children, :attributes
+
+      class << self
+        def element(name, *, parent:, &block) = new(name, **Dispatch.parse(name, *), parent:, &block)
+
+        def root(*, &block)                   = element(:svg, *, parent: RootParent, &block)
+
+        def root?(element)                    = element.parent == RootParent
+
+        def valid?(name)                      = Standard.element?(name)
+      end
+
+      module Dispatch
+        extend self
+
+        def call(element, name, *, &block)
+          # Low-hanging fruit optimization: define missing method to avoid dispatching cost
+          Element.class_exec do
+            define_method(name) { |*args, &block| self.class.element(name, *args, parent: self, &block) }
+          end unless Element.method_defined?(name)
+
+          element.public_send(name, *, &block)
+        end
+
+        def parse(name, *args)
+          attributes, contents = {}, []
+
+          args.each do |arg|
+            case arg
+            when ::Hash   then attributes = arg
+            when ::String then contents << Graphics.Content(arg)
+            when Content  then contents << arg
+            else               ArgumentError.("Argument of element '#{name}' must be a Hash or String: #{arg}")
+            end
+          end
+
+          { attributes:, contents: }
+        end
+      end
+
+      private_constant :Dispatch
+    end
+  end
+end

data/lib/sevgi/graphics/external.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module External
+      def Canvas(...)                                        = Canvas.(...)
+
+      def Verbatim(content)                                  = Content::Verbatim.new(content)
+
+      def SVG(document = :default, canvas = nil, **, &block) = Profile.(document, canvas, **, &block)
+    end
+
+    extend External
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Core
+        module InstanceMethods
+          extend Forwardable
+          def_delegators :@attributes, :[], :[]=, :has?
+          def_delegators :@children, :first, :last, :at
+
+          def Adopt(new_parent = nil, index: -1)
+            tap do
+              if new_parent
+                ArgumentError.("Element type does not match the new parent type: #{self.class}") unless instance_of?(new_parent.class)
+              else
+                new_parent = parent
+              end
+
+              self.Orphan
+              (@parent = new_parent).children.insert(index, self)
+            end
+          end
+
+          def AdoptFirst(*)
+            Adopt(*, index: 0)
+          end
+
+          def Append(*elements)
+            tap { elements.each { _1.Adopt(self) } }
+          end
+
+          def Orphan
+            parent.children&.delete(self) unless Root?
+          end
+
+          def Prepend(*elements)
+            tap { elements.each { _1.AdoptFirst(self) } }
+          end
+
+          def Root
+            element = self
+            while element
+              break if element.Root?
+
+              element = element.parent
+            end
+            element
+          end
+
+          def Root?
+            self.class.root?(self)
+          end
+
+          def Traverse(depth = 0, leave = nil, &block)
+            tap do
+              yield(self, depth)
+
+              children.each { |child| child.Traverse(depth + 1, leave, &block) }
+              leave&.call(self, depth)
+            end
+          end
+
+          def With(element = nil, ...)
+            tap { (element || self).parent.instance_exec(self, ...) }
+          end
+
+          def Within(element = nil, ...)
+            tap { (element || self).instance_exec(...) }
+          end
+
+          def <<(element)
+            Append(element)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Duplicate
+        module InstanceMethods
+          def Duplicate(dx: nil, dy: nil, parent: nil, &block)
+            duplicated = dup
+
+            duplicated.Traverse do |element|
+              element.children = element.children.map(&:dup)
+              id = (element.attributes = element.attributes.dup).delete(:id)
+              element[:_id] = id if id
+              block&.call(element)
+            end
+
+            duplicated.Translate(dx, dy) if dx || dy
+
+            duplicated.Adopt(parent)
+
+            duplicated
+          end
+
+          def DuplicateH(dx, parent: nil, &block)
+            Duplicate(dx:, dy: 0, parent:, &block)
+          end
+
+          def DuplicateV(dy, parent: nil, &block)
+            Duplicate(dx: 0, dy:, parent:, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Hatch
+        module InstanceMethods
+          def Draw(segments, **)
+            segments.each { |segment| segment.draw(self, **) }
+          end
+
+          def Hatch(canvas, direction:, step:, **)
+            Geometry::Operation.sweep!(rect = canvas.rect, initial: rect.position, direction:, step:).tap do |segments|
+              Draw(segments, **)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Identify
+        module InstanceMethods
+          class Identifiers
+            attr_reader :element, :namespace, :collision
+
+            def initialize(element)
+              @element   = element
+              @namespace = {}
+              @collision = {}
+
+              build
+            end
+
+            def conflict?
+              !@collision.empty?
+            end
+
+            def [](*)
+              @namespace[*]
+            end
+
+            private
+
+            def build
+              element.Traverse do |element|
+                next unless (id = element[:id])
+
+                if @namespace.key?(id)
+                  (@collision[id] ||= [@namespace[id]]) << element
+                else
+                  @namespace[id] = element
+                end
+              end
+            end
+          end
+
+          def Disidentify
+            Traverse do |element|
+              next unless element[:id]
+
+              element[:_id] = element.attributes.delete(:id)
+            end
+          end
+
+          def IdentifyAsTable(...) = IdentifyAsTable.(...)
+
+          def IdentifyAsList(...)  = IdentifyAsList.(...)
+
+          def Reidentify
+          end
+
+          def Identifiers = Identifiers.new(self)
+
+          SEPARATOR = "-"
+
+          IdentifyAs = Data.define(:id) do
+            def label(*indexes) = (id and [id, *indexes].map(&:to_s).join(SEPARATOR))
+          end
+
+          IdentifyAsList = Class.new(IdentifyAs) do
+            class << self
+              def call(element, i)
+                element.each_with_index do |it, index|
+                  i and (label = self[i].label(index + 1)) and it[:id] = label
+                end
+              end
+            end
+          end
+
+          IdentifyAsTable = Class.new(IdentifyAs) do
+            class << self
+              def call(element, ix: nil, iy: nil)
+                element.each_with_index do |row, irow|
+                  iy and (label = self[iy].label(irow + 1)) and row[:id] = label
+                  ix and row.children.each_with_index do |col, icol|
+                    (label = self[ix].label(irow + 1, icol + 1)) and col[:id] = label
+                  end
+                end
+              end
+            end
+          end
+
+          private_constant :IdentifyAs, :IdentifyAsTable, :IdentifyAsList
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Inkscape
+        module InstanceMethods
+          def layer(**, &block)
+            g("inkscape:groupmode": "layer", "sodipodi:insensitive": "true", **, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Sevgi
+  LintError = Class.new(Error)
+
+  module Graphics
+    module Mixtures
+      module Lint
+        module InstanceMethods
+          def Lint(...)
+            IdentitiesAreUniq.(self, ...)
+          end
+
+          module IdentitiesAreUniq
+            extend self
+
+            def call(element)
+              return true unless (identifiers = element.Identifiers).conflict?
+
+              collisions = identifiers.collision.map do |id, elements|
+                "Element(s) with the same id '#{id}': #{elements.map(&:name).uniq.join(", ")}"
+              end.map { "\t#{_1}" }.join("\n")
+
+              LintError.("Found Id collisions:\n#{collisions}")
+            end
+          end
+
+          private_constant :IdentitiesAreUniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Render
+        class Renderer
+          DEFAULTS = { indent: "  ", linelength: 140, style: :hybrid }.freeze
+
+          module Attributes
+            module Block
+              def attributes(element, depth)
+                attributes_block(element, depth, element.attributes.to_xml_lines)
+              end
+            end
+
+            module Hybrid
+              def attributes(element, depth)
+                if attributes_as_block?(lines = element.attributes.to_xml_lines, depth)
+                  attributes_block(element, depth, lines)
+                else
+                  attributes_inline(element, depth, lines)
+                end
+              end
+
+              def linelength(lines, depth)
+                indent(depth).length + lines.sum(&:length)
+              end
+
+              def attributes_as_block?(lines, depth)
+                linelength(lines, depth) > options[:linelength]
+              end
+            end
+
+            module Inline
+              def attributes(element, depth)
+                attributes_inline(element, depth, element.attributes.to_xml_lines)
+              end
+            end
+          end
+
+          private_constant :Attributes
+
+          attr_reader :root, :options, :output
+
+          def initialize(root, **)
+            @root    = root
+            @options = DEFAULTS.merge(**)
+            @output  = []
+
+            build
+          end
+
+          def call(*preambles)
+            output.append(preambles) unless preambles.empty?
+
+            root.Traverse(
+              0,
+              proc { |element, depth| render_leave(element, depth) },
+            )      { |element, depth| render_enter(element, depth) }
+
+            output.join("\n")
+          end
+
+          def append(depth, *lines)
+            unless lines.empty?
+              indentation = indent(depth)
+              output.append(lines.map { "#{indentation}#{_1}" })
+            end
+          end
+
+          private
+
+          def build
+            ArgumentError.("Missing style") unless options[:style]
+
+            case options[:style]
+            when :hybrid then extend(Attributes::Hybrid)
+            when :inline then extend(Attributes::Inline)
+            when :block  then extend(Attributes::Block)
+            else              ArgumentError.("Unrecognized style: #{options[:style]}")
+            end
+
+            unclosed
+          end
+
+          def childless?(element)
+            element.children.empty? && element.contents.empty?
+          end
+
+          def closed  = @closed = true
+
+          def closed? = @closed.tap { unclosed }
+
+          def attributes_block(element, depth, lines)
+            append(depth, "<#{element.name}")
+            append(depth + 1, *lines)
+            append(depth, ">") unless childless?(element)
+          end
+
+          def attributes_inline(element, depth, lines)
+            line = "<#{[element.name, *lines].join(" ")}"
+
+            append(depth, (childless?(element) ? "#{line}/>".tap { closed } : "#{line}>"))
+          end
+
+          def contents(element, depth)
+            return if element.contents.empty?
+
+            if floating?(element)
+              append(depth, *element.contents.map(&:to_s))
+            else
+              element.contents.each { |content| content.render(self, depth) }
+            end
+          end
+
+          def indent(depth)
+            options[:indent] * depth
+          end
+
+          def render_enter(element, depth)
+            attributes(element, depth) unless floating?(element)
+            contents(element, depth)
+          end
+
+          def render_leave(element, depth)
+            return if closed? || floating?(element)
+
+            append(depth, (childless?(element) ? "/>" : "</#{element.name}>").to_s)
+          end
+
+          def unclosed = @closed = false
+
+          def floating?(element) = element.name == :"-"
+
+          class << self
+            def call(root, **) = new(root, **).call(*root.class.preambles)
+          end
+        end
+
+        private_constant :Renderer
+
+        module InstanceMethods
+          def Render(**) = Renderer.(self, **)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Replicate
+        module InstanceMethods
+          def Replicate(nx: Undefined, dx: Undefined, ix: nil, ny: Undefined, dy: Undefined, iy: nil, id: nil, &block)
+            Ensure.without_block(block, nx:, dx:, ny:, dy:)
+
+            With do |base|
+              layer(id:) do
+                row = layer do
+                  (nx - 1).times do |time|
+                    base.DuplicateH((time + 1) * dx, parent: self)
+                  end
+                end
+
+                base.AdoptFirst(row)
+
+                (ny - 1).times do |time|
+                  row.DuplicateV((time + 1) * dy)
+                end
+              end.tap do |element|
+                IdentifyAsTable(element.children, ix:, iy:)
+              end
+            end
+          end
+
+          def ReplicateH(n: Undefined, d: Undefined, i: nil, id: nil, &block)
+            Ensure.without_block(block, n:, d:)
+
+            With do |base|
+              layer(id:) do
+                (n - 1).times do |time|
+                  base.DuplicateH((time + 1) * d, parent: self)
+                end
+              end.tap do |element|
+                base.AdoptFirst(element)
+                IdentifyAsList(element.children, i)
+              end
+            end
+          end
+
+          def ReplicateV(n: Undefined, d: Undefined, i: nil, id: nil, &block)
+            Ensure.without_block(block, n:, d:)
+
+            With do |base|
+              layer(id:) do
+                (n - 1).times do |time|
+                  base.DuplicateV((time + 1) * d, parent: self)
+                end
+              end.tap do |element|
+                base.AdoptFirst(element)
+                IdentifyAsList(element.children, i)
+              end
+            end
+          end
+
+          def Tile(symbol = Undefined, nx: Undefined, dx: Undefined, ix: nil, ny: Undefined, dy: Undefined, iy: nil, id: nil, &block)
+            Ensure.with_block(block, symbol:, nx:, dx:, ny:, dy:)
+
+            symbol(id: symbol).Within(&block)
+            use("xlink:href": "##{symbol}").Replicate(nx:, dx:, ix:, ny:, dy:, iy:, id:)
+          end
+
+          def TileH(symbol = Undefined, n: Undefined, d: Undefined, i: nil, id: nil, &block)
+            Ensure.with_block(block, symbol:, n:, d:)
+
+            symbol(id: symbol).Within(&block)
+            use("xlink:href": "##{symbol}").ReplicateH(n:, d:, i:, id:)
+          end
+
+          def TileV(symbol = Undefined, n: Undefined, d: Undefined, i: nil, id: nil, &block)
+            Ensure.with_block(block, symbol:, n:, d:)
+
+            symbol(id: symbol).Within(&block)
+            use("xlink:href": "##{symbol}").ReplicateV(n:, d:, i:, id:)
+          end
+        end
+
+        module Ensure
+          extend self
+
+          ASSERTION = {
+            symbol: proc { |name, value| "Argument '#{name}' must be a string"           unless value.is_a?(::String)  },
+            n:      proc { |name, value| "Argument '#{name}' must be a positive integer" unless value.positive?        },
+            nx:     proc { |name, value| "Argument '#{name}' must be a positive integer" unless value.positive?        },
+            ny:     proc { |name, value| "Argument '#{name}' must be a positive integer" unless value.positive?        },
+            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) },
+          }.freeze
+
+          def with_block(block, **)
+            ArgumentError.("Block required") unless block
+
+            call(**)
+          end
+
+          def without_block(block, **)
+            ArgumentError.("Block not allowed") if block
+
+            call(**)
+          end
+
+          private
+
+          def call(**kwargs)
+            kwargs.each do |name, value|
+              issue = "Argument '#{name}' required" if value == Undefined
+
+              unless issue
+                next unless (assertion = ASSERTION[name])
+                next unless (issue = assertion.call(name, value))
+              end
+
+              ArgumentError.(issue)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Save
+        module InstanceMethods
+          EXT = ".svg"
+
+          def Out(*, **)                = F.out(self.(**), *)
+
+          def Out!(*, **)               = F.out(self.(**), *, smart: true)
+
+          def Save(dir = ".", **)       = Out(Savefile(caller_locations(1..1).first.path, dir), **)
+
+          def Save!(dir = ".", **)      = Out!(Savefile(caller_locations(1..1).first.path, dir), **)
+
+          def Savefile(path, dir = ".") = ::File.expand_path(::File.join(dir, "#{::File.basename(path, ".*")}#{EXT}"), ::File.dirname(path))
+        end
+      end
+    end
+  end
+end