laser-cutter 1.0.3 → 2.0.0

data/lib/{laser-cutter → laser/cutter}/box.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     # Note: this class badly needs refactoring and tests.  Both are coming.
@@ -5,18 +7,13 @@ module Laser
     class Box
       # Everything is in millimeters
 
-      attr_accessor :dim, :thickness, :notch_width, :kerf
-      attr_accessor :padding, :units, :inside_box
-
-      attr_accessor :front, :back, :top, :bottom, :left, :right
-      attr_accessor :faces, :bounds, :conf, :corner_face
-      attr_accessor :metadata, :notches
+      attr_accessor :dim, :thickness, :notch_width, :kerf, :padding, :units, :inside_box, :front, :back, :top, :bottom, :left, :right, :faces, :bounds, :conf, :corner_face, :metadata, :notches
 
       def initialize(config = {})
         self.dim = Geometry::Dimensions.new(config['width'], config['height'], config['depth'])
         self.thickness = config['thickness']
 
-        self.notch_width = config['notch'] || (1.0 * self.longest / 5.0)
+        self.notch_width = config['notch'] || (1.0 * longest / 5.0)
         self.kerf = config['kerf'] || 0.0
         self.padding = config['padding']
         self.units = config['units']
@@ -27,28 +24,27 @@ module Laser
         self.metadata = Geometry::Point[config['metadata_width'] || 0, config['metadata_height'] || 0]
 
         create_faces! # generates dimensions for each side
-        self.faces =     [top, front, bottom, back, left, right]
-
-        self.conf   = {
-            valign: [    :out, :out,  :out,   :out, :in, :in],
-            halign: [    :in,  :out,  :in,    :out, :in, :in],
-            corners: {
-                front: [ :no,  :yes,  :no,    :yes, :no, :no], # our default choice, but may not work
-                top:   [ :yes, :no,   :yes,   :no,  :no, :no]  # 2nd choice, has to work if 1st doesn't
-            },
+        self.faces = [top, front, bottom, back, left, right]
+
+        self.conf = {
+          valign:  [:out, :out, :out, :out, :in, :in],
+          halign:  [:in, :out, :in, :out, :in, :in],
+          corners: {
+            front: [:no, :yes, :no, :yes, :no, :no], # our default choice, but may not work
+            top:   [:yes, :no, :yes, :no, :no, :no] # 2nd choice, has to work if 1st doesn't
+          },
         }
-        self
       end
 
       def enclosure
-        generate_notches if self.notches.empty?
+        generate_notches if notches.empty?
         p1 = notches.first.p1.to_a
         p2 = notches.first.p2.to_a
 
         notches.each do |notch|
           n = notch.normalized
-          n.p1.to_a.each_with_index {|c, i| p1[i] = c if c < p1[i] }
-          n.p2.to_a.each_with_index {|c, i| p2[i] = c if c > p2[i] }
+          n.p1.to_a.each_with_index { |c, i| p1[i] = c if c < p1[i] }
+          n.p2.to_a.each_with_index { |c, i| p2[i] = c if c > p2[i] }
         end
 
         Geometry::Rect[Geometry::Point.new(p1), Geometry::Point.new(p2)]
@@ -60,34 +56,31 @@ module Laser
         self.notches = []
         faces.each_with_index do |face, face_index|
           bound = face_bounding_rect(face)
-          side_lines = []
           edges = []
-          bound.sides.each_with_index do |bounding_side, side_index |
-            include_corners = (self.conf[:corners][corner_face][face_index] == :yes && side_index.odd?)
+          bound.sides.each_with_index do |bounding_side, side_index|
+            include_corners = conf[:corners][corner_face][face_index] == :yes && side_index.odd?
             key = side_index.odd? ? :valign : :halign
-            center_out = (self.conf[key][face_index] == :out)
-            edges << Notching::Edge.new(bounding_side, face.sides[side_index],
-                            {:notch_width => notch_width,
-                             :thickness => thickness,
-                             :kerf => kerf,
-                             :center_out => center_out,
-                             :corners => include_corners
-                            })
+            center_out = (conf[key][face_index] == :out)
+            edges << Notching::Edge.new(bounding_side,
+                                        face.sides[side_index],
+                                        { notch_width: notch_width,
+                                          thickness:   thickness,
+                                          kerf:        kerf,
+                                          center_out:  center_out,
+                                          corners:     include_corners })
           end
 
-          if edges.any?{|e| e.corners} && !edges.all?{|e| e.first_notch_out? }
-            edges.each {|e| e.adjust_corners = true }
+          if edges.any?(&:corners) && !edges.all?(&:first_notch_out?)
+            edges.each { |e| e.adjust_corners = true }
           end
 
-          edges.each do |edge|
-            side_lines << Notching::PathGenerator.new(edge).generate
+          side_lines = edges.map do |edge|
+            Notching::PathGenerator.new(edge).generate
           end
 
-          aggregator = Aggregator.new(side_lines.flatten)
-          aggregator.dedup!.deoverlap!.dedup!
-          self.notches << aggregator.lines
+          notches << Aggregator.new(side_lines.flatten).lines
         end
-        self.notches.flatten!
+        notches.flatten!
       end
 
       def w; dim.w; end
@@ -95,7 +88,7 @@ module Laser
       def d; dim.d; end
 
       def longest
-        [w, h, d].max()
+        [w, h, d].max
       end
 
       def to_s
@@ -111,7 +104,7 @@ module Laser
         b.relocate!
       end
 
-      #___________________________________________________________________
+      # ___________________________________________________________________
       #
       #               +-----------------+
       #               |                 |
@@ -131,22 +124,22 @@ module Laser
       #               +-----------------+
       #
       # 0,0
-      #___________________________________________________________________
+      # ___________________________________________________________________
 
       def position_faces!
-        offset_x = [padding + d + 3 * thickness, metadata.x + 2 * thickness + padding].max
-        offset_y = [padding + d + 3 * thickness, metadata.y + 2 * thickness + padding].max
+        offset_x = [padding + d + (3 * thickness), metadata.x + (2 * thickness) + padding].max
+        offset_y = [padding + d + (3 * thickness), metadata.y + (2 * thickness) + padding].max
 
         # X Coordinate
-        left.x  = offset_x - d - 2 * thickness - padding
-        right.x = offset_x + w + 2 * thickness + padding
+        left.x  = offset_x - d - (2 * thickness) - padding
+        right.x = offset_x + w + (2 * thickness) + padding
 
         [bottom, front, top, back].each { |s| s.x = offset_x }
 
         # Y Coordinate
-        top.y    = offset_y - d - 2 * thickness - padding
-        bottom.y = offset_y + h + 2 * thickness + padding
-        back.y   = bottom.y + d + 2 * thickness + padding
+        top.y    = offset_y - d - (2 * thickness) - padding
+        bottom.y = offset_y + h + (2 * thickness) + padding
+        back.y   = bottom.y + d + (2 * thickness) + padding
 
         [left, front, right].each { |s| s.y = offset_y }
 
@@ -171,11 +164,10 @@ module Laser
         b = face_bounding_rect(front)
         edges = []
         front.sides[0..1].each_with_index do |face, index|
-          edges << Notching::Edge.new(b.sides[index], face, :notch_width => notch_width, :kerf => kerf )
+          edges << Notching::Edge.new(b.sides[index], face, notch_width: notch_width, kerf: kerf )
         end
-        edges.map(&:notch_count).all?{|c| c % 4 == 3} ? :top : :front
+        edges.map(&:notch_count).all?{ |c| c % 4 == 3 } ? :top : :front
       end
-
     end
   end
 end

data/lib/laser/cutter/cli/command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      # What every command inherits: the ui helpers, and the flags they all share.
+      class Command < Dry::CLI::Command
+        include Dry::CLI::UI
+
+        # Cells in a progress bar.
+        BAR_WIDTH = 60
+
+        def self.inherited(subclass)
+          super
+          subclass.option :verbose, type: :boolean, default: false, aliases: ['-v'],
+                                    desc: 'Print the configuration, and the full backtrace on failure'
+        end
+
+        # Boxes are as wide as help is.
+        def ui
+          @ui ||= Dry::CLI::UI::Console.new(out: out, err: err, box_width: CLI.help_width)
+        end
+
+        # A green bar of BAR_WIDTH cells, or fewer when the terminal is narrower.
+        #
+        # @param label [String]
+        # @param total [Integer]
+        # @yieldparam bar [#advance]
+        def progress(label, total:, &)
+          Dry::CLI::UI::Console
+            .new(out: out, err: err, box_width: CLI.help_width, width: progress_width(label))
+            .progress(label, total: total, color: :green, &)
+        end
+
+        private
+
+        # dry-cli-ui sizes a bar as the terminal width less the label and the
+        # counters around it, so the bar is capped by capping that width.
+        def progress_width(label)
+          wanted = BAR_WIDTH + label.length + Dry::CLI::UI::Widgets::Progress::CHROME
+          err.respond_to?(:tty?) && err.tty? ? [wanted, TTY::Screen.width].min : wanted
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/completion.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      # Dry::CLI::Autocomplete::Command[] builds an anonymous subclass, which
+      # loses the description and the examples. This one states its own.
+      class Completion < Dry::CLI::Autocomplete::Command
+        @registry = CLI
+        @program_name = PROGRAM
+
+        desc 'Generates auto-complete for BASH or ZSH'
+
+        example [
+          "bash > /usr/local/etc/bash_completion.d/#{PROGRAM}",
+          "zsh  > \"${fpath[1]}/_#{PROGRAM}\""
+        ]
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/config_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      # A configuration saved as JSON. The path '-' stands for STDIN when
+      # reading, and for the command's own output when writing.
+      class ConfigFile
+        STDIO = '-'
+
+        # @param path [String]
+        def initialize(path)
+          @path = path
+        end
+
+        # @return [Hash{String => Object}]
+        # @raise [Error] when the file is missing, or is not JSON
+        def read
+          JSON.parse(@path == STDIO ? $stdin.read : File.read(@path))
+        rescue SystemCallError, JSON::ParserError => e
+          raise Error, "cannot read the configuration from #{@path}: #{e.message}"
+        end
+
+        # @param settings [Hash]
+        # @param out [IO] where '-' writes to
+        # @raise [Error] when the file cannot be written
+        def write(settings, out)
+          json = JSON.pretty_generate(settings)
+          @path == STDIO ? out.puts(json) : File.write(@path, "#{json}\n")
+        rescue SystemCallError => e
+          raise Error, "cannot write the configuration to #{@path}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/examples.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Examples < Command
+        desc 'Show detailed usage examples'
+
+        TEXT = <<~EXAMPLES
+          1. A box in inches, with the kerf set to 0.008", opened once it is written:
+
+               laser-cutter generate -b 3x2x2/0.125 -k 0.008 -O -o box.pdf
+
+          2. A box in millimeters on a landscape A3 page, with a 0.5mm stroke:
+
+               laser-cutter generate -u mm -w 70 -H 20 -d 50 -t 4.3 -n 5 -i A3 -l landscape -s 0.5 -o box.pdf
+
+          3. The same box as an SVG:
+
+               laser-cutter generate -b 3x2x2/0.125 -f svg -o box.svg
+
+          4. Every page size, in millimeters:
+
+               laser-cutter page-sizes -u mm
+
+          5. A box whose settings are saved for later:
+
+               laser-cutter generate -b 1.1x2.5x1.5/0.125/0.125 -p 0.1 -o box.pdf -W box-settings.json
+
+          6. A box from settings saved earlier, from a file or from STDIN:
+
+               laser-cutter generate -o box.pdf -R box-settings.json
+               cat box-settings.json | laser-cutter generate -o box.pdf -R -
+        EXAMPLES
+
+        def call(**)
+          out.puts TEXT
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/generate.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Generate < Command
+        desc 'Draw the panels of a box into a PDF or an SVG file'
+
+        BANNER = "Laser-Cutter (ruby gem) Version #{Laser::Cutter::VERSION}, © 2015-2026 Konstantin Gredeskoul".freeze
+
+        # Columns a box spends on its borders and padding.
+        BOX_CHROME = 6
+
+        # What the opening box reports, in this order.
+        DIMENSIONS = %i[width height depth thickness notch kerf].freeze
+
+        # Options that describe the run rather than the box, kept out of a saved configuration.
+        RUN_ONLY = %i[verbose read write open format args].freeze
+
+        option :box, aliases: ['-b'], desc: 'WxHxD/T[/N]: width, height, depth, thickness and optional notch, in one'
+        option :width, aliases: ['-w'], desc: 'Internal width of the box'
+        option :height, aliases: ['-H'], desc: 'Internal height of the box'
+        option :depth, aliases: ['-d'], desc: 'Internal depth of the box'
+        option :thickness, aliases: ['-t'], desc: 'Thickness of the material'
+        option :notch, aliases: ['-n'], desc: 'Notch length, a guide only (default: three times the thickness)'
+        option :kerf, aliases: ['-k'], desc: 'Kerf, the width of the cut (default: 0.0024in)'
+        option :units, default: 'in', values: %w[in mm], aliases: ['-u'], desc: 'Units every dimension is in'
+
+        option :file, aliases: ['-o'], desc: 'File to write (required)'
+        option :format, default: 'pdf', aliases: ['-f'], desc: 'Output format: pdf or svg, in either case'
+
+        option :margin, aliases: ['-m'], desc: 'Margin from the edge of the page'
+        option :padding, aliases: ['-p'], desc: 'Space between the panels'
+        option :stroke, aliases: ['-s'], desc: 'Stroke width of the lines'
+        option :page_size, aliases: ['-i'], desc: 'Page size, such as LETTER or A3 (default: fit the box; PDF only)'
+        option :page_layout, default: 'portrait', values: %w[portrait landscape], aliases: ['-l'], desc: 'Page layout (PDF only)'
+
+        option :metadata, type: :boolean, default: true, aliases: ['-M'], desc: 'Print the settings of the box on the page'
+        option :inside_box, type: :boolean, default: false, aliases: ['-B'],
+                            desc: 'Also draw the box without kerf, in red, to check the kerf'
+        option :open, type: :boolean, default: false, aliases: ['-O'], desc: 'Open the file once it is written'
+        option :write, aliases: ['-W'], desc: "Save the configuration to a file, or to STDOUT with '-'"
+        option :read, aliases: ['-R'], desc: "Read the configuration from a file, or from STDIN with '-'"
+
+        example [
+          '-b 3x2x2/0.125 -o box.pdf # a box in inches',
+          '-b 3x2x2/0.125 -f svg -o box.svg # as an SVG',
+          '-u mm -w 70 -H 20 -d 50 -t 4.3 -o box.pdf'
+        ]
+
+        def call(format:, verbose:, **options)
+          config = configuration(options)
+          ui.debug('Configuration:', JSON.pretty_generate(config.to_hash)) if verbose
+          config.validate!
+          renderer = Renderer.for(format, config)
+          ui.info(BANNER, dimensions(config), "Format: #{format.upcase}")
+          ConfigFile.new(options[:write]).write(config.to_hash, out) if options[:write]
+
+          progress("Drawing #{File.basename(config.file)}", total: renderer.total) do |bar|
+            renderer.render { bar.advance }
+          end
+
+          report(format, File.expand_path(config.file))
+          system('open', config.file) if options[:open]
+        end
+
+        private
+
+        # A box wraps in the middle of a word, which would break a path nobody
+        # could then copy, so this one widens to fit a path longer than it.
+        def report(format, path)
+          ui.success("Generated #{format.upcase} file:", path, width: [CLI.help_width, path.length + BOX_CHROME].max)
+        end
+
+        # What was read from a file, overridden by what the command line gave.
+        def configuration(options)
+          given = options.except(*RUN_ONLY).compact
+          saved = options[:read] ? ConfigFile.new(options[:read]).read : {}
+          settings = saved.transform_keys(&:to_sym).merge(given)
+          Configuration.new(settings.merge(debug: settings.delete(:inside_box)))
+        end
+
+        # One line per dimension, aligned, in the units of the box.
+        def dimensions(config)
+          DIMENSIONS.map { |name| "#{"#{name.capitalize}:".ljust(11)} #{config[name]} #{config.units}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/help.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Help < Command
+        desc 'Show help, for the program or for one command'
+
+        argument :command, required: false, desc: 'The command to explain'
+
+        example ['', 'generate']
+
+        # Asks dry-cli for the help it prints on --help, which exits by itself.
+        def call(command: nil, **)
+          Dry::CLI.new(CLI).call(arguments: [command, '--help'].compact, out: out, err: err)
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/page_sizes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class PageSizes < Command
+        desc 'List every page size, with its dimensions'
+
+        option :units, default: 'in', values: %w[in mm], aliases: ['-u'], desc: 'Units to print the dimensions in'
+
+        example ['', '--units mm']
+
+        def call(units:, **)
+          out.puts PageManager.new(units).all_page_sizes
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Version < Command
+        desc 'Print the version'
+
+        def call(**)
+          out.puts Laser::Cutter::VERSION
+        end
+      end
+    end
+  end
+end

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,101 @@
+# 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',
+                                        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? }
+        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?
+      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