laser-cutter 1.0.3 → 2.0.0

data/spec/laser/cutter/aggregator_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    RSpec.describe Aggregator do
+      def line(x1, y1, x2, y2)
+        Geometry::Line.new(Geometry::Point[x1, y1], Geometry::Point[x2, y2])
+      end
+
+      def outline(*lines)
+        described_class.new(lines).lines.map(&:to_s)
+      end
+
+      let(:short) { line(0, 0, 5, 0) }
+      let(:long) { line(2, 0, 10, 0) }
+      let(:vertical) { line(2, 0, 2, 12) }
+
+      it 'keeps lines that share nothing, sorted' do
+        expect(outline(vertical, short)).to eq([short, vertical].map(&:to_s))
+      end
+
+      it 'cancels two identical lines, whichever way each one points' do
+        expect(outline(short, line(5, 0, 0, 0), vertical)).to eq([vertical.to_s])
+      end
+
+      it 'keeps a line drawn three times' do
+        expect(outline(short, short, short)).to eq([short.to_s])
+      end
+
+      it 'keeps only the parts two overlapping lines do not share' do
+        expect(outline(short, long, vertical)).to eq([line(0, 0, 2, 0), line(2, 0, 2, 12), line(5, 0, 10, 0)].map(&:to_s))
+      end
+
+      it 'joins lines that meet end to end' do
+        expect(outline(line(0, 0, 2, 0), line(2, 0, 5, 0))).to eq([short.to_s])
+      end
+
+      it 'drops a line one other line covers whole, leaving the rest of it' do
+        expect(outline(line(0, 0, 10, 0), line(2, 0, 5, 0))).to eq([line(0, 0, 2, 0), line(5, 0, 10, 0)].map(&:to_s))
+      end
+
+      it 'treats coordinates within the tolerance as the same' do
+        expect(outline(line(0, 0, 5, 0), line(5, 0.0004, 10, 0.0004))).to eq([line(0, 0, 10, 0).to_s])
+      end
+
+      it 'keeps horizontal and vertical lines apart' do
+        expect(outline(line(0, 0, 5, 0), line(0, 0, 0, 5)).size).to eq(2)
+      end
+
+      it 'passes a line on neither axis through' do
+        skewed = line(0, 0, 3, 4)
+        expect(outline(skewed, skewed)).to eq([skewed, skewed].map(&:to_s))
+      end
+
+      # A relative bound, since a shared CI runner can be several times slower
+      # than a laptop: four times the lines take about four and a half times as
+      # long when swept, and sixteen times as long when compared pairwise.
+      it 'scales with n log n rather than the square of the line count' do
+        seconds_for = lambda do |count|
+          lines = Array.new(count) { |i| line(i, 0, i + 1.5, 0) }
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          described_class.new(lines)
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        end
+
+        expect(seconds_for.call(16_000) / seconds_for.call(4_000)).to be < 10
+      end
+    end
+  end
+end

data/spec/laser/cutter/box_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Laser
+  module Cutter
+    RSpec.describe Box do
+      let(:config) { { 'width' => 50, 'height' => 60, 'depth' => 70, 'margin' => 5, 'padding' => 3, 'units' => 'mm' } }
+      let(:box1) { Box.new(config.merge('thickness' => 6, 'notch' => 10)) }
+      let(:box2) { Box.new(config.merge('thickness' => 6, )) }
+
+      describe '#initialize' do
+        it 'initializes with passed in parameters' do
+          expect(box1.w).to eq(50.0)
+          expect(box1.thickness).to eq(6.0)
+          expect(box1.notch_width).to eq(10.0)
+        end
+
+        it 'initializes with default notch' do
+          expect(box2.notch_width).to eq(70.0 / 5.0)
+        end
+      end
+
+      describe 'notch counts across joints' do
+        # Sides meeting at a joint share a nominal length, and must get the
+        # same number of notches or the two panels do not fit together.
+        [0.0, 0.0024].each do |kerf|
+          it "agree on a 4x3x2 box with a 0.5 notch and a #{kerf} kerf" do
+            edges = []
+            allow(Notching::Edge).to receive(:new).and_wrap_original do |original, *args|
+              original.call(*args).tap { |edge| edges << edge }
+            end
+            Box.new(Configuration.new(width: 4, height: 3, depth: 2, thickness: 0.125,
+                                      notch: 0.5, kerf: kerf, file: 'box.pdf')).generate_notches
+
+            counts = edges.group_by { |edge| edge.inside.length.round(1) }
+                          .transform_values { |group| group.map(&:notch_count).uniq }
+            expect(counts).to eq(4.0 => [9], 3.0 => [7], 2.0 => [5])
+          end
+        end
+      end
+
+      describe '#notches' do
+        before do
+          box1.generate_notches
+          box2.generate_notches
+        end
+
+        it 'generates notches' do
+          expect(box1.notches).not_to be_nil
+          expect(box1.notches.size).to eql(344)
+        end
+
+        it 'properlies calculate enclosure' do
+          expect(box1.enclosure.to_a.flatten.map(&:round)).to eql([0, 0, 232, 317])
+          expect(box2.enclosure.to_a.flatten.map(&:round)).to eql([0, 0, 232, 317])
+        end
+      end
+    end
+  end
+end

