sevgi 0.0.0

data/README.md

@@ -0,0 +1,15 @@
+[![test status](https://github.com/roktas/sevgi/workflows/Test/badge.svg)](https://github.com/roktas/sevgi/actions?query=workflow%3ATest)
+[![code quality](https://codebeat.co/badges/f2de3389-dd66-4d7a-b7fb-452330d62176)](https://codebeat.co/projects/github-com-roktas-sevgi-dev)
+
+# Sevgi
+
+<p align="center"><img src="srv/static/assets/light/logo.svg#gh-light-mode-only"/></p>
+<p align="center"><img src="srv/static/assets/dark/logo.svg#gh-dark-mode-only"/></p>
+
+<p align="center"><img src="srv/static/assets/light/pacman-animation.png"/></p>
+
+Inspired by [Victor](https://github.com/DannyBen/victor), which might be a better choice for those seeking something
+simpler. Please note that a fair amount of the examples used for demonstration purposes come from this project (thanks
+to the author).
+
+### Roadmap

data/bin/sevgi

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "sevgi/external"
+
+module Sevgi
+  module CLI
+    extend self
+
+    CLIError = Class.new(Sevgi::Error)
+
+    PROGNAME = "sevgi"
+    ENVVOMIT = "SEVGI_VOMIT"
+
+    Options = Struct.new(:library, :vomit, :help, :version) do
+      class << self
+        def parse(argv)
+          new.tap do |options|
+            argv.first.start_with?("-") ? option(argv, options) : break until argv.empty?
+
+            next unless options.library
+
+            CLIError.("No library found: #{options.library}") unless ::File.exist?(options.library)
+          end
+        end
+
+        private
+
+        def option(argv, options)
+          case (arg = argv.shift)
+          when "-l", "--library"   then options.library = argv.shift
+          when "-x", "--exception" then options.vomit = true
+          when "-h", "--help"      then options.help = true
+          when "-v", "--version"   then options.version = true
+          else                          CLIError.("Not a valid option: #{arg}")
+          end
+        end
+      end
+    end
+
+    private_constant :Options
+
+    def call(argv)
+      return puts(help)           if (options = Options.parse(argv)).help
+      return puts(Sevgi::VERSION) if options.version
+
+      Signal.trap("INT") { Kernel.abort("") }
+      Kernel.load(file = options.library) if options.library
+      Kernel.load(file = script(argv))
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      die(e, file, options)
+    end
+
+    private
+
+    def description(e, file)
+      case e
+      when ArgumentError   then "Programming error"
+      when GeometryError   then "Geometry error"
+      when ValidationError then "Validation error"
+      else                      "Error"
+      end => error
+
+      <<~DESCRIPTION
+        #{error} #{scene(e.backtrace, file)}
+          #{e.message}
+      DESCRIPTION
+    end
+
+    def die(e, file, options)
+      abort(e.message) if e.is_a?(CLIError)
+
+      raise e if options.vomit || ENV[ENVVOMIT]
+
+      warn(description(e, file))
+      warn("")
+      abort(postmortem(file))
+    end
+
+    def help
+      <<~HELP
+        Usage: #{PROGNAME} [options...] <SCRIPT> [ARGS...]
+
+        See documentation for detailed help.
+
+        Options:
+
+          -l, --library FILE    Preload library FILE
+          -x, --exception       Raise exceptions instead of abort
+          -h, --help            Show this help
+          -v, --version         Display version
+      HELP
+    end
+
+    def postmortem(file)
+      <<~POSTMORTEM
+        For more details, run the script again:
+
+          - By using the -x switch
+
+              #{PROGNAME} -x #{file}
+
+          - By setting the #{ENVVOMIT} environment variable
+
+              #{ENVVOMIT}=t #{file}
+
+        If you think this is a bug, you can report it by creating an issue.
+      POSTMORTEM
+    end
+
+    def scene(backtrace, file)
+      default = "in #{file}"
+      return default unless backtrace
+
+      path = ::File.expand_path(file)
+      _, line = backtrace.map { _1.split(":")[..1] }.find do |spot|
+        ::File.expand_path(spot.first) == path
+      end
+
+      line ? "in '#{file}', around line #{line}" : default
+    end
+
+    def script(argv)
+      CLIError.("No script file given.")        unless (file = argv.shift)
+      CLIError.("No such script file: #{file}") unless ::File.exist?(file)
+
+      file
+    end
+  end
+end
+
+def main
+  Sevgi::CLI.(ARGV)
+end
+
+main

data/lib/sevgi/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Sevgi
+  class Error < StandardError
+    class << self
+      def call(...) = raise(self, ...)
+    end
+  end
+
+  ArgumentError = Class.new(Error)
+end

data/lib/sevgi/external.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "../sevgi"
+
+include Sevgi::Function::External
+include Sevgi::Geometry::External
+include Sevgi::Graphics::External
+include Sevgi::Utensils::External

data/lib/sevgi/function.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Function
+    module External
+      EXTENSIONS  = ["sevgi", "rb"].freeze
+      DIRECTORIES = ["lib", "library"].freeze
+
+      def Lib(name)
+        start = ::File.dirname(caller_locations(1..1).first.path)
+
+        paths = F.variations(name, DIRECTORIES, EXTENSIONS)
+
+        raise Error, "No library found matching: #{name}" unless (location = Locate.(paths, start))
+
+        Kernel.load(location.file)
+      end
+
+      module Function
+        extend Sevgi::Function::Float
+        extend Sevgi::Function::Math
+      end
+
+      class << self
+        def included(base)
+          super
+
+          base.const_set(:F, External::Function)
+        end
+      end
+    end
+  end
+
+  F = Function
+end

data/lib/sevgi/geometry/elements/rect.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# codebeat:disable[TOO_MANY_IVARS]
+
+require "forwardable"
+
+module Sevgi
+  module Geometry
+    class Rect < Element
+      # Argument order is in clockwise rotation from position point
+      Corner = Data.define(:top_left, :top_right, :bottom_right, :bottom_left) do
+        class << self
+          def of(rect)
+            position = rect.position
+
+            new(
+              top_left:     position,
+              top_right:    position.translate(dx: rect.width),
+              bottom_right: position.translate(dx: rect.width, dy: rect.height),
+              bottom_left:  position.translate(dy: rect.height),
+            )
+          end
+        end
+      end
+
+      # Argument order is in clockwise rotation from top segment (as in CSS)
+      Side = Data.define(:top, :right, :bottom, :left) do
+        class << self
+          def of(rect)
+            corner = rect.corner
+
+            new(
+              top:    Segment[corner.top_left,    corner.top_right],
+              right:  Segment[corner.top_right,   corner.bottom_right],
+              bottom: Segment[corner.bottom_left, corner.bottom_right],
+              left:   Segment[corner.top_left,    corner.bottom_left],
+            )
+          end
+        end
+      end
+
+      extend Forwardable
+
+      def_delegators :@side,   *Side.members
+      def_delegators :@corner, *Corner.members
+
+      attr_reader :position, :width, :height
+      attr_reader :corner, :corners, :side, :sides
+
+      def initialize(position: nil, width:, height:)
+        super()
+
+        @position = position || Point.origin
+        @width    = width.to_f
+        @height   = height.to_f
+
+        compute
+      end
+
+      def bbox
+        BBox[*@corner.deconstruct]
+      end
+
+      def diagonal
+        Segment.forward(top_left, bottom_right)
+      end
+
+      def draw(container, **)
+        container.rect(x: position.x, y: position.y, width: width, height: height, **)
+      end
+
+      def inside?(point)
+        onto?(point) || (left.right?(point) && right.left?(point) && top.left?(point) && bottom.right?(point))
+      end
+
+      # codebeat:disable[ABC]
+      def intersection(line, precision: nil)
+        points = sides.map { _1.intersection(line).approx(precision) }.uniq.select { onto?(_1) }
+        return if points.empty?
+
+        GeometryError.("Unexpected number of intersection points: #{points.size}") if points.size > 2
+
+        Segment.forward(*points)
+      end
+      # codebeat:enable[ABC]
+
+      def onto?(point)
+        left.onto?(point) || right.onto?(point) || top.onto?(point) || bottom.onto?(point)
+      end
+
+      def orient(new_orientation)
+        return self if orientation == new_orientation
+
+        with(width: height, height: width)
+      end
+
+      def orientation
+        F.gt?(width, height) ? :landscape : :portrait
+      end
+
+      def outside?(point)
+        !inside?(point)
+      end
+
+      def to_s
+        strings = []
+
+        strings << "R[#{F.approx(width)}x#{F.approx(height)}]"
+        strings << position.to_s if Point.eq?(position, Point.origin)
+
+        strings.join("@")
+      end
+
+      def translate(dx: nil, dy: nil)
+        self.class.new(position: position.translate(dx:, dy:), width: width, height: height)
+      end
+
+      private
+
+      def compute
+        @corner   = Corner.of(self)
+        @corners  = Corner.members.map { public_send(_1) }
+
+        @side     = Side.of(self)
+        @sides    = Side.members.map { public_send(_1) }
+      end
+
+      class << self
+        def [](width, height) = new(width:, height:)
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/elements/segment.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Sevgi
+  module Geometry
+    class Segment < Element
+      extend Forwardable
+
+      def_delegators :line, :left?, :right?, :intersection
+
+      attr_reader :position, :ending
+
+      def initialize(position: Point.origin, ending:, &block)
+        super()
+
+        @position = position
+        @ending   = ending
+
+        instance_exec(&block) if block # optimization backdoor for constructors
+      end
+
+      def bbox
+        BBox[position, ending]
+      end
+
+      def direction
+        @direction ||= F.angler(dx, dy)
+      end
+
+      def dx
+        @dx ||= F.dxp(position, ending)
+      end
+
+      def dy
+        @dy ||= F.dyp(position, ending)
+      end
+
+      def draw(container, **)
+        container.segment(x1: position.x, y1: position.y, x2: ending.x, y2: ending.y, **)
+      end
+
+      def horizontal?(precision = nil)
+        F.horizontal?(direction, precision:)
+      end
+
+      def infinite?
+        [position, ending].any(&:infinite?)
+      end
+
+      def length
+        @length ||= F.distance(position, ending)
+      end
+
+      def line
+        @line ||= Equation::Line.from_segment(self)
+      end
+
+      def onto?(point)
+        point.unordered_between?(ending, position) && line.onto?(point)
+      end
+
+      def rect
+        @rect ||= Rect[dx.abs, dy.abs]
+      end
+
+      def to_s
+        "S[#{position} -> #{ending}]"
+      end
+
+      def translate(dx: nil, dy: nil)
+        self.class.new(position: position.translate(dx:, dy:), ending: ending.translate(dx:, dy:))
+      end
+
+      def vertical?(precision = nil)
+        F.vertical?(direction, precision:)
+      end
+
+      class << self
+        def [](position, ending)
+          new(position:, ending:)
+        end
+
+        def forward(p, q = nil)
+          new(position: (points = [p, q || p]).sort!.shift, ending: points.shift)
+        end
+
+        def directed(position: Point.origin, length:, direction:)
+          dx = F.dxa(length, direction)
+          dy = F.dya(length, direction)
+
+          new(position: position, ending: position.translate(dx:, dy:)) do # avoid recalculations
+            @direction = direction.to_f
+            @length    = length.to_f
+            @dx        = dx
+            @dy        = dy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/elements.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    class Element
+      def bbox = raise(NotImplementedError, "Instance method required: bbox")
+
+      def ignorable?(precision = nil) = bbox.zero?(precision)
+    end
+
+    class BBox
+      BBoxError = Class.new(GeometryError)
+
+      attr_reader :ne, :sw
+
+      def initialize(ne:, sw:)   = (@ne, @sw = ne, sw)
+
+      def height                 = @height ||= F.height(ne, sw)
+
+      def to_s                   = "[#{width}x#{height}]@[#{ne} ↘ #{sw}]"
+
+      def width                  = @width ||= F.width(ne, sw)
+
+      def zero?(precision = nil) = Point.eq?(ne, sw, precision:)
+
+      private
+
+      def validate!
+        BBoxError.("North-East is not to the left of South-West: #{self}") if ne > sw
+        BBoxError.("North-East is not below South-West: #{self}")          unless ne.below?(sw)
+      end
+
+      class << self
+        def [](*points) = new(ne: points.min, sw: points.max)
+      end
+    end
+  end
+end
+
+require_relative "elements/segment"
+require_relative "elements/rect"

data/lib/sevgi/geometry/equation/line/diagonal.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Equation
+      module Line
+        class Diagonal
+          attr_reader :slope, :intercept, :direction
+
+          def initialize(slope:, intercept:)
+            @slope     = slope.to_f
+            @intercept = intercept.to_f
+            @direction = F.angles(@slope)
+          end
+
+          def approx(precision = nil)
+            self.class.new(slope: F.approx(slope, precision), intercept: F.approx(intercept, precision))
+          end
+
+          def eql?(other)
+            self.class == other.class && [slope, intercept] == [other.slope, other.intercept]
+          end
+
+          alias_method :==, :eql?
+
+          def hash
+            [self.class, slope, intercept].hash
+          end
+
+          def intersection(other)
+            case other
+            when Diagonal
+              x = (other.intercept - intercept) / (slope - other.slope)
+              y = y(x)
+            when Horizontal
+              y = other.y
+              x = x(y)
+            when Vertical
+              x = other.x
+              y = y(x)
+            end
+
+            Point[x, y]
+          end
+
+          def left?(point)
+            F.gt?(point.y, y(point.x))
+          end
+
+          def onto?(point)
+            F.eq?(point.y, y(point.x))
+          end
+
+          def right?(point)
+            F.lt?(point.y, y(point.x))
+          end
+
+          def shift(distance = nil, dx: nil, dy: nil)
+            dx ||= 0.0
+            dy ||= 0.0
+
+            if distance
+              dx += F.rx(distance, direction)
+              dy -= F.ry(distance, direction)
+            end
+
+            Diagonal.new(slope:, intercept: intercept - slope * dx + dy)
+          end
+
+          def to_s
+            strings = []
+
+            strings << "#{F.approx(slope)} * x"     if F.nonzero?(slope)
+            strings << F.approx(intercept).abs.to_s if F.nonzero?(intercept)
+
+            "L<y = #{strings.join(intercept.positive? ? " + " : " - ")}>"
+          end
+
+          def x(y)
+            (y - intercept) / slope
+          end
+
+          def y(x)
+            (slope * x) + intercept
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/equation/line/horizontal.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Equation
+      module Line
+        class Horizontal < Diagonal
+          def initialize(c)
+            super(slope: 0, intercept: c)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/equation/line/vertical.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Equation
+      module Line
+        class Vertical
+          def initialize(c)
+            @x = c
+          end
+
+          def intersection(other)
+            case other
+            when Diagonal, Horizontal then x, y = self.x, other.y(self.x)
+            when Vertical             then x, y = ::Float::INFINITY, ::Float::INFINITY
+            end
+
+            Point[x, y]
+          end
+
+          def left?(point)
+            F.lt?(point.x, x(point.y))
+          end
+
+          def onto?(point)
+            F.eq?(point.x, x(point.y))
+          end
+
+          def right?(point)
+            F.gt?(point.x, x(point.y))
+          end
+
+          def shift(distance = nil, dx: nil, dy: nil)
+            self.class.new(x + (distance || 0.0) + (dx || 0.0))
+          end
+
+          def to_s
+            "L<x = #{F.approx(x)}>"
+          end
+
+          def x(_ = nil)
+            @x
+          end
+
+          def y(_ = nil)
+            ::Float::INFINITY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/equation/line.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "line/diagonal"
+require_relative "line/horizontal"
+require_relative "line/vertical"
+
+module Sevgi
+  module Geometry
+    module Equation
+      module Line
+        extend self
+
+        def diagonal(slope:, intercept:)
+          Diagonal.new(slope:, intercept:)
+        end
+
+        def from_direction(point:, direction:)
+          return horizontal(point.y) if F.horizontal?(direction)
+          return vertical(point.x)   if F.vertical?(direction)
+
+          diagonal(slope: (slope = F.slopea(direction)), intercept: F.intercept(point, direction, slope))
+        end
+
+        def from_segment(segment)
+          from_direction(point: segment.position, direction: segment.direction)
+        end
+
+        def horizontal(const)
+          Horizontal.new(const)
+        end
+
+        def vertical(const)
+          Vertical.new(const)
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/equation.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "equation/line"

data/lib/sevgi/geometry/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Sevgi
+  GeometryError = Class.new(Error)
+end