laser-cutter 1.0.5 → 2.0.1

data/lib/laser/cutter/cli.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # Every command the executable answers to.
+    module CLI
+      extend Dry::CLI::Registry
+
+      PROGRAM = 'laser-cutter'
+
+      # Help and boxes are never wider than this, however wide the terminal is.
+      HELP_WIDTH = 90
+
+      # Columns assumed when there is no terminal, or it reports none.
+      DEFAULT_COLUMNS = 80
+
+      # @return [Integer] columns help wraps at, and a box takes: the terminal's less 6,
+      #   capped at HELP_WIDTH
+      def self.help_width(columns = IO.console&.winsize&.last)
+        columns = DEFAULT_COLUMNS unless columns&.positive?
+        [columns - 6, HELP_WIDTH].min
+      end
+
+      Dry::CLI::Help.configure do
+        title "laser-cutter #{Laser::Cutter::VERSION}"
+        description 'Draws the notched panels of a box, ready to cut on a laser cutter, as a PDF or an SVG.'
+        epilogue 'Documentation: https://github.com/kigster/laser-cutter'
+
+        width CLI.help_width
+        exit_code_without_arguments 0
+
+        styles do
+          heading :bold, :cyan, case: :UPPERCASE
+          usage :yellow
+          example :yellow
+          option :green
+          example_comment :bright_black
+        end
+      end
+
+      register 'generate', Generate, aliases: ['g']
+      register 'page-sizes', PageSizes
+      register 'examples', Examples
+      register 'help', Help
+      register 'version', Version, aliases: ['-V', '--version']
+      register 'completion', Completion
+    end
+  end
+end

data/lib/laser/cutter/configuration.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    class Configuration < Hashie::Mash
+      include ::Hashie::Extensions::Mash::SymbolizeKeys
+
+      SIZE_REGEXP = %r{[\d.]+x[\d.]+x[\d.]+/[\d.]+(/[\d.]+)?}
+
+      FLOATS   = %i(width height depth thickness notch margin padding stroke kerf).freeze
+      NON_ZERO = %i(width height depth thickness stroke).freeze
+      REQUIRED = %i(width height depth thickness notch file).freeze
+
+      @mutex = Mutex.new
+
+      class << self
+        attr_accessor :mutex, :defaults
+
+        def compute_defaults!
+          mutex.synchronize do
+            if defined?(@defaults)
+              @defaults
+            else
+              @defaults = compute_metric_units!
+            end
+          end.dup
+        end
+
+        def compute_metric_units!
+          defaults = Hashie::Mash.new({
+                                        units:       :in,
+                                        page_layout: 'portrait',
+                                        lid:         'full',
+                                        metadata:    true,
+                                        in:          {
+                                          kerf:    0.0024, # smallest kerf for thin material, usually it's more than that.
+                                          margin:  0.125,
+                                          padding: 0.1,
+                                          stroke:  0.001,
+                                        }
+                                      })
+
+          defaults[:mm] = defaults[:in].map { |k, v| [k, UnitsConverter.in2mm(v)] }.to_h
+          defaults
+        end
+      end
+
+      compute_defaults!
+
+      def initialize(options = {})
+        ::Hashie::Extensions::SymbolizeKeys.symbolize_keys!(options)
+
+        options.delete_if { |_k, v| v.nil? }
+        options.delete(:lid) if options[:lid].to_s.empty? # a blank form field
+        if options[:units]
+          unit = options[:units].to_sym
+          unless self.class.defaults.key?(unit) || self.class.defaults.key?(unit.to_s)
+            options.delete(:units)
+          end
+        end
+
+        super(self.class.defaults.merge(options))
+
+        if box =~ SIZE_REGEXP
+          dim, self[:thickness], self[:notch]       = self[:box].split('/')
+          self[:width], self[:height], self[:depth] = dim.split('x')
+          delete(:box)
+        end
+        FLOATS.each do |k|
+          self[k] = self[k].to_f if self[k].is_a?(String)
+        end
+        merge!(self.class.defaults[self[:units].to_sym].merge(self))
+        self[:notch] = (self[:thickness] * 3.0).round(5) if self[:thickness] && self[:notch].nil?
+      end
+
+      def validate!
+        missing = []
+        REQUIRED.each { |k| missing << k if self[k].nil? }
+        raise MissingOption, "#{missing.join(', ')} #{missing.size > 1 ? 'are' : 'is'} required, but missing." unless missing.empty?
+
+        zeros = []
+        NON_ZERO.each { |k| zeros << k if self[k] == 0 }
+        raise ZeroValueNotAllowed, "#{zeros.join(', ')} #{zeros.size > 1 ? 'are' : 'is'} required, but is zero." unless zeros.empty?
+
+        return if Box::LIDS.include?(lid.to_s.to_sym)
+
+        raise InvalidOption, "lid is #{lid.to_s.inspect}, but must be one of: #{Box::LIDS.join(', ')}."
+      end
+
+      def change_units(new_units)
+        new_units = new_units.to_sym
+        return if new_units == units.to_sym
+        return unless self.class.defaults.key?(new_units)
+
+        k = units.to_sym == :in ? UnitsConverter.in2mm(1.0) : UnitsConverter.mm2in(1.0)
+
+        FLOATS.each do |field|
+          next if send(field).nil?
+
+          send("#{field}=", (send(field) * k).round(5))
+        end
+
+        self.units = new_units
+      end
+    end
+  end
+end

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

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
       class Dimensions < Tuple
-
         def w
           coords.[](0)
         end
@@ -22,9 +23,7 @@ module Laser
         def hash_keys
           [:w, :h, :d]
         end
-
       end
     end
   end
-
 end

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/invalid_option.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # An option has a value it cannot take.
+    class InvalidOption < Error; 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