stationery 0.1.0 → 0.3.0

data/lib/stationery/railtie.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Loaded by stationery/rails inside a Rails app. Adds `render pdf:` and the
+  # app's font directories. Configure in config/application.rb:
+  #
+  #   config.stationery.renderer = false            # keep another gem's render pdf:
+  #   config.stationery.font_paths = ["app/fonts"]  # relative to Rails.root
+  #   config.stationery.preview_paths = ["spec/pdfs/previews"] # see Stationery::Preview
+  #   config.stationery.show_previews = true        # default: development only
+  class Railtie < ::Rails::Railtie
+    config.stationery = ActiveSupport::OrderedOptions.new
+    config.stationery.renderer = true
+    config.stationery.font_paths = ["vendor/fonts"]
+    config.stationery.preview_paths = ["spec/pdfs/previews", "test/pdfs/previews"]
+    config.stationery.show_previews = ::Rails.env.development?
+
+    initializer "stationery.font_paths" do |app|
+      Railtie.add_font_paths(app.root, app.config.stationery.font_paths)
+    end
+
+    initializer "stationery.renderer" do |app|
+      Railtie.add_renderer if app.config.stationery.renderer
+    end
+
+    initializer "stationery.previews" do |app|
+      Railtie.add_previews(app.routes) if app.config.stationery.show_previews
+    end
+
+    def self.add_font_paths(root, dirs)
+      dirs.each do |dir|
+        path = root.join(dir).to_s
+        Stationery.font_paths << path if File.directory?(path) && !Stationery.font_paths.include?(path)
+      end
+    end
+
+    def self.preview_paths(root, dirs) = dirs.map { root.join(it).to_s }.select { File.directory?(it) }
+
+    def self.add_previews(routes)
+      ActiveSupport.on_load(:action_controller_base) { require "stationery/rails/previews_controller" }
+      routes.prepend do
+        get "/rails/stationery/previews" => "stationery/previews#index", :as => :stationery_previews
+        get "/rails/stationery/previews/*path" => "stationery/previews#show"
+      end
+    end
+
+    def self.add_renderer
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Renderers.add(:pdf) do |document, options|
+          unless document.respond_to?(:to_pdf)
+            raise ArgumentError, "render pdf: expects a Stationery::Document (got #{document.class})"
+          end
+
+          send_pdf(document, **{ filename: options[:filename],
+                                 disposition: options.fetch(:disposition, "inline") }.compact)
+        end
+      end
+    end
+  end
+end

data/lib/stationery/regions.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Stationery
+  # A header or footer declaration: which slot, how much space it reserves
+  # (nil = measured), the gap to the body, the pages it applies to and the
+  # block that draws it.
+  Region = Data.define(:slot, :height, :gap, :on, :block)
+
+  # A document's header and footer declarations. Later declarations win for
+  # the pages they match; a region without a height is measured once, at the
+  # first page that asks for it.
+  class Regions
+    SELECTORS = %i[all first rest odd even last].freeze
+    SLOTS = %i[header footer].freeze
+
+    def self.validate!(on)
+      return on if SELECTORS.include?(on) || on.is_a?(Integer) || on.is_a?(Range) || on.respond_to?(:call)
+
+      raise ArgumentError, "on: takes #{SELECTORS.map(&:inspect).join(", ")}, a page number, a range or a proc, " \
+                           "got #{on.inspect}"
+    end
+
+    def self.matches?(on, number, last: false)
+      case on
+      when :all then true
+      when :first then number == 1
+      when :rest then number > 1
+      when :odd then number.odd?
+      when :even then number.even?
+      when :last then last
+      when Integer then number == on
+      when Range then on.cover?(number)
+      else on.call(number)
+      end
+    end
+
+    def initialize(entries, measure:)
+      @entries = entries
+      @measure = measure
+      @heights = {}.compare_by_identity
+      @last = entries.any? { |entry| entry.on == :last }
+    end
+
+    def entry_for(slot, number, last: false)
+      @entries.reverse_each.find { |entry| entry.slot == slot && self.class.matches?(entry.on, number, last:) }
+    end
+
+    # [top, bottom] points taken from the body on page `number`.
+    def reserve(number, last: false)
+      SLOTS.map do |slot|
+        entry = entry_for(slot, number, last:)
+        height = entry ? height_of(entry, number) : 0
+        height.positive? ? height + entry.gap : 0
+      end
+    end
+
+    # Whether page `number` would reserve different space as the last page.
+    def last_sensitive?(number) = @last && reserve(number, last: true) != reserve(number)
+
+    def height_of(entry, number)
+      return entry.height if entry.height
+      return 0 unless entry.block
+
+      @heights[entry] ||= @measure.call(entry, number)
+    end
+  end
+end