data/spec/laser/cutter/cli/config_file_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require 'tmpdir'
+
+RSpec.describe Laser::Cutter::CLI::ConfigFile do
+  describe '#read' do
+    it 'reads STDIN for -' do
+      stdin = $stdin
+      $stdin = StringIO.new('{"width": 4}')
+      expect(described_class.new('-').read).to eq('width' => 4)
+    ensure
+      $stdin = stdin
+    end
+
+    it 'raises on a file that is not JSON' do
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, 'broken.json')
+        File.write(path, 'not json')
+        expect { described_class.new(path).read }.to raise_error(Laser::Cutter::Error, /cannot read/)
+      end
+    end
+  end
+
+  describe '#write' do
+    it 'raises when the file cannot be written' do
+      expect { described_class.new('/nowhere/at/all.json').write({}, StringIO.new) }
+        .to raise_error(Laser::Cutter::Error, /cannot write/)
+    end
+  end
+end

data/spec/laser/cutter/cli_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+RSpec.describe 'laser-cutter', type: :aruba do
+  let(:box) { '-b 4x3x2/0.125/0.5' }
+
+  describe 'without arguments' do
+    before { run_command_and_stop('laser-cutter') }
+
+    it 'lists the commands and exits 0' do
+      expect(last_command_started).to have_output(/generate.*page-sizes.*examples.*help/m)
+    end
+
+    it 'wraps help at 90 columns or fewer' do
+      expect(last_command_started.output.lines.map { |line| line.chomp.length }.max).to be <= 90
+    end
+  end
+
+  describe 'the width of help' do
+    { 200 => 90, 80 => 74, 0 => 74, nil => 74 }.each do |columns, width|
+      it "is #{width} on a terminal #{columns.inspect} columns wide" do
+        expect(Laser::Cutter::CLI.help_width(columns)).to eq(width)
+      end
+    end
+  end
+
+  describe 'help' do
+    it 'prints the top-level help' do
+      run_command_and_stop('laser-cutter help')
+      expect(last_command_started).to have_output(/COMMANDS/)
+    end
+
+    it 'describes the completion command' do
+      run_command_and_stop('laser-cutter help')
+      expect(last_command_started).to have_output(/completion\s+Generates auto-complete for BASH or ZSH/)
+    end
+
+    # In-process, dry-cli names the program after the process: rspec.
+    it 'shows the shell the completion command takes' do
+      run_command_and_stop('laser-cutter help completion')
+      expect(last_command_started).to have_output(/completion SHELL \[OPTIONS\]/)
+    end
+
+    it 'explains one command' do
+      run_command_and_stop('laser-cutter help generate')
+      expect(last_command_started).to have_output(/-H, --height=VALUE/)
+    end
+  end
+
+  describe 'version' do
+    %w[version -V --version].each do |argument|
+      it "answers to #{argument}" do
+        run_command_and_stop("laser-cutter #{argument}")
+        expect(last_command_started).to have_output(Laser::Cutter::VERSION)
+      end
+    end
+  end
+
+  describe 'examples' do
+    it 'shows how to generate a box' do
+      run_command_and_stop('laser-cutter examples')
+      expect(last_command_started).to have_output(/laser-cutter generate -b 3x2x2/)
+    end
+  end
+
+  describe 'page-sizes' do
+    it 'lists the sizes in inches' do
+      run_command_and_stop('laser-cutter page-sizes')
+      expect(last_command_started).to have_output(/B10:\s+1\.2\s+x\s+1\.7/)
+    end
+
+    it 'lists the sizes in millimeters' do
+      run_command_and_stop('laser-cutter page-sizes -u mm')
+      expect(last_command_started).to have_output(/B10:\s+31\.0\s+x\s+44\.0/)
+    end
+  end
+
+  # dry-cli-autocomplete writes to $stdout rather than the stream Aruba hands
+  # the command, so this reads the process's stdout instead.
+  describe 'completion' do
+    it 'prints a zsh completion script' do
+      expect { run_command_and_stop('laser-cutter completion zsh') }.to output(/laser-cutter/).to_stdout
+    end
+  end
+
+  describe 'generate' do
+    it 'writes a PDF by default' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf")
+      expect(read('box.pdf').first).to start_with('%PDF')
+    end
+
+    it 'reports one unit of progress per line drawn' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf")
+      expect(last_command_started).to have_output(%r{Drawing box\.pdf 328/328})
+    end
+
+    it 'draws the info box as wide as help' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf")
+      info = last_command_started.stdout.split('┌─ Success').first
+      expect(info.lines.map { |line| line.chomp.length }.max).to eq(Laser::Cutter::CLI.help_width)
+    end
+
+    it 'keeps the path of the file on one line' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf")
+      expect(last_command_started.stdout).to include(expand_path('box.pdf'))
+    end
+
+    it 'opens with an info box that names the gem and the dimensions' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf")
+      expect(last_command_started.stdout).to match(/─ Info ─.*Laser-Cutter \(ruby gem\) Version #{Laser::Cutter::VERSION}, ©/m)
+        .and match(/Width:\s+4\.0 in.*Height:\s+3\.0 in.*Depth:\s+2\.0 in.*Notch:\s+0\.5 in.*Format: PDF/m)
+    end
+
+    it 'closes with a success box that gives the path of the file' do
+      run_command_and_stop("laser-cutter generate #{box} -f svg -o box.svg")
+      expect(last_command_started.stdout).to match(/─ Info ─.*─ Success ─.*Generated SVG file:.*box\.svg/m)
+    end
+
+    it 'writes an SVG, whatever the case of the format' do
+      run_command_and_stop("laser-cutter generate #{box} -f SVG -o box.svg")
+      expect(read('box.svg').join).to include('<svg', '<line').and include('viewBox="0 0 9.2012 11.5512"')
+    end
+
+    it 'draws the box without kerf as well with --inside-box' do
+      run_command_and_stop("laser-cutter generate #{box} --inside-box -o box.pdf")
+      expect(last_command_started).to have_output(%r{Drawing box\.pdf 656/656})
+    end
+
+    it 'takes each dimension as its own option, in millimeters' do
+      run_command_and_stop('laser-cutter generate -u mm -w 70 -H 20 -d 50 -t 4.3 -n 5 -f svg -o box.svg')
+      expect(read('box.svg').first).to match(/width="[\d.]+mm"/)
+    end
+
+    it 'prints the configuration with --verbose' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf -v")
+      expect(last_command_started).to have_output(/"thickness": 0\.125/)
+    end
+
+    it 'saves the configuration, and reads it back' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf -W settings.json")
+      expect(JSON.parse(read('settings.json').join)).to include('width' => 4.0, 'notch' => 0.5)
+
+      run_command_and_stop('laser-cutter generate -R settings.json -f svg -o again.svg')
+      expect(read('again.svg').join).to include('viewBox="0 0 9.2012 11.5512"')
+    end
+
+    it 'prints the configuration to STDOUT when saving to -' do
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf -W -")
+      expect(last_command_started).to have_output(/"depth": 2\.0/)
+    end
+
+    it 'opens the file with --open' do
+      allow_any_instance_of(Laser::Cutter::CLI::Generate).to receive(:system)
+      run_command_and_stop("laser-cutter generate #{box} -o box.pdf --open")
+      expect(last_command_started).to have_exit_status(0)
+    end
+
+    context 'when it cannot run' do
+      it 'fails without a file' do
+        run_command_and_stop("laser-cutter generate #{box}", fail_on_error: false)
+        expect(last_command_started).to have_exit_status(1)
+        expect(last_command_started.stderr).to match(/─ Error ─.*file is required/m)
+        expect(last_command_started.stdout).to be_empty
+      end
+
+      it 'draws the error box as wide as help' do
+        run_command_and_stop("laser-cutter generate #{box}", fail_on_error: false)
+        expect(last_command_started.stderr.lines.map { |line| line.chomp.length }.max).to eq(Laser::Cutter::CLI.help_width)
+      end
+
+      it 'fails on an unknown format' do
+        run_command_and_stop("laser-cutter generate #{box} -f dxf -o box.dxf", fail_on_error: false)
+        expect(last_command_started).to have_output(/unknown format "dxf", expected one of: pdf, svg/)
+      end
+
+      it 'fails on a missing configuration file' do
+        run_command_and_stop('laser-cutter generate -R nothing.json -o box.pdf', fail_on_error: false)
+        expect(last_command_started).to have_output(/cannot read the configuration from nothing\.json/)
+      end
+
+      it 'prints the backtrace with --verbose' do
+        run_command_and_stop("laser-cutter generate #{box} -f dxf -o box.dxf -v", fail_on_error: false)
+        expect(last_command_started).to have_output(/renderer\.rb/)
+      end
+    end
+  end
+end

data/spec/laser/cutter/configuration_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Laser
+  module Cutter
+    RSpec.describe Configuration do
+      subject(:config) { described_class.new(opts) }
+
+      context 'when a box is 2x3x2/0.125/0.5' do
+        let(:opts) { { 'box' => '2x3x2/0.125/0.5' } }
+
+        its(:width) { is_expected.to eql(2.0) }
+        its(:height) { is_expected.to eql(3.0) }
+        its(:depth) { is_expected.to eql(2.0) }
+        its(:thickness) { is_expected.to eql(0.125) }
+        its(:page_layout) { is_expected.to eql('portrait') }
+        its(:notch) { is_expected.to eql(0.5) }
+      end
+
+      describe '#validate' do
+        context 'when required options are missing' do
+          let(:opts) { { 'height' => '23' } }
+
+          its(:height) { is_expected.to eql(23.0) }
+
+          it 'raises MissingOption' do
+            expect { config.validate! }.to raise_error(Laser::Cutter::MissingOption)
+          end
+        end
+
+        context 'when a required option is zero' do
+          let(:opts) { { 'box' => '2.0x0.0x2/0.125/0.5', 'file' => '/tmp/a' } }
+
+          its(:height) { is_expected.to eql(0.0) }
+
+          it 'raises ZeroValueNotAllowed' do
+            expect { config.validate! }.to raise_error(Laser::Cutter::ZeroValueNotAllowed)
+          end
+        end
+      end
+
+      context 'when notch is omitted' do
+        let(:opts) { { 'box' => '2.0x1.0x2/0.125', 'file' => '/tmp/a' } }
+
+        before { config.validate! }
+
+        its(:thickness) { is_expected.to eql(0.125) }
+        its(:notch) { is_expected.to eql(0.375) }
+      end
+
+      context 'when invalid units are provided' do
+        let(:opts) { { 'box' => '2x3x2/0.125/0.5', 'units' => 'xx' } }
+
+        its(:units) { is_expected.to eql(:in) }
+      end
+
+      context 'when converting between units' do
+        context 'from inches to mm' do
+          let(:opts) { { 'box' => '2.0x3x2/0.125/0.5', 'padding' => '4.2', 'units' => 'in' } }
+
+          its(:width) { is_expected.to eql(2.0) }
+
+          context 'after change_units(:in)' do
+            subject(:config) { described_class.new(opts).tap { |c| c.change_units(:in) } }
+
+            its(:width) { is_expected.to eql(2.0) }
+          end
+
+          context 'after change_units(:mm)' do
+            subject(:config) { described_class.new(opts).tap { |c| c.change_units(:mm) } }
+
+            its(:units) { is_expected.to eql(:mm) }
+            its(:width) { is_expected.to eql(50.8) }
+            its(:padding) { is_expected.to eql(106.68) }
+          end
+        end
+
+        context 'from mm to inches' do
+          let(:opts) { { 'box' => '20.0x30.0x40.0/5/5', 'margin' => '10.0', 'units' => 'mm' } }
+
+          its(:width) { is_expected.to eql(20.0) }
+
+          context 'after change_units(:mm)' do
+            subject(:config) { described_class.new(opts).tap { |c| c.change_units(:mm) } }
+
+            its(:width) { is_expected.to eql(20.0) }
+          end
+
+          context 'after change_units(:in)' do
+            subject(:config) { described_class.new(opts).tap { |c| c.change_units(:in) } }
+
+            its(:width) { is_expected.to be_within(0.00001).of(0.787401575) }
+            its(:margin) { is_expected.to be_within(0.00001).of(0.393700787) }
+            its(:units) { is_expected.to eql(:in) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/{dimensions_spec.rb → laser/cutter/dimensions_spec.rb}

@@ -1,22 +1,24 @@
-require_relative 'spec_helper'
+# frozen_string_literal: true
+
+require 'spec_helper'
 module Laser
   module Cutter
     module Geometry
-
-      describe Dimensions do
+      RSpec.describe Dimensions do
         let(:dim1) { Dimensions.new(20, 10, 50) }
 
         context 'creation' do
           context 'from string' do
             let(:dim2) { Dimensions.new "20x10x50" }
-            it 'should instantiate correctly from a string' do
-              expect(dim2).to_not be_nil
+
+            it 'instantiates correctly from a string' do
+              expect(dim2).not_to be_nil
               expect(dim2).to eql(dim1)
             end
           end
 
           context 'from hash' do
-            it 'should instantiate correctly from a hash' do
+            it 'instantiates correctly from a hash' do
               expect(Dimensions.new(h: 10, w: 20, d: 50)).to eql(dim1)
             end
           end

data/spec/laser/cutter/edge_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Laser
+  module Cutter
+    module Notching
+      RSpec.describe Edge do
+        # When the notch divides the side exactly, length / notch lands on a
+        # whole number, and float noise in the edge coordinates used to tip
+        # #ceil either way, so panels meeting at one joint disagreed.
+        context 'when the notch divides the side exactly' do
+          let(:outside) { Geometry::Line.new(Geometry::Point[0, 0], Geometry::Point[0, 3.25]) }
+
+          [2.9999999999999991, 3.0, 3.0000000000000013].each do |length|
+            it "gives a #{length.inspect}-long side 7 notches" do
+              inside = Geometry::Line.new(Geometry::Point[0.125, 0.125], Geometry::Point[0.125, 0.125 + length])
+              edge = described_class.new(outside, inside, notch_width: 0.5, thickness: 0.125)
+              expect(edge.notch_count).to eq(7)
+            end
+          end
+        end
+
+        context 'left vertical side' do
+          let(:notch_width) { 2 }
+          let(:inside) { Geometry::Line.new(Geometry::Point[1, 1], Geometry::Point[1, 9]) }
+          let(:outside) { Geometry::Line.new(Geometry::Point[0, 0], Geometry::Point[0, 10]) }
+          let(:edge) {
+            Notching::Edge.new(inside,
+                               outside,
+                               center_out:   true,
+                               fill_corners: true,
+                               notch_width:  notch_width,
+                               kerf:         0.02,
+                               thickness:    1)
+          }
+
+          it 'creates a node correctly' do
+            expect(inside.length).to eql(8.0)
+            expect(outside.length).to eql(10.0)
+            expect(edge.center_out).to be_truthy
+            expect(edge.kerf).to be_within(0.0001).of(0.02)
+            expect(edge.thickness).to be_within(0.0001).of(1)
+            expect(edge.notch_width).to be_within(notch_width / 3.0).of(notch_width)
+          end
+
+          it 'calculates notch width correctly' do
+            expect(inside.length).to eql(8.0)
+            expect(outside.length).to eql(10.0)
+            expect(edge.center_out).to be_truthy
+
+            expect(edge.kerf).to be_within(0.0001).of(0.02)
+            expect(edge.thickness).to be_within(0.0001).of(1)
+          end
+
+          it 'correctlies calculate v1 and v2' do
+            expect(edge.v1.to_a).to eql([1.0, 1.0])
+            expect(edge.v2.to_a).to eql([1.0, -1.0])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/{line_spec.rb → laser/cutter/line_spec.rb}

@@ -1,39 +1,43 @@
-require_relative 'spec_helper'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module Laser
   module Cutter
     module Geometry
-      describe Line do
+      RSpec.describe Line do
         let(:p1) { Point.new(1, 1) }
         let(:p2) { Point.new(7, 11) }
         let(:center) { Point.new((7 + 1) / 2, (11 + 1) / 2) }
         let(:line) { Line.new(p1, p2) }
 
-        context '#center' do
-          it 'should calculate' do
+        describe '#center' do
+          it 'calculates' do
             expect(line.center).to eql(center)
           end
         end
 
-        context '#initialize' do
+        describe '#initialize' do
           let(:line2) { Line.new(from: [1, 1], to: [7, 11]) }
           let(:line3) { Line.new(from: Point.new(1, 1), to: Point.new(7, 11)) }
-          it 'should create' do
+
+          it 'creates' do
             expect(line2.p1).to eql(Point.new(1, 1))
             expect(line2.p2).to eql(Point.new(7, 11))
           end
-          it 'should properly equal identical line' do
+
+          it 'properlies equal identical line' do
             expect(line).to eql(line2)
             expect(line).to eql(line3)
           end
-
         end
 
-        context '#length' do
+        describe '#length' do
           let(:line1) { Line.new(Point.new(0, 0), Point.new(0, 10)) }
           let(:line2) { Line.new(Point.new(0, 0), Point.new(-10, 0)) }
           let(:line3) { Line.new(Point.new(0, 0), Point.new(3, 4)) }
-          it 'should calculate' do
+
+          it 'calculates' do
             expect(line1.length).to be_within(0.001).of(10)
             expect(line2.length).to be_within(0.001).of(10)
             expect(line3.length).to be_within(0.001).of(5)
@@ -46,25 +50,27 @@ module Laser
           let(:l3) { Line.new(Point[0, 0], Point[11, 10]) }
           let(:l4) { Line.new(Point[20, 20], Point[1, 1]) }
           let(:l5) { Line.new(Point[11, 10], Point[0, 0]) }
-          it 'should detect equality' do
+
+          it 'detects equality' do
             expect(l1).to eql(Line.new(l1.p1, l1.p2))
-            expect(l1).to_not eql(Line.new(l1.p1, Point[2, 4]))
+            expect(l1).not_to eql(Line.new(l1.p1, Point[2, 4]))
             expect(l5).to eql(l3)
             expect(l5.hash).to eql(l3.hash)
           end
 
-          it 'should properly compare' do
+          it 'properlies compare' do
             list = [l4, l3, l1, l2]
             list.sort!
             expect(list).to eql([l1, l3, l2, l4])
           end
 
-          it 'should properly uniq' do
+          it 'properlies uniq' do
             list = [l4, l1, l4, l2, l3, l3, l2, l1]
             list.sort!.uniq!
             expect(list).to eql([l1, l3, l2, l4])
           end
         end
+
         context 'overlaps and such' do
           let(:l1) { Line.new(Point[0, 0], Point[10, 0]) }
           let(:l2) { Line.new(Point[7, 0], Point[15, 0]) }
@@ -72,9 +78,8 @@ module Laser
           let(:l4) { Line.new(Point[0, 1], Point[0, 3]) }
           let(:l5) { Line.new(Point[0, -1], Point[0, 2]) }
 
-
-          context '#overlaps?' do
-            it 'should detect overlap' do
+          describe '#overlaps?' do
+            it 'detects overlap' do
               expect(l1.overlaps?(l2)).to be_truthy
               expect(l1.overlaps?(l3)).to be_falsey
               expect(l2.overlaps?(l3)).to be_falsey
@@ -84,9 +89,10 @@ module Laser
             end
           end
 
-          context '#xor' do
-            let(:xor) { [ Line.new(Point[0, 0], Point[7, 0]),  Line.new(Point[10, 0], Point[15, 0])]}
-            it 'should subtract lines' do
+          describe '#xor' do
+            let(:xor) { [Line.new(Point[0, 0], Point[7, 0]), Line.new(Point[10, 0], Point[15, 0])] }
+
+            it 'subtracts lines' do
               expect(l1.xor(l2)).to eql(xor)
               expect(l1.overlaps?(l3)).to be_falsey
               expect(l2.overlaps?(l3)).to be_falsey