dieses 0.0.1

data/lib/dieses/geometry/rect.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Dieses
+  module Geometry
+    # codebeat:disable[TOO_MANY_IVARS]
+    class Rect < Element
+      Side   = Struct.new(*%i[top right bottom left], keyword_init: true)                       # in CSS margin order
+      Corner = Struct.new(*%i[bottom_left top_left top_right bottom_right], keyword_init: true) # cw from position
+
+      private_constant :Side
+      private_constant :Corner
+
+      extend Forwardable
+
+      def_delegators :@side,   *Side.members
+      def_delegators :@corner, *Corner.members
+
+      attr_reader :width, :height, :position
+
+      def initialize(width, height, position: Point.origin)
+        @width    = width.to_f
+        @height   = height.to_f
+        @position = Point.cast(position)
+        @corner   = calculate_corner
+        @side     = calculate_side
+
+        super()
+      end
+
+      def translate(x: 0, y: 0)
+        self.class.new width, height, position: position.translate(x: x, y: y)
+      end
+
+      def shrink(width: 0, height: 0)
+        self.class.new self.width - width, self.height - height, position: position
+      end
+
+      module Align
+        module_function
+
+        def center(this, that)
+          Point.new(this.position.x + (this.width  - that.width)  / 2,
+                    this.position.y + (this.height - that.height) / 2)
+        end
+
+        def left(this, that)
+          Point.new(this.position.x, that.position.y)
+        end
+
+        def right(this, that)
+          Point.new(this.position.x + (this.width - that.width), that.position.y)
+        end
+
+        def top(this, that)
+          Point.new(that.position.x, this.position.y + (this.height - that.height))
+        end
+
+        def bottom(this, that)
+          Point.new(that.position.x, this.position.y)
+        end
+      end
+
+      private_constant :Align
+
+      def align(other, alignment = :center)
+        raise ArgumentError, "No such alignment type: #{alignment}" unless Align.respond_to? alignment
+
+        self.class.new other.width, other.height, position: Align.public_send(alignment, self, other).approx
+      end
+
+      Orientation = Support::Enum.of(:portrait, :landscape)
+
+      def orientation
+        value = if Support.almost_greater_than(width, height)
+                  :landscape
+                else
+                  :portrait
+                end
+        Orientation.(value)
+      end
+
+      def orient(new_orientation)
+        new_orientation = Orientation.(new_orientation)
+        return self if orientation == new_orientation
+
+        self.class.new height, width, position: position
+      end
+
+      module Predicate
+        def inside?(point)
+          onto?(point) || (
+            left.right?(point) && right.left?(point) && top.left?(point) && bottom.right?(point)
+          )
+        end
+
+        def outside?(point)
+          !inside?(point)
+        end
+
+        def onto?(point)
+          left.onto?(point) || right.onto?(point) || top.onto?(point) || bottom.onto?(point)
+        end
+
+        def cover?(element)
+          bbox = element.bbox
+          inside?(bbox.minimum) && inside?(bbox.maximum)
+        end
+      end
+
+      include Predicate
+
+      # codebeat:disable[LOC,ABC]
+      def intersect(equation, precision: nil)
+        points = Side.members
+          .map { |line| public_send(line).intersect(equation).approx(precision) }
+          .uniq
+          .select { |intersect| onto?(intersect) }
+          .sort
+
+        return if points.empty?
+
+        raise "Unexpected number of intersection points: #{points.size}" unless points.size <= 2
+
+        Line.new((starting = points.shift), (points.shift || starting))
+      end
+      # codebeat:enable[LOC,ABC]
+
+      def angle
+        Math.atan(height / width)
+      end
+
+      def bbox
+        BoundingBox.new(@corner.values.min, @corner.values.max)
+      end
+
+      def to_s
+        repr = "R(#{width}, #{height})"
+        return repr if position == Point.origin
+
+        "#{repr}@#{position}"
+      end
+
+      def to_h
+        { width: width, height: height, **position.to_h }
+      end
+
+      # codebeat:disable[ABC]
+      def to_svgf
+        <<~SVG
+          <rect width="#{Support.approx(width)}" height="#{Support.approx(height)}" x="#{Support.approx(position.x)}" y="#{Support.approx(position.y)}" %{attributes}/>
+        SVG
+      end
+
+      private
+
+      def calculate_corner
+        Corner.new(top_left:     position,
+                   top_right:    Point.new(position.x + width, position.y),
+                   bottom_right: Point.new(position.x + width, position.y + height),
+                   bottom_left:  Point.new(position.x,         position.y + height))
+      end
+
+      def calculate_side
+        Side.new(top:    Line.new(@corner.top_left,     @corner.top_right),
+                 right:  Line.new(@corner.top_right,    @corner.bottom_right),
+                 bottom: Line.new(@corner.bottom_left,  @corner.bottom_right),
+                 left:   Line.new(@corner.top_left,     @corner.bottom_left))
+      end
+    end
+  end
+end

