laser-cutter 1.0.3 → 2.0.0

data/lib/{laser-cutter/geometry/shape → laser/cutter/geometry}/line.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
       class Line < Shape
-
-        def self.[] *array
-          self.new *array
+        def self.[](*array)
+          new(*array)
         end
 
         attr_accessor :p1, :p2
@@ -19,31 +20,33 @@ module Laser
             self.p2 = point2.clone
           end
           self.position = p1.clone
-          raise 'Both points are required for line definition' unless (p1 && p2)
+          raise 'Both points are required for line definition' unless p1 && p2
         end
 
         def overlaps?(another)
           xs, ys = sorted_coords(another)
-          return false unless xs.all?{|x| x == xs[0] } || ys.all?{|y| y == ys[0] }
+          return false unless xs.all?{ |x| x == xs[0] } || ys.all?{ |y| y == ys[0] }
           return false if xs.first[1] < xs.last[0] || xs.first[0] > xs.last[1]
           return false if ys.first[1] < ys.last[0] || ys.first[0] > ys.last[1]
+
           true
         end
 
         def sorted_coords(another)
           xs = [[p1.x, p2.x].sort, [another.p1.x, another.p2.x].sort]
           ys = [[p1.y, p2.y].sort, [another.p1.y, another.p2.y].sort]
-          return xs, ys
+          [xs, ys]
         end
 
         def xor(another)
           return nil unless overlaps?(another)
+
           xs, ys = sorted_coords(another)
           xs.flatten!.sort!
           ys.flatten!.sort!
 
-          [ Line.new(Point[xs[0], ys[0]], Point[xs[1], ys[1]]),
-            Line.new(Point[xs[2], ys[2]], Point[xs[3], ys[3]])]
+          [Line.new(Point[xs[0], ys[0]], Point[xs[1], ys[1]]),
+           Line.new(Point[xs[2], ys[2]], Point[xs[3], ys[3]])]
         end
 
         def relocate!
@@ -60,16 +63,16 @@ module Laser
         end
 
         def length
-          Math.sqrt((p2.x - p1.x)**2 + (p2.y - p1.y)**2)
+          Math.sqrt(((p2.x - p1.x)**2) + ((p2.y - p1.y)**2))
         end
 
         def to_s
-          "#{self.class.name.gsub(/.*::/,'').downcase} #{p1}=>#{p2}"
+          "#{self.class.name.gsub(/.*::/, '').downcase} #{p1}=>#{p2}"
         end
 
         def eql?(other)
           (other.p1.eql?(p1) && other.p2.eql?(p2)) ||
-          (other.p2.eql?(p1) && other.p1.eql?(p2))
+            (other.p2.eql?(p1) && other.p1.eql?(p2))
         end
 
         def normalized
@@ -77,17 +80,17 @@ module Laser
         end
 
         def <=>(other)
-          n1 = self.normalized
+          n1 = normalized
           n2 = other.normalized
           n1.p1.eql?(n2.p1) ? n1.p2 <=> n2.p2 : n1.p1 <=> n2.p1
         end
 
-        def < (other)
-          self.p1 == other.p1 ? self.p2 < other.p2 : self.p1 < other.p1
+        def <(other)
+          p1 == other.p1 ? p2 < other.p2 : p1 < other.p1
         end
 
-        def > (other)
-          self.p1 == other.p1 ? self.p2 > other.p2 : self.p1 > other.p1
+        def >(other)
+          p1 == other.p1 ? p2 > other.p2 : p1 > other.p1
         end
 
         def hash
@@ -97,9 +100,7 @@ module Laser
         def clone
           self.class.new(p1, p2)
         end
-
       end
-
     end
   end
 end

data/lib/{laser-cutter → laser/cutter}/geometry/point.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
       class Point < Tuple
-        def self.[] *array
-          Point.new *array
+        def self.[](*array)
+          Point.new(*array)
         end
       end
     end

data/lib/{laser-cutter/geometry/shape → laser/cutter/geometry}/rect.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
       class Rect < Line
-
         attr_accessor :sides, :vertices
 
-        def self.[] p1, p2
+        def self.[](p1, p2)
           Rect.new(p1, p2)
         end
 
@@ -19,8 +20,8 @@ module Laser
           Rect.new(line.p1, line.p2)
         end
 
-        def initialize(*args)
-          super(*args)
+        def initialize(*)
+          super
           relocate!
         end
 
@@ -47,15 +48,13 @@ module Laser
         end
 
         def to_s
-          "#{sprintf "%3d", w}(w)x#{sprintf "%3d", h}(h) @ #{position.to_s}"
+          "#{sprintf '%3d', w}(w)x#{sprintf '%3d', h}(h) @ #{position}"
         end
 
         def to_a
           [[p1.x, p1.y], [p2.x, p2.y]]
         end
       end
-
     end
-
   end
 end

data/lib/{laser-cutter → laser/cutter}/geometry/shape.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
@@ -8,27 +10,28 @@ module Laser
           @position ||= Point.new(0, 0)
         end
 
