sevgi 0.0.0

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Transform
+        module InstanceMethods
+          def Translate(x, y = nil)
+            tap do
+              next if x.to_f == 0.0 && (y.nil? || y.to_f == 0.0)
+
+              attributes[:"transform+"] = "translate(#{(y ? [x, y] : [x]).join(" ")})"
+            end
+          end
+
+          def Scale(x, y = nil)
+            tap do
+              next if x.to_f == 0.0 && (y.nil? || y.to_f == 0.0)
+
+              attributes[:"transform+"] = "scale(#{(y ? [x, y] : [x]).join(", ")})"
+            end
+          end
+
+          def Scale!(...)
+            Scale(...).tap do
+              attributes[:"vector-effect"] = "non-scaling-stroke" unless attributes[:"vector-effect"]
+            end
+          end
+
+          def SkewX(a)
+            tap do
+              next if a.to_f == 0.0
+
+              attributes[:"transform+"] = "skewX(#{a})"
+            end
+          end
+
+          def SkewY(a)
+            tap do
+              next if a.to_f == 0.0
+
+              attributes[:"transform+"] = "skewY(#{a})"
+            end
+          end
+
+          def Rotate(a, *origin)
+            tap do
+              ArgumentError.("Incorrect origin (two coordinates required): #{origin}") if !origin.empty? && origin.size != 2
+
+              next if a.to_f == 0.0
+
+              attributes[:"transform+"] = "rotate(#{[a, *origin].join(", ")})"
+            end
+          end
+
+          def Matrix(*values)
+            tap do
+              ArgumentError.("Incorrect transform matrix (six values required): #{values}") if values.size != 6
+
+              next if values.map(&:to_f).all? { _1 == 0.0 }
+
+              attributes[:"transform+"] = "matrix(#{values.join(" ")})"
+            end
+          end
+
+          def Align(position, inner:, outer:)
+            return self unless position && inner && outer
+
+            case position.to_sym
+            when :center then Translate((outer.width - inner.width) / 2.0, (outer.height - inner.height) / 2.0)
+            else              ArgumentError.("Unsupported alignment: #{position}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Underscore
+        module InstanceMethods
+          def _(*contents)
+            self.class.call(:_, parent: self, contents:)
+          end
+
+          def Ancestral
+            {}.tap do |result|
+              Root.Traverse { |element| result.merge!(element[:_]) if element.has?(:_) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "sevgi/standard"
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Validate
+        module InstanceMethods
+          def CData
+            return if !contents || contents.empty?
+
+            Graphics.Text(contents)
+          end
+
+          def Validate
+            Traverse do |element|
+              Standard.conform(
+                element.name, attributes: element.attributes.list, cdata: element.CData, elements: element.children.map(&:name)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Graphics
+    module Mixtures
+      module Wrappers
+        module InstanceMethods
+          def Cline(x1: 0, y1: 0, x2:, y2:, **)
+            path(d: "M #{x1} #{y1} L #{x2} #{y2}", **)
+          end
+
+          def Hline(x1: 0, y1: 0, x2:, **)
+            path(d: "M #{x1} #{y1} H #{x2}", **)
+          end
+
+          def Vline(x1: 0, y1: 0, y2:, **)
+            path(d: "M #{x1} #{y1} V #{y2}", **)
+          end
+
+          def cline(x1: 0, y1: 0, angle:, length:, **)
+            dx = length * ::Math.cos(angle.to_f / 180 * ::Math::PI)
+            dy = length * ::Math.sin(angle.to_f / 180 * ::Math::PI)
+            path(d: "M #{x1} #{y1} l #{dx} #{dy}", **)
+          end
+
+          def css(hash, **)
+            style(Content::CSS.new(hash), type: "text/css", **)
+          end
+
+          def cxline(x1: 0, y1: 0, angle:, dx:, **)
+            dy = dx * ::Math.tan(angle.to_f / 180 * ::Math::PI)
+            path(d: "M #{x1} #{y1} l #{dx} #{dy}", **)
+          end
+
+          def cyline(x1: 0, y1: 0, angle:, dy:, **)
+            dx = dy / ::Math.tan(angle.to_f / 180 * ::Math::PI)
+            path(d: "M #{x1} #{y1} l #{dx} #{dy}", **)
+          end
+
+          def hline(x1: 0, y1: 0, length:, **)
+            path(d: "M #{x1} #{y1} h #{length}", **)
+          end
+
+          def layer(...)
+            g(...)
+          end
+
+          def segment(...)
+            Cline(...)
+          end
+
+          def square(length:, **)
+            rect(width: length, height: length, **)
+          end
+
+          def vline(x1: 0, y1: 0, length:, **)
+            path(d: "M #{x1} #{y1} v #{length}", **)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/graphics/mixtures.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "mixtures/core"
+
+require_relative "mixtures/duplicate"
+require_relative "mixtures/hatch"
+require_relative "mixtures/identify"
+require_relative "mixtures/inkscape"
+require_relative "mixtures/lint"
+require_relative "mixtures/render"
+require_relative "mixtures/replicate"
+require_relative "mixtures/save"
+require_relative "mixtures/transform"
+require_relative "mixtures/underscore"
+require_relative "mixtures/validate"
+require_relative "mixtures/wrappers"

data/lib/sevgi/graphics.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "graphics/attribute"
+require_relative "graphics/content"
+require_relative "graphics/canvas"
+require_relative "graphics/element"
+require_relative "graphics/mixtures"
+require_relative "graphics/document"
+
+require_relative "graphics/external"

data/lib/sevgi/internal/constant.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sevgi
+  Undefined = Object.new.freeze
+end

data/lib/sevgi/internal/dim.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sevgi
+  Dim = Data.define(:width, :height, :unit) do
+    def initialize(width:, height:, unit: "mm") = super(width: Float(width), height: Float(height), unit:)
+
+    def longest  = deconstruct.max
+
+    def rect     = Geometry::Rect[width, height]
+
+    def shortest = deconstruct.min
+  end
+end

data/lib/sevgi/internal/function/file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Sevgi
+  module Function
+    module File
+      def changed?(file, content)
+        ::File.exist?(file) ? Digest::SHA1.digest(::File.read(file)) != Digest::SHA1.digest(content) : true
+      end
+
+      def out(content, *paths, smart: false)
+        if paths.empty?
+          ::Kernel.puts(content)
+        else
+          file   = ::File.expand_path(::File.join(*paths))
+          output = "#{content.chomp}\n"
+
+          ::File.write(file, output) if !smart || changed?(file, output)
+        end
+      end
+
+      def variations(name, dirs, exts)
+        dirs.product(exts).map { |dir, ext| ::File.join(dir, "#{name}.#{ext}") }
+      end
+    end
+
+    extend File
+  end
+end

data/lib/sevgi/internal/function/float.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Function
+    module Float
+      @precision = PRECISION = 6
+
+      class << self
+        attr_accessor :precision
+      end
+
+      def approx(float, precision = nil)   = float.round(precision || Function::Float.precision)
+
+      def eq?(left, right, precision: nil) = approx(left, precision) == approx(right, precision)
+
+      def ge?(left, right, precision: nil) = approx(left, precision) >= approx(right, precision)
+
+      def gt?(left, right, precision: nil) = approx(left, precision) > approx(right, precision)
+
+      def le?(left, right, precision: nil) = approx(left, precision) <= approx(right, precision)
+
+      def lt?(left, right, precision: nil) = approx(left, precision) < approx(right, precision)
+
+      def nonzero?(...)                    = !zero?(...)
+
+      def prettify(*args)                  = args.map { (i = _1.to_i) == _1.to_f ? i : _1 }
+
+      def round(float, precision)          = precision ? float.round(precision) : float
+
+      def zero?(value, precision: nil)     = eq?(value, 0.0, precision:)
+    end
+
+    extend Float
+  end
+end

data/lib/sevgi/internal/function/formula.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Function
+    module Formula
+      #  Y
+      #  ^
+      #  |                                     slope (Y/X)
+      #  |                                   .
+      #  |                                 .
+      #  |                             pb +
+      #  |                              . . coangle°
+      #  |                            .   .
+      #  |                          .     .
+      #  |                        .       .
+      #  |        (hypothenus)   d        dy
+      #  |                    .           .
+      #  |                  .             .
+      #  |            pa  .  angle°   . pc
+      #  |              +  .  .  dx .  .  +
+      #  |        90° . ..
+      #  |          .   .  .
+      #  |        .     .    r
+      #  |      .       ry    .
+      #  |              .       .
+      #  |   .          + . rx  . +
+      #  | .            .           . noangle°
+      #  +--------------+------------+---------------------> X
+      #  | intercept (Y)
+      #  |
+      #  |
+      #
+
+      def coangle(angle)                 = 90.0 - angle # complementary angle
+
+      def angler(dx, dy)                 = atan(dy / dx)
+
+      def angles(slope)                  = atan(slope)
+
+      def distance(p, q)                 = ::Math.sqrt(dxp(p, q)**2 + dyp(p, q)**2)
+
+      def height(pa, pb)                 = dyp(pa, pb).abs
+
+      def hypothenus(dx, dy)             = ::Math.sqrt(dx**2 + dy**2)
+
+      def intercept(point, angle, slope) = point.y - (slope * point.x) # point is pa or pb
+
+      def noangle(angle)                 = 90.0 + angle # normal angle
+
+      def rx(r, angle)                   = r * sin(angle)
+
+      def ry(r, angle)                   = r * cos(angle)
+
+      def slopea(angle)                  = tan(angle)
+
+      def sloper(dx, dy)                 = dy / dx
+
+      def width(pa, pb)                  = dxp(pa, pb).abs
+
+      def dxp(pa, pb)                    = pb.x - pa.x
+
+      def dyp(pa, pb)                    = pb.y - pa.y
+
+      def dxa(d, angle)                  = d * cos(angle)
+
+      def dya(d, angle)                  = d * sin(angle)
+    end
+
+    extend Formula
+  end
+end

data/lib/sevgi/internal/function/math.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Function
+    module Math
+      def acos(value)                           = to_degrees(::Math.acos(value))
+
+      def acot(value)                           = 90.0 - to_degrees(::Math.atan(value))
+
+      def asin(value)                           = to_degrees(::Math.asin(value))
+
+      def atan(value)                           = to_degrees(::Math.atan(value))
+
+      def complement(degrees)                   = 90.0 - degrees
+
+      def cos(degrees)                          = ::Math.cos(to_radians(degrees))
+
+      def cot(degrees)                          = 1.0 / ::Math.tan(to_radians(degrees))
+
+      def golden                                = @golden ||= ((1.0 + ::Math.sqrt(5)) / 2.0)
+
+      def horizontal?(degrees, precision = nil) = zero?(degrees % 180.0, precision:)
+
+      def nangle(degrees)                       = degrees - 90.0
+
+      def sin(degrees)                          = ::Math.sin(to_radians(degrees))
+
+      def sqrt2                                 = @sqrt2  ||= ::Math.sqrt(2)
+
+      def sqrt2h                                = @sqrt2h ||= (sqrt2 / 2.0)
+
+      def tan(degrees)                          = ::Math.tan(to_radians(degrees))
+
+      def to_degrees(radians)                   = radians.to_f * 180 / ::Math::PI
+
+      def to_radians(degrees)                   = degrees.to_f / 180 * ::Math::PI
+
+      def vertical?(degrees, precision = nil)   = zero?(degrees % 90.0, precision:)
+    end
+
+    extend Math
+  end
+end

data/lib/sevgi/internal/function/string.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Function
+    module String
+      def start_with_upper?(string) = upper?(string[0])
+
+      def upper?(char)              = /[[:upper:]]/.match?(char)
+    end
+
+    extend String
+  end
+end

data/lib/sevgi/internal/function.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "function/file"
+require_relative "function/float"
+require_relative "function/formula"
+require_relative "function/math"
+require_relative "function/string"

data/lib/sevgi/internal/list.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module List
+    def [](name)         = data[name]
+
+    def import(**kwargs) = data.merge!(kwargs.reject { |key, _| data.key?(key) })
+
+    def valid?(name)     = data.key?(name)
+
+    class << self
+      def extended(base)
+        super
+
+        base.class_exec do
+          @data = {}
+
+          class << self
+            attr_reader :data
+          end
+        end
+      end
+    end
+  end
+
+  private_constant :List
+end

data/lib/sevgi/internal/locate.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sevgi
+  class Locate
+    Location = Data.define(:file, :slug, :dir)
+
+    private_constant :Location
+
+    attr_reader :slugs, :start
+
+    def initialize(slugs, start = Dir.pwd)
+      @slugs  = slugs
+      @start  = start
+    end
+
+    def call(&block)
+      origin = Dir.pwd
+      Dir.chdir(start)
+
+      here = Dir.pwd
+      until (found = match(&block))
+        Dir.chdir("..")
+        return if Dir.pwd == here
+
+        here = Dir.pwd
+      end
+
+      Location[::File.expand_path(found, here), found, here]
+    ensure
+      Dir.chdir(origin)
+    end
+
+    private
+
+    def match(&block)
+      finder = block || proc { |path| ::File.exist?(path) }
+
+      slugs.find { finder.call(_1) }
+    end
+
+    class << self
+      def call(*, &block) = new(*).call(&block)
+    end
+  end
+
+  private_constant :Locate
+end

data/lib/sevgi/internal/margin.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sevgi
+  Margin = Data.define(:top, :right, :bottom, :left) do
+    def initialize(top: nil, right: nil, bottom: nil, left: nil)
+      case [top, right, bottom, left]
+      in Numeric,  Numeric,  Numeric,  Numeric  then # nop
+      in Numeric,  Numeric,  Numeric,  NilClass then left                     = right
+      in Numeric,  Numeric,  NilClass, NilClass then bottom, left             = top, right
+      in Numeric,  NilClass, NilClass, NilClass then bottom, left, right      = top, top, top
+      in NilClass, NilClass, NilClass, NilClass then top, bottom, left, right = 0, 0, 0, 0
+      end
+
+      super(top: Float(top), right: Float(right), bottom: Float(bottom), left: Float(left))
+    end
+
+    alias_method :to_a, :deconstruct
+
+    class << self
+      def zero = (@zero ||= self[0.0, 0.0, 0.0, 0.0])
+    end
+  end
+end

data/lib/sevgi/internal/minitest/script.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Test
+    class Script
+      attr_reader :file
+
+      def initialize(file) = @file = sanitize(file)
+
+      def dir              = @dir  ||= ::File.dirname(file)
+
+      def name             = @name ||= ::File.basename(file, ".*")
+
+      def run(*)           = Shell.run(file, *)
+
+      def suite            = @suite ||= ::File.basename(dir)
+
+      def svg?             = ::File.exist?(svg)
+
+      def svg              = @svg ||= "#{dir}/#{name}.svg"
+
+      # A gross hack to avoid touching filesystem during testing.  Intercept the Save methods to display output in stdout
+      # instead of saving an actual file. This hack meets the following criteria:
+      #
+      # - Does not make an invasive change to the library just for the sake of testing (hence the interception technique)
+      # - Do not create a separate file for the interceptor (hence feeding the interceptor through /dev/stdin)
+
+      INTERCEPTOR = <<~LIB
+        class Sevgi::Graphics::Document::Base
+          def Save(*, **) = Out(**)
+          def Save!(...)  = Save(...)
+        end
+      LIB
+
+      def run_passive(*)
+        warn("  ==> #{file}")
+        Shell.run("sevgi", "-l", "/dev/stdin", file, *) { puts INTERCEPTOR }
+      end
+
+      private
+
+      def sanitize(file)
+        file.tap do
+          ArgumentError.("No such file: #{file}")      unless ::File.exist?(file)
+          ArgumentError.("Not an executable: #{file}") unless ::File.executable?(file)
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/internal/minitest/shell.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Sevgi
+  module Test
+    module Shell
+      Result = Data.define(:args, :out, :err, :exit_code) do
+        def cmd     = args.join(" ")
+
+        def notok?  = !ok?
+
+        def ok?     = exit_code&.zero?
+
+        def outline = out.first
+
+        def to_s    = out.join("\n")
+      end
+
+      # Adapted to popen3 from github.com/mina-deploy/mina
+      class Runner
+        def initialize
+          @coathooks = 0
+        end
+
+        def run(*args, &block)
+          out, err, status = Open3.popen3(*args) do |stdin, stdout, stderr, thread|
+            inputs(stdin, thread, &block) if block
+            outputs(stdout, stderr, thread)
+          end
+
+          Result[args, out, err, status.exitstatus]
+        end
+
+        private
+
+        def inputs(stdin, thread, &block)
+          stdin.instance_exec(thread, &block)
+          stdin.close unless stdin.closed?
+        end
+
+        def outputs(stdout, stderr, thread)
+          trap("INT") { handle_sigint(thread.pid) } # handle `^C`
+
+          out = stdout.readlines.map(&:chomp)
+          err = stderr.readlines.map(&:chomp)
+
+          [out, err, thread.value]
+        end
+
+        def handle_sigint(pid)
+          message, signal = if @coathooks > 1
+            ["SIGINT received again. Force quitting...", "KILL"]
+          else
+            ["SIGINT received.", "TERM"]
+          end
+
+          warn("\n#{message}")
+          ::Process.kill(signal, pid)
+          @coathooks += 1
+        rescue Errno::ESRCH
+          warn("No process to kill.")
+        end
+      end
+
+      extend self
+
+      def run(...) = Runner.new.run(...)
+    end
+  end
+end