labrat 0.1.13

data/lib/labrat/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Labrat
+  class OptionError < StandardError; end
+
+  class DimensionError < StandardError; end
+
+  class LabelNameError < StandardError; end
+
+  class EmptyLabelError < StandardError; end
+
+  class RecursionError < StandardError; end
+end

data/lib/labrat/hash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+class Hash
+  # Transform hash keys to symbols suitable for calling as methods, i.e.,
+  # translate any hyphens to underscores.  This is the form we want to keep
+  # config hashes in Labrat.
+  def methodize
+    transform_keys { |k| k.to_s.gsub('-', '_').to_sym }
+  end
+
+  # Convert the given Hash into a Array of Strings that represent an
+  # equivalent set of command-line args and pass them into the #parse method.
+  def optionize
+    options = []
+    each_pair do |k, v|
+      key = k.to_s.gsub('_', '-')
+      options <<
+        if [TrueClass, FalseClass].include?(v.class)
+          v ? "--#{key}" : "--no-#{key}"
+        else
+          "--#{key}=#{v}"
+        end
+    end
+    options
+  end
+
+  def report(title)
+    warn "#{title}:"
+    if empty?
+      warn "  [[Empty]]"
+    else
+      each do |k, v|
+        val = v.class == Float ? v.round(2).to_s + 'pt' : v
+        warn "  #{k}: #{val}"
+      end
+    end
+    warn ""
+  end
+end

