sevgi 0.0.0

data/lib/sevgi/geometry/external.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module External
+      class << self
+        def included(base)
+          super
+
+          base.const_set(:Geometry, Geometry)
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/operation/align.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Operation
+      module Align
+        def align(element, other, alignment = :center)
+          translate(element, other, alignment).apply(element)
+        end
+
+        def alignment(element, other, alignment = :center)
+          this, that = element.bbox, other.bbox
+
+          case alignment
+          when :center then Translation[(this.width - that.width) / 2.0, (this.height - that.height) / 2.0]
+          when :left   then Translation[this.ne.x - that.ne.x, 0]
+          when :right  then Translation[this.sw.x - that.sw.x, 0]
+          when :top    then Translation[0, this.ne.y - that.ne.y]
+          when :bottom then Translation[0, this.sw.y - that.sw.y]
+          else              ArgumentError.("No such type of alignment: #{alignment}")
+          end
+        end
+
+        def applicable?(element)
+          Translation.applicable?(element)
+        end
+      end
+
+      register(Align, :align, :alignment)
+    end
+
+    Translation = Data.define(:dx, :dy) do
+      def apply(element) = element.translate(**to_h)
+
+      class << self
+        def applicable?(element) = element.respond_to?(:translate)
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/operation/sweep.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Operation
+      module Sweep
+        extend self
+
+        LIMIT = 1_000
+
+        def sweep(element, initial:, direction:, step:, limit: LIMIT, &block)
+          line = Equation::Line.from_direction(point: initial, direction:)
+
+          [
+            *unisweep(element, line.shift(-step), -step, limit:).reverse,
+            *unisweep(element, line, step, limit:),
+          ].tap do |segments|
+            yield(segments) if block
+          end
+        end
+
+        def sweep!(element, initial:, direction:, step:, limit: LIMIT, &block)
+          sweep(element, initial: initial, direction:, step:, limit:) do |segments|
+            OperationError.("No segments found [initial: #{initial}, direction: #{direction} step: #{step}]") if segments.empty?
+
+            yield(segments) if block
+          end
+        end
+
+        def unisweep(element, line, step, limit: LIMIT)
+          segments = []
+
+          limit.times do
+            return segments unless (segment = element.intersection(line))
+
+            segments << segment unless segment.ignorable?
+
+            line = line.shift(step)
+          end
+
+          OperationError.("Loop limit reached: #{limit}")
+        end
+
+        def applicable?(element)
+          element.respond_to?(:intersection)
+        end
+      end
+
+      register(Sweep, :sweep, :sweep!, :unisweep)
+    end
+  end
+end

