aro 0.2.0 → 0.2.1

data/sys/{cli → dom}/config.rb

@@ -2,22 +2,24 @@
   
   config.rb
 
-  configuration interface.
+  dom config interface.
 
   by i2097i
 
 =end
 
-module CLI
+module Aro
 
   # cli entrypoint
   def self.config
-    CLI::Config.process_config_command(ARGV)
+    Aro::Config.process_config_command(ARGV)
   end
 
   class Config
     include Singleton
 
+    attr_accessor :config_path, :display_lines
+
     ARO_CONFIG_PREFIX = :ARO_CONFIG_
     ARO_ENV_PREFIX = :ARO_ENV_
 
@@ -28,7 +30,7 @@ module CLI
     # possible envs
     # 
     # example usage:
-    # CLI::Config::ENVS[:PRODUCTION]
+    # Aro::Config::ENVS[:PRODUCTION]
     ENVS = {
       DEVELOPMENT: :development,
       PRODUCTION: :production,
@@ -38,7 +40,7 @@ module CLI
     # possible formats
     # 
     # example usage:
-    # CLI::Config::FORMATS[:TEXT]
+    # Aro::Config::FORMATS[:TEXT]
     FORMATS = {
       TEXT: :text,
       JSON: :json,
@@ -47,7 +49,7 @@ module CLI
     # possible dimensions
     # 
     # example usage:
-    # CLI::Config::DMS[:DEV_TAROT]
+    # Aro::Config::DMS[:DEV_TAROT]
     DMS = {
       DEV_TAROT: :dev_tarot,
       RUBY_FACOT: :ruby_facot,
@@ -56,7 +58,7 @@ module CLI
     # ovar and ivar access
     #
     # example usage:
-    # CLI::Config::DEF_ACCESS[:READ]
+    # Aro::Config::DEF_ACCESS[:READ]
     DEF_ACCESS = {
       READ: :read,
       WRITE: :write
@@ -77,21 +79,21 @@ module CLI
     # types used in definition
     # 
     # example usage:
-    # CLI::Config::DEF_TYPES[:INT][:validator].call(unvalid, CLI::Config::DEF[:DIMENSION])
+    # Aro::Config::DEF_TYPES[:INT][:validator].call(unvalid, Aro::Config::DEF[:DIMENSION])
     DEF_TYPES = {
       BOOL: {
-        name: CLI::Config::TYPES[:BOOL],
+        name: Aro::Config::TYPES[:BOOL],
         description: I18n.t("cli.config.type.bool_description"),
         converter: Proc.new{|v|
-          if [CLI::Config::BOOLS[:TRUE].to_s, Aro::Mancy::S].include?(v)
-            CLI::Config::BOOLS[:TRUE]
+          if [Aro::Config::BOOLS[:TRUE].to_s, Aro::Mancy::S].include?(v)
+            Aro::Config::BOOLS[:TRUE]
           else
-            CLI::Config::BOOLS[:FALSE]
+            Aro::Config::BOOLS[:FALSE]
           end
         },
         validator: Proc.new{|unvalid, k, v|
-          CLI::Config.def_valid?(k, v) &&
-          CLI::Config.bool_valid?(unvalid)
+          Aro::Config.def_valid?(k, v) &&
+          Aro::Config.bool_valid?(unvalid)
         }
       },
       INT: {
@@ -99,11 +101,11 @@ module CLI
         description: I18n.t("cli.config.type.int_description"),
         converter: Proc.new{|v| v.to_i},
         validator: Proc.new{|unvalid, k, v|
-          Aro::V.say("validating #{k} (#{CLI::Config::DEF_TYPES[:INT][:name]})")
+          Aro::V.say("validating #{k} (#{Aro::Config::DEF_TYPES[:INT][:name]})")
           Aro::V.say("unvalid = #{unvalid}")
           Aro::V.say("[min, max] = [#{v[:min]}, #{v[:max]}]")
-          int_valid = CLI::Config.def_valid?(k, v) &&
-            CLI::Config.int_valid?(unvalid)        &&
+          int_valid = Aro::Config.def_valid?(k, v) &&
+            Aro::Config.int_valid?(unvalid)        &&
             unvalid.to_i >= v[:min]                &&
             unvalid.to_i <= v[:max]
           Aro::V.say("unvalid(#{unvalid}) is#{int_valid ? " " : :" not ".to_s}valid.")
@@ -115,8 +117,8 @@ module CLI
         description: I18n.t("cli.config.type.string_description"),
         converter: Proc.new{|v| v.to_s},
         validator: Proc.new{|unvalid, k, v|
-          CLI::Config.def_valid?(k, v) &&
-          CLI::Config.string_valid?(unvalid)
+          Aro::Config.def_valid?(k, v) &&
+          Aro::Config.string_valid?(unvalid)
         }
       },
       VALUES: {
@@ -124,14 +126,14 @@ module CLI
         description: I18n.t("cli.config.type.values_description"),
         converter: Proc.new{|v| v.to_s},
         validator: Proc.new{|unvalid, k, v|
-          CLI::Config.def_valid?(k, v) &&
+          Aro::Config.def_valid?(k, v) &&
           v[:possible_values].keys.include?(unvalid&.to_sym)
         }
       },
     }
 
     def self.bool_valid?(unvalid)
-      CLI::Config::BOOLS.values.map{|b| b.to_s.to_sym}.include?(unvalid&.to_s&.to_sym)
+      Aro::Config::BOOLS.values.map{|b| b.to_s.to_sym}.include?(unvalid&.to_s&.to_sym)
     end
 
     def self.int_valid?(unvalid)
@@ -143,7 +145,7 @@ module CLI
     end
 
     def self.def_valid?(key, deff)
-      def_valid = deff == CLI::Config::DEF[key]
+      def_valid = deff == Aro::Config::DEF[key]
       unless def_valid
         Aro::V.say("invalid def! #{key} => #{deff}")
       end
@@ -153,10 +155,10 @@ module CLI
 
     def validate_config
       invalid_vars = []
-      CLI::Config::DEF.each{|k, v|
-        is_valid = v[:access] == CLI::Config::DEF_ACCESS[:READ]
+      Aro::Config::DEF.each{|k, v|
+        is_valid = v[:access] == Aro::Config::DEF_ACCESS[:READ]
         unless is_valid
-          is_valid = valid_var?(CLI::Config.ivar(k), k, v)
+          is_valid = valid_var?(Aro::Config.ivar(k), k, v)
         end
         invalid_vars << k unless is_valid
       }
@@ -165,32 +167,32 @@ module CLI
 
     def valid_var?(var_value, k, v)
       Aro::V.say(v)
-      return true if v[:access] == CLI::Config::DEF_ACCESS[:READ]
+      return true if v[:access] == Aro::Config::DEF_ACCESS[:READ]
 
-      CLI::Config::DEF_TYPES[
+      Aro::Config::DEF_TYPES[
         v[:type].to_s.upcase.to_sym
       ][:validator].call(var_value, k, v)
     end
 
     def convert_var_for_def(k)
-      CLI::Config::DEF_TYPES[
-        CLI::Config::DEF[k][:type].upcase
-      ][:converter].call(ENV[CLI::Config.ivar_k(k)])
+      Aro::Config::DEF_TYPES[
+        Aro::Config::DEF[k][:type].upcase
+      ][:converter].call(ENV[Aro::Config.ivar_k(k)])
     end
 
     # adapts I18n translations to generate bash environment vars.
     # 
     # example usage:
-    # CLI::Config::DEF[:Z_MAX]
+    # Aro::Config::DEF[:Z_MAX]
     DEF = {
 
       #
       # => ivars
       #
       ENV: {
-        type: CLI::Config::TYPES[:VALUES],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: CLI::Config::ENVS[:PRODUCTION],
+        type: Aro::Config::TYPES[:VALUES],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Config::ENVS[:PRODUCTION],
         description: I18n.t("cli.config.env.description"),
         possible_values: {
           development: I18n.t("cli.config.env.development_description"),
@@ -199,28 +201,28 @@ module CLI
         }
       },
       VERBOSE: {
-        type: CLI::Config::TYPES[:BOOL],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: CLI::Config::BOOLS[:FALSE],
+        type: Aro::Config::TYPES[:BOOL],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Config::BOOLS[:FALSE],
         description: I18n.t("cli.config.verbose_description"),
       },
       LOG_AOS_DB: {
-        type: CLI::Config::TYPES[:BOOL],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: CLI::Config::BOOLS[:FALSE],
+        type: Aro::Config::TYPES[:BOOL],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Config::BOOLS[:FALSE],
         description: I18n.t("cli.config.log_aos_db_description"),
       },
       LOG_ARO_DB: {
-        type: CLI::Config::TYPES[:BOOL],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: CLI::Config::BOOLS[:FALSE],
+        type: Aro::Config::TYPES[:BOOL],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Config::BOOLS[:FALSE],
         description: I18n.t("cli.config.log_aro_db_description"),
       },
       FORMAT: { # not implemented yet.
-        type: CLI::Config::TYPES[:VALUES],
+        type: Aro::Config::TYPES[:VALUES],
         implemented: false,
-        access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: CLI::Config::FORMATS[:TEXT],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Config::FORMATS[:TEXT],
         description: I18n.t("cli.config.format.description"),
         possible_values: {
           text: I18n.t("cli.config.format.text_description"),
@@ -228,9 +230,9 @@ module CLI
         }
       },
       DIMENSION: {
-        type: CLI::Config::TYPES[:VALUES],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
-        value: CLI::Config::DMS[:DEV_TAROT],
+        type: Aro::Config::TYPES[:VALUES],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
+        value: Aro::Config::DMS[:DEV_TAROT],
         description: I18n.t("cli.config.dimension.description"),
         possible_values: {
           dev_tarot: I18n.t("cli.config.dimension.dev_tarot_description"),
@@ -238,8 +240,8 @@ module CLI
         }
       },
       HEIGHT: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
         value: Aro::Mancy::NUMERALS[:XLII],
         min: Aro::Mancy::NUMERALS[:I],
         max: Aro::Mancy::NUMERALS[:MMXCVII],
@@ -250,8 +252,8 @@ module CLI
         ),
       },
       WIDTH: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
         value: Aro::Mancy::NUMERALS[:C] + Aro::Mancy::NUMERALS[:XXXVII] - Aro::Mancy::S,
         min: Aro::Mancy::NUMERALS[:I],
         max: Aro::Mancy::NUMERALS[:MMXCVII],
@@ -262,8 +264,8 @@ module CLI
         ),
       },
       Z: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
         value: Aro::Mancy::NUMERALS[:I],
         min: Aro::Mancy::NUMERALS[:I],
         max: Aro::Mancy::NUMERALS[:MMXCVII],
@@ -274,8 +276,8 @@ module CLI
         ),
       },
       Z_MAX: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:WRITE],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:WRITE],
         value: Aro::Mancy::NUMERALS[:VII],
         min: Aro::Mancy::NUMERALS[:I],
         max: Aro::Mancy::NUMERALS[:XXII],