data/lib/labrat/label.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Labrat
+  class Label
+    attr_reader :ops
+    attr_accessor :texts
+
+    def initialize(texts, ops)
+      @ops = ops
+      unless @ops.nl_sep.nil? || @ops.nl_sep == ''
+        @texts = texts.map { |t| t.gsub(ops.nl_sep, "\n") }
+      end
+      if @ops.copies > 1
+        duped_texts = []
+        @texts.each { |t| @ops.copies.times { duped_texts << t } }
+        @texts = duped_texts
+      end
+    end
+
+    def generate
+      # The default margin is 0.5in on all sides, way too big for labels, so
+      # it is important to set these here.  The margins' designation as "top,"
+      # "left," "bottom," and "right" take into account the page layout.  That
+      # is, the left margin is on the left in both portrait and landscape
+      # orientations.  But I want the user to be able to set the margins
+      # according to the label type, independent of the orientation.  I adopt
+      # the convention that the margins are named assuming a portrait
+      # orientation and swap them here so that when Prawn swaps them again,
+      # they come out correct.
+      layout = ops.landscape ? :landscape : :portrait
+      if layout == :portrait
+        tpm = ops.top_page_margin
+        bpm = ops.bottom_page_margin
+        lpm = ops.left_page_margin
+        rpm = ops.right_page_margin
+      else
+        lpm = ops.top_page_margin
+        rpm = ops.bottom_page_margin
+        tpm = ops.left_page_margin
+        bpm = ops.right_page_margin
+      end
+      out_file = File.expand_path(ops.out_file)
+      Prawn::Document.generate(out_file, page_size: [ops.page_width, ops.page_height],
+                               left_margin: lpm, right_margin: rpm,
+                               top_margin: tpm, bottom_margin: bpm,
+                               page_layout: layout) do |pdf|
+        # Define a grid with each grid box to be used for a single label.
+        pdf.define_grid(rows: ops.rows, columns: ops.columns,
+                        row_gutter: ops.row_gap, column_gutter: ops.column_gap)
+        if ops.verbose
+          warn "Page dimensions:"
+          warn "  [pg_wd, pg_ht] = [#{ops.page_width.round(2)}pt,#{ops.page_height.round(2)}pt]"
+          warn "  orientation: #{layout}"
+          warn "  [rows, columns] = [#{ops.rows},#{ops.columns}]"
+          warn "  [lpm, rpm] = [#{lpm.round(2)}pt,#{rpm.round(2)}pt]"
+          warn "  [tpm, bpm] = [#{tpm.round(2)}pt,#{bpm.round(2)}pt]"
+          warn ""
+        end
+        if ops.template
+          # Replace any texts with the numbers and show the grid.
+          self.texts = (1..(ops.rows * ops.columns)).map(&:to_s)
+          ops.font_name = 'Helvetica'
+          ops.font_style = 'bold'
+          ops.font_size = 16
+          pdf.grid.show_all
+        end
+        raise EmptyLabelError, "Empty label" if waste_of_labels?
+
+        last_k = texts.size - 1
+        lab_dims_reported = false
+        texts.each_with_index do |text, k|
+          row, col = row_col(k + 1)
+          pdf.grid(row, col).bounding_box do
+            bounds = pdf.bounds
+            pdf.stroke_bounds if ops.grid
+            box_wd = (bounds.right - bounds.left) - ops.left_pad - ops.right_pad
+            box_ht = (bounds.top - bounds.bottom) - ops.top_pad - ops.bottom_pad
+            box_x = ops.left_pad + ops.delta_x
+            box_y = ops.bottom_pad + box_ht + ops.delta_y
+            pdf.font ops.font_name, style: ops.font_style, size: ops.font_size.to_f
+            pdf.text_box(text, width: box_wd, height: box_ht,
+                         align: ops.h_align, valign: ops.v_align,
+                         overflow: :truncate, at: [box_x, box_y])
+            if ops.verbose && !lab_dims_reported
+              warn "Label text box dimensions:"
+              warn "  [box_wd, box_ht] = [#{box_wd.round(2)}pt,#{box_ht.round(2)}pt]"
+              warn "  [box_x, box_y] = [#{box_x.round(2)}pt,#{box_y.round(2)}pt]"
+              warn "  [delta_x, delta_y] = [#{ops.delta_x.round(2)}pt,#{ops.delta_y.round(2)}pt]"
+              warn ''
+              lab_dims_reported = true
+            end
+            if ops.verbose
+              warn "Label \##{(k % lpp) + 1} on page #{page_num(k)} at row #{row + 1}, column #{col + 1}:"
+              warn '-------------------'
+              warn text
+              warn '-------------------'
+              warn ''
+            end
+            pdf.start_new_page if needs_new_page?(k, last_k)
+          end
+        end
+      end
+      self
+    end
+
+    def print
+      cmd = ops.print_command.gsub('%p', ops.printer).gsub('%o', ops.out_file)
+      if ops.verbose
+        warn "Printing with:"
+        warn "  #{cmd} &"
+      end
+      system("#{cmd} &")
+    end
+
+    def view
+      cmd = ops.view_command.gsub('%o', ops.out_file)
+      if ops.verbose
+        warn "Viewing with:"
+        warn "  #{cmd} &"
+      end
+      system("#{cmd} &")
+    end
+
+    def remove
+      FileUtils.rm(ops.out_file)
+    end
+
+    # Labels per page
+    def lpp
+      ops.rows * ops.columns
+    end
+
+    # Page number of the kth label
+    def page_num(k)
+      k.divmod(lpp)[0] + 1
+    end
+
+    # Return the 0-based row and column within a page on which the k-th
+    # (1-based) label should be printed.
+    def row_col(k)
+      k_on_page = (k + ops.start_label - 2) % lpp
+      k_on_page.divmod(ops.columns)
+    end
+
+    # Should we emit a new page at this point?
+    def needs_new_page?(k, last_k)
+      return false if k == last_k
+      r, c = row_col(k + 1)
+      (r + 1 == ops.rows && c + 1 == ops.columns)
+    end
+
+    # Would we just be printing blank labels?
+    def waste_of_labels?
+      (texts.nil? || texts.empty? || texts.all?(&:blank?)) &&
+        !ops.view
+    end
+  end
+end

data/lib/labrat/label_db.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Labrat
+  module LabelDb
+    class << self
+      # Module-level variable to hold the merged database.
+      attr_accessor :db
+    end
+
+    # Read in the Labrat database of label settings, merging system and user
+    # databases.
+    def self.read(dir_prefix: '')
+      self.db = Config.read('labrat', base: 'labeldb', dir_prefix: dir_prefix)
+        .transform_keys(&:to_sym)
+    end
+
+    # Return a hash of config settings for the label named by labname.
+    def self.[](labname)
+      read unless db
+      db[labname.to_sym] || {}
+    end
+
+    # Set a runtime configuration for a single labelname.
+    def self.[]=(labname, config = {})
+      read unless db
+      db[labname.to_sym] = config
+    end
+
+    # Return an Array of label names.
+    def self.known_names
+      read unless db
+      db.keys.sort
+    end
+
+    def self.db_paths(dir_prefix = '')
+      system_db_paths(dir_prefix) + user_db_paths(dir_prefix)
+    end
+
+    def self.system_db_paths(dir_prefix = '')
+      paths = Config.config_paths('labrat', base: 'labeldb', dir_prefix: dir_prefix)
+      paths[:system]
+    end
+
+    def self.user_db_paths(dir_prefix = '')
+      paths = Config.config_paths('labrat', base: 'labeldb', dir_prefix: dir_prefix)
+      paths[:user]
+    end
+  end
+end

