laser-cutter 1.0.5 → 2.0.0

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

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

@@ -1,22 +1,35 @@
-require_relative 'spec_helper'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module Laser
   module Cutter
-    describe PageManager do
+    RSpec.describe PageManager do
       let(:pm) { Laser::Cutter::PageManager.new(units) }
 
       context 'a single value' do
         context 'to inches' do
           let(:units) { 'in' }
-          it 'should be correct' do
-            expect(pm.value_from_units(150)).to be_within(0.0001).of(150.0/72.0)
-            expect(pm.value_from_units(150, 'mm')).to be_within(0.0001).of(150.0/25.4)
+
+          it 'is correct' do
+            expect(pm.value_from_units(150)).to be_within(0.0001).of(150.0 / 72.0)
+            expect(pm.value_from_units(150, 'mm')).to be_within(0.0001).of(150.0 / 25.4)
             expect(pm.value_from_units(150, 'in')).to be_within(0.0001).of(150.0)
           end
         end
+
+        context 'when units are a Symbol, as the configuration defaults them' do
+          let(:units) { :in }
+
+          it 'reads them as inches' do
+            expect(pm.value_from_units(72)).to be_within(0.0001).of(1.0)
+          end
+        end
+
         context 'to mm' do
           let(:units) { 'mm' }
-          it 'should be correct' do
+
+          it 'is correct' do
             expect(pm.value_from_units(150)).to be_within(0.0001).of(25.4 * 150.0 / 72.0)
             expect(pm.value_from_units(150, 'in')).to be_within(0.0001).of(150.0 * 25.4)
             expect(pm.value_from_units(150, 'mm')).to be_within(0.0001).of(150.0)
@@ -24,18 +37,21 @@ module Laser
         end
       end
 
-      context '#list_page_sizes' do
+      describe '#list_page_sizes' do
         context 'formatting of output' do
           context 'when using inches' do
             let(:units) { "in" }
-            it 'should return the list in inches' do
-              expect(pm.all_page_sizes).to match %r(.*B10\:\s+1\.2\s+x\s+1\.7)
+
+            it 'returns the list in inches' do
+              expect(pm.all_page_sizes).to match /.*B10:\s+1\.2\s+x\s+1\.7/
             end
           end
+
           context 'when using mm' do
             let(:units) { "mm" }
-            it 'should return the list in mm' do
-              expect(pm.all_page_sizes).to match %r(.*B10\:\s+31\.0\s+x\s+44\.0)
+
+            it 'returns the list in mm' do
+              expect(pm.all_page_sizes).to match /.*B10:\s+31\.0\s+x\s+44\.0/
             end
           end
         end

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

@@ -1,18 +1,22 @@
-require_relative 'spec_helper'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module Laser
   module Cutter
     module Notching
-      describe PathGenerator do
+      RSpec.describe PathGenerator do
         let(:notch) { 2 }
         let(:thickness) { 1 }
         let(:center_out) { true }
         let(:corners) { true }
 
-        let(:options) { {notch_width: notch,
-                         thickness: thickness,
-                         center_out: center_out,
-                         corners: corners} }
+        let(:options) {
+          { notch_width: notch,
+            thickness:   thickness,
+            center_out:  center_out,
+            corners:     corners }
+        }
 
         let(:outside) { Geometry::Line.new(from: [0, 0], to: [10, 0]) }
         let(:inside)  { Geometry::Line.new(from: [1, 1], to: [9,  1]) }
@@ -20,14 +24,16 @@ module Laser
         let(:generator) { PathGenerator.new(edge) }
 
         context 'edge' do
-          it 'should properly calculate notch size' do
+          it 'properlies calculate notch size' do
             expect(edge.notch_width).to be_within(0.001).of(1.6)
           end
+
           context 'edge cases with the edge :)' do
             let(:notch) { 15 } # too big
-            it 'should properly handle edge cases' do
+
+            it 'properlies handle edge cases' do
               # 3 is the minimum number of notches we support per side
-              expect(edge.notch_width).to be_within(0.001).of(8.0/3.0)
+              expect(edge.notch_width).to be_within(0.001).of(8.0 / 3.0)
             end
           end
         end