data/lib/dieses/geometry/support.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'diesis/support'

data/lib/dieses/support.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'support/const'
+require_relative 'support/kernel'
+require_relative 'support/class'
+require_relative 'support/enum'
+require_relative 'support/float'
+require_relative 'support/math'
+require_relative 'support/hash'

data/lib/dieses/support/class.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Support
+    # Stolen and improved from dry-rb/dry-core
+    module ClassAttribute
+      module Value
+        Update = Object.new.tap do |object|
+          def object.call(current_value, new_value)
+            raise ArgumentError, "Value must be updateable: #{new_value}" unless new_value.respond_to? :[]
+
+            current_value.tap { new_value.each { |k, v| current_value[k.to_sym] = v } }
+          end
+        end.freeze
+
+        Append = Object.new.tap do |object|
+          def object.call(current_value, new_value)
+            raise ArgumentError, "Value must be appendable: #{new_value}" unless new_value.respond_to? :<<
+
+            current_value.tap { new_value.each { |v| current_value << v } }
+          end
+        end.freeze
+
+        Assign = Object.new.tap do |object|
+          def object.call(_, new_value)
+            new_value.dup
+          end
+        end.freeze
+
+        class << self
+          def behave(behave, value = Undefined)
+            Undefined.equal?(behave) ? implicit(value) : explicit(behave)
+          end
+
+          private
+
+          # Map given symbol to relevant module
+          def explicit(behave)
+            const_get behave.to_s.capitalize
+          rescue NameError
+            raise ArgumentError, "Unrecognized behave: #{behave}"
+          end
+
+          # Deduce semantics from a value
+          def implicit(value)
+            require 'ostruct'
+            require 'set'
+
+            case value
+            when ::Hash, ::Struct, ::OpenStruct then Update
+            when ::Array, ::Set                 then Append
+            else                                     Assign
+            end
+          end
+        end
+      end
+
+      private_constant :Value
+
+      # rubocop:disable Metrics/MethodLength,Layout/LineLength,Lint/RedundantCopDisableDirective
+      def define(name, default: Undefined, behave: Undefined, inherit: true, instance_reader: false)
+        ivar   = :"@#{name}"
+        behave = Value.behave(behave, default)
+
+        instance_variable_set(ivar, default.dup)
+
+        mod = ::Module.new do
+          define_method(name) do |new_value = Undefined|
+            if Undefined.equal?(new_value)
+              return instance_variable_defined?(ivar) ? instance_variable_get(ivar) : nil
+            end
+
+            instance_variable_set(
+              ivar,
+              behave.(
+                instance_variable_defined?(ivar) ? instance_variable_get(ivar) : instance_variable_set(ivar, default.dup),
+                new_value
+              )
+            )
+          end
+
+          define_method(:inherited) do |klass|
+            klass.send(name, (inherit ? send(name) : default).dup)
+
+            super(klass)
+          end
+        end
+
+        extend(mod)
+
+        define_method(name) { self.class.send(name) } if instance_reader
+      end
+      # rubocop:enable Metrics/MethodLength,Layout/LineLength,Lint/RedundantCopDisableDirective
+
+      def defines(*names, behave: Undefined)
+        names.each { |name| define(name, behave: behave) }
+      end
+    end
+  end
+end