data/lib/labrat/options.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Labrat
+  # The Options class is a glorified Hash, a container for the options
+  # settings gathered from the defaults, the config files, the command line,
+  # and perhaps environment.  An Options instance can be handed off to the
+  # label-printing objects to inform its formatting, printing, etc.
+  class Options
+    attr_accessor :label, :page_width, :page_height,
+                  :left_page_margin, :right_page_margin,
+                  :top_page_margin, :bottom_page_margin,
+                  :rows, :columns, :row_gap, :column_gap, :landscape,
+                  :start_label, :grid,
+                  :h_align, :v_align,
+                  :left_pad, :right_pad, :top_pad, :bottom_pad,
+                  :delta_x, :delta_y,
+                  :font_name, :font_style, :font_size,
+                  :in_file, :nl_sep, :label_sep, :copies,
+                  :printer, :out_file, :print_command, :view_command, :view,
+                  :template, :verbose, :msg
+
+    # Initialize with an optional hash of default values for the attributes.
+    def initialize(**init)
+      self.label = init[:label] || nil
+      # Per-page attributes
+      self.page_width = init[:page_width] || 24.mm
+      self.page_height = init[:page_height] || 87.mm
+      self.left_page_margin = init[:left_page_margin] || 5.mm
+      self.right_page_margin = init[:right_page_margin] || 5.mm
+      self.top_page_margin = init[:top_page_margin] ||  0.mm
+      self.bottom_page_margin = init[:bottom_page_margin] || 0.mm
+      self.rows = init[:rows] || 1
+      self.columns = init[:columns] || 1
+      self.row_gap = init[:row_gap] || 0.mm
+      self.column_gap = init[:column_gap] || 0.mm
+      self.start_label = init[:start_label] || 1
+      self.landscape = init.fetch(:landscape, false)
+      # Per-label attributes
+      self.h_align = init[:h_align]&.to_sym || :center
+      self.v_align = init[:v_align]&.to_sym || :center
+      self.left_pad = init[:left_pad] || 4.5.mm
+      self.right_pad = init[:right_pad] || 4.5.mm
+      self.top_pad = init[:top_pad] ||  0
+      self.bottom_pad = init[:bottom_pad] || 0
+      self.delta_x = init[:delta_x] ||  0
+      self.delta_y = init[:delta_y] ||  0
+      self.font_name = init[:font_name] || 'Helvetica'
+      self.font_style = init[:font_style]&.to_sym || :normal
+      self.font_size = init[:font_size] || 12
+      # Input attributes
+      self.in_file = init[:in_file] || nil
+      self.nl_sep = init[:nl_sep] || '++'
+      self.label_sep = init[:label_sep] || ']*['
+      self.copies = init[:copies] || 1
+      # Output attributes
+      self.printer = init[:printer] || ENV['LABRAT_PRINTER'] || ENV['PRINTER'] || 'dymo'
+      self.out_file = init[:out_file] || 'labrat.pdf'
+      self.print_command = init[:print_command] || 'lpr -P %p %o'
+      self.view_command = init[:view_command] || 'qpdfview --unique --instance labrat %o'
+      self.view = init.fetch(:view, false)
+      self.template = init.fetch(:landscape, false)
+      self.grid = init.fetch(:gid, false)
+      self.verbose = init.fetch(:verbose, false)
+      self.msg = init[:msg] || nil
+    end
+
+    # High-level setting of options from config files, and given command-line
+    # args.
+    def self.set_options(args, verbose: false)
+      # Default, built-in config; set verbose to param.
+      default_config = Labrat::Options.new(verbose: verbose).to_hash
+      default_config.report("Default settings") if verbose
+
+      # Config files
+      file_config = Labrat::Config.read('labrat', verbose: verbose)
+      file_config.report("Settings from merged config files") if verbose
+      file_options = Labrat::ArgParser.new.parse(file_config, prior: default_config, verbose: verbose)
+
+      # Command-line
+      if verbose
+        warn "Command-line:"
+        args.each do |arg|
+          warn arg.to_s
+        end
+        warn ""
+      end
+      Labrat::ArgParser.new.parse(args, prior: file_options, verbose: verbose)
+    end
+
+    # Return any string in msg, e.g., the usage help or error.
+    def to_s
+      msg
+    end
+
+    # Allow hash-like assignment to attributes.  This allows an Options object
+    # to be used, for example, in the OptionParser#parse :into parameter.
+    def []=(att, val)
+      att = att.to_s.gsub('-', '_')
+      send("#{att}=", val)
+    end
+
+    # Allow hash-like access to attributes.  This allows an Options object
+    # to be used, for example, in the OptionParser#parse :into parameter.
+    def [](att)
+      att = att.to_s.gsub('-', '_')
+      send(att.to_s)
+    end
+
+    # For testing, return an Array of the attributes as symbols.
+    def self.attrs
+      instance_methods(false).grep(/\A[a-z_]+=\Z/)
+        .map { |a| a.to_s.sub(/=\z/, '').to_sym }
+    end
+
+    # For testing, return an Array of the flags-form of the attributes, i.e.,
+    # with the underscores, _, replaced with hyphens.
+    def self.flags
+      attrs.map { |a| a.gsub('_', '-') }
+    end
+
+    # Return a hash of the values in this Options object.  This is the
+    # canonical form of a Hash for Labrat, i.e., symbolic keys with any
+    # hyphens translated into underscores.  Don't include the msg attribute.
+    def to_hash
+      {
+        label: label,
+        page_width: page_width,
+        page_height: page_height,
+        left_page_margin: left_page_margin,
+        right_page_margin: right_page_margin,
+        top_page_margin: top_page_margin,
+        bottom_page_margin: bottom_page_margin,
+        rows: rows,
+        columns: columns,
+        row_gap: row_gap,
+        column_gap: column_gap,
+        grid: grid,
+        start_label: start_label,
+        landscape: landscape,
+        # Per-label attributes
+        h_align: h_align,
+        v_align: v_align,
+        left_pad: left_pad,
+        right_pad: right_pad,
+        top_pad: top_pad,
+        bottom_pad: bottom_pad,
+        delta_x: delta_x,
+        delta_y: delta_y,
+        font_name: font_name,
+        font_style: font_style,
+        font_size: font_size,
+        # Input attributes
+        in_file: in_file,
+        nl_sep: nl_sep,
+        label_sep: label_sep,
+        copies: copies,
+        # Output attributes
+        printer: printer,
+        out_file: out_file,
+        print_command: print_command,
+        view_command: view_command,
+        view: view,
+        template: template,
+        verbose: verbose,
+      }
+    end
+
+    # Update the fields of this Option instance by merging in the values in
+    # hsh into self.  Ignore any keys in hsh not corresponding to a setter for
+    # an Options object.
+    def merge!(hsh)
+      # Convert any separator hyphens in the hash keys to underscores
+      hsh = hsh.to_hash.transform_keys { |key| key.to_s.gsub('-', '_').to_sym }
+      new_hash = to_hash.merge(hsh)
+      new_hash.each_pair do |k, val|
+        setter = "#{k}=".to_sym
+        next unless respond_to?(setter)
+
+        send(setter, val)
+      end
+      self
+    end
+  end
+end

