MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/Config-Migrate.rb

@@ -1,47 +1,53 @@
-require 'pathname'
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
 require 'fileutils'
+require 'pathname'
 require 'yaml'
 require 'MrMurano/verbosing'
 require 'MrMurano/Account'
 require 'MrMurano/Config'
 
-
 module MrMurano
   class ConfigMigrate
     include Verbose
 
     def import_secret
       solsecret = Pathname.new($cfg['location.base']) + '.Solutionfile.secret'
-      if solsecret.exist? then
-        # Is in JSON, which as a subset of YAML, so use YAML parser
-        solsecret.open do |io|
-          ss = YAML.load(io)
-
-          pff = $cfg.file_at('passwords', :user)
-          pwd = MrMurano::Passwords.new(pff)
-          pwd.load
-          ps = pwd.get($cfg['net.host'], ss['email'])
-          if ps.nil? then
+      return unless solsecret.exist?
+      # Is in JSON, which as a subset of YAML, so use YAML parser
+      solsecret.open do |io|
+        # rubocop:disable Security/YAMLLoad: Prefer using YAML.safe_load over YAML.load.
+        # MAYBE/2017-07-02: Switch to YAML.safe_load.
+        ss = YAML.load(io)
+
+        pff = $cfg.file_at('passwords', :user)
+        pwd = MrMurano::Passwords.new(pff)
+        pwd.load
+        ps = pwd.get($cfg['net.host'], ss['email'])
+        if ps.nil?
+          pwd.set($cfg['net.host'], ss['email'], ss['password'])
+          pwd.save
+        elsif ps != ss['password']
+          y = ask('A different password for this account already exists. Overwrite? N/y')
+          if y =~ /^y/i
             pwd.set($cfg['net.host'], ss['email'], ss['password'])
             pwd.save
-          elsif ps != ss['password'] then
-            y = ask("A different password for this account already exists. Overwrite? N/y")
-            if y =~ /^y/i then
-              pwd.set($cfg['net.host'], ss['email'], ss['password'])
-              pwd.save
-            end
-          else
-            # already set, nothing to do.
           end
-
-          $cfg.set('user.name', ss['email'])
-          $cfg.set('solution.id', ss['solution_id']) if ss.has_key? 'solution_id'
-          $cfg.set('product.id', ss['product_id']) if ss.has_key? 'product_id'
+        # else, already set, nothing to do.
         end
+
+        $cfg.set('user.name', ss['email'])
+        $project.refresh_user_name
+
+        $cfg.set('application.id', ss['solution_id']) if ss.key? 'solution_id'
+        $cfg.set('product.id', ss['product_id']) if ss.key? 'product_id'
       end
     end
-
   end
 end
 
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/Config.rb

@@ -1,109 +1,147 @@
-require 'pathname'
-require 'inifile'
+# Last Modified: 2017.08.18 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
 require 'highline'
+require 'inifile'
+require 'pathname'
+require 'rainbow'
+require 'MrMurano/verbosing'
+require 'MrMurano/SyncRoot'
 
 module MrMurano
   class Config
-    #
-    #  internal    transient this-run-only things (also -c options)
-    #  specified   from --configfile
-    #  env         from ENV['MURANO_CONFIGFILE']
-    #  project     .murano/config at project dir
-    #  user        .murano/config at $HOME
-    #  defaults    Internal hardcoded defaults
-    #
+    include Verbose
+
+    # Config scopes:
+    #  :internal    transient this-run-only things (also -c options)
+    #  :specified   from --configfile
+    #  :env         from ENV['MURANO_CONFIGFILE']
+    #  :project     .murano/config at project dir
+    #  :user        .murano/config at $HOME
+    #  :defaults    Internal hardcoded defaults
+    # NOTE: This list is ordered, such that values stored in upper scopes
+    #   mask values of the same keys in the lower scopes.
+    CFG_SCOPES = %i[internal specified env project user defaults].freeze
+
     ConfigFile = Struct.new(:kind, :path, :data) do
-      def load()
+      def load
         return if kind == :internal
         return if kind == :defaults