data/lib/dieses/support/const.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Support
+    module Const
+      # Copied from https://github.com/dry-rb/dry-core.  All kudos to the original authors.
+
+      require 'set'
+
+      # An empty array
+      EMPTY_ARRAY = [].freeze
+      # An empty hash
+      EMPTY_HASH = {}.freeze
+      # An empty list of options
+      EMPTY_OPTS = {}.freeze
+      # An empty set
+      EMPTY_SET = ::Set.new.freeze
+      # An empty string
+      EMPTY_STRING = ''
+      # Identity function
+      IDENTITY = (->(x) { x }).freeze
+
+      Undefined = Object.new.tap do |undefined| # rubocop:disable Metrics/BlockLength
+        const_set(:Self, -> { Undefined })
+
+        def undefined.to_s
+          'Undefined'
+        end
+
+        def undefined.inspect
+          'Undefined'
+        end
+
+        def undefined.default(x, y = self)
+          if equal?(x)
+            if equal?(y)
+              yield
+            else
+              y
+            end
+          else
+            x
+          end
+        end
+
+        def undefined.map(value)
+          if equal?(value)
+            self
+          else
+            yield(value)
+          end
+        end
+
+        def undefined.dup
+          self
+        end
+
+        def undefined.clone
+          self
+        end
+
+        def undefined.coalesce(*args)
+          args.find(Self) { |x| !equal?(x) }
+        end
+      end.freeze
+
+      def self.included(base)
+        super
+
+        constants.each do |const_name|
+          base.const_set(const_name, const_get(const_name))
+        end
+      end
+    end
+  end
+
+  include Support::Const
+end

data/lib/dieses/support/enum.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Support
+    class Enum
+      extend ClassAttribute
+
+      define :values, behave: :assign, instance_reader: true
+
+      attr_reader :value
+
+      def initialize(value)
+        self.value = value
+      end
+
+      def value=(value)
+        raise ArgumentError, "Invalid enum value: #{value}" unless self.class.values.member?(value = value.to_sym)
+
+        @value = value
+      end
+
+      def eql?(other)
+        return false unless other.is_a? self.class
+
+        value == other.value
+      end
+
+      alias == eql?
+
+      def hash
+        self.class.hash ^ values.hash ^ value.hash
+      end
+
+      def to_s
+        value.to_s
+      end
+
+      class << self
+        require 'set'
+
+        def of(*members) # rubocop:disable Metrics/MethodLength
+          values Set.new(members.map(&:to_sym)).freeze
+
+          members.each do |member|
+            define_method("#{member}?") do
+              value == member
+            end
+          end
+
+          Class.new(self) do
+            def self.call(value)
+              new(value)
+            end
+
+            define_singleton_method(:default) { members.first }
+          end
+        end
+      end
+
+      private_class_method :new
+    end
+  end
+end

data/lib/dieses/support/float.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Dieses
+  module Support
+    module Float
+      @precision = PRECISION = 5
+
+      class << self
+        attr_accessor :precision
+      end
+
+      def round(float, precision)
+        precision ? float.round(precision) : float
+      end
+
+      def approx(float, precision = nil)
+        float.round(precision || Float.precision)
+      end
+
+      def almost_equal(left, right, precision: Float.precision)
+        round(left, precision) == round(right, precision)
+      end
+
+      def almost_less_or_equal(left, right, precision: Float.precision)
+        round(left, precision) <= round(right, precision)
+      end
+
+      def almost_greater_or_equal(left, right, precision: Float.precision)
+        round(left, precision) >= round(right, precision)
+      end
+
+      def almost_less_than(left, right, precision: Float.precision)
+        round(left, precision) < round(right, precision)
+      end
+
+      def almost_greater_than(left, right, precision: Float.precision)
+        round(left, precision) > round(right, precision)
+      end
+    end
+
+    extend Float
+  end
+end