labrat 1.4.0 → 1.5.0

data/lib/labrat/config.rb

@@ -1,215 +1,11 @@
 # frozen_string_literal: true
 
+# A thin wrapper around FatConfig.
 module Labrat
-  # This class is responsible for finding a config files, reading them, and
-  # returning a Hash to reflect the configuration.  We use YAML as the
-  # configuration format and look for the config file in the standard places.
-  class Config
-    # Return a Hash of the YAML-ized config files for app_name directories.
-    # Config file may be located in either the xdg locations (containing any
-    # variant of base: base, base.yml, or base.yaml) or in the classic
-    # locations (/etc/app_namerc, /etc/app_name, ~/.app_namerc~, or
-    # ~/.app_name/base[.ya?ml]). Return a hash that reflects the merging of
-    # those files according to the following priorities, from highest to
-    # lowest:
-    #
-    # 1. A config file pointed to by the environment variable APPNAME_CONFIG
-    # 2. User classic config files
-    # 3. User xdg config files for app_name,
-    # 4. A config file pointed to by the environment variable APPNAME_SYS_CONFIG
-    # 5. System classic config files,
-    # 6. System xdg config files for for app_name,
-    #
-    # If an environment variable is found, the search for xdg and classic
-    # config files is skipped. Any dir_prefix is pre-pended to search
-    # locations environment, xdg and classic config paths so you can run this
-    # on a temporary directory set up for testing.
+  module Config
     def self.read(app_name, base: 'config', dir_prefix: '', xdg: true, verbose: false)