@@ -290,116 +292,115 @@ module CLI
       # => ovars
       #
       ARO_ENV_O: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::O,
         description: I18n.t("cli.config.aro_env.O_description"),
       },
       ARO_ENV_S: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::S,
         description: I18n.t("cli.config.aro_env.S_description"),
       },
       ARO_ENV_OS: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::OS,
         description: I18n.t("cli.config.aro_env.OS_description"),
       },
       ARO_ENV_E: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::E,
         description: I18n.t("cli.config.aro_env.E_description"),
       },
       ARO_ENV_N: {
-        type: CLI::Config::TYPES[:INT],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:INT],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::N,
         description: I18n.t("cli.config.aro_env.N_description"),
       },
       ARO_ENV_PS1: {
-        type: CLI::Config::TYPES[:STRING],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:STRING],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::PS1,
         description: I18n.t("cli.config.aro_env.PS1_description"),
       },
       ARO_ENV_NAME_FILE: {
-        type: CLI::Config::TYPES[:STRING],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:STRING],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::NAME_FILE,
         description: I18n.t("cli.config.aro_env.NAME_FILE_description"),
       },
       ARO_ENV_I2097I: {
-        type: CLI::Config::TYPES[:STRING],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:STRING],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::I2097I,
         description: I18n.t("cli.config.aro_env.I2097I_description"),
       },
       ARO_ENV_YES: {
-        type: CLI::Config::TYPES[:STRING],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:STRING],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::YES,
         description: I18n.t("cli.config.aro_env.YES_description"),
       },
       ARO_ENV_ALL: {
-        type: CLI::Config::TYPES[:STRING],
-        access: CLI::Config::DEF_ACCESS[:READ],
+        type: Aro::Config::TYPES[:STRING],
+        access: Aro::Config::DEF_ACCESS[:READ],
         value: Aro::Mancy::ALL,
         description: I18n.t("cli.config.aro_env.ALL_description"),
       },
     }
 