-        def x= value
+        def x=(value)
           position.x = value
         end
+
         def x
           position.x
         end
 
-        def y= value
+        def y=(value)
           position.y = value
         end
+
         def y
           position.y
         end
 
-        def move_to new_point
+        def move_to(new_point)
           self.position = new_point
           relocate!
           self
         end
 
-
         # Implement in each shape to move to the new pointd
         def relocate!
           raise 'Abstract method'
@@ -37,6 +40,3 @@ module Laser
     end
   end
 end
-
-require_relative 'shape/line'
-require_relative 'shape/rect'

data/lib/{laser-cutter → laser/cutter}/geometry/tuple.rb

@@ -1,60 +1,63 @@
-require 'matrix'
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
       class Tuple
         attr_accessor :coords
+
         PRECISION = 0.000001
 
         def initialize(*args)
           x = args.first
-          coordinates = if x.is_a?(String)
-            parse_string(x)
-          elsif x.is_a?(Hash)
-            parse_hash(x)
-          elsif x.is_a?(Array)
-            x.clone
-          elsif x.is_a?(Tuple) or x.is_a?(Vector)
-            x.to_a
-          else
-            args.clone
-          end
+          coordinates = case x
+                        when String
+                          parse_string(x)
+                        when Hash
+                          parse_hash(x)
+                        when Array
+                          x.clone
+                        when Tuple, Vector
+                          x.to_a
+                        else
+                          args.clone
+                        end
           coordinates.map!(&:to_f)
           self.coords = Vector.[](*coordinates)
         end
 
-        def + x, y = nil
+        def +(x, y = nil)
           shift = if x.is_a?(Vector)
                     x
                   elsif x.is_a?(Tuple)
                     x.coords
                   elsif y
-                    Vector.[](x,y)
+                    Vector.[](x, y)
                   end
-          self.class.new(self.coords + shift)
+          self.class.new(coords + shift)
         end
 
-
         alias_method :plus, :+
 
         def to_a
-          self.coords.to_a
+          coords.to_a
         end
 
         def to_s
-          "{#{coords.to_a.map { |a| sprintf("%.5f", a) }.join(separator)}}"
+          "{#{coords.to_a.map { |a| sprintf('%.5f', a) }.join(separator)}}"
         end
 
         def valid?
-          raise "Have nil value: #{self.inspect}" if coords.to_a.any? { |c| c.nil? }
+          raise "Have nil value: #{inspect}" if coords.to_a.any?(&:nil?)
+
           true
         end
 
-        def x= value
+        def x=(value)
           self.coords = Vector.[](value, coords.[](1))
         end
 
-        def y= value
+        def y=(value)
           self.coords = Vector.[](coords.[](0), value)
         end
 
@@ -70,11 +73,10 @@ module Laser
           ','
         end
 
-        def [] value
+        def [](value)
           coords.[](value)
         end
 
-
         # Override in subclasses, eg:
         # def separator
         #   ';'
@@ -90,8 +92,9 @@ module Laser
         # Identity, cloning and sorting/ordering
         def eql?(other)
           return false unless other.respond_to?(:coords)
+
           equal = true
-          self.coords.each_with_index do |c, i|
+          coords.each_with_index do |c, i|
             if (c - other.coords.to_a[i])**2 > PRECISION
               equal = false
               break
@@ -99,18 +102,22 @@ module Laser
           end
           equal
         end
+
         def <=>(other)
-          self.x == other.x ? self.y <=> other.y : self.x <=> other.x
+          x == other.x ? y <=> other.y : x <=> other.x
         end
-        def < (other)
-          self.x == other.x ? self.y < other.y : self.x < other.x
+
+        def <(other)
+          x == other.x ? y < other.y : x < other.x
         end
-        def > (other)
-          self.x == other.x ? self.y > other.y : self.x > other.x
+
+        def >(other)
+          x == other.x ? y > other.y : x > other.x
         end
+
         def clone
           clone = super
-          clone.coords = self.coords.clone
+          clone.coords = coords.clone
           clone
         end
 
@@ -118,18 +125,15 @@ module Laser
 
         #
         # Convert from, eg "100,50" to [100.0, 50.0],
-        def parse_string string
+        def parse_string(string)
           string.split(separator).map(&:to_f)
         end
 
         # Return array of coordinates
-        def parse_hash hash
-          hash_keys.map{ |k,v| hash[k] }
+        def parse_hash(hash)
+          hash_keys.map{ |k, _v| hash[k] }
         end
-
       end
-
-
     end
   end
 end