-      paths = config_paths(app_name, base: base, dir_prefix: dir_prefix, xdg: xdg)
-      sys_configs = paths[:system]
-      usr_configs = paths[:user]
-      merge_configs_from((sys_configs + usr_configs).compact, verbose: verbose)
-    end
-
-    def self.config_paths(app_name, base: 'config', dir_prefix: '', xdg: true)
-      sys_configs = []
-      sys_env_name = "#{app_name.upcase}_SYS_CONFIG"
-      if ENV[sys_env_name]
-        sys_fname = File.join(dir_prefix, File.expand_path(ENV[sys_env_name]))
-        sys_configs << sys_fname if File.readable?(sys_fname)
-      else
-        sys_configs +=
-          if xdg
-            find_xdg_sys_config_files(app_name, base, dir_prefix)
-          else
-            find_classic_sys_config_files(app_name, base, dir_prefix)
-          end
-      end
-
-      usr_configs = []
-      usr_env_name = "#{app_name.upcase}_CONFIG"
-      if ENV[usr_env_name]
-        usr_fname = File.join(dir_prefix, File.expand_path(ENV[usr_env_name]))
-        usr_configs << usr_fname if File.readable?(usr_fname)
-      else
-        usr_configs <<
-          if xdg
-            find_xdg_user_config_file(app_name, base, dir_prefix)
-          else
-            find_classic_user_config_file(app_name, dir_prefix)
-          end
-      end
-      { system: sys_configs.compact, user: usr_configs.compact }
-    end
-
-    # Merge the settings from the given Array of config files in order from
-    # lowest priority to highest priority, starting with an empty hash.  Any
-    # values of the top-level hash that are themselves Hashes are merged
-    # recursively.
-    def self.merge_configs_from(files = [], verbose: false)
-      hash = {}
-      files.each do |f|
-        next unless File.readable?(f)
-
-        yml_hash = YAML.load_file(f)
-        next unless yml_hash
-
-        if yml_hash.is_a?(Hash)
-          yml_hash = yml_hash
-        else
-          raise "Error loading file #{f}:\n#{File.read(f)[0..500]}"
-        end
-        yml_hash.report("Merging config from file '#{f}") if verbose
-        hash.deep_merge!(yml_hash)
-      end
-      hash
-    end
-
-    ########################################################################
-    # XDG config files
-    ########################################################################
-
-    # From the XDG standard:
-    # Your application should store and load data and configuration files to/from
-    # the directories pointed by the following environment variables:
-    #
-    # $XDG_CONFIG_HOME (default: "$HOME/.config"): user-specific configuration files.
-    # $XDG_CONFIG_DIRS (default: "/etc/xdg"): precedence-ordered set of system configuration directories.
-
-    # Return the absolute path names of all XDG system config files for
-    # app_name with the basename variants of base. Return the lowest priority
-    # files first, highest last. Prefix the search locations with dir_prefix
-    # if given.
-    def self.find_xdg_sys_config_files(app_name, base, dir_prefix)
-      configs = []
-      xdg_search_dirs = ENV['XDG_CONFIG_DIRS']&.split(':')&.reverse || ['/etc/xdg']
-      xdg_search_dirs.each do |dir|
-        dir = File.expand_path(File.join(dir, app_name))
-        dir = File.join(dir_prefix, dir) unless dir_prefix.nil? || dir_prefix.strip.empty?
-        base = app_name if base.nil? || base.strip.empty?
-        base_candidates = [
-          base.to_s,
-          "#{base}.yml",
-          "#{base}.yaml",
-          "#{base}.cfg",
-          "#{base}.config"
-        ]
-        config_fname = base_candidates.find { |b| File.readable?(File.join(dir, b)) }
-        configs << File.join(dir, config_fname) if config_fname
-      end
-      configs
-    end
-
-    # Return the absolute path name of any XDG user config files for app_name
-    # with the basename variants of base. The XDG_CONFIG_HOME environment
-    # variable for the user configs is intended to be the name of a single xdg
-    # config directory, not a list of colon-separated directories as for the
-    # system config. Return the name of a config file for this app in
-    # XDG_CONFIG_HOME (or ~/.config by default).  Prefix the search location
-    # with dir_prefix if given.
-    def self.find_xdg_user_config_file(app_name, base, dir_prefix)
-      dir_prefix ||= ''
-      base ||= base&.strip || app_name
-      xdg_search_dir = ENV['XDG_CONFIG_HOME'] || ['~/.config']
-      dir = File.expand_path(File.join(xdg_search_dir, app_name))
-      dir = File.join(dir_prefix, dir) unless dir_prefix.strip.empty?
-      return unless Dir.exist?(dir)
-
-      base_candidates = [
-        base.to_s,
-        "#{base}.yml",
-        "#{base}.yaml",
-        "#{base}.cfg",
-        "#{base}.config"
-      ]
-      config_fname = base_candidates.find { |b| File.readable?(File.join(dir, b)) }
-      if config_fname
-        File.join(dir, config_fname)
-      end
-    end
-
-    ########################################################################
-    # Classic config files
-    ########################################################################
-
-    # Return the absolute path names of all "classic" system config files for
-    # app_name with the basename variants of base. Return the lowest priority
-    # files first, highest last.  Prefix the search locations with dir_prefix
-    # if given.
-    def self.find_classic_sys_config_files(app_name, base, dir_prefix)
-      dir_prefix ||= ''
-      configs = []
-      env_config = ENV["#{app_name.upcase}_SYS_CONFIG"]
-      if env_config && File.readable?(config = File.join(dir_prefix, File.expand_path(env_config)))
-        configs = [config]
-      elsif File.readable?(config = File.join(dir_prefix, "/etc/#{app_name}"))
-        configs = [config]
-      elsif File.readable?(config = File.join(dir_prefix, "/etc/#{app_name}rc"))
-        configs = [config]
-      else
-        dir = File.join(dir_prefix, "/etc/#{app_name}")
-        if Dir.exist?(dir)
-          base = app_name if base.nil? || base.strip.empty?
-          base_candidates = [
-            base.to_s + "#{base}.yml",
-            "#{base}.yaml",
-            "#{base}.cfg",
-            "#{base}.config"
-          ]
-          config = base_candidates.find { |b| File.readable?(File.join(dir, b)) }
-          configs = [File.join(dir, config)] if config
-        end
-      end
-      configs
-    end
-
-    # Return the absolute path names of all "classic" system config files for
-    # app_name with the basename variants of base. Return the lowest priority
-    # files first, highest last.  Prefix the search locations with dir_prefix if
-    # given.
-    def self.find_classic_user_config_file(app_name, dir_prefix)
-      dir_prefix ||= ''
-      config_fname = nil
-      env_config = ENV["#{app_name.upcase}_CONFIG"]
-      if env_config && File.readable?(config = File.join(dir_prefix, File.expand_path(env_config)))
-        config_fname = config
-      elsif Dir.exist?(config_dir = File.join(dir_prefix, File.expand_path("~/.#{app_name}")))
-        base_candidates = ["config.yml", "config.yaml", "config"]
-        base_fname = base_candidates.find { |b| File.readable?(File.join(config_dir, b)) }
-        config_fname = File.join(config_dir, base_fname)
-      elsif Dir.exist?(config_dir = File.join(dir_prefix, File.expand_path('~/')))
-        base_candidates = [
-          ".#{app_name}",
-          ".#{app_name}rc",
-          ".#{app_name}.yml",
-          ".#{app_name}.yaml",
-          ".#{app_name}.cfg",
-          ".#{app_name}.config"
-        ]
-        base_fname = base_candidates.find { |b| File.readable?(File.join(config_dir, b)) }
-        config_fname = File.join(config_dir, base_fname)
-      end
-      config_fname
+      reader = FatConfig::Reader.new(app_name, xdg:, root_prefix: dir_prefix)
+      reader.read(verbose:)
     end
   end
 end