-    def initialize
-      @@context = nil
-      if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
-        @@context = Aro::Db
-      elsif Aro::Dom.in_arodom? && Aro::Dom.is_initialized?
-        @@context = Aos::Db
-      end
-
-      return if @@context.nil?
-      Aro::V.say(@@context)
-
-      unless File.exist?(CLI::Config.config_filepath)
+    def load
+      unless File.exist?(Aro::Config.config_filepath)
         generate_config
       end
 
       source_config
       setup_env
+
+      self.display_lines = Aro::Config.base_lines
     end
 
-    def self.context
-      @@context
+    def self.base_lines
+      # print Aro::Config::DEF
+      lines = []
+      lines << "loaded config at: #{Aos::Os.osify(Aro::Config.config_filepath)}"
+      lines << "<Aro::Config::DEF>"
+      lines += Aro::Config.dump_config
+
+      # print config commands
+      lines << ""
+      lines << I18n.t("aos.constants.commands")
+      lines += Aos::Vw::Base.lines_for_cmd(Aos::Os::CMDS[:CONFIG])
+      lines
     end
 
     def self.config_filepath
-      cfp = nil
-      if @@context == Aro::Db &&
-        Aro::Dom.in_arodom? &&
-        Aro::Dom.is_initialized?
-
-        # override when in arodome game room
-        # this ensures the arodome config is being used
-        cfp = File.join(Aos::Db.base_aro_dir, CLI::Config::CONFIG_FILE.to_s)
-      else
-        cfp = File.join(@@context.base_aro_dir, CLI::Config::CONFIG_FILE.to_s)
+      if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
+        self.instance.config_path = File.join(Dir.pwd, Aro::Db.base_aro_dir)
+      elsif Aro::Dom.in_arodom? && Aro::Dom.is_initialized?
+        self.instance.config_path = File.join(Aro::Dom::dom_root, Aro::Dom.room_path(:config))
       end
 