data/lib/sevgi/geometry/operation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Operation
+      extend self
+
+      OperationError             = Class.new(GeometryError)
+      OperationInapplicableError = Class.new(GeometryError)
+
+      def register(handler, *operations) = operations.each { |operation| def_operation(operation, handler) }
+
+      private
+
+      def def_operation(operation, handler)
+        define_singleton_method(operation) do |element, *args, **kwargs, &block|
+          OperationInapplicableError.("Not a Geometric Element: #{element}")               unless element.is_a?(Geometry::Element)
+          OperationInapplicableError.("Unapplicable operation for #{element}: #{handler}") unless handler.applicable?(element)
+
+          handler.public_send(operation, element, *args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end
+
+require_relative "operation/align"
+require_relative "operation/sweep"

data/lib/sevgi/geometry/point.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    Point = Data.define(:x, :y) do
+      include Comparable
+
+      def initialize(x:, y:)
+        super(x: x.to_f, y: y.to_f)
+      end
+
+      def above?(other)
+        y <= other.y
+      end
+
+      def below?(other)
+        y >= other.y
+      end
+
+      def approx(precision = nil)
+        with(x: F.approx(x, precision), y: F.approx(y, precision))
+      end
+
+      def eq?(other, precision: nil)
+        self.class.eq?(self, other, precision:)
+      end
+
+      def infinite?
+        [x, y].any?(&:infinite?)
+      end
+
+      def nan?
+        [x, y].any?(&:nan?)
+      end
+
+      def to_s
+        "P(#{F.approx(x)} #{F.approx(y)})"
+      end
+
+      def translate(dx: nil, dy: nil)
+        with(x: x + (dx || 0.0), y: y + (dy || 0.0))
+      end
+
+      def unordered_between?(p, q)
+        nan? ? false : between?([p, q].min, [p, q].max)
+      end
+
+      def <=>(other)
+        return unless other.is_a?(self.class)
+        return if other.nan? || nan?
+
+        deconstruct <=> other.deconstruct
+      end
+
+      class << self
+        def eq?(p, q, precision: nil) = F.eq?(p.x, q.x, precision:) && F.eq?(p.y, q.y, precision:)
+
+        def origin                    = new(x: 0.0, y: 0.0)
+      end
+    end
+  end
+end

data/lib/sevgi/geometry.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "geometry/errors"
+
+require_relative "geometry/point"
+require_relative "geometry/equation"
+require_relative "geometry/elements"
+require_relative "geometry/operation"
+
+require_relative "geometry/external"

data/lib/sevgi/graphics/attribute.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Some parts are adapted from https://github.com/DannyBen/victor (lib/victor/attributes.rb)
+
+module Sevgi
+  module Graphics
+    module Attribute
+      module Ident
+        INTERNAL_PREFIX = "_"
+        UPDATE_SUFFIX   = "+"
+
+        def internal?(given)
+          (@internal ||= {})[given] ||= given.start_with?(INTERNAL_PREFIX)
+        end
+
+        def id(given)
+          (@id ||= {})[given] ||= (updateable?(given) ? given.to_s.delete_suffix(UPDATE_SUFFIX) : given).to_sym
+        end
+
+        def updateable?(given)
+          (@updateable ||= {})[given] ||= given.end_with?(UPDATE_SUFFIX)
+        end
+      end
+
+      extend Ident
+
+      class Store
+        def initialize(attributes = {})
+          @store = {}
+
+          import(attributes)
+        end
+
+        def import(attributes)
+          hash = attributes.compact.to_a.map do |key, value|
+            [key.to_sym, value.is_a?(::Hash) ? value.transform_keys!(&:to_sym) : value]
+          end.to_h
+
+          @store.merge!(hash)
+        end
+
+        def [](key)
+          @store[Attribute.id(key)]
+        end
+
+        def []=(key, value)
+          return if value.nil?
+
+          @store[id = Attribute.id(key)] = @store.key?(id) && Attribute.updateable?(key) ? update(id, value) : value
+        end
+
+        def delete(key)
+          @store.delete(Attribute.id(key))
+        end
+
+        def export
+          hash = @store.reject { |id, _| Attribute.internal?(id) }
+          return hash unless hash.key?(:id)
+
+          # A small aesthetic touch: always keep the id attribute first
+          { id: hash.delete(:id), **hash }
+        end
+
+        def has?(key)
+          @store.key?(Attribute.id(key))
+        end
+
+        def initialize_copy(original)
+          @store = {}
+          original.store.each { |key, value| @store[key] = value.dup }
+
+          super
+        end
+
+        def list
+          export.keys
+        end
+
+        def to_h
+          @store
+        end
+
+        def to_xml_lines
+          export.map { |id, value| to_xml(id, value) }
+        end
+
+        protected
+
+        attr_reader :store
+
+        private
+
+        UPDATER = {
+          ::String => proc { |old_value, new_value| [old_value, new_value].reject(&:empty?).join(" ") },
+          ::Symbol => proc { |old_value, new_value| [old_value, new_value].reject(&:empty?).join(" ").to_sym },
+          ::Array  => proc { |old_value, new_value| [old_value, new_value] },
+          ::Hash   => proc { |old_value, new_value| merge(old_value, new_value.transform_keys(&:to_sym)) },
+        }.freeze
+
+        def update(id, new_value)
+          (old_value = @store[id]).nil? ? new_value : UPDATER[new_value.class].call(*sanitized(old_value, new_value))
+        end
+
+        def sanitized(old_value, new_value)
+          ArgumentError.("Incompatible values: #{new_value} vs #{old_value}") unless new_value.is_a?(old_value.class)
+          ArgumentError.("Unsupported value for update: #{new_value}")        unless UPDATER.key?(new_value.class)
+
+          [old_value, new_value]
+        end
+
+        private_constant :UPDATER
+
+        def to_xml(id, value)
+          case value
+          when ::Hash  then %[#{id}="#{value.map { "#{_1}:#{_2}" }.join("; ")}"]
+          when ::Array then %[#{id}="#{value.join(" ")}"]
+          else              %[#{id}=#{value.to_s.encode(xml: :attr)}]
+          end
+        end
+      end
+    end
+
+    Attributes = Attribute::Store
+  end
+end

data/lib/sevgi/graphics/canvas.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Sevgi
+  module Graphics
+    class Canvas
+      extend Forwardable
+      def_delegators :@margin, *Margin.members
+      def_delegators :@dim,    *Dim.members
+
+      attr_reader :dim, :margin, :content
+
+      def initialize(width:, height:, unit: "mm", margins: [])
+        @dim    = Dim[width, height, unit]
+        @margin = Margin[*margins]
+
+        compute
+        freeze
+      end
+
+      def attributes     = { **viewport, viewBox: viewbox }
+
+      def rect           = content.rect
+
+      def viewport       = { width: "#{width}#{unit}", height: "#{height}#{unit}" }
+
+      def viewbox        = F.prettify(-margin.left, -margin.top, width, height).join(" ")
+
+      def with(*margins) = margins.empty? ? self : self.class.new(**dim.to_h, margins:)
+
+      private
+
+      def compute
+        @content = dim.with(width: width - margin.left - margin.right, height: height - margin.top - margin.bottom)
+      end
+
+      class << self
+        def call(arg = Paper.default, *)
+          case arg
+          when Canvas then arg
+          when Symbol then new(**Paper[arg].to_h)
+          else             ArgumentError.("Argument must be a Symbol or Canvas instance: #{arg}")
+          end => canvas
+
+          canvas.with(*)
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/graphics/content.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    class Content
+      attr_reader :content
+
+      def initialize(content)     = @content = content
+
+      def render(renderer, depth) = raise NotImplementedError
+
+      def to_s                    = content.to_s
+
+      class CData < Content
+        def render(renderer, depth)
+          depth += 1
+
+          renderer.append(depth, "<![CDATA[")
+          renderer.append(depth + 1, *Array(content))
+          renderer.append(depth, "]]>")
+        end
+      end
+
+      class CSS < Content
+        def initialize(content)
+          ArgumentError.("CSS content must be a hash: #{content}") unless content.is_a?(::Hash)
+
+          super
+        end
+
+        def render(renderer, depth)
+          depth += 1
+
+          renderer.append(depth, "<![CDATA[")
+
+          depth += 1
+          content.each do |rule, styles|
+            case styles
+            when ::Hash
+              renderer.append(depth, "#{rule} {")
+              renderer.append(depth + 1, *styles.map { |key, value| "#{key}: #{value};" })
+              renderer.append(depth, "}")
+            when ::String, ::Symbol, ::Numeric
+              renderer.append(depth, "#{rule}: #{styles};")
+            else
+              ArgumentError.("Malformed style: #{styles}")
+            end
+          end
+          depth -= 1
+
+          renderer.append(depth, "]]>")
+        end
+      end
+
+      class Encoded < Content
+        def to_s                    = content.to_s.encode(xml: :text)
+
+        def render(renderer, depth) = renderer.append(depth + 1, to_s)
+      end
+
+      class Verbatim < Content
+        def render(renderer, depth) = renderer.append(depth + 1, to_s)
+      end
+    end
+
+    extend self
+
+    def Content(arg)    = Content::Encoded.new(arg)
+
+    def Text(contents)  = Array(contents).map(&:to_s).join("\n")
+  end
+end

data/lib/sevgi/graphics/document/base.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Document
+      DEFAULTS = { lint: true, validate: true }.freeze
+
+      class Proto < Element
+        extend Profile::DSL
+
+        mixture Mixtures::Core
+        mixture Mixtures::Render
+
+        def call(*, **)
+          options = DEFAULTS.merge(**)
+
+          self.Process(*, **options) if respond_to?(:Process)
+          self.Render(*, **options)
+        end
+
+        class << self
+          def attributes = self == Proto ? {} : { **superclass.attributes, **profile.attributes }
+
+          def preambles  = self == Proto ? nil : profile.preambles || superclass.preambles
+        end
+      end
+
+      class Base < Proto
+        public_class_method :new
+
+        document :base
+
+        mixture Mixtures::Duplicate
+        mixture Mixtures::Hatch
+        mixture Mixtures::Identify
+        mixture Mixtures::Lint
+        mixture Mixtures::Replicate
+        mixture Mixtures::Save
+        mixture Mixtures::Transform
+        mixture Mixtures::Underscore
+        mixture Mixtures::Validate
+        mixture Mixtures::Wrappers
+
+        def Process(**options)
+          self.Validate if options[:validate]
+          self.Lint     if options[:lint]
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/graphics/document/default.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Document
+      class Default < Minimal
+        document :default,
+          attributes: {
+            "xmlns":       "http://www.w3.org/2000/svg",
+            "xmlns:xlink": "http://www.w3.org/1999/xlink",
+          },
+          preambles: [
+            '<?xml version="1.0" standalone="no"?>',
+            '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">',
+          ]
+      end
+    end
+  end
+end

data/lib/sevgi/graphics/document/html.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Document
+      class HTML < Default
+        document :html, preambles: []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Document
+      class Inkscape < Default
+        document :inkscape, attributes: {
+          "xmlns:inkscape":  "http://www.inkscape.org/slugs/inkscape",
+          "xmlns:sodipodi":  "http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd",
+          "shape-rendering": "crispEdges",
+        }
+
+        mixture Mixtures::Inkscape
+      end
+    end
+  end
+end

data/lib/sevgi/graphics/document/minimal.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Document
+      class Minimal < Base
+        document :minimal
+      end
+    end
+  end
+end

data/lib/sevgi/graphics/document.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    class Profile
+      @available = {}
+
+      class << self
+        attr_reader :available
+
+        def call(document, canvas = nil, **, &block)
+          (klass = self[document]).root(**klass.attributes, **(canvas ? Graphics.Canvas(canvas).attributes : {}), **, &block)
+        end
+
+        def register(name, klass) = (available[name] = klass)
+
+        def [](name)              = available[name]
+      end
+
+      attr_reader :name, :attributes, :preambles
+
+      def initialize(name, attributes: nil, preambles: nil)
+        @name       = name
+        @attributes = attributes || {}
+        @preambles  = preambles
+      end
+
+      module DSL
+        attr_reader :profile
+
+        def document(name, attributes: {}, preambles: nil)
+          @profile = Profile.new(name, attributes:, preambles:).tap do
+            Profile.register(name, self)
+          end
+        end
+
+        def mixture(*modules)
+          modules.each do |mod|
+            include(mod::InstanceMethods) if defined?(mod::InstanceMethods)
+            extend(mod::ClassMethods)     if defined?(mod::ClassMethods)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "document/base"
+require_relative "document/minimal"
+
+require_relative "document/default"
+require_relative "document/html"
+require_relative "document/inkscape"