data/lib/stationery/resources.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 module Stationery
-  # Document-wide names for fonts, images and graphics states, so each is
+  # Document-wide names for fonts, images, graphics states and shadings, so each is
   # embedded once however many pages use it.
   class Resources
     def initialize
       @fonts = {}
       @images = {}
       @states = {}
+      @shadings = {}
     end
 
     def font(font)
@@ -22,12 +23,17 @@ module Stationery
       @states[value.to_f.round(3)] ||= :"GS#{@states.size + 1}"
     end
 
+    def shading(dictionary)
+      @shadings[dictionary] ||= :"Sh#{@shadings.size + 1}"
+    end
+
     # Writes every resource once; returns { category => { name => ref } }.
     def build(writer)
       {
         Font: @fonts.to_h { |font, name| [name, font.build(writer)] },
         XObject: @images.to_h { |image, name| [name, image.build(writer)] },
-        ExtGState: @states.to_h { |alpha, name| [name, writer.add({ Type: :ExtGState, ca: alpha, CA: alpha })] }
+        ExtGState: @states.to_h { |alpha, name| [name, writer.add({ Type: :ExtGState, ca: alpha, CA: alpha })] },
+        Shading: @shadings.to_h { |dictionary, name| [name, writer.add(dictionary)] }
       }
     end
   end

data/lib/stationery/rich/nodes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Stationery
+  # The block model rich-text parsers (HTML, Markdown) produce and elements render.
+  module Rich
+    # A run of text with its marks: any of bold:, italic:, underline:, strike:, code:, link: (href),
+    # script: (:sub/:sup) and break: true, a hard line break whose text is "".
+    Inline = Data.define(:text, :marks) do
+      def self.break = new(text: "", marks: { break: true })
+
+      def initialize(text:, marks: {}) = super(text: text.to_s, marks: marks.frozen? ? marks : marks.dup.freeze)
+      def break? = marks[:break] == true
+    end
+
+    Paragraph = Data.define(:inlines)
+    Heading = Data.define(:level, :inlines)
+    List = Data.define(:ordered, :start, :items)
+    Blockquote = Data.define(:blocks)
+    CodeBlock = Data.define(:text, :language)
+    Rule = Data.define
+    Table = Data.define(:rows)
+    Cell = Data.define(:header, :align, :blocks)
+    Image = Data.define(:src, :alt, :width, :height)
+
+    # Operations on inline sequences shared by the parsers.
+    module Inlines
+      module_function
+
+      # Joins adjacent inlines with equal marks and drops empty ones; breaks and images pass through.
+      def merge(items)
+        items.each_with_object([]) do |item, merged|
+          next merged << item unless item.is_a?(Inline) && !item.break?
+          next if item.text.empty?
+
+          last = merged.last
+          if last.is_a?(Inline) && !last.break? && last.marks == item.marks
+            merged[-1] = last.with(text: last.text + item.text)
+          else
+            merged << item
+          end
+        end
+      end
+
+      # Groups inlines into paragraphs, with each image standing as a block between them.
+      def paragraphs(items)
+        items.chunk_while { |a, b| !a.is_a?(Image) && !b.is_a?(Image) }.filter_map do |run|
+          next run.first if run.first.is_a?(Image)
+
+          inlines = merge(block_given? ? yield(run) : run)
+          Paragraph.new(inlines:) unless inlines.empty?
+        end
+      end
+    end
+  end
+end

data/lib/stationery/rich/renderer/inlines.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Rich
+    class Renderer
+      # Writes inlines into a Text::RunsBuilder, nesting one builder call per mark.
+      class Inlines
+        STYLE_STEPS = {
+          weight: ->(value) { [:b] if value == :bold },
+          style: ->(value) { [:i] if value == :italic },
+          underline: ->(value) { [:u] if value },
+          strikethrough: ->(value) { [:strikethrough] if value },
+          color: ->(value) { [:color, value] if value },
+          size: ->(value) { [:size, value] if value },
+          font: ->(value) { [:font, value] if value }
+        }.freeze
+
+        MARK_STEPS = {
+          bold: [[:b]], italic: [[:i]], underline: [[:u]], strike: [[:strikethrough]]
+        }.freeze
+
+        def initialize(runs, styles)
+          @runs = runs
+          @styles = styles
+        end
+
+        def write(inlines) = inlines.grep(Inline).each { |inline| inline.break? ? @runs.br : write_one(inline) }
+
+        private
+
+        def write_one(inline) = nest(inline.marks.flat_map { |mark, value| steps(mark, value) }, inline.text)
+
+        def nest(steps, text)
+          return @runs.plain(text) if steps.empty?
+
+          name, *args = steps.first
+          @runs.public_send(name, *args) { nest(steps.drop(1), text) }
+        end
+
+        def steps(mark, value)
+          case mark
+          when :link then [[:link, value], *style_steps(@styles[:a])]
+          when :code then style_steps(@styles[:code])
+          when :script then [[value]]
+          else MARK_STEPS.fetch(mark, [])
+          end
+        end
+
+        def style_steps(style) = style.filter_map { |key, value| STYLE_STEPS[key]&.call(value) }
+      end
+    end
+  end
+end

data/lib/stationery/rich/renderer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "nodes"
+require_relative "styles"
+require_relative "renderer/inlines"
+
+module Stationery
+  module Rich
+    # Draws rich-text blocks with a component's element DSL. Images come from
+    # `images:` (a callable given the src, returning a path, an IO or nil) or
+    # from files under `base_path:`; remote URLs are never fetched.
+    class Renderer
+      REMOTE = /\A[a-z][a-z0-9+.-]*:/i
+
+      def initialize(component, builder, gap:, styles:, images:, base_path:, bookmarks: false)
+        @component = component
+        @builder = builder
+        @gap = gap
+        @styles = Styles.resolve(styles)
+        @images = images
+        @base_path = base_path && File.expand_path(base_path.to_s)
+        @bookmarks = bookmarks
+      end
+
+      def render(blocks) = @component.group(gap: @gap) { blocks.each { |block| block(block) } }
+
+      private
+
+      def block(block)
+        case block
+        when Paragraph then paragraph(block.inlines, **@styles[:p])
+        when Heading then heading(block)
+        when List then list(block)
+        when Blockquote then @component.box(**@styles[:blockquote]) { render(block.blocks) }
+        when CodeBlock then code(block)
+        when Rule then @component.rule(**@styles[:hr])
+        when Table then table(block)
+        when Image then image(block)
+        end
+      end
+
+      def paragraph(inlines, **)
+        @component.text(**) { |runs| Inlines.new(runs, @styles).write(inlines) }
+      end
+
+      def heading(heading)
+        style = @styles[:"h#{heading.level}"]
+        size = style[:size] || (@builder.style.size * style.fetch(:scale, 1))
+        bookmark = heading_bookmark(heading)
+        paragraph(heading.inlines, **style.except(:scale), size:, **({ bookmark: } if bookmark))
+      end
+
+      def heading_bookmark(heading)
+        return unless @bookmarks && heading.level <= 3
+
+        { title: heading.inlines.grep(Inline).map(&:text).join, level: heading.level }
+      end
+
+      def list(list)
+        options = list.ordered ? { start: list.start || 1 } : {}
+        @component.public_send(list.ordered ? :ol : :ul, **options) do
+          list.items.each do |blocks|
+            @component.li { @component.text_style(**@styles[:li]) { render(blocks) } }
+          end
+        end
+      end
+
+      def code(block)
+        font = @styles[:code][:font]
+        @component.box(**@styles[:pre]) { @component.text(block.text, **({ font: } if font)) }
+      end
+
+      def table(table)
+        header = table.rows.first&.all?(&:header) ? 1 : 0
+        rows = table.rows.map { |row| row.map { |cell| cell_content(cell) } }
+        @component.table(rows, header:, cell: @styles[:table][:cell])
+      end
+
+      def cell_content(cell)
+        style = cell.header ? @styles[:table][:header] : {}
+        -> { @component.text_style(**style, align: cell.align) { render(cell.blocks) } }
+      end
+
+      def image(node)
+        source = resolve(node.src)
+        return unless source
+
+        loaded = Images.load(source)
+        @component.image(loaded, **dimensions(node, loaded))
+      rescue UnsupportedImage => e
+        skip(node.src, e.message)
+      end
+
+      def resolve(src)
+        return @images.call(src) || skip(src, "not found") if @images
+        return skip(src, "remote") if REMOTE.match?(src)
+        return skip(src, "not found") unless @base_path
+
+        path = File.expand_path(src, @base_path)
+        return skip(src, "outside base_path") unless path.start_with?(@base_path + File::SEPARATOR)
+
+        File.file?(path) ? path : skip(src, "not found")
+      end
+
+      def dimensions(node, loaded)
+        width = node.width
+        height = node.height
+        limit = @styles[:img][:max_width]
+        natural = width || (height ? loaded.width * height.fdiv(loaded.height) : loaded.width)
+        return { width:, height: } unless limit && natural > limit
+
+        { width: limit, height: height && (height * limit.fdiv(natural)) }
+      end
+
+      def skip(source, reason)
+        @builder.warnings << Warnings::SkippedImage.new(source:, reason:)
+        nil
+      end
+    end
+  end
+end

data/lib/stationery/rich/styles.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Rich
+    # How the html and markdown elements style each kind of block. Heading
+    # `scale:` multiplies the current text size; a `size:` in points wins.
+    module Styles
+      HEADING_SCALES = [2.0, 1.6, 1.3, 1.1, 1.0, 0.9].freeze
+
+      DEFAULTS = {
+        **HEADING_SCALES.each_with_index.to_h do |scale, index|
+          [:"h#{index + 1}", { scale:, weight: :bold, keep_with_next: true }]
+        end,
+        p: {},
+        a: { color: "#2563EB", underline: true },
+        code: { font: nil },
+        pre: { background: "#F3F4F6", padding: 8, radius: 4 },
+        blockquote: { border: { sides: [:left], width: 3, color: "#E5E7EB" }, padding: [0, 0, 0, 10] },
+        hr: { height: 1, color: "#E5E7EB" },
+        table: { cell: { padding: 4 }, header: { weight: :bold } },
+        li: {},
+        img: { max_width: nil }
+      }.freeze
+
+      module_function
+
+      def resolve(overrides) = merge(DEFAULTS, overrides)
+
+      def merge(base, overrides)
+        base.merge(overrides) { |_, old, new| old.is_a?(Hash) && new.is_a?(Hash) ? merge(old, new) : new }
+      end
+    end
+  end
+end

data/lib/stationery/rspec.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "stationery"
+require_relative "testing/matchers"
+
+RSpec.configure { |config| config.include Stationery::Testing::Matchers }

data/lib/stationery/structure.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Resolves internal links (`#name`) against the anchors painted on the
+  # finished pages and fills page-number slots with the pages their anchors
+  # landed on. Anchors drawn by page templates repeat on every page, so they
+  # resolve to their first page and never count as duplicates.
+  class Structure
+    # Where a named anchor sits: a zero-based page index and a PDF-space top.
+    Destination = Data.define(:page, :top)
+
+    # Returns the destinations by name; unresolved links are dropped.
+    # Runs before resources are written, so slot digits join the font subset.
+    def self.resolve(pages, warnings:, resources: nil, book: nil) = new(pages, warnings, resources, book).resolve
+
+    def initialize(pages, warnings, resources, book)
+      @pages = pages
+      @warnings = warnings
+      @resources = resources
+      @book = book
+      @destinations = {}
+    end
+
+    def resolve
+      collect
+      collect_templates
+      @pages.each_with_index do |page, index|
+        page.slots.each { |slot| fill(page, slot) }
+        page.annotations.replace(page.annotations.filter_map { |link| link_to(link, index) })
+      end
+      @destinations
+    end
+
+    private
+
+    def collect
+      @pages.each_with_index do |page, index|
+        page.anchors.each do |name, top|
+          if @destinations.key?(name)
+            @warnings << Warnings::DuplicateAnchor.new(name:, page: index + 1)
+          else
+            @destinations[name] = Destination.new(index, top)
+          end
+        end
+      end
+    end
+
+    def collect_templates
+      @pages.each_with_index do |page, index|
+        page.template_anchors.each { |name, top| @destinations[name] ||= Destination.new(index, top) }
+      end
+    end
+
+    def fill(page, slot)
+      destination = @destinations[slot.anchor] or return
+      label = (destination.page + 1).to_s
+      font, face = @book.resolve(slot.style)
+      style = slot.style
+      width = font.width_of(label, style.render_size, letter_spacing: style.letter_spacing)
+      canvas = Canvas.new(page, @resources)
+      canvas.link(*slot.link, "##{slot.anchor}") if slot.link
+      canvas.text(label, x: slot.x + slot.width - width, y: slot.baseline, font:,
+                         size: style.render_size, color: style.color,
+                         letter_spacing: style.letter_spacing, opacity: style.opacity,
+                         synthetic_bold: face.synthetic_bold, synthetic_oblique: face.synthetic_oblique)
+    end
+
+    def link_to(link, index)
+      return link unless link.key?(:dest)
+
+      destination = @destinations[link[:dest]]
+      return { rect: link[:rect], dest: destination } if destination
+
+      @warnings << Warnings::UnresolvedLink.new(name: link[:dest], page: index + 1)
+      nil
+    end
+  end
+end

data/lib/stationery/svg/arc.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # An SVG elliptical arc as cubic Bezier segments (SVG 1.1 appendix F.6.5:
+    # endpoint to centre parameterisation, then at most 90 degrees a segment).
+    class Arc
+      def initialize(x1, y1, rx, ry, rotation, large, sweep, x2, y2)
+        @x1 = x1.to_f
+        @y1 = y1.to_f
+        @x2 = x2
+        @y2 = y2
+        @rx = rx.to_f
+        @ry = ry.to_f
+        @phi = rotation * Math::PI / 180
+        @large = large == 1
+        @sweep = sweep == 1
+      end
+
+      def curves
+        centre
+        count = [(@delta.abs / (Math::PI / 2)).ceil, 1].max
+        step = @delta / count
+        curves = Array.new(count) { |i| segment(@theta + (i * step), step) }
+        curves.last[4] = @x2
+        curves.last[5] = @y2
+        curves
+      end
+
+      private
+
+      def centre
+        cos = Math.cos(@phi)
+        sin = Math.sin(@phi)
+        dx = (@x1 - @x2) / 2.0
+        dy = (@y1 - @y2) / 2.0
+        x1p = (cos * dx) + (sin * dy)
+        y1p = (-sin * dx) + (cos * dy)
+        scale_radii(x1p, y1p)
+        cxp, cyp = centre_prime(x1p, y1p)
+        @cx = (cos * cxp) - (sin * cyp) + ((@x1 + @x2) / 2.0)
+        @cy = (sin * cxp) + (cos * cyp) + ((@y1 + @y2) / 2.0)
+        angles(x1p, y1p, cxp, cyp)
+      end
+
+      def scale_radii(x1p, y1p)
+        lambda = ((x1p**2) / (@rx**2)) + ((y1p**2) / (@ry**2))
+        return unless lambda > 1
+
+        @rx *= Math.sqrt(lambda)
+        @ry *= Math.sqrt(lambda)
+      end
+
+      def centre_prime(x1p, y1p)
+        rx2 = @rx**2
+        ry2 = @ry**2
+        numerator = (rx2 * ry2) - (rx2 * (y1p**2)) - (ry2 * (x1p**2))
+        denominator = (rx2 * (y1p**2)) + (ry2 * (x1p**2))
+        coefficient = Math.sqrt([numerator, 0].max / denominator) * (@large == @sweep ? -1 : 1)
+        [coefficient * @rx * y1p / @ry, -coefficient * @ry * x1p / @rx]
+      end
+
+      def angles(x1p, y1p, cxp, cyp)
+        ux = (x1p - cxp) / @rx
+        uy = (y1p - cyp) / @ry
+        vx = (-x1p - cxp) / @rx
+        vy = (-y1p - cyp) / @ry
+        @theta = Math.atan2(uy, ux)
+        @delta = Math.atan2((ux * vy) - (uy * vx), (ux * vx) + (uy * vy))
+        @delta -= 2 * Math::PI if !@sweep && @delta.positive?
+        @delta += 2 * Math::PI if @sweep && @delta.negative?
+      end
+
+      def segment(start, step)
+        t = 4.0 / 3 * Math.tan(step / 4)
+        a1 = start
+        a2 = start + step
+        p1 = point(Math.cos(a1) - (t * Math.sin(a1)), Math.sin(a1) + (t * Math.cos(a1)))
+        p2 = point(Math.cos(a2) + (t * Math.sin(a2)), Math.sin(a2) - (t * Math.cos(a2)))
+        p3 = point(Math.cos(a2), Math.sin(a2))
+        [*p1, *p2, *p3]
+      end
+
+      def point(ux, uy)
+        x = @rx * ux
+        y = @ry * uy
+        [(Math.cos(@phi) * x) - (Math.sin(@phi) * y) + @cx, (Math.sin(@phi) * x) + (Math.cos(@phi) * y) + @cy]
+      end
+    end
+  end
+end

data/lib/stationery/svg/bounds.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Stationery
+  module SVG
+    # A path sink that measures a shape's bounding box in its own user space,
+    # curves by their extrema. Takes the calls Shapes.trace makes on a path.
+    class Bounds
+      def initialize
+        @xs = []
+        @ys = []
+      end
+
+      def move_to(x, y) = add(x, y)
+      def line_to(x, y) = add(x, y)
+      def close = self
+
+      def curve_to(x1, y1, x2, y2, x, y)
+        x0 = @xs.last || 0
+        y0 = @ys.last || 0
+        (extrema(x0, x1, x2, x) + extrema(y0, y1, y2, y)).each do |at|
+          add(cubic(at, x0, x1, x2, x), cubic(at, y0, y1, y2, y))
+        end
+        add(x, y)
+      end
+
+      def rounded_rect(x, y, w, h, _radius)
+        add(x, y)
+        add(x + w, y + h)
+      end
+
+      def ellipse(cx, cy, rx, ry)
+        add(cx - rx, cy - ry)
+        add(cx + rx, cy + ry)
+      end
+
+      # [x, y, width, height], or nil when the shape has no area.
+      def box
+        return nil if @xs.empty?
+
+        width = @xs.max - @xs.min
+        height = @ys.max - @ys.min
+        [@xs.min, @ys.min, width, height] if width.positive? && height.positive?
+      end
+
+      private
+
+      def add(x, y)
+        @xs << x
+        @ys << y
+        self
+      end
+
+      # Parameters in (0, 1) where the cubic's derivative is zero.
+      def extrema(from, first, second, to)
+        a = -from + (3 * first) - (3 * second) + to
+        b = 2 * (from - (2 * first) + second)
+        c = first - from
+        roots(a, b, c).select { |t| t.positive? && t < 1 }
+      end
+
+      def roots(a, b, c)
+        return b.zero? ? [] : [-c.fdiv(b)] if a.zero?
+
+        discriminant = (b**2) - (4 * a * c)
+        return [] if discriminant.negative?
+
+        [1, -1].map { |sign| (-b + (sign * Math.sqrt(discriminant))) / (2.0 * a) }
+      end
+
+      def cubic(at, from, first, second, to)
+        rest = 1 - at
+        ((rest**3) * from) + (3 * (rest**2) * at * first) + (3 * rest * (at**2) * second) + ((at**3) * to)
+      end
+    end
+  end
+end