data/lib/labrat/label_db.rb

@@ -4,26 +4,26 @@ module Labrat
   module LabelDb
     class << self
       # Module-level variable to hold the merged database.
-      attr_accessor :db
+      attr_accessor :db, :reader
     end
 
     # Read in the Labrat database of label settings, merging system and user
     # databases.
     def self.read(dir_prefix: '')
-      reader = FatConfig::Reader.new('labrat', root_prefix: dir_prefix)
-      self.db = reader.read('labeldb')
+      self.reader = FatConfig::Reader.new('labrat', root_prefix: dir_prefix)
+      self.db = reader.read('labeldb').transform_keys(&:downcase)
     end
 
     # Return a hash of config settings for the label named by labname.
     def self.[](labname)
       read unless db
-      db[labname.to_sym] || {}
+      db[labname.to_sym] || db[labname.downcase.to_sym] || {}
     end
 
     # Set a runtime configuration for a single labelname.
     def self.[]=(labname, config = {})
       read unless db
-      db[labname.to_sym] = config
+      db[labname.to_sym.downcase] = config
     end
 
     # Return an Array of label names.
@@ -37,13 +37,11 @@ module Labrat
     end
 
     def self.system_db_paths(dir_prefix = '')
-      paths = Config.config_paths('labrat', base: 'labeldb', dir_prefix: dir_prefix)
-      paths[:system]
+      reader.config_paths[:system]
     end
 
     def self.user_db_paths(dir_prefix = '')
-      paths = Config.config_paths('labrat', base: 'labeldb', dir_prefix: dir_prefix)
-      paths[:user]
+      reader.config_paths[:user]
     end
   end
 end

data/lib/labrat/read_files.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Labrat
-  def self.read_label_texts(fname, nlsep)
+  def self.read_label_texts(fname, nl_sep)
     file =
       if fname
         ofname = fname
@@ -22,20 +22,20 @@ module Labrat
 
       if /\A\s*\z/.match?(line)
         # At blank line record any accumulated label into texts, but remove
-        # the nlsep from the end.
+        # the nl_sep from the end.
         if label
-          texts << label.sub(/#{Regexp.quote(nlsep)}\z/, '')
+          texts << label.sub(/#{Regexp.quote(nl_sep)}\z/, '')
           label = nil
         end
       else
         # Append a non-blank line to the current label, creating it if
         # necessary.
         label ||= +''
-        label << line.chomp + nlsep
+        label << line.chomp + nl_sep
       end
     end
     # Last label in the file.
-    texts << label.sub(/#{Regexp.quote(nlsep)}\z/, '') if label
+    texts << label.sub(/#{Regexp.quote(nl_sep)}\z/, '') if label
     texts
   end
 end

data/lib/labrat/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: labrat
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Daniel E. Doherty
@@ -37,20 +37,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: matrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: prawn
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - "<="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.5'
 description: |2+
 
   Labrat is a linux command-line program for quickly printing labels.  Labrat uses
@@ -146,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.0
 specification_version: 4
 summary: Command-line and Emacs label print software.
 test_files: []