-      cfp
+      File.join(
+        self.instance.config_path,
+        Aro::Config::CONFIG_FILE.to_s
+      )
     end
 
     def self.is_test?
-      ENV[:ARO_ENV.to_s] == CLI::Config::ENVS[:TEST].to_s
+      ENV[:ARO_ENV.to_s] == Aro::Config::ENVS[:TEST].to_s
     end
 
-    def self.display_config
+    def self.display_configuration
       height, width = IO.console.winsize
       result = {
-        HEIGHT: height, #CLI::Config.ivar(:HEIGHT).to_i,
+        HEIGHT: height, #Aro::Config.ivar(:HEIGHT).to_i,
         WIDTH: width - Aro::Mancy::O,
-        DIVIDER: :"_".to_s
+        DIVIDER: :".".to_s
       }
       # Aro::V.say(result)
 
@@ -407,57 +408,52 @@ module CLI
     end
 
     def self.is_format_text?
-      CLI::Config.ivar(:FORMAT)&.to_sym == CLI::Config::FORMATS[:TEXT]
+      Aro::Config.ivar(:FORMAT)&.to_sym == Aro::Config::FORMATS[:TEXT]
     end
 
     def self.process_config_command(args)
-      if args[1].nil? || args[1] == :aos.to_s
-        # print config
-        Aro::P.say((
-          ["config loaded from #{CLI::Config.config_filepath}"] +
-          CLI::Config.dump_config
-        ).join("\n"))
-      elsif [args[2],args[3]].compact.any? && args[1] == Aos::Os::CMDS[:CONFIG][:cmds][:SET][:key].to_s
-        CLI::Config.set_ivar(args[2], args[3])
+      if [args[2],args[3]].compact.any? && args[1] == Aos::Os::CMDS[:CONFIG][:cmds][:SET][:key].to_s
+        Aro::Config.set_ivar(args[2], args[3])
       end
     end
 
     # out vars
     def self.ovar(suffix)