data/lib/laser/cutter/launcher.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # Starts the CLI. The executable and the Aruba suite both build one, each
+    # with its own argv and streams, and it exits only through kernel.exit.
+    class Launcher
+      def initialize(argv, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = Kernel)
+        @argv = argv
+        @stdin = stdin
+        @stdout = stdout
+        @stderr = stderr
+        @kernel = kernel
+      end
+
+      def execute!
+        @kernel.exit(run)
+      end
+
+      private
+
+      # dry-cli exits by itself after help or a usage error; its status is kept.
+      def run
+        Dry::CLI.new(CLI).call(arguments: @argv, out: @stdout, err: @stderr)
+        0
+      rescue SystemExit => e
+        e.status
+      rescue StandardError => e
+        ui.error(e.message)
+        @stderr.puts(e.backtrace) if @argv.intersect?(%w[-v --verbose])
+        1
+      end
+
+      # The same boxes the commands draw, on this run's own streams.
+      def ui
+        Dry::CLI::UI::Console.new(out: @stdout, err: @stderr, box_width: CLI.help_width)
+      end
+    end
+  end
+end

data/lib/laser/cutter/missing_option.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    class MissingOption < Error; end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Notching
+      class Base
+        attr_accessor :edge
+
+        def initialize(edge)
+          @edge = edge
+        end
+
+        def notches
+          raise 'Abstract method'
+        end
+      end
+    end
+  end
+end

data/lib/{laser-cutter → laser/cutter}/notching/edge.rb

@@ -1,29 +1,27 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Notching
       MINIMUM_NOTCHES_PER_SIDE = 3
+      # Decimal places kept of length / notch width before counting notches.
+      RATIO_DIGITS = 6
       # This class represents a single edge of one side: both inside
       # and outside edge of the material.  It's also responsible
       # for calculating the "perfect" notch width.
       class Edge
-
-        attr_accessor :outside, :inside
-        attr_accessor :notch_width
-        attr_accessor :thickness, :kerf
-        attr_accessor :center_out, :corners, :adjust_corners
-        attr_accessor :notch_count, :v1, :v2
-
+        attr_accessor :outside, :inside, :notch_width, :thickness, :kerf, :center_out, :corners, :adjust_corners, :notch_count, :v1, :v2
 
         def initialize(outside, inside, options = {})
           self.outside = outside.clone
           self.inside = inside.clone
 
           # two vectors representing directions going from beginning of each inside line to the outside
-          self.v1 = [inside.p1.x - outside.p1.x, inside.p1.y - outside.p1.y].map{|e| -(e / e.abs).to_f }
-          self.v2 = [inside.p2.x - outside.p2.x, inside.p2.y - outside.p2.y].map{|e| -(e / e.abs).to_f }
+          self.v1 = [inside.p1.x - outside.p1.x, inside.p1.y - outside.p1.y].map{ |e| -(e / e.abs).to_f }
+          self.v2 = [inside.p2.x - outside.p2.x, inside.p2.y - outside.p2.y].map{ |e| -(e / e.abs).to_f }
 
-          self.v1 = Vector.[](*self.v1)
-          self.v2 = Vector.[](*self.v2)
+          self.v1 = Vector.[](*v1)
+          self.v2 = Vector.[](*v2)
 
           self.center_out = options[:center_out] || false
           self.thickness = options[:thickness]
@@ -37,13 +35,13 @@ module Laser
         end
 
         def adjust_for_kerf!
-          if kerf?
-            self.inside  = move_line_for_kerf(inside)
-            self.outside = move_line_for_kerf(outside)
-          end
+          return unless kerf?
+
+          self.inside  = move_line_for_kerf(inside)
+          self.outside = move_line_for_kerf(outside)
         end
 
-        def move_line_for_kerf line
+        def move_line_for_kerf(line)
           k = kerf / 2.0
           p1 = line.p1.plus(v1 * k)
           p2 = line.p2.plus(v2 * k)
@@ -51,7 +49,7 @@ module Laser
         end
 
         def kerf?
-          self.kerf > 0.0
+          kerf > 0.0
         end
 
         # face_setting determines if we want that face to have center notch
@@ -65,17 +63,20 @@ module Laser
         def first_notch_out?
           add_across_line?(center_out)
         end
+
         private
 
         def calculate_notch_width!
-          length = kerf? ? self.inside.length - kerf : self.inside.length
-          count = (length / notch_width).to_f.ceil + 1
+          length = kerf? ? inside.length - kerf : inside.length
+          # Rounded before #ceil: when the notch divides the side exactly,
+          # float noise in the coordinates would otherwise decide the count,
+          # and the two panels meeting at this joint would disagree.
+          count = (length / notch_width).to_f.round(RATIO_DIGITS).ceil + 1
           count = (count / 2 * 2) + 1 # make count always an odd number
           count = [MINIMUM_NOTCHES_PER_SIDE, count].max
           self.notch_width = 1.0 * length / count
           self.notch_count = count
         end
-
       end
     end
   end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Notching
+      # Alternating iterator
+      InfiniteIterator = Struct.new(:array) do
+        attr_accessor :array, :next_index, :calls
+
+        def initialize(array)
+          self.array = array
+          self.calls = 0
+          self.next_index = 0
+        end
+
+        def next
+          item = array[next_index].clone
+          self.next_index += 1
+          self.next_index %= array.size
+          self.calls += 1
+          item = yield item, calls if block_given?
+          item
+        end
+      end
+    end
+  end
+end