poetry-charts 0.0.2

data/lib/poetry/charts/geometry/scale/band.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Charts
+    module Geometry
+      # The scale namespace: Linear, Band, and Point.
+      module Scale
+        # A band scale: categorical domain -> evenly stepped positions
+        # with inner/outer padding and alignment. Point is band with
+        # padding_inner = 1 (bandwidth 0), where padding: drives the
+        # outer padding - the axis shape line/area charts position
+        # categories with.
+        #
+        # @example
+        #   Poetry::Charts::Geometry::Scale::Band
+        #     .new(domain: %w[a b c], range: [0, 300]).positions
+        class Band
+          attr_reader :domain, :range, :padding_inner, :padding_outer, :align, :step, :bandwidth, :positions
+
+          def initialize(domain:, range:, padding_inner: 0.0, padding_outer: 0.0, align: 0.5, round: false)
+            @domain = domain.to_a
+            @range = range.map(&:to_f)
+            @padding_inner = [1.0, padding_inner.to_f].min
+            @padding_outer = padding_outer.to_f
+            @align = align.to_f.clamp(0.0, 1.0)
+            @round = round
+            rescale
+          end
+
+          # Convenience for the common single padding: knob - one value
+          # sets inner AND outer padding.
+          def self.padded(domain:, range:, padding: 0.0, align: 0.5, round: false)
+            new(domain:, range:, padding_inner: padding, padding_outer: padding, align:, round:)
+          end
+
+          # The band's leading-edge position for a category (nil when the
+          # category is unknown).
+          def call(value)
+            index = domain.index(value)
+            index && @positions[index]
+          end
+          alias [] call
+
+          private
+
+          def rescale
+            n = domain.length
+            reverse = range[1] < range[0]
+            start = reverse ? range[1] : range[0]
+            stop = reverse ? range[0] : range[1]
+
+            @step = (stop - start) / [1.0, n - padding_inner + (padding_outer * 2)].max
+            @step = @step.floor.to_f if @round
+            start += (stop - start - (@step * (n - padding_inner))) * align
+            @bandwidth = @step * (1 - padding_inner)
+            if @round
+              start = Geometry.js_round(start).to_f
+              @bandwidth = Geometry.js_round(@bandwidth).to_f
+            end
+
+            values = Array.new(n) { |i| start + (@step * i) }
+            @positions = reverse ? values.reverse : values
+          end
+        end
+
+        # A point scale: a band with padding_inner pinned to 1 - every
+        # category is a zero-width position, padding: is the outer
+        # padding.
+        #
+        # @example
+        #   Poetry::Charts::Geometry::Scale::Point
+        #     .new(domain: %w[a b c], range: [0, 300]).positions
+        class Point < Band
+          def initialize(domain:, range:, padding: 0.0, align: 0.5, round: false)
+            super(domain:, range:, padding_inner: 1.0, padding_outer: padding.to_f, align:, round:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/poetry/charts/geometry/scale/linear.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Charts
+    module Geometry
+      module Scale
+        # A linear scale reduced to the closed poetry surface: a
+        # two-point numeric domain/range with bimap normalization
+        # (descending domains supported), ticks via Geometry::Ticks, and
+        # the nice() domain extension. Degenerate domains map every
+        # input to the range midpoint.
+        #
+        # @example Map a value into an inverted pixel range
+        #   Poetry::Charts::Geometry::Scale::Linear
+        #     .new(domain: [0, 100], range: [300, 5]).call(50)
+        class Linear
+          attr_reader :domain, :range
+
+          # @param domain [Array<Numeric>] the two-point input interval
+          # @param range [Array<Numeric>] the two-point output interval
+          def initialize(domain: [0.0, 1.0], range: [0.0, 1.0])
+            @domain = domain.map(&:to_f)
+            @range = range.map(&:to_f)
+          end
+
+          # The range value for a domain value.
+          #
+          # @param value [Numeric]
+          # @return [Float]
+          def call(value)
+            value = value.to_f
+            d0, d1 = domain
+            r0, r1 = range
+
+            # bimap: descending domains swap both sides.
+            if d1 < d0
+              d0, d1 = d1, d0
+              r0, r1 = r1, r0
+            end
+
+            t = normalize(value, d0, d1)
+            r0 + ((r1 - r0) * t)
+          end
+          alias [] call
+
+          # The domain value for a range value - the inverse map.
+          #
+          # @param value [Numeric]
+          # @return [Float]
+          def invert(value)
+            value = value.to_f
+            d0, d1 = domain
+            r0, r1 = range
+
+            if d1 < d0
+              d0, d1 = d1, d0
+              r0, r1 = r1, r0
+            end
+
+            t = normalize(value, r0, r1)
+            d0 + ((d1 - d0) * t)
+          end
+
+          # Float-exact ticks across the domain.
+          #
+          # @return [Array<Numeric>]
+          def ticks(count = 10)
+            Ticks.ticks(domain.first, domain.last, count)
+          end
+
+          # Extends the domain to tick-increment boundaries, iterating
+          # until the increment is stable. Returns a NEW scale (poetry
+          # immutability).
+          #
+          # @return [Linear]
+          def nice(count = 10)
+            d = domain.dup
+            i0 = 0
+            i1 = d.length - 1
+            start = d[i0]
+            stop = d[i1]
+            prestep = nil
+            max_iter = 10
+
+            if stop < start
+              start, stop = stop, start
+              i0, i1 = i1, i0
+            end
+
+            while max_iter.positive?
+              max_iter -= 1
+              step = Ticks.tick_increment(start, stop, count)
+              if step == prestep
+                d[i0] = start
+                d[i1] = stop
+                break
+              elsif step.positive?
+                start = (start / step).floor * step
+                stop = (stop / step).ceil * step
+              elsif step.negative? && step.finite?
+                start = (start * step).ceil / step
+                stop = (stop * step).floor / step
+              else
+                # Degenerate domain (zero span): JS churns NaN until maxIter
+                # and leaves the domain unchanged; bail with the same result.
+                break
+              end
+              prestep = step
+            end
+
+            self.class.new(domain: d, range: range)
+          end
+
+          private
+
+          # A degenerate (zero-span) interval maps everything to t = 0.5.
+          def normalize(value, from, to)
+            span = to - from
+            return span.nan? ? Float::NAN : 0.5 if span.zero?
+
+            (value - from) / span
+          end
+        end
+      end
+    end
+  end
+end

data/lib/poetry/charts/geometry/stack.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Charts
+    module Geometry
+      # The stack layout (declaration order): rows x series keys ->
+      # per-series [base, top] pairs. Missing values behave as
+      # JS +undefined = NaN (the offsets carry the exact NaN fallbacks).
+      # :expand normalizes each row to sum 1; :diverging routes negatives
+      # below the axis.
+      #
+      # @example Stack two series over shared rows
+      #   Poetry::Charts::Geometry::Stack.new(keys: %w[a b]).series(rows)
+      class Stack
+        # The stack baseline modes.
+        OFFSETS = %i[none expand diverging].freeze
+
+        # One stacked series: its key, order index, and [base, top]
+        # points.
+        Series = ::Struct.new(:key, :index, :points) do
+          # The [base, top] pair at one row index.
+          def [](index)
+            points[index]
+          end
+
+          # The number of rows stacked.
+          def length
+            points.length
+          end
+        end
+
+        def initialize(keys:, value: nil, offset: :none)
+          @keys = keys.to_a
+          @value = value || ->(d, key) { d[key] }
+          raise ArgumentError, "unknown stack offset #{offset.inspect}" unless OFFSETS.include?(offset.to_sym)
+
+          @offset = offset.to_sym
+        end
+
+        # The stacked series for the rows, offsets applied.
+        #
+        # @param data [Enumerable] the rows
+        # @return [Array<Series>]
+        def series(data)
+          data = data.to_a
+          sz = @keys.map { |key| Series.new(key, nil, []) }
+
+          data.each do |d|
+            sz.each do |s|
+              value = @value.call(d, s.key)
+              s.points << [0.0, value.nil? ? Float::NAN : value.to_f]
+            end
+          end
+
+          order = (0...sz.length).to_a
+          order.each_with_index { |series_index, i| sz[series_index].index = i }
+
+          apply_offset(sz, order)
+          sz
+        end
+
+        private
+
+        def apply_offset(series, order)
+          case @offset
+          when :none then offset_none(series, order)
+          when :expand then offset_expand(series, order)
+          when :diverging then offset_diverging(series, order)
+          end
+        end
+
+        # Each series bases on the previous series' top (NaN tops fall back
+        # to the previous base - the JS isNaN branch).
+        def offset_none(series, order)
+          return unless series.length > 1
+
+          s1 = series[order[0]]
+          m = s1.length
+          (1...series.length).each do |i|
+            s0 = s1
+            s1 = series[order[i]]
+            (0...m).each do |j|
+              base = s0.points[j][1].nan? ? s0.points[j][0] : s0.points[j][1]
+              s1.points[j][0] = base
+              s1.points[j][1] += base
+            end
+          end
+        end
+
+        # Normalize each row to [0, 1] (percent stacking), then stack.
+        def offset_expand(series, order)
+          return if series.empty?
+
+          m = series[0].length
+          (0...m).each do |j|
+            sum = series.sum { |s| s.points[j][1].nan? ? 0.0 : s.points[j][1] }
+            series.each { |s| s.points[j][1] /= sum } unless sum.zero?
+          end
+          offset_none(series, order)
+        end
+
+        # Positives stack up from zero, negatives stack down.
+        def offset_diverging(series, order)
+          return if series.empty?
+
+          m = series[order[0]].length
+          (0...m).each do |j|
+            yp = 0.0
+            yn = 0.0
+            order.each do |series_index|
+              point = series[series_index].points[j]
+              dy = point[1] - point[0]
+              if dy.positive?
+                point[0] = yp
+                point[1] = (yp += dy)
+              elsif dy.negative?
+                point[1] = yn
+                point[0] = (yn += dy)
+              else
+                point[0] = 0.0
+                point[1] = dy
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/poetry/charts/geometry/ticks.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Charts
+    module Geometry
+      # Float-exact tick generation: ticks / tick_increment / tick_step.
+      # The 1-2-5-10 step selection runs against square-root thresholds,
+      # and the inverted-increment encoding (negative inc = divisor)
+      # keeps tick values float-exact - a sub-1 step divides by an
+      # integer instead of multiplying by a fraction.
+      #
+      # @example
+      #   Poetry::Charts::Geometry::Ticks.ticks(0, 10, 5) # => [0, 2, 4, 6, 8, 10]
+      module Ticks
+        # The step-10 selection threshold: sqrt(50).
+        E10 = Math.sqrt(50)
+        # The step-5 selection threshold: sqrt(10).
+        E5 = Math.sqrt(10)
+        # The step-2 selection threshold: sqrt(2).
+        E2 = Math.sqrt(2)
+
+        module_function
+
+        # The [first index, last index, increment] spec for a tick run.
+        # @api private
+        def tick_spec(start, stop, count)
+          step = (stop - start) / [0, count].max.to_f
+          # JS runs degenerate inputs (zero span) through its float arithmetic
+          # and lands on inc = -Infinity; Ruby's floor would raise on the way.
+          # Return the same OBSERVABLE outputs analytically: tickIncrement
+          # gives -Infinity, tickStep gives 1/Infinity = 0, and the linearish
+          # nice() loop bails via its non-finite guard.
+          return [Float::NAN, Float::NAN, -Float::INFINITY] unless step.finite? && step.positive?
+
+          power = Math.log10(step).floor
+          error = step / (10.0**power)
+          factor = if error >= E10 then 10
+                   elsif error >= E5 then 5
+                   elsif error >= E2 then 2
+                   else 1
+                   end
+
+          if power.negative?
+            inc = (10.0**-power) / factor
+            i1 = Geometry.js_round(start * inc)
+            i2 = Geometry.js_round(stop * inc)
+            i1 += 1 if i1 / inc < start
+            i2 -= 1 if i2 / inc > stop
+            inc = -inc
+          else
+            inc = (10.0**power) * factor
+            i1 = Geometry.js_round(start / inc)
+            i2 = Geometry.js_round(stop / inc)
+            i1 += 1 if i1 * inc < start
+            i2 -= 1 if i2 * inc > stop
+          end
+
+          return tick_spec(start, stop, count * 2) if i2 < i1 && count >= 0.5 && count < 2
+
+          [i1, i2, inc]
+        end
+
+        # About `count` evenly stepped, float-exact values covering
+        # [start, stop].
+        #
+        # @return [Array<Numeric>]
+        def ticks(start, stop, count)
+          start = start.to_f
+          stop = stop.to_f
+          count = count.to_f
+          return [] unless count.positive?
+          return [start] if start == stop
+
+          reverse = stop < start
+          i1, i2, inc = reverse ? tick_spec(stop, start, count) : tick_spec(start, stop, count)
+          return [] if i2 < i1
+
+          n = i2 - i1 + 1
+          Array.new(n) do |i|
+            index = reverse ? i2 - i : i1 + i
+            inc.negative? ? index / -inc : index * inc
+          end
+        end
+
+        # The raw increment for the run - negative encodes a divisor.
+        def tick_increment(start, stop, count)
+          tick_spec(start.to_f, stop.to_f, count.to_f)[2]
+        end
+
+        # The absolute step size for the run (the increment decoded,
+        # signed by direction).
+        def tick_step(start, stop, count)
+          start = start.to_f
+          stop = stop.to_f
+          count = count.to_f
+          reverse = stop < start
+          inc = reverse ? tick_increment(stop, start, count) : tick_increment(start, stop, count)
+          (reverse ? -1 : 1) * (inc.negative? ? 1.0 / -inc : inc)
+        end
+      end
+    end
+  end
+end

data/lib/poetry/charts/geometry.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Charts
+    # The geometry core: the tick, scale, and shape math the charts stand
+    # on - array ticks, linear/band/point scales, line/area/curve
+    # generators, stack layout, and decimal-exact nice-ticks. Every piece
+    # is oracle-tested: committed fixtures
+    # (test/support/generate_geometry_fixtures.mjs) pin the expected
+    # outputs byte-for-byte, alongside translated spec cases.
+    #
+    # JS number semantics are part of the contract - path strings must
+    # match the fixture output byte-for-byte - so rounding and
+    # stringification go through js_round / js_number below, never
+    # through Ruby defaults (Ruby rounds half away from zero and prints
+    # "80.0"; JS floors x+0.5 and prints "80").
+    #
+    # @example
+    #   Poetry::Charts::Geometry.js_number(80.0) # => "80"
+    module Geometry
+      module_function
+
+      # JS Math.round: floor(x + 0.5) - differs from Float#round at negative
+      # halves (JS rounds -2.5 to -2; Ruby to -3).
+      def js_round(value)
+        (value + 0.5).floor
+      end
+
+      # JS Number#toString for the values that appear in SVG path data:
+      # integral doubles print bare ("80", not "80.0"), -0 prints "0", and
+      # everything else uses shortest round-trip decimal (Ruby and V8 agree
+      # on shortest-repr in the post-rounding magnitude range; the exponent
+      # guard covers the sub-1e-4 corner where Ruby switches early).
+      def js_number(value)
+        return "0" if value.zero?
+
+        integral = value.to_i
+        return integral.to_s if value == integral
+
+        text = value.to_s
+        return text unless text.include?("e")
+
+        format("%.12f", value).sub(/0+\z/, "").delete_suffix(".")
+      end
+
+      # JS truthiness for the curve state machines (the line state flag
+      # runs nil | 0 | 1 | NaN): nil, 0, and NaN are falsy.
+      def js_truthy?(value)
+        return false if value.nil?
+        return false if value.is_a?(Float) && value.nan?
+
+        value != 0
+      end
+    end
+  end
+end
+
+require_relative "geometry/ticks"
+require_relative "geometry/nice_ticks"
+require_relative "geometry/scale/linear"
+require_relative "geometry/scale/band"
+require_relative "geometry/path"
+require_relative "geometry/curve"
+require_relative "geometry/line"
+require_relative "geometry/area"
+require_relative "geometry/stack"

data/lib/poetry/charts/polar.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Charts
+    # The polar geometry: pie-sector accumulation, tangent-circle corner
+    # rounding, and wedge/ring paths. Angles are degrees COUNTERCLOCKWISE
+    # from 3 o'clock, negated into SVG's y-down plane by
+    # polar_to_cartesian; pies start at angle 0 and sweep to 360.
+    #
+    # @example Slice values into pie sector angles
+    #   Poetry::Charts::Polar.pie_sectors([3, 1], padding_angle: 2)
+    module Polar
+      # Degrees-to-radians factor.
+      RADIAN = Math::PI / 180
+
+      module_function
+
+      # -1, 0, or 1 by the value's sign.
+      def sign(value)
+        return 0 if value.zero?
+
+        value.negative? ? -1 : 1
+      end
+
+      # The [x, y] point at (radius, angle) from the center, in SVG's
+      # y-down plane.
+      def polar_to_cartesian(cx, cy, radius, angle)
+        [cx + (Math.cos(-RADIAN * angle) * radius), cy + (Math.sin(-RADIAN * angle) * radius)]
+      end
+
+      # The largest radius fitting the plot: half the shorter side.
+      def max_radius(width, height)
+        [width, height].min / 2.0
+      end
+
+      # "80%" of the max radius, or a plain number.
+      def percent_value(value, total, default = 0)
+        return default if value.nil?
+
+        text = value.to_s
+        text.end_with?("%") ? total * (text.to_f / 100.0) : text.to_f
+      end
+
+      # The pie accumulation: values -> per-slice angles. Zero values
+      # collapse (and skip padding); paddings live BETWEEN non-zero
+      # slices (full circles pad after the last slice too, closing the
+      # ring).
+      def pie_sectors(values, start_angle: 0, end_angle: 360, padding_angle: 0, min_angle: 0)
+        numeric = values.map { |value| value.is_a?(Numeric) ? value.to_f : 0.0 }
+        sum = numeric.sum
+        return [] if sum <= 0
+
+        delta = sign(end_angle - start_angle) * [(end_angle - start_angle).abs, 360].min
+        abs_delta = delta.abs
+        direction = sign(delta)
+        not_zero = numeric.count { |value| !value.zero? }
+        total_padding = (abs_delta >= 360 ? not_zero : [not_zero - 1, 0].max) * padding_angle
+
+        needs_min = min_angle.positive? &&
+                    numeric.any? { |value| !value.zero? && (value / sum) * abs_delta < min_angle }
+        effective_min = needs_min ? min_angle : 0
+
+        real_total = abs_delta - (not_zero * effective_min) - total_padding
+
+        cursor = start_angle.to_f
+        numeric.each_with_index.map do |value, i|
+          percent = value / sum
+          slice_start = if i.zero?
+                          start_angle.to_f
+                        else
+                          cursor + (direction * padding_angle * (value.zero? ? 0 : 1))
+                        end
+          slice_end = slice_start + (direction * ((value.zero? ? 0 : effective_min) + (percent * real_total)))
+          cursor = slice_end
+
+          {
+            value: value,
+            percent: percent,
+            start_angle: slice_start,
+            end_angle: slice_end,
+            mid_angle: (slice_start + slice_end) / 2.0
+          }
+        end
+      end
+
+      # The corner circle tangent to an arc (at `radius`) and a radial
+      # edge (at `angle`) - the rounded-corner primitive for the radial
+      # bar's corner_radius.
+      def tangent_circle(cx:, cy:, radius:, angle:, sign:, corner_radius:, external: false)
+        center_radius = (corner_radius * (external ? 1 : -1)) + radius
+        theta = Math.asin(corner_radius / center_radius) / RADIAN
+        center_angle = angle + (sign * theta)
+        {
+          circle_tangency: polar_to_cartesian(cx, cy, radius, center_angle),
+          line_tangency: polar_to_cartesian(cx, cy, center_radius * Math.cos(theta * RADIAN), angle),
+          theta: theta
+        }
+      end
+
+      # The ring segment with all four corners rounded by tangent
+      # circles. Falls back to the plain path when the sweep is too small
+      # to fit the corners.
+      def sector_path_with_corners(cx:, cy:, inner_radius:, outer_radius:, start_angle:, end_angle:,
+                                   corner_radius:, fmt: nil)
+        fmt ||= ->(v) { Geometry.js_number((v * 10_000).round / 10_000.0) }
+        corner = [corner_radius.to_f, (outer_radius - inner_radius).abs / 2.0].min
+        if corner <= 0 || (end_angle - start_angle).abs >= 360
+          return sector_path(cx:, cy:, inner_radius:, outer_radius:, start_angle:, end_angle:, fmt:)
+        end
+
+        s = sign(end_angle - start_angle)
+        so = tangent_circle(cx:, cy:, radius: outer_radius, angle: start_angle, sign: s, corner_radius: corner)
+        eo = tangent_circle(cx:, cy:, radius: outer_radius, angle: end_angle, sign: -s, corner_radius: corner)
+        outer_arc = (start_angle - end_angle).abs - so[:theta] - eo[:theta]
+        if outer_arc.negative?
+          return sector_path(cx:, cy:, inner_radius:, outer_radius:, start_angle:, end_angle:, fmt:)
+        end
+
+        ccw = s.negative? ? 1 : 0
+        p = ->(point) { "#{fmt.call(point[0])},#{fmt.call(point[1])}" }
+        path = "M#{p.call(so[:line_tangency])}" \
+               "A#{fmt.call(corner)},#{fmt.call(corner)},0,0,#{ccw},#{p.call(so[:circle_tangency])}" \
+               "A#{fmt.call(outer_radius)},#{fmt.call(outer_radius)},0,#{outer_arc > 180 ? 1 : 0},#{ccw}," \
+               "#{p.call(eo[:circle_tangency])}" \
+               "A#{fmt.call(corner)},#{fmt.call(corner)},0,0,#{ccw},#{p.call(eo[:line_tangency])}"
+
+        if inner_radius.positive?
+          si = tangent_circle(cx:, cy:, radius: inner_radius, angle: start_angle, sign: s,
+                              corner_radius: corner, external: true)
+          ei = tangent_circle(cx:, cy:, radius: inner_radius, angle: end_angle, sign: -s,
+                              corner_radius: corner, external: true)
+          inner_arc = (start_angle - end_angle).abs - si[:theta] - ei[:theta]
+          return "#{path}L#{fmt.call(cx)},#{fmt.call(cy)}Z" if inner_arc.negative? && corner.zero?
+
+          path << "L#{p.call(ei[:line_tangency])}" \
+                  "A#{fmt.call(corner)},#{fmt.call(corner)},0,0,#{ccw},#{p.call(ei[:circle_tangency])}" \
+                  "A#{fmt.call(inner_radius)},#{fmt.call(inner_radius)},0,#{inner_arc > 180 ? 1 : 0}," \
+                  "#{s.positive? ? 1 : 0},#{p.call(si[:circle_tangency])}" \
+                  "A#{fmt.call(corner)},#{fmt.call(corner)},0,0,#{ccw},#{p.call(si[:line_tangency])}Z"
+        else
+          path << "L#{fmt.call(cx)},#{fmt.call(cy)}Z"
+        end
+
+        path
+      end
+
+      # The wedge/ring path. The delta clamps at 359.999 so a full
+      # circle's endpoints never coincide.
+      def sector_path(cx:, cy:, inner_radius:, outer_radius:, start_angle:, end_angle:, fmt: nil)
+        # 4-decimal precision: a full circle's 359.999-degree endpoints
+        # differ only past the 2nd decimal - rounding coarser would collapse
+        # them and erase the arc.
+        fmt ||= ->(v) { Geometry.js_number((v * 10_000).round / 10_000.0) }
+        delta = sign(end_angle - start_angle) * [(end_angle - start_angle).abs, 359.999].min
+        temp_end = start_angle + delta
+        large = (delta.abs > 180 ? 1 : 0)
+
+        ox0, oy0 = polar_to_cartesian(cx, cy, outer_radius, start_angle)
+        ox1, oy1 = polar_to_cartesian(cx, cy, outer_radius, temp_end)
+
+        path = "M#{fmt.call(ox0)},#{fmt.call(oy0)}" \
+               "A#{fmt.call(outer_radius)},#{fmt.call(outer_radius)},0," \
+               "#{large},#{start_angle > temp_end ? 1 : 0},#{fmt.call(ox1)},#{fmt.call(oy1)}"
+
+        if inner_radius.positive?
+          ix0, iy0 = polar_to_cartesian(cx, cy, inner_radius, start_angle)
+          ix1, iy1 = polar_to_cartesian(cx, cy, inner_radius, temp_end)
+          path << "L#{fmt.call(ix1)},#{fmt.call(iy1)}" \
+                  "A#{fmt.call(inner_radius)},#{fmt.call(inner_radius)},0," \
+                  "#{large},#{start_angle <= temp_end ? 1 : 0},#{fmt.call(ix0)},#{fmt.call(iy0)}Z"
+        else
+          path << "L#{fmt.call(cx)},#{fmt.call(cy)}Z"
+        end
+
+        path
+      end
+    end
+  end
+end