-      CLI::Config::DEF[suffix][:value]
+      Aro::Config::DEF[suffix][:value]
     end
     # out vars
     def self.ovar_k(suffix)
-      "#{CLI::Config::ARO_ENV_PREFIX}#{suffix}"
+      "#{Aro::Config::ARO_ENV_PREFIX}#{suffix}"
     end
 
     # in vars
     def self.ivar(suffix)
-      ENV[CLI::Config.ivar_k(suffix)]
+      ENV[Aro::Config.ivar_k(suffix)]
     end
     # in vars
     def self.ivar_k(suffix)
-      "#{CLI::Config::ARO_CONFIG_PREFIX}#{suffix}"
+      "#{Aro::Config::ARO_CONFIG_PREFIX}#{suffix}"
     end
 
     def self.set_ivar(k, new_value)
       k = k.upcase.to_sym
 
-      current_value = CLI::Config.ivar(k)
+      current_value = Aro::Config.ivar(k)
       # ensure the var name is valid
       unless current_value.nil?
         Aro::Dom::P.say("validating #{k} with value #{new_value}")
-        if CLI::Config.instance.valid_var?(new_value, k, CLI::Config::DEF[k])
+        if Aro::Config.instance.valid_var?(new_value, k, Aro::Config::DEF[k])
           # set ENV value
-          ENV[CLI::Config.ivar_k(k)] = new_value
+          ENV[Aro::Config.ivar_k(k)] = new_value
           Aro::Dom::P.say("#{k} set to #{new_value}")
-          Aro::V.say(ENV[CLI::Config.ivar_k(k)])
+          Aro::V.say(ENV[Aro::Config.ivar_k(k)])
 
           # flush existing config and regen
-          CLI::Config.instance.generate_config(true)
-          CLI::Config.instance.source_config
-          CLI::Config.instance.setup_env
-          @@context.configure_logger
+          Aro::Config.instance.generate_config(true)
+          Aro::Config.instance.source_config
+          Aro::Config.instance.setup_env
+          Aro::Db.configure_logger
+          Aos::Db.configure_logger
         else
           Aro::Dom::P.say("the ivar value you entered is invalid. ignoring.")
         end
@@ -470,19 +466,19 @@ module CLI
       # do not change - update $ARO_CONFIG_ENV .aro/.config file
       # 
       # default is production