-        self[:path] = Pathname.new(path) unless path.kind_of? Pathname
-        self[:data] = IniFile.new(:filename=>path.to_s) if self[:data].nil?
+        # DEVs: Uncomment if you're trying to figure where settings are coming from.
+        #   See also: murano config --locations
+        #puts "Loading config at: #{path}"
+        self[:path] = Pathname.new(path) unless path.is_a? Pathname
+        self[:data] = IniFile.new(filename: path.to_s) if self[:data].nil?
         self[:data].restore
       end
 
-      def write()
+      def write
         return if kind == :internal
         return if kind == :defaults
-        self[:path] = Pathname.new(path) unless path.kind_of? Pathname
-        self[:data] = IniFile.new(:filename=>path.to_s) if self[:data].nil?
+        if defined?($cfg) && !$cfg.nil? && $cfg['tool.dry']
+          # $cfg.nil? when run from spec tests that don't load it with:
+          #   include_context "CI_CMD"
+          MrMurano::Verbose.warning('--dry: Not writing config file')
+          return
+        end
+        self[:path] = Pathname.new(path) unless path.is_a?(Pathname)
+        # Ensure path to the file exists.
+        unless path.dirname.exist?
+          path.dirname.mkpath
+          MrMurano::Config.fix_modes(path.dirname)
+        end
+        self[:data] = IniFile.new(filename: path.to_s) if self[:data].nil?
         self[:data].save
-        path.chmod(0600)
+        path.chmod(0o600)
       end
     end
 
-    attr :paths
+    attr_reader :paths
     attr_reader :projectDir
+    attr_reader :project_exists
+    attr_writer :exclude_scopes
+    attr_accessor :curlfile_f
 
-    CFG_SCOPES=%w{internal specified env project user defaults}.map{|i| i.to_sym}.freeze
+    CFG_ENV_NAME = %(MURANO_CONFIGFILE)
+    CFG_FILE_NAME = %(.murano/config)
+    CFG_DIR_NAME = %(.murano)
 
-    CFG_ENV_NAME=%{MURANO_CONFIGFILE}.freeze
-    CFG_FILE_NAME=%[.murano/config].freeze
-    CFG_DIR_NAME=%[.murano].freeze
+    CFG_OLD_ENV_NAME = %(MR_CONFIGFILE)
+    CFG_OLD_DIR_NAME = %(.mrmurano)
+    CFG_OLD_FILE_NAME = %(.mrmuranorc)
 
-    CFG_OLD_ENV_NAME=%[MR_CONFIGFILE].freeze
-    CFG_OLD_DIR_NAME=%[.mrmurano].freeze
-    CFG_OLD_FILE_NAME=%[.mrmuranorc].freeze
+    CFG_SOLUTION_ID_KEYS = %w[application.id product.id].freeze
 
-    def warning(msg)
-      $stderr.puts HighLine.color(msg, :yellow)
-    end
-    def error(msg)
-      $stderr.puts HighLine.color(msg, :red)
-    end
-
-    def migrateOldEnv
-      unless ENV[CFG_OLD_ENV_NAME].nil? then
-        warning %{ENV "#{CFG_OLD_ENV_NAME}" is no longer supported. Rename it to "#{CFG_ENV_NAME}"}
-        unless ENV[CFG_ENV_NAME].nil? then
-          error %{Both "#{CFG_ENV_NAME}" and "#{CFG_OLD_ENV_NAME}" defined, please remove "#{CFG_OLD_ENV_NAME}".}
-        end
-        ENV[CFG_ENV_NAME] = ENV[CFG_OLD_ENV_NAME]
+    def migrate_old_env
+      return if ENV[CFG_OLD_ENV_NAME].nil?
+      warning %(ENV "#{CFG_OLD_ENV_NAME}" is no longer supported. Rename it to "#{CFG_ENV_NAME}")
+      unless ENV[CFG_ENV_NAME].nil?
+        warning %(Both "#{CFG_ENV_NAME}" and "#{CFG_OLD_ENV_NAME}" defined, please remove "#{CFG_OLD_ENV_NAME}".)
       end
+      ENV[CFG_ENV_NAME] = ENV[CFG_OLD_ENV_NAME]
     end
 