@@ -35,7 +41,8 @@ module Laser
         context 'alternating iterator' do
           let(:a) { "hello" }
           let(:b) { "again" }
-          let(:iterator) { InfiniteIterator.new([a,b]) }
+          let(:iterator) { InfiniteIterator.new([a, b]) }
+
           it 'returns things in alternating order' do
             expect(iterator.next).to eq(a)
             expect(iterator.next).to eq(b)
@@ -44,7 +51,6 @@ module Laser
         end
 
         context 'shift definition' do
-
           it 'correctly defines shifts' do
             shifts = generator.send(:define_shifts)
             expect(edge.outside.length).to eql(10.0)
@@ -55,7 +61,6 @@ module Laser
           end
         end
 
-
         context 'path generation' do
           # let(:outside) { Line.new(
           #     from: inside.p1.plus(-thickness, -thickness),
@@ -63,7 +68,7 @@ module Laser
 
           context 'center out' do
             it 'generates correct path vertices' do
-              expect(inside.p1).to_not eql(inside.p2)
+              expect(inside.p1).not_to eql(inside.p2)
               lines = generator.generate
               expect(lines.size).to be > 5
 
@@ -81,7 +86,6 @@ module Laser
             end
           end
         end
-
       end
     end
   end

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

@@ -1,25 +1,28 @@
-require_relative 'spec_helper'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module Laser
   module Cutter
     module Geometry
-      describe Point do
+      RSpec.describe Point do
         let(:p1) { Point.new(1, 2) }
+
         context 'creation' do
           context 'from string' do
-            it 'should instantiate correctly' do
-              expect(Point.new "1,2").to eql(p1)
+            it 'instantiates correctly' do
+              expect(Point.new("1,2")).to eql(p1)
             end
           end
 
           context 'from a point' do
-            it 'should instantiate correctly' do
+            it 'instantiates correctly' do
               expect(Point.new(Point.new("1,2"))).to eql(p1)
             end
           end
 
           context 'from an array' do
-            it 'should properly duplicate underlying coordinates and not bug out' do
+            it 'properlies duplicate underlying coordinates and not bug out' do
               a = [1, 2]
               p2 = Point.new(a)
               expect(p2).to eql(p1)
@@ -28,25 +31,26 @@ module Laser
               expect(p2).to eql(p1)
             end
 
-            it 'should create point from class method' do
-              expect(Point[1,2]).to eql(p1)
+            it 'creates point from class method' do
+              expect(Point[1, 2]).to eql(p1)
             end
           end
 
           context 'from a hash' do
-            it 'should instantiate correctly' do
+            it 'instantiates correctly' do
               expect(Point.new(x: 1, y: 2)).to eql(p1)
             end
           end
         end
 
         context 'move by' do
-          it 'should move properly' do
+          it 'moves properly' do
             p = p1.plus(10, -2)
             expect(p.x).to be_within(0.001).of(11)
             expect(p.y).to be_within(0.001).of(0)
           end
-          it 'should move cloned version properly' do
+
+          it 'moves cloned version properly' do
             p2 = p1.clone.plus(10, -2)
             expect(p2.x).to be_within(0.001).of(11)
             expect(p2.y).to be_within(0.001).of(0)
@@ -54,20 +58,21 @@ module Laser
         end
 
         context 'ordering and equality' do
-          let(:p1) { Point[0,0]}
-          let(:p2) { Point[10,0]}
-          let(:p3) { Point[0,10]}
-          let(:p4) { Point[10,10]}
-          let(:p5) { Point[-1,-1]}
-          it 'should propertly sort' do
-            expect([p3,p2,p1,p4,p5].sort).to eql([p5,p1,p3,p2,p4])
+          let(:p1) { Point[0, 0] }
+          let(:p2) { Point[10, 0] }
+          let(:p3) { Point[0, 10] }
+          let(:p4) { Point[10, 10] }
+          let(:p5) { Point[-1, -1] }
+
+          it 'propertlies sort' do
+            expect([p3, p2, p1, p4, p5].sort).to eql([p5, p1, p3, p2, p4])
           end