-      varenv = CLI::Config.ivar(:ENV)
-      is_valid = valid_var?(varenv, :ENV, CLI::Config::DEF[:ENV])
-      ENV[:ARO_ENV.to_s] = is_valid ? varenv : CLI::Config::ENVS[:PRODUCTION].to_s
+      varenv = Aro::Config.ivar(:ENV)
+      is_valid = valid_var?(varenv, :ENV, Aro::Config::DEF[:ENV])
+      ENV[:ARO_ENV.to_s] = is_valid ? varenv : Aro::Config::ENVS[:PRODUCTION].to_s
       Aro::D.say("setup_env: #{ENV[:ARO_ENV.to_s]}")
     end
 
     def self.dump_config
       dump = []
-      CLI::Config::DEF.each{|k, v|
-        if v[:access] == CLI::Config::DEF_ACCESS[:WRITE]
-          dump << "$#{CLI::Config.ivar_k(k).ljust(Aro::Mancy::NUMERALS[:XIV] * Aro::Mancy::OS)}=#{CLI::Config.ivar(k)}"
+      Aro::Config::DEF.each{|k, v|
+        if v[:access] == Aro::Config::DEF_ACCESS[:WRITE]
+          dump << "$#{Aro::Config.ivar_k(k).ljust(Aro::Mancy::NUMERALS[:XIV] * Aro::Mancy::OS)}=#{Aro::Config.ivar(k)}"
         else
-          dump << "$#{CLI::Config.ovar_k(k).ljust(Aro::Mancy::NUMERALS[:XIV] * Aro::Mancy::OS)}=#{CLI::Config.ovar(k)}"
+          dump << "$#{Aro::Config.ovar_k(k).ljust(Aro::Mancy::NUMERALS[:XIV] * Aro::Mancy::OS)}=#{Aro::Config.ovar(k)}"
         end
       }
 
@@ -490,9 +486,9 @@ module CLI
     end
 
     def source_config
-      Aro::D.say(I18n.t("cli.config.source", name: CLI::Config.config_filepath))
-      File.read(CLI::Config.config_filepath).split("\n").select{|line|
-        line.match?(/export #{CLI::Config::ARO_CONFIG_PREFIX}/)
+      Aro::D.say(I18n.t("cli.config.source", name: Aro::Config.config_filepath))
+      File.read(Aro::Config.config_filepath).split("\n").select{|line|
+        line.match?(/export #{Aro::Config::ARO_CONFIG_PREFIX}/)
       }.map{|line| 
         line.gsub("export ", "").split("=")
       }.each{|kv|
@@ -503,21 +499,21 @@ module CLI
       
       # todo: implement
       invalid_defs = validate_config
-      CLI::Config.dump_config.each{|l| Aro::V.say(l)}
+      Aro::Config.dump_config.each{|l| Aro::V.say(l)}
       invalid_defs.each{|k|
-        v = CLI::Config::DEF[k.to_sym]
-        if v[:access] == CLI::Config::DEF_ACCESS[:WRITE]
-          ENV[CLI::Config.ivar_k(k)] = v[:value]
+        v = Aro::Config::DEF[k.to_sym]
+        if v[:access] == Aro::Config::DEF_ACCESS[:WRITE]
+          ENV[Aro::Config.ivar_k(k)] = v[:value]
         else
-          ENV[CLI::Config.ovar_k(k)] = v[:value]
+          ENV[Aro::Config.ovar_k(k)] = v[:value]
         end
       }
     end
 
     def generate_config(from_memory = false)
       # todo: localize generated config text
-      Aro::D.say(I18n.t("cli.config.generate", name: CLI::Config.config_filepath))
-      File.open(CLI::Config.config_filepath, "w+") do |file|
+      Aro::D.say(I18n.t("cli.config.generate", name: Aro::Config.config_filepath))
+      File.open(Aro::Config.config_filepath, "w+") do |file|
         # intro
         Aro::Mancy::OS.times do
           print_div file.object_id
@@ -550,8 +546,8 @@ module CLI
         print_osr file.object_id
 
         # vars
-        CLI::Config::DEF.each{|k, v|
-          print_var file.object_id, k, v, (from_memory ? ENV[CLI::Config.ivar_k(k)] : nil)
+        Aro::Config::DEF.each{|k, v|
+          print_var file.object_id, k, v, (from_memory ? ENV[Aro::Config.ivar_k(k)] : nil)
         }
 
         print_osr file.object_id
@@ -603,13 +599,13 @@ module CLI
 
     def print_def_types f_object_id
       file = ObjectSpace._id2ref f_object_id
-      file.write("# CLI::Config::DEF_TYPES\n")
+      file.write("# Aro::Config::DEF_TYPES\n")
       file.write("# describes the possible types of variables.\n")
-      CLI::Config::DEF_TYPES.each{|k, v|
+      Aro::Config::DEF_TYPES.each{|k, v|
         file.write("# #{k}: #{v[:description]}\n")
       }
       print_osr f_object_id
-      file.write("# CLI::Config::DEF\n")
+      file.write("# Aro::Config::DEF\n")
       file.write("# define & expose an aro bash api via ENV variables.\n")
       file.write("# there are two types of bash vars in aro.\n")
       file.write("# 1) in vars (ivars). \n")
@@ -625,25 +621,25 @@ module CLI
     def print_var f_object_id, k, v, mem_v
       file = ObjectSpace._id2ref f_object_id
 
-      is_ovar = CLI::Config::DEF[k][:access] == CLI::Config::DEF_ACCESS[:READ]
+      is_ovar = Aro::Config::DEF[k][:access] == Aro::Config::DEF_ACCESS[:READ]
       if is_ovar
         var_name = k
       else
-        var_name = CLI::Config.ivar_k(k)
+        var_name = Aro::Config.ivar_k(k)
       end
-      Aro::V.say("access for #{k} is #{CLI::Config::DEF[k][:access]}")
+      Aro::V.say("access for #{k} is #{Aro::Config::DEF[k][:access]}")
       Aro::V.say("using var_name: #{var_name}")
       file.write("# [#{var_name}] (#{is_ovar ? :ovar : :ivar})\n")
-      file.write("#   => CLI::Config::DEF_TYPES: #{v[:type]}\n")
+      file.write("#   => Aro::Config::DEF_TYPES: #{v[:type]}\n")
       case v[:type]
-      when CLI::Config::DEF_TYPES[:INT][:name]
+      when Aro::Config::DEF_TYPES[:INT][:name]
         file.write("#   => #{I18n.t("cli.config.type.int_description")}\n")
         file.write("#   => #{I18n.t("cli.config.minimum")}: #{v[:min]}\n")
         file.write("#   => #{I18n.t("cli.config.maximum")}: #{v[:max]}\n")
-      when CLI::Config::DEF_TYPES[:STRING][:name]
+      when Aro::Config::DEF_TYPES[:STRING][:name]
         file.write("#   => #{I18n.t("cli.config.type.string_description")}\n")
         file.write("#   => use \"double quotes\" if there are any spaces.\n")
-      when CLI::Config::DEF_TYPES[:VALUES][:name]
+      when Aro::Config::DEF_TYPES[:VALUES][:name]
         file.write("#   => #{I18n.t("cli.config.type.values_description")}\n")
         file.write("#   => #{I18n.t("cli.config.possible_values")}:\n")
         print_sr f_object_id
@@ -657,7 +653,7 @@ module CLI
       print_osr f_object_id
       file.write("#   => description:\n")
       file.write("#   => #{v[:description]}\n")
-      if is_ovar && CLI::Config::DEF_TYPES[:STRING][:name] == v[:type]
+      if is_ovar && Aro::Config::DEF_TYPES[:STRING][:name] == v[:type]
         file.write("export #{var_name}=\"#{v[:value]}\"\n")
       else
         file.write("export #{var_name}=#{mem_v || v[:value]}\n")