-    def migrateOldConfig(where)
+    def migrate_old_config(where)
       # Check for dir.
-      if (where + CFG_OLD_DIR_NAME).exist? then
-        warning %{Moving old directory "#{CFG_OLD_DIR_NAME}" to "#{CFG_DIR_NAME}" in "#{where}"}
+      if (where + CFG_OLD_DIR_NAME).exist?
+        warning %(Moving old directory "#{CFG_OLD_DIR_NAME}" to "#{CFG_DIR_NAME}" in "#{where}")
         (where + CFG_OLD_DIR_NAME).rename(where + CFG_DIR_NAME)
       end
 
-      # check for cfg.
-      if (where + CFG_OLD_FILE_NAME).exist? then
-        warning %{Moving old config "#{CFG_OLD_FILE_NAME}" to "#{CFG_FILE_NAME}" in "#{where}"}
+      # Check for cfg.
+      # rubocop:disable Style/GuardClause
+      if (where + CFG_OLD_FILE_NAME).exist?
+        warning %(Moving old config "#{CFG_OLD_FILE_NAME}" to "#{CFG_FILE_NAME}" in "#{where}")
         (where + CFG_DIR_NAME).mkpath
         (where + CFG_OLD_FILE_NAME).rename(where + CFG_FILE_NAME)
       end
     end
 
-    def initialize
+    def initialize(cmd_runner=nil)
+      @runner = cmd_runner
+      @curlfile_f = nil
+
       @paths = []
-      @paths << ConfigFile.new(:internal, nil, IniFile.new())
+      @paths << ConfigFile.new(:internal, nil, IniFile.new)
       # :specified --configfile FILE goes here. (see load_specific)
 
-      migrateOldEnv
-      unless ENV[CFG_ENV_NAME].nil? then
+      migrate_old_env
+      unless ENV[CFG_ENV_NAME].nil?
         # if it exists, must be a file
         # if it doesn't exist, that's ok
         ep = Pathname.new(ENV[CFG_ENV_NAME])
-        if ep.file? or not ep.exist? then
-          @paths << ConfigFile.new(:env, ep)
-        end
+        @paths << ConfigFile.new(:env, ep) if ep.file? || !ep.exist?
       end
 
-      @projectDir = findProjectDir()
-      migrateOldConfig(@projectDir)
-      @paths << ConfigFile.new(:project,  @projectDir + CFG_FILE_NAME)
-      (@projectDir + CFG_DIR_NAME).mkpath
-      fixModes(@projectDir + CFG_DIR_NAME)
+      @project_dir, @project_exists = find_project_dir
+      # For murano init, do not use parent config file as project config.
+      if !@runner.nil? && @runner.active_command.restrict_to_cur_dir
+        pwd = Pathname.new(Dir.pwd).realpath
+        if @project_dir != pwd
+          @project_dir = pwd
+          @project_exists = false
+        end
+      end
+      @paths << ConfigFile.new(:project, @project_dir + CFG_FILE_NAME)
 
-      migrateOldConfig(Pathname.new(Dir.home))
       @paths << ConfigFile.new(:user, Pathname.new(Dir.home) + CFG_FILE_NAME)
-      (Pathname.new(Dir.home) + CFG_DIR_NAME).mkpath
-      fixModes(Pathname.new(Dir.home) + CFG_DIR_NAME)
 
-      @paths << ConfigFile.new(:defaults, nil, IniFile.new())
+      @paths << ConfigFile.new(:defaults, nil, IniFile.new)
 
+      # The user can exclude certain scopes.
+      @exclude_scopes = []
+
+      set_defaults
+    end
+
+    def set_defaults
+      # All these set()'s are against the :defaults config.
+      # So no disk writing ensues. And these serve as defaults
+      # unless, say, a SolutionFile says otherwise.
 
       set('tool.verbose', false, :defaults)
       set('tool.debug', false, :defaults)
@@ -113,31 +151,85 @@ module MrMurano
 
       set('net.host', 'bizapi.hosted.exosite.io', :defaults)
 
-      set('location.base', @projectDir, :defaults) unless @projectDir.nil?
+      set('location.base', @project_dir, :defaults) unless @project_dir.nil?
       set('location.files', 'files', :defaults)
       set('location.endpoints', 'routes', :defaults)
       set('location.modules', 'modules', :defaults)
       set('location.eventhandlers', 'services', :defaults)
-      set('location.specs', 'specs/resources.yaml', :defaults)
+      set('location.resources', 'specs/resources.yaml', :defaults)
       set('location.cors', 'cors.yaml', :defaults)
 
-      set('sync.bydefault', SyncRoot.bydefault.join(' '), :defaults) if defined? SyncRoot
+      set('sync.bydefault', SyncRoot.instance.bydefault.join(' '), :defaults) if defined? SyncRoot
 
       set('files.default_page', 'index.html', :defaults)
       set('files.searchFor', '**/*', :defaults)
       set('files.ignoring', '', :defaults)
 
-      set('endpoints.searchFor', '{,../endpoints}/*.lua {,../endpoints}s/*/*.lua', :defaults)
-      set('endpoints.ignoring', '*_test.lua *_spec.lua .*', :defaults)
-
-      set('eventhandler.searchFor', '*.lua */*.lua {../eventhandlers,../event_handler}/*.lua {../eventhandlers,../event_handler}/*/*.lua', :defaults)
-      set('eventhandler.ignoring', '*_test.lua *_spec.lua .*', :defaults)
-      set('eventhandler.skiplist', 'websocket webservice device.service_call', :defaults)
-
-      set('modules.searchFor', '*.lua */*.lua', :defaults)
-      set('modules.ignoring', '*_test.lua *_spec.lua .*', :defaults)
-
-      if Gem.win_platform? then
+      set('endpoints.searchFor', %w[
+        {,../endpoints}/*.lua
+        {,../endpoints}s/*/*.lua
+      ].join(' '), :defaults)
+      set('endpoints.ignoring', %w[
+        *_test.lua
+        *_spec.lua
+        .*
+      ].join(' '), :defaults)
+
+      set('eventhandler.searchFor', %w[
+        *.lua
+        */*.lua
+        {../eventhandlers,../event_handler}/*.lua
+        {../eventhandlers,../event_handler}/*/*.lua
+      ].join(' '), :defaults)
+      set('eventhandler.ignoring', %w[
+        *_test.lua
+        *_spec.lua
+        .*
+      ].join(' '), :defaults)
+      # 2017-08-07: device.datapoint is the v1 device event handler.
+      #   It is deprecated and will be removed in 12 months.
+      #   So it technically still works, but eventually will not.
+      #   CAVEAT: One must manually enable the Device V1 service for a Murano 1.1 business.
+      # device2.event is the event handler that is created when two solutions
+      #   are linked (say, an application and a product). Do not delete this.
+      # The interface service contains lots of simple device event handlers
+      #   that we don't want to touch.
+      set('eventhandler.skiplist', %w[
+        device.service_call
+        device2.event
+        interface
+        webservice
+        websocket
+      ].join(' '), :defaults)
+      # Do not delete boilerplate event handlers.
+      set('eventhandler.undeletable', %w[
+        *.event
+        timer.timer
+        tsdb.exportJob
+        user.account
+      ].join(' '), :defaults)
+
+      # 2017-07-26: Nested Lua support: Change '*/*.lua' to '**/*.lua'.
+      #   There are similar changes made to the ProjectFile,
+      #   to modules.include and modules.exclude, which, if set,
+      #   override modules.searchFor and modules.ignoring, respectively.
+      # NOTE: ** finds files in subdirs in subdirs,
+      #     e.g., modules/subdir1/subdir2/<here>/and/<here>
+      #     otherwise, */*.lua just finds files modules/subdir1/<here>.
+      set('modules.searchFor', %w[
+        *.lua
+        **/*.lua
+      ].join(' '), :defaults)
+
+      set('modules.ignoring', %w[
+        *_test.lua
+        *_spec.lua
+        .*
+      ].join(' '), :defaults)
+
+      set('modules.no-nesting', false, :defaults)
+
+      if Gem.win_platform?
         set('diff.cmd', 'fc', :defaults)
       else
         set('diff.cmd', 'diff -u', :defaults)
@@ -148,46 +240,75 @@ module MrMurano
 
     ## Find the root of this project Directory.
     #
-    # The Project dir is the directory between PWD and HOME that has one of (in
-    # order of preference):
+    # The Project dir is the directory between PWD and HOME
+    # that has one of (in order of preference):
     # - .murano/config
     # - .mrmuranorc
     # - .murano/
     # - .mrmurano/
-    def findProjectDir()
-      result=nil
-      fileNames=[CFG_FILE_NAME, CFG_OLD_FILE_NAME]
-      dirNames=[CFG_DIR_NAME, CFG_OLD_DIR_NAME]
+    def find_project_dir
+      file_names = [CFG_FILE_NAME, CFG_OLD_FILE_NAME]
+      dir_names = [CFG_DIR_NAME, CFG_OLD_DIR_NAME]
       home = Pathname.new(Dir.home).realpath
       pwd = Pathname.new(Dir.pwd).realpath
-      return home if home == pwd
-      pwd.ascend do |i|
-        break unless result.nil?
-        break if i == home
-        fileNames.each do |f|
-          if (i + f).exist? then
-            result = i
-          end
+      # The home directory contains the user ~/.murano/config,
+      # so we cannot also have a project .murano/ directory.
+      return home, false if home == pwd
+      pwd.ascend do |path|
+        # Don't bother with home or looking above it.
+        break if path == home
+        file_names.each do |fname|
+          return path, true if (path + fname).exist?
         end
-        dirNames.each do |f|
-          if (i + f).directory? then
-            result = i
-          end
+        dir_names.each do |dname|
+          return path, true if (path + dname).directory?
         end
       end
-
       # Now if nothing found, assume it will live in pwd.
-      result = Pathname.new(Dir.pwd) if result.nil?
-      return result
+      result = Pathname.new(Dir.pwd)
+      [result, false]
+    end
+    private :find_project_dir
+
+    def prompt_if_logged_off
+      # MAYBE/2017-07-31: [lb] likes the idea of only prompting for the
+      # password for certain commands (e.g., `murano login` and `murano init`),
+      # but this might break a user's experience if they don't want to store
+      # their password in ~/.murano but instead always want to be prompted.
+      #!@runner.nil? && @runner.active_command.prompt_if_logged_off
+      # Disabling for now...
+      true
     end
-    private :findProjectDir
 
-    def fixModes(path)
-      if path.directory? then
-        path.chmod(0700)
-      elsif path.file? then
-        path.chmod(0600)
+    def validate_cmd
+      # Most commands should be run from within a Murano project (sub-)directory.
+      # If user is running a project command not within a project directory,
+      # we'll print a message now and exit the app from run_active_command later.
+      unless @runner.nil?
+        the_cmd = @runner.active_command
+        unless the_cmd.name == 'help' || the_cmd.project_not_required || @project_exists
+          error %(The "#{the_cmd.name}" command only works in a Murano project.)
+          say %(Please change to a project directory, or run `murano init` to create a new project.)
+          # Note that commnander-rb uses an at_exit hook, which we hack around.
+          @runner.command_exit = 1
+          return
+        end
       end
+
+      migrate_old_config(@project_dir)
+      migrate_old_config(Pathname.new(Dir.home))
+    end
+
+    def self.fix_modes(path)
+      if path.directory?
+        path.chmod(0o700)
+      elsif path.file?
+        path.chmod(0o600)
+      end
+    end
+
+    def fix_modes(path)
+      MrMurano::Config.fix_modes(path)
     end
 
     def file_at(name, scope=:project)
@@ -197,7 +318,7 @@ module MrMurano
       when :specified
         root = nil
       when :project
-        root = @projectDir + CFG_DIR_NAME
+        root = @project_dir + CFG_DIR_NAME
       when :user
         root = Pathname.new(Dir.home) + CFG_DIR_NAME
       when :defaults
@@ -209,9 +330,11 @@ module MrMurano
     end
 
     ## Load all of the potential config files
-    def load()
+    def load
       # - read/write config file in [Project, User, System] (all are optional)
-      @paths.each { |cfg| cfg.load }
+      @paths.each(&:load)
+      # If user wants curl commands dumped to a file, open that file.
+      init_curl_file
     end
 
     ## Load specified file into the config stack
@@ -222,52 +345,115 @@ module MrMurano
       @paths.insert(1, spc)
     end
 
-    ## Get a value for key, looking at the specificed scopes
+    ## Get a value for key, looking at the specified scopes
     # key is <section>.<key>
     def get(key, scope=CFG_SCOPES)
-      scope = [scope] unless scope.kind_of? Array
-      paths = @paths.select{|p| scope.include? p.kind}
+      scope = [scope] unless scope.is_a? Array
+      paths = @paths.select { |p| scope.include? p.kind }
+      paths = paths.reject { |p| @exclude_scopes.include? p.kind }
+
+      section, ikey = key.split('.')
+      paths.each do |path|
+        next unless path.data.has_section?(section)
+        sec = path.data[section]
+        return sec if ikey.nil?
+        return sec[ikey] if sec.key?(ikey)
+      end
+      nil
+    end
+
+    ## Get one or more key-values for the specified scopes, honoring '*' wildcard.
+    # key is <section>.<key>, <section>.*, or *.<key>
+    def get_wild(key, scope=CFG_SCOPES)
+      scope = [scope] unless scope.is_a? Array
+      paths = @paths.select { |p| scope.include? p.kind }
+      paths = paths.reject { |p| @exclude_scopes.include? p.kind }
 
+      seen = {}
+
+      kvals = []
+      is_wild = wild?(key)
       section, ikey = key.split('.')
       paths.each do |path|
-        if path.data.has_section?(section) then
+        if section != '*' || !is_wild
+          next unless path.data.has_section?(section)
           sec = path.data[section]
-          return sec if ikey.nil?
-          if sec.has_key?(ikey) then
-            return sec[ikey]
+          if ikey != '*' || !is_wild
+            # blah.blug query
+            if !ikey.nil?
+              next unless sec.key?(ikey)
+              kvals += [["#{section}.#{ikey}", sec[ikey], path.kind]]
+            else
+              sec.each do |skey|
+                kvals += [["#{section}.#{skey}", sec[skey], path.kind]]
+              end
+            end
+            return kvals
+          else
+            # blah.* query
+            sec.each do |kv|
+              kvid = "#{section}.#{kv[0]}"
+              next if seen[kvid]
+              seen[kvid] = true
+              kvals += [[kvid, kv[1].to_s, path.kind]]
+            end
+          end
+        else
+          # *.blah query
+          path.data.each do |ini|
+            path.data[ini].keys.each do |skey|
+              next unless ikey == '*' || skey == ikey
+              kvid = "#{ini}.#{skey}"
+              next if seen[kvid]
+              seen[kvid] = true
+              kvals += [[kvid, path.data[ini][skey].to_s, path.kind]]
+            end
           end
         end
       end
-      return nil
+      kvals.sort_by! { |kv| kv[0] }
+      kvals
     end
 
-    ## Dump out a combined config
-    def dump()
-      # have a fake, merge all into it, then dump it.
-      base = IniFile.new()
-      @paths.reverse.each do |ini|
-        base.merge! ini.data
-      end
-      base.to_s
+    def wild?(key)
+      section, ikey = key.split('.')
+      is_wild = (
+        !section.to_s.empty? &&
+        !ikey.to_s.empty? &&
+        ((section == '*') || (ikey == '*'))
+      )
+      is_wild
     end
 
     def set(key, value, scope=:project)
       section, ikey = key.split('.', 2)
-      raise "Invalid key" if section.nil?
-      if not section.nil? and ikey.nil? then
+      raise 'Invalid key' if section.nil?
+      if ikey.nil?
         # If key isn't dotted, then assume the tool section.
         ikey = section
         section = 'tool'
       end
 
-      paths = @paths.select{|p| scope == p.kind}
-      raise "Unknown scope" if paths.empty?
+      paths = @paths.select { |p| scope == p.kind }
+      raise "Unknown scope ‘#{scope}’" if paths.empty?
+      raise "Too many scopes ‘#{scope}’" if paths.length > 1
+
       cfg = paths.first
       data = cfg.data
       tomod = data[section]
       tomod[ikey] = value unless value.nil?
       tomod.delete(ikey) if value.nil?
       data[section] = tomod
+      # Remove empty sections to make test results more predictable.
+      # Interesting: IniFile.each only returns sections with key-vals,
+      #              so call IniFile.each_section instead, which includes
+      #              empty empty section. Here's what "each" looks like:
+      #                 data.each do |sectn, param, val|
+      #                   puts "#{param} = #{val} [in section: #{sectn}]"
+      data.each_section do |sectn|
+        data.delete_section(sectn) if data[sectn].empty?
+      end
+
       cfg.write
     end
 
@@ -276,16 +462,109 @@ module MrMurano
       get(key)
     end
 
-    # For setting internal, this-run-only values
+    # For setting internal, this-run-only values.
     def []=(key, value)
       set(key, value, :internal)
     end
 
+    ## Dump out a combined config
+    def dump
+      # have a fake, merge all into it, then dump it.
+      base = IniFile.new
+      @paths.reverse.each do |ini|
+        base.merge! ini.data
+      end
+      base.to_s
+    end
+
+    ## Dump out locations of all known configs
+    def locations
+      locats = ''
+      first = true
+      puts ''
+      CFG_SCOPES.each do |scope|
+        locats += "\n" unless first
+        first = false
+
+        cfg_paths = @paths.select { |p| p.kind == scope }
+
+        msg = "Scope: ‘#{scope}’\n\n"
+        locats += Rainbow(msg).bright.underline
+
+        if !cfg_paths.empty?
+          cfg = cfg_paths.first
+
+          if !cfg.path.nil? && cfg.path.exist?
+            path = "Path: #{cfg.path}\n"
+          elsif %i[internal defaults].include? cfg.kind
+            # cfg.path is nil.
+            path = "Path: ‘#{scope}’ config is not saved.\n"
+          else
+            path = "Path: ‘#{scope}’ config does not exist.\n"
+          end
+          #locats += Rainbow(path).bright
+          locats += path
+          locats += "\n"
+
+          skip_content = false
+          if scope == :env
+            locats += "Use the environment variable, MURANO_CONFIGFILE, to specify this config file.\n"
+            locats += "\n"
+            if ENV['MURANO_PASSWORD'].to_s.empty?
+              locats += "The MURANO_PASSWORD environ is not set.\n"
+            else
+              locats += "The MURANO_PASSWORD environ is set and will be used.\n"
+            end
+            skip_content = !cfg.path.exist?
+          end
+          next if skip_content
+          locats += "\n" if scope == :env
+
+          base = IniFile.new
+          base.merge! cfg.data
+          content = base.to_s
+          if !content.empty?
+            locats += "Config:\n\n"
+            #locats += base.to_s
+            base.to_s.split("\n").each do |line|
+              locats += '  ' + line + "\n"
+            end
+          else
+            msg = "Config: Empty INI file.\n"
+            #locats += Rainbow(msg).aqua.bright
+            locats += msg
+          end
+        else
+          msg = "No config found for ‘#{scope}’.\n"
+          if scope != :specified
+            locats += Rainbow(msg).red.bright
+          else
+            locats += "Path: ‘#{scope}’ config does not exist.\n\n"
+            locats += "Use --configfile to specify this config file.\n"
+          end
+        end
+      end
+      locats
+    end
+
+    # To capture curl calls when running rspec, write to a file.
+    def init_curl_file
+      if self['tool.curldebug'] && !self['tool.curlfile'].to_s.strip.empty?
+        if @curlfile_f.nil?
+          @curlfile_f = File.open(self['tool.curlfile'], 'a')
+          # MEH: Call @curlfile_f.close() at some point? Or let Ruby do on exit.
+          @curlfile_f << Time.now.to_s + "\n"
+          @curlfile_f << "murano #{ARGV.join(' ')}\n"
+          @curlfile_f.flush
+        end
+      elsif !@curlfile_f.nil?
+        @curlfile_f.close
+        @curlfile_f = nil
+      end
+    end
   end
 
   class ConfigError < StandardError
   end
-
 end
 
-#  vim: set ai et sw=2 ts=2 :