-          it 'should detect equality' do
-            expect(p1).to_not eql(p2)
-            expect(p2).to eql(Point[10,0])
+
+          it 'detects equality' do
+            expect(p1).not_to eql(p2)
+            expect(p2).to eql(Point[10, 0])
           end
         end
-
       end
     end
   end

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

@@ -1,10 +1,12 @@
-require_relative 'spec_helper'
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module Laser
   module Cutter
     module Geometry
-      describe Rect do
-        let(:p1) { Point[ 1.0,  3.0] }
+      RSpec.describe Rect do
+        let(:p1) { Point[1.0, 3.0] }
         let(:p2) { Point[11.0, 23.0] }
 
         let(:rect1) { Rect.new(p1, p2) }
@@ -22,14 +24,16 @@ module Laser
             expect(rect1.position).to eql(rect1.vertices[0])
             expect(rect1.p2).to eql(rect1.vertices[2])
           end
-          it 'it generates four side lines' do
+
+          it 'generates four side lines' do
             expect(rect1.sides.size).to eql(4)
-            expect(rect1.sides.first).to be_kind_of(Line)
+            expect(rect1.sides.first).to be_a(Line)
             expect(rect1.sides.first.p1).to eql(p1)
             expect(rect1.sides[0].p1.to_s).to eql("{1.00000,3.00000}")
             expect(rect1.sides[1].p1.to_s).to eql("{11.00000,3.00000}")
             expect(rect1.sides[2].p1).to eql(p1.plus(10, 20))
           end
+
           it 'can be moved' do
             expect(rect1.sides[0].p1.to_s).to eql("{1.00000,3.00000}")
             rect1.x = 1000

data/spec/laser/cutter/renderer/layout_renderer_spec.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Laser
+  module Cutter
+    module Renderer
+      RSpec.describe LayoutRenderer do
+        describe '#render' do
+          let(:renderer) { LayoutRenderer.new(config) }
+          let(:file) { File.expand_path("../../../laser-cutter-pdf-test.#{$$}.pdf", __FILE__) }
+
+          def render_file(filename)
+            real_file = ENV['RSPEC_SAVE_PDF'] ? true : false
+            config.validate!
+            expect(!File.exist?(filename)) if real_file
+            renderer.render
+            expect(File.exist?(filename)) if real_file
+            expect(File.size(filename) > 0) if real_file
+          rescue Exception => e
+            warn e.backtrace.join("\n")
+            fail e.message
+          ensure
+            if real_file
+              begin
+                File.delete(filename)
+              rescue StandardError
+                nil
+              end
+              expect(!File.exist?(filename))
+            end
+          end
+
+          before do
+            unless ENV['RSPEC_SAVE_PDF']
+              expect_any_instance_of(Prawn::Document).to receive(:render_file).once
+            end
+          end
+
+          context 'metric' do
+            let(:config) {
+              Laser::Cutter::Configuration.new(
+                'width'     => 50,
+                'height'    => 60,
+                'depth'     => 20,
+                'thickness' => 6,
+                'margin'    => 5,
+                'padding'   => 3,
+                'notch'     => 10,
+                'file'      => file
+              )
+            }
+
+            it 'is able to generate a PDF file' do
+              render_file file
+            end
+          end
+
+          context 'imperial' do
+            context 'margins and padding provided' do
+              let(:config) {
+                Laser::Cutter::Configuration.new(
+                  'width'     => 2.5,
+                  'height'    => 3.5,
+                  'depth'     => 2.0,
+                  'thickness' => 0.125,
+                  'margin'    => 0,
+                  'padding'   => 0.125,
+                  'notch'     => 0.25,
+                  'file'      => file,
+                  'units'     => 'in'
+                )
+              }
+
+              it 'is able to generate a PDF file' do
+                render_file file
+              end
+            end
+
+            context 'margins and padding are defaults' do
+              let(:config) {
+                Laser::Cutter::Configuration.new(
+                  'width'     => 2.5,
+                  'height'    => 2,
+                  'depth'     => 2.0,
+                  'thickness' => 0.125,
+                  'notch'     => 0.25,
+                  'file'      => file,
+                  'units'     => 'in'
+                )
+              }
+
+              it 'is able to generate a PDF file' do
+                render_file file
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/laser/cutter/renderer/svg_renderer_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+RSpec.describe Laser::Cutter::Renderer::SvgRenderer do
+  subject(:renderer) { described_class.new(config) }
+
+  let(:dir) { Dir.mktmpdir }
+  let(:file) { File.join(dir, 'box.svg') }
+  let(:settings) { { box: '4x3x2/0.125/0.5', file: file } }
+  let(:config) { Laser::Cutter::Configuration.new(settings) }
+  let(:svg) { File.read(file) }
+
+  after { FileUtils.remove_entry(dir) }
+
+  its(:total) { is_expected.to eq(328) }
+
+  it 'draws every line, yielding each' do
+    yielded = 0
+    renderer.render { yielded += 1 }
+    expect(yielded).to eq(328)
+    expect(svg.scan('<line').size).to eq(328)
+  end
+
+  it 'sizes the page in the units of the box' do
+    renderer.render
+    expect(svg).to include('width="9.2012in" height="11.5512in"')
+  end
+
+  # Kerf moves the outline out by half its width, into the margin.
+  it 'keeps every line on the page' do
+    renderer.render
+    coordinates = svg.scan(/[xy][12]="([\d.-]+)"/).flatten.map(&:to_f)
+    expect(coordinates.min).to be_within(0.002).of(0.125)
+    expect(coordinates.max).to be_within(0.002).of(11.5512 - 0.125)
+  end
+
+  it 'describes the box' do
+    renderer.render
+    expect(svg).to match(/<desc>\s*Made with laser-cutter.*thickness: 0\.125/)
+  end
+
+  context 'without metadata' do
+    let(:settings) { super().merge(metadata: false) }
+
+    it 'leaves the description out' do
+      renderer.render
+      expect(svg).not_to include('<desc>')
+    end
+  end
+end

data/spec/laser/cutter/renderer_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe Laser::Cutter::Renderer do
+  let(:config) { Laser::Cutter::Configuration.new(box: '4x3x2/0.125', file: 'box') }
+
+  describe '.for' do
+    it 'writes a PDF with the layout renderer' do
+      expect(described_class.for('PDF', config)).to be_a(described_class::LayoutRenderer)
+    end
+
+    it 'writes an SVG with the SVG renderer' do
+      expect(described_class.for(:svg, config)).to be_a(described_class::SvgRenderer)
+    end
+
+    it 'raises on a format it does not write' do
+      expect { described_class.for('dxf', config) }.to raise_error(Laser::Cutter::Error, /unknown format/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,28 +1,41 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+# frozen_string_literal: true
 
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __FILE__)
-require 'rubygems'
-require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
-require 'simplecov'
-SimpleCov.start
-require 'laser-cutter'
+# SimpleCov must start before the gem's own code loads, or that code counts as
+# never run. The badge lands in docs/badges/coverage_badge.svg for the README.
+require "simplecov"
+require "coverage/badge"
+require "fileutils"
 
+SimpleCov.start do
+  # SimpleCov 1.x gives project-relative paths without a leading slash; 0.22 kept it.
+  skip %r{\A/?(spec|test)/}
+  minimum_coverage 95
+  formatter SimpleCov::Formatter::MultiFormatter.new(
+    [SimpleCov::Formatter::HTMLFormatter, Coverage::Badge::Formatter]
+  )
+end
 
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 
-RSpec.configure do |config|
-  #config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = 'random'
+SimpleCov.at_exit do
+  SimpleCov.result.format!
+  puts "Coverage: #{SimpleCov.result.covered_percent.round(2)}%" # rubocop:disable RSpec/Output
+  FileUtils.mkdir_p("docs/badges")
+  FileUtils.mv("coverage/badge.svg", "docs/badges/coverage_badge.svg")
 end
 
+require "rspec/its"
+require "laser/cutter"
+
+Dir[File.expand_path("support/**/*.rb", __dir__)].each { |file| require file }
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.disable_monkey_patching!
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/support/aruba.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "aruba/rspec"
+
+# In-process: the suite builds a Launcher per example instead of forking, so
+# the CLI's own code counts towards coverage.
+Aruba.configure do |config|
+  config.command_launcher = :in_process
+  config.main_class = Laser::Cutter::Launcher
+end