data/lib/labrat/read_files.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Labrat
+  def self.read_label_texts(fname, nlsep)
+    file =
+      if fname
+        ofname = fname
+        fname = File.expand_path(fname)
+        unless File.readable?(fname)
+          raise "Cannot open label file '#{ofname}' for reading"
+        end
+        File.open(fname)
+      else
+        $stdin
+      end
+
+    texts = []
+    label = nil
+    file.each do |line|
+      next if line =~ /\A#/
+
+      if line =~ /\A\s*\z/
+        # At blank line record any accumulated label into texts, but remove
+        # the nlsep from the end.
+        if label
+          texts << label.sub(/#{Regexp.quote(nlsep)}\z/, '')
+          label = nil
+        end
+      else
+        # Append a non-blank line to the current label, creating it if
+        # necessary.
+        label ||= +''
+        label << line.chomp + nlsep
+      end
+    end
+    # Last label in the file.
+    texts << label.sub(/#{Regexp.quote(nlsep)}\z/, '') if label
+    texts
+  end
+end

data/lib/labrat/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Labrat
+  VERSION = "0.1.13"
+end

data/lib/labrat.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'fat_core/enumerable'
+require 'prawn'
+require 'prawn/measurement_extensions'
+require 'optparse'
+require 'yaml'
+require 'pp'
+
+require_relative "labrat/version"
+require_relative "labrat/errors"
+require_relative "labrat/hash"
+require_relative "labrat/options"
+require_relative "labrat/arg_parser"
+require_relative "labrat/label"
+require_relative "labrat/config"
+require_relative "labrat/label_db"
+require_relative "labrat/read_files"

data/lib/lisp/labrat.el

@@ -0,0 +1,108 @@
+;;;; labrat -- Print labels using labrat from within a buffer.
+
+;;; Commentary:
+
+;; Lisp commands to print labels from within Emacs a buffer by invoking
+;; labrat, a Ruby application desgined for printing labels from the
+;; command-line rather than through a GUI.  You must have labrat installed
+;; first.  See https://github.com/ddoherty03/labrat for details.
+
+;;; Code:
+
+(require 'thingatpt)
+(require 's)
+(require 'dash)
+
+(defcustom labrat-executable "labrat"
+  "Executable for labrat.
+
+If the executable is not in your variable `exec-path', set this
+to the full path name of the executable,
+e.g. ~/.rbenv/shims/labrat, for an rbenv ruby installation."
+  :type 'string
+  :group 'labrat)
+
+(defcustom labrat-nl-sep "++"
+  "String to mark newlines in label text.
+
+If you change this, you need to make a corresponding change in your
+labrat configuration at ~/.config/labrat/config.yml."
+  :type 'string
+  :group 'labrat)
+
+(defcustom labrat-label-sep "]*["
+  "String to mark the separation between labels on the labrat command-line.
+
+If you change this, you need to make a corresponding change in your
+labrat configuration at ~/.config/labrat/config.yml."
+  :type 'string
+  :group 'labrat)
+
+(defun labrat/pars-in-region ()
+  "Return a string of paragraphs in region, separated by `labrat-label-sep'.
+
+If the region is not active, just return the paragraph at or before point as
+is done by `labrat-par-at-point'.  In either case strip comment lines."
+  (if (region-active-p)
+      (progn
+        (let ((beg (region-beginning))
+              (end (save-excursion
+                     (progn (goto-char (region-end))
+                            (forward-paragraph)
+                            (point))))
+              (pars ""))
+          (progn
+            (save-excursion
+              (goto-char beg)
+              (while (< (point) end)
+                (forward-paragraph)
+                (setq pars (s-concat pars (labrat/par-at-point) labrat-label-sep))))
+            (s-chop-prefix labrat-label-sep (s-chop-suffix labrat-label-sep pars)))))
+    (labrat/par-at-point)))
+
+(defun labrat/par-at-point ()
+  "Return the paragraph at or before point.
+
+Similar to the command `thing-at-point' for paragraph, but look
+for preceding paragraph even if there are several blank lines
+before point, trim white space, comments, and properties from the
+result."
+  (save-excursion
+    (unless (looking-at ".+")
+      (re-search-backward "^.+$" nil 'to-bob))
+    (s-replace "\n" labrat-nl-sep
+               (labrat/remove-comments
+                          (s-trim (thing-at-point 'paragraph t))))))
+
+(defun labrat/remove-comments (str)
+  "Remove any lines from STR that start with the comment character '#'.
+
+If STR consists of multiple new-line separated lines, the lines
+that start with '#' are removed, and the remaining lines
+returned"
+  (s-join "\n" (--remove (string-match "^#" it) (s-split "\n" str))))
+
+(defun labrat-view ()
+  "View the paragraph at or before point as a label with labrat.
+
+This invokes the \"labrat -V\ <label>\" command with the
+paragraph at or before point inserted in the <label> position,
+but with each new-line replaced with the value of the variable
+labrat-nl-sep, '++' by default."
+  (interactive)
+  (call-process labrat-executable nil nil nil
+                "-V" (labrat/pars-in-region)))
+
+(defun labrat-print ()
+  "Print the paragraph at or before point as a label with labrat.
+
+This invokes the \"labrat -P <label>\" command with the paragraph
+at or before point inserted in the <label> position, but with
+each new-line replaced with the value of the variable
+labrat-nl-sep, '++' by default."
+  (interactive)
+  (call-process labrat-executable nil nil nil
+                (labrat/pars-in-region)))
+
+(provide 'labrat)
+;;; labrat.el ends here