laser-cutter 2.0.0 → 2.0.1

data/lib/laser/cutter/notching/path_generator.rb

@@ -26,105 +26,63 @@ module Laser
         # We always want to create a symmetric path that has a notch in the middle
         # (for center_out = true) or dip in the middle (center_out = false)
         def generate
-          shifts = define_shifts
-          vertices = []
           lines = []
+          lines << corner_box_sides if corners
+          lines << notch_lines
+          lines.flatten
+        end
 
-          if corners
-            lines << corner_box_sides
-          end
-
+        # The zigzag alone, without the corner boxes.
+        #
+        # @return [Array<Geometry::Line>]
+        def notch_lines
           point = starting_point
-
-          vertices << point
-          adjust_for_kerf(vertices, -1) if adjust_corners && !first_notch_out?
-          shifts.each do |shift|
+          vertices = [point]
+          adjust_for_kerf(vertices, -1) if adjust_end?(1)
+          define_shifts.each do |shift|
             point = shift.next_point_after point
             vertices << point
           end
-          adjust_for_kerf(vertices, 1) if adjust_corners && !first_notch_out?
-          lines << create_lines(vertices)
-          lines.flatten
+          adjust_for_kerf(vertices, 1) if adjust_end?(2)
+          create_lines(vertices)
         end
 
         def adjust_for_kerf(vertices, direction)
           return unless kerf?
 
           point = vertices.pop
-          point = point.plus(2 * direction * shift_vector(1)) if corners
+          point = point.plus(2 * direction * shift_vector(1))
           vertices << point
         end
 
         def corner_box_sides
-          boxes = []
-          extra_lines = []
+          ends = Edge::ENDS.select { |end_index| edge.corner_at?(end_index) }
 
-          # These two boxes occupy the corners of the 3D box. They do not match
+          # These boxes occupy the corners of the 3D box. They do not match
           # in width to our notches because they are usually merged with them.
           # It's just an aesthetic choice I guess.
-          boxes << Geometry::Rect[edge.inside.p1.clone, edge.outside.p1.clone]
-          boxes << Geometry::Rect[edge.inside.p2.clone, edge.outside.p2.clone]
-
-          if kerf? && adjust_corners
-            if first_notch_out?
-              k = 2
-              direction = -1
-              dim_index = 1
-              extra_lines << add_corners_when_out(dim_index, direction, k)
-            else
-              k = -2
-              direction = 1
-              dim_index = 0
-              extra_lines << add_boxes_when_in(dim_index, direction, k)
-            end
-          end
-          sides = boxes.flatten.map(&:relocate!).map(&:sides)
-          sides << extra_lines if !extra_lines.empty?
+          boxes = ends.map { |end_index| Geometry::Rect[inside_point(end_index).clone, outside_point(end_index).clone] }
+          sides = boxes.map(&:relocate!).map(&:sides)
+          sides << ends.map { |end_index| kerf_strip(end_index) } if kerf? && adjust_corners
           sides.flatten
         end
 
-        def add_boxes_when_in(dim_index, direction, k)
-          v1 = k * direction * shift_vector(1, dim_index)
-          v2 = k * direction * shift_vector(2, dim_index)
-          p1 = edge.inside.p1.plus(v1)
-          coords = []
-          coords[d_index_along] = edge.inside.p1[d_index_along]
-          coords[d_index_across] = edge.outside.p1[d_index_across]
-          p2 = Geometry::Point[*coords]
-          r1 = Geometry::Rect[p1, p2]
-
-          p1 = edge.inside.p2.plus(v2)
-          coords = []
-          coords[d_index_along] = edge.inside.p2[d_index_along]
-          coords[d_index_across] = edge.outside.p2[d_index_across]
-          p2 = Geometry::Point[*coords]
-          r2 = Geometry::Rect[p1, p2]
-          lines = [r1, r2].map(&:sides).flatten
-          lines << Geometry::Line[edge.inside.p1.plus(v1), edge.inside.p1.clone]
-          lines << Geometry::Line[edge.inside.p2.plus(v2), edge.inside.p2.clone]
-          lines
-        end
-
-        def add_corners_when_out(dim_index, direction, k)
-          v1 = direction * k * shift_vector(1, dim_index)
-          v2 = direction * k * shift_vector(2, dim_index)
-          p1 = edge.inside.p1.plus(v1)
-          coords = []
-          coords[d_index_along] = edge.outside.p1[d_index_along]
-          coords[d_index_across] = edge.inside.p1[d_index_across]
-          p2 = Geometry::Point[*coords]
-          r1 = Geometry::Rect[p1, p2]
+        # Widens the corner box at one end by the kerf, on the side where
+        # nothing is attached to it: along the edge when the first notch is a
+        # hole, across it when the first notch is a tab.
+        #
+        # @param end_index [Integer] 1 for p1, 2 for p2
+        # @return [Array<Geometry::Line>]
+        def kerf_strip(end_index)
+          inside = inside_point(end_index)
+          outside = outside_point(end_index)
+          along, across = first_notch_out? ? [outside, inside] : [inside, outside]
+          moved = inside.plus(-2 * shift_vector(end_index, first_notch_out? ? 1 : 0))
 
-          p1 = edge.inside.p2.plus(v2)
           coords = []
-          coords[d_index_along] = edge.outside.p2[d_index_along]
-          coords[d_index_across] = edge.inside.p2[d_index_across]
-          p2 = Geometry::Point[*coords]
-          r2 = Geometry::Rect[p1, p2]
-          lines = [r1, r2].map(&:sides).flatten
-          lines << Geometry::Line[edge.inside.p1.plus(v1), edge.inside.p1.clone]
-          lines << Geometry::Line[edge.inside.p2.plus(v2), edge.inside.p2.clone]
-          lines
+          coords[d_index_along] = along[d_index_along]
+          coords[d_index_across] = across[d_index_across]
+          Geometry::Rect[moved, Geometry::Point[*coords]].sides << Geometry::Line[moved, inside.clone]
         end
 
         def shift_vector(index, dim_shift = 0)
@@ -157,6 +115,19 @@ module Laser
 
         private
 
+        def inside_point(end_index)
+          edge.inside.public_send(:"p#{end_index}")
+        end
+
+        def outside_point(end_index)
+          edge.outside.public_send(:"p#{end_index}")
+        end
+
+        # A corner box next to a hole is widened by the kerf, so the hole starts that much later.
+        def adjust_end?(end_index)
+          adjust_corners && !first_notch_out? && edge.corner_at?(end_index)
+        end
+
         # This method has the bulk of the logic: we create the list of path deltas
         # to be applied when we walk the edge next.
         # @param [Object] shift

data/lib/laser/cutter/options.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # Everything a box can be asked for, typed. This is what a Ruby program
+    # hands to {Laser::Cutter.render} or {Laser::Cutter.write}.
+    #
+    # Values are coerced, so the Strings of a web form will do, and an
+    # instance cannot be changed: #new(lid: :plain) returns a changed copy.
+    # Keys may be Strings or Symbols. A key it does not
+    # know, a value of the wrong type or a dimension left out all raise,
+    # at once, before anything is drawn.
+    #
+    # The distances left nil take the default for the units: a kerf of
+    # 0.0024in, a margin of 0.125in, a padding of 0.1in, a stroke of 0.001in,
+    # and a notch three times the thickness.
+    #
+    # @example A box in millimeters, with a plain lid, as an SVG
+    #   options = Laser::Cutter::Options.new(width: 70, height: 20, depth: 50, thickness: 4.3,
+    #                                        units: :mm, lid: :plain, format: :svg)
+    #   options.lid                 # => "plain"
+    #   Laser::Cutter.render(options) # => "<svg ..."
+    #
+    # @raise [MissingOption] when width, height, depth or thickness is left out
+    # @raise [InvalidOption] when a value cannot be used, or a key is not an option
+    class Options < Dry::Struct
+      # The dimensions a box cannot be drawn without.
+      REQUIRED = %i[width height depth thickness].freeze
+
+      # The longest list of allowed values an error spells out.
+      MAXIMUM_CHOICES = 5
+
+      transform_keys(&:to_sym)
+      schema schema.strict
+
+      # @!attribute [r] width
+      #   @return [Float] internal width of the box
+      attribute :width, Types::Length
+
+      # @!attribute [r] height
+      #   @return [Float] internal height of the box
+      attribute :height, Types::Length
+
+      # @!attribute [r] depth
+      #   @return [Float] internal depth of the box
+      attribute :depth, Types::Length
+
+      # @!attribute [r] thickness
+      #   @return [Float] thickness of the material
+      attribute :thickness, Types::Length
+
+      # @!attribute [r] notch
+      #   @return [Float, nil] notch length, a guide only; nil for three times the thickness
+      attribute? :notch, Types.optional(Types::Length)
+
+      # @!attribute [r] kerf
+      #   @return [Float, nil] width of the cut; nil for the default
+      attribute? :kerf, Types.optional(Types::Allowance)
+
+      # @!attribute [r] units
+      #   @return [String] "in" or "mm", the units of every distance here
+      attribute :units, Types::Units
+
+      # @!attribute [r] lid
+      #   @return [String] "full", "back" or "plain": notched on every side, into the back wall only, or on no side
+      attribute :lid, Types::Lid
+
+      # @!attribute [r] format
+      #   @return [String, nil] "pdf" or "svg"; nil for a PDF, or for what the extension of the file says
+      attribute? :format, Types.optional(Types::Format)
+
+      # @!attribute [r] file
+      #   @return [String, nil] the file {Laser::Cutter.write} writes
+      attribute? :file, Types.optional(Types::Coercible::String)
+
+      # @!attribute [r] margin
+      #   @return [Float, nil] margin from the edge of the page; nil for the default
+      attribute? :margin, Types.optional(Types::Allowance)
+
+      # @!attribute [r] padding
+      #   @return [Float, nil] space between the panels; nil for the default
+      attribute? :padding, Types.optional(Types::Allowance)
+
+      # @!attribute [r] stroke
+      #   @return [Float, nil] stroke width of the lines; nil for the default
+      attribute? :stroke, Types.optional(Types::Length)
+
+      # @!attribute [r] page_size
+      #   @return [String, nil] a page size such as "A4", for a PDF; nil to fit the box
+      attribute? :page_size, Types.optional(Types::PageSize)
+
+      # @!attribute [r] page_layout
+      #   @return [String] "portrait" or "landscape", for a PDF
+      attribute :page_layout, Types::PageLayout
+
+      # @!attribute [r] metadata
+      #   @return [Boolean] whether the settings of the box are printed on the page
+      attribute :metadata, Types::Params::Bool.default(true)
+
+      # @!attribute [r] inside_box
+      #   @return [Boolean] whether the box is also drawn without kerf, in red
+      attribute :inside_box, Types::Params::Bool.default(false)
+
+      class << self
+        # @param attributes [Hash, Options] the options, by name
+        # @return [Options]
+        # @raise [MissingOption, InvalidOption]
+        def new(attributes = {}, *)
+          return attributes if attributes.is_a?(self)
+
+          require_dimensions!(attributes) if attributes.respond_to?(:to_h)
+          super
+        rescue Dry::Struct::Error => e
+          raise InvalidOption, explain(e)
+        end
+
+        private
+
+        def require_dimensions!(attributes)
+          given = attributes.to_h.transform_keys(&:to_sym)
+          missing = REQUIRED.select { |name| Types.blank?(given[name]) }
+          return if missing.empty?
+
+          raise MissingOption, "#{missing.join(', ')} #{missing.size > 1 ? 'are' : 'is'} required, but missing."
+        end
+
+        # Says which option was refused, and what it may be when that is a short list.
+        def explain(error)
+          cause = error.cause
+          return error.message.sub(/\A\[.*?\] /, '') unless cause.respond_to?(:key) && cause.respond_to?(:value)
+
+          choices = choices_of(schema.key(cause.key).type)
+          allowed = choices && choices.size <= MAXIMUM_CHOICES ? ", but must be one of: #{choices.join(', ')}" : ''
+          "#{cause.key} cannot be #{cause.value.inspect}#{allowed}."
+        end
+
+        # The words an attribute may be, found under whatever wraps its type.
+        #
+        # @return [Array<String>, nil] nil when the attribute is not one of a list
+        def choices_of(type)
+          return type.values if type.respond_to?(:values)
+
+          inner = %i[right type].find { |name| type.respond_to?(name) }
+          choices_of(type.public_send(inner)) if inner
+        end
+      end
+
+      # @return [Configuration] the same settings, as the renderers take them
+      def to_configuration
+        Configuration.new(to_h.except(:format, :inside_box).merge(debug: inside_box))
+      end
+    end
+  end
+end

data/lib/laser/cutter/renderer/base.rb

@@ -18,7 +18,13 @@ module Laser
           self.page_manager = Laser::Cutter::PageManager.new(config.units)
         end
 
-        def render
+        # Writes the document to config.file, yielding after each line drawn.
+        def render(&)
+          File.binwrite(config.file, document(&))
+        end
+
+        # @return [String] the document, yielding after each line drawn
+        def document
           raise 'Abstract method'
         end
 

data/lib/laser/cutter/renderer/layout_renderer.rb

@@ -18,8 +18,8 @@ module Laser
           box_renderers.sum { |renderer| renderer.lines.size }
         end
 
-        # Writes the file, yielding after each line drawn.
-        def render(&)
+        # @return [String] the PDF, yielding after each line drawn
+        def document(&)
           margin = config.margin.to_f.send(units)
           pdf = Prawn::Document.new(margin:      margin,
                                     page_size:   config.page_size || calculate_image_boundary(box_renderers.first, margin),
@@ -28,7 +28,7 @@ module Laser
           box_renderers.first.render(pdf, &)
           meta_renderer&.render(pdf)
           box_renderers.drop(1).each { |renderer| renderer.render(pdf, &) }
-          pdf.render_file(config.file)
+          pdf.render
         end
 
         def calculate_image_boundary(box_renderer, margin)

data/lib/laser/cutter/renderer/meta_renderer.rb

@@ -4,7 +4,7 @@ module Laser
   module Cutter
     module Renderer
       class MetaRenderer < Laser::Cutter::Renderer::Base
-        META_KEYS = %i(units width height depth thickness notch kerf stroke padding margin page_size page_layout).freeze
+        META_KEYS = %i(units width height depth thickness notch lid kerf stroke padding margin page_size page_layout).freeze
 
         def initialize(config = {})
           self.config = config

data/lib/laser/cutter/renderer/svg_renderer.rb

@@ -24,15 +24,15 @@ module Laser
           lines.size
         end
 
-        # Writes the file, yielding after each line drawn.
-        def render
+        # @return [String] the SVG, yielding after each line drawn
+        def document
           svg = Victor::SVG.new(width: "#{width}#{units}", height: "#{height}#{units}", viewBox: "0 0 #{width} #{height}")
           svg.element(:desc, description) if config.metadata
           lines.each do |line|
             svg.line(**coordinates(line), stroke: "##{config[:color] || BLACK}", stroke_width: config.stroke)
             yield line if block_given?
           end
-          File.write(config.file, svg.render)
+          svg.render
         end
 
         private

data/lib/laser/cutter/types.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # The types of the attributes of {Options}. Each one coerces what a form
+    # or a command line sends, Strings mostly, and rejects what it cannot use.
+    module Types
+      include Dry.Types()
+
+      # Whether a value was left out: nil, or the empty String of a blank form field.
+      #
+      # @param value [Object]
+      # @return [Boolean]
+      def self.blank?(value)
+        value.nil? || Dry::Types::Undefined.equal?(value) || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+      # One of a few words, given as a String or a Symbol. Blank means the default.
+      #
+      # @param values [Array<String>] the words allowed
+      # @param default [String] the word a blank value stands for
+      # @return [Dry::Types::Type]
+      def self.choice(values, default:)
+        String.default(default).enum(*values).constructor { |value| blank?(value) ? Dry::Types::Undefined : value.to_s }
+      end
+
+      # A type that also takes nil, and reads a blank value as nil.
+      #
+      # @param type [Dry::Types::Type]
+      # @return [Dry::Types::Type]
+      def self.optional(type)
+        type.optional.constructor { |value| blank?(value) ? nil : value }
+      end
+
+      # A size of the box or of its material: a number above zero.
+      Length = Coercible::Float.constrained(gt: 0)
+
+      # A distance that may be zero, such as the kerf or a margin.
+      Allowance = Coercible::Float.constrained(gteq: 0)
+
+      # The units every dimension is in.
+      Units = choice(%w[in mm], default: 'in')
+
+      # How the lid joins the walls, see Box::LIDS.
+      Lid = choice(Box::LIDS.map(&:to_s), default: 'full')
+
+      # The way the page is turned, for a PDF.
+      PageLayout = choice(%w[portrait landscape], default: 'portrait')
+
+      # The kind of file to draw.
+      Format = Coercible::String.constructor(&:downcase).enum(*Renderer::FORMATS.keys)
+
+      # The name of a page size a PDF can take, such as A4 or LETTER.
+      PageSize = Coercible::String.constructor(&:upcase).enum(*PageManager::SIZES.keys)
+    end
+  end
+end

data/lib/laser/cutter/version.rb

@@ -2,6 +2,6 @@
 
 module Laser
   module Cutter
-    VERSION = "2.0.0"
+    VERSION = "2.0.1"
   end
 end

data/lib/laser/cutter.rb

@@ -14,12 +14,50 @@ require "dry/cli"
 require "dry/cli/help"
 require "dry/cli/ui"
 require "dry/cli/autocomplete/command"
+require "dry/struct"
 require "tty-screen"
 require "zeitwerk"
 
 module Laser
+  # Draws the notched panels of a box. A Ruby program needs {Options},
+  # {Cutter.render} and {Cutter.write}; the command line is one caller of many.
   module Cutter
     class Error < StandardError; end
+
+    class << self
+      # Draws a box, and returns the document without writing a file.
+      #
+      # @example In a Rails controller
+      #   box = params.require(:box).permit(*Laser::Cutter::Options.attribute_names)
+      #   options = Laser::Cutter::Options.new(box.to_h)
+      #   send_data Laser::Cutter.render(options), type: "application/pdf", filename: "box.pdf"
+      #
+      # @param options [Options, Hash] a Hash becomes an {Options}
+      # @yieldparam line [Geometry::Line] each line, once it is drawn
+      # @return [String] the PDF, or the SVG when the options ask for one
+      # @raise [MissingOption, InvalidOption]
+      def render(options, &)
+        options = Options.new(options)
+        Renderer.for(options.format || Renderer::FORMATS.keys.first, options.to_configuration).document(&)
+      end
+
+      # Draws a box into the file the options name. Without a format, the
+      # extension of the file decides, and anything but .svg is a PDF.
+      #
+      # @param options [Options, Hash] a Hash becomes an {Options}
+      # @yieldparam line [Geometry::Line] each line, once it is drawn
+      # @return [String] the path of the file
+      # @raise [MissingOption, InvalidOption]
+      def write(options, &)
+        options = Options.new(options)
+        raise MissingOption, 'file is required, but missing.' unless options.file
+
+        extension = File.extname(options.file).delete('.').downcase
+        format = options.format || (Renderer::FORMATS.key?(extension) ? extension : nil)
+        File.binwrite(options.file, render(options.new(format: format), &))
+        options.file
+      end
+    end
   end
 end
 

data/spec/laser/cutter/box_lid_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'digest'
+
+module Laser
+  module Cutter
+    # Every outline here is checked as a region, point by point, against a
+    # description of the panel that owes nothing to the code that drew it.
+    RSpec.describe Box, 'lid' do
+      # Wide enough for a sample to land in every strip the kerf adds.
+      let(:kerf) { 0.5 }
+      let(:boxes) { Hash.new { |cache, (lid, cut)| cache[[lid, cut]] = build(lid, cut) } }
+
+      def build(lid, cut)
+        settings = dimensions.merge(units: 'mm', file: 'box.pdf', lid: lid, kerf: cut)
+        Box.new(Configuration.new(settings)).tap(&:generate_notches)
+      end
+
+      # @return [Array<Array(Float, Float)>] points over a face and the margin around it
+      def samples(face)
+        Outline.samples(face, margin: 1.5 * dimensions[:thickness])
+      end
+
+      # @return [Boolean] whether a point is inside the named panel of a box cut without kerf
+      def material?(lid, name, x, y)
+        Outline.inside?(boxes[[lid, 0.0]].outlines[name], x, y)
+      end
+
+      def between?(value, from, to)
+        from < value && value < to
+      end
+
+      # The region each panel should cover without kerf, given the box with a full lid.
+      def expected?(lid, face, x, y)
+        t = dimensions[:thickness]
+        full = material?(:full, face.name, x, y)
+        across = between?(x, face.p1.x, face.p2.x)
+        case face.name
+        when 'bottom' then full
+        when 'front', 'left', 'right' then full && y > face.p1.y
+        when 'back' then lid == :plain ? full && y < face.p2.y : full && (across || y < face.p2.y)
+        when 'top'
+          covered = between?(x, face.p1.x - t, face.p2.x + t) && between?(y, face.p1.y - t, face.p2.y + t)
+          lid == :plain || y > face.p1.y ? covered : covered && (full || !across)
+        end
+      end
+
+      shared_examples 'a box with a lid that lifts off' do |lid|
+        let(:box) { boxes[[lid, 0.0]] }
+        let(:cut) { boxes[[lid, kerf]] }
+
+        it 'closes every outline' do
+          expect([box, cut].flat_map { |b| b.outlines.values }).to all(satisfy { |lines| Outline.closed?(lines) })
+        end
+
+        it 'keeps every panel where the full lid has it' do
+          expect(box.faces.map(&:to_a)).to eq(boxes[[:full, 0.0]].faces.map(&:to_a))
+        end
+
+        %w[top front back left right bottom].each do |name|
+          it "cuts the #{name} panel to shape" do
+            face = box.public_send(name)
+            wrong = samples(face).reject { |x, y| material?(lid, name, x, y) == expected?(lid, face, x, y) }
+            expect(wrong).to be_empty
+          end
+
+          it "grows the #{name} panel by half the kerf on every side" do
+            wrong = samples(box.public_send(name)).reject do |x, y|
+              Outline.inside?(cut.outlines[name], x, y) == Outline.within?(box.outlines[name], x, y, kerf / 2)
+            end
+            expect(wrong).to be_empty
+          end
+        end
+      end
+
+      shared_examples 'a box of any size' do
+        describe 'with a plain lid' do
+          it_behaves_like 'a box with a lid that lifts off', :plain
+
+          it 'draws the lid as four lines' do
+            expect(boxes[[:plain, kerf]].outlines['top'].size).to eq(4)
+          end
+
+          it 'sizes the lid to the outside of the walls, plus the kerf' do
+            w, d, t = dimensions.values_at(:width, :depth, :thickness)
+            lengths = boxes[[:plain, kerf]].outlines['top'].map(&:length).sort
+            expect(lengths).to match_array([d, d, w, w].map { |side| be_within(1e-6).of(side + (2 * t) + kerf) })
+          end
+        end
+
+        describe 'with a lid notched into the back wall' do
+          it_behaves_like 'a box with a lid that lifts off', :back
+
+          it 'leaves the back wall its notches under the lid' do
+            back = boxes[[:back, 0.0]].back
+            tabs = samples(back).count { |x, y| y > back.p2.y && material?(:back, 'back', x, y) }
+            expect(tabs).to be_positive
+          end
+        end
+      end
+
+      context 'when the lid would own the corners anyway, and its notches start with a tab' do
+        let(:dimensions) { { width: 50, height: 60, depth: 70, thickness: 6, notch: 10 } }
+
+        it_behaves_like 'a box of any size'
+      end
+
+      context 'when the front would own the corners, and the notches of the lid start with a hole' do
+        let(:dimensions) { { width: 40, height: 30, depth: 20, thickness: 3, notch: 5 } }
+
+        it_behaves_like 'a box of any size'
+      end
+
+      context 'when the box is wide and its material thin' do
+        let(:dimensions) { { width: 100, height: 80, depth: 60, thickness: 3, notch: 9 } }
+
+        it_behaves_like 'a box of any size'
+      end
+
+      describe 'a full lid' do
+        # Digests of the lines 2.0.0 drew, before the lid became an option.
+        {
+          [{ width: 50, height: 60, depth: 70, thickness: 6, notch: 10 }, 0.0] => '35d6a17c6f524b00',
+          [{ width: 50, height: 60, depth: 70, thickness: 6, notch: 10 }, 0.1] => 'af287e64ac6a249f',
+          [{ width: 40, height: 30, depth: 20, thickness: 3, notch: 6 }, 0.15] => '1aed155401688002',
+          [{ width: 100, height: 80, depth: 60, thickness: 3, notch: 9 }, 0.1] => '06b3cbc4e66bd18b'
+        }.each do |(dimensions, cut), digest|
+          it "draws what 2.0.0 drew for #{dimensions.values.join('x')} with a #{cut} kerf" do
+            lines = Box.new(Configuration.new(dimensions.merge(units: 'mm', file: 'box.pdf', kerf: cut))).generate_notches
+            coordinates = lines.map { |l| [l.p1.x, l.p1.y, l.p2.x, l.p2.y].map { |v| v.round(6) + 0.0 } }.sort
+            expect(Digest::SHA256.hexdigest(coordinates.inspect)[0, 16]).to eq(digest)
+          end
+        end
+
+        it 'is the default' do
+          expect(Box.new(Configuration.new(box: '4x3x2/0.125', file: 'box.pdf')).lid).to eq(:full)
+        end
+      end
+    end
+  end
+end