aro 0.2.6 → 0.2.7

data/sys/aro/{cor.rb → settings/cor.rb}

@@ -1,65 +1,60 @@
+# frozen_string_literal: true
+
 =begin
   
   cor.rb
 
-  cor interface.
+  oss_om cor.
 
   by i2097i
 
 =end
 
-require_relative :"./mancy".to_s
+# require_relative :"./mancy".to_s
 
 module Aro
-  # cli entrypoint
-  def self.cor
-    if CLI::FLAGS[:HELP].include?(CLI::ARGV1)
-      CLI.usage_cor
-      exit(CLI::EXIT_CODES[:SUCCESS])
-    end
-
-    Aro::Cor.instance.load_env
-    Aro::Cor.process_command(ARGV)
-  end
-
   class Cor
     include Singleton
 
-    attr_accessor :base_lines_def, :display_lines, :use_less
+    EXEC_METHODS = [
+      :print_env,
+      :print_cor_def,
+      :edit_config
+    ]
 
-    def self.process_command(args)
-      k = Aro::Cor::DEF.keys.filter{|k| k == args[Aro::Mancy::S]&.upcase&.to_sym}&.first
-      unless k.nil?
-        unless args[Aro::Mancy::OS].nil?
-          # config var_name var_value
-          Aro::Cor.set_ivar(args[Aro::Mancy::S], args[Aro::Mancy::OS])
-        end
-
-        # basic show var description and value
-        self.instance.display_lines = self.instance.lines_var(k, Aro::Cor::DEF[k], ENV[Aro::Cor.ivar_k(k)])
-      else
-        self.instance.display_lines = Aro::Cor.base_lines(args)
-      end
+    def self.print_env
+      self.instance.source_config
+      Aro::P.say(:printing_ivars)
+      Aro::P.say("\n")
+      puts ivars_dump.join("\n")
+      Aro::P.say(:printing_ovars)
+      Aro::P.say("\n")
+      puts ovars_dump.join("\n")
+    end
 
-      if Aro::Mancy.in_aro?
-        if self.instance.use_less
-          Aro::P.less(self.instance.display_lines.join("\n"))
-        else
-          Aro::P.say(self.instance.display_lines)
-        end
-      end
+    def self.print_cor_def
+      self.instance.source_config
+      Aro::P.say("Aro::Cor::DEF")
+      Aro::P.say("\n" + Aro::Cor::DEF.map{|k, v|
+        "#{k}: " + JSON.pretty_generate(Aro::Cor::DEF[k])
+      }.join("\n"))
+    end
 
-      self.instance.use_less = false
+    def self.edit_config
+      puts self.name
+      puts __method__
+      puts :todo_open_cor_editor
+      Aro::Dom::Ma_ain.i2097i_bookmark
     end
 
     ARO_IVA_PREFIX = :ARO_IVA_
     ARO_OVA_PREFIX = :ARO_OVA_
 
-    COR_FILE = :".cor"
+    COR_FILE = :".om_cor"
 
     DATE_FORMAT = "%Y:%m:%d:%H:%M:%S"
 
-    DBG_MODES = [:development, :test]
+    DEBUG_MODES = [:development, :test]
 
     # possible envs
     #
@@ -71,24 +66,6 @@ module Aro
       TEST: :test
     }
 
-    # possible interfaces
-    #
-    # example usage:
-    # Aro::Cor::INTERFACES[:TERMINAL]
-    INTERFACES = {
-      TERMINAL: :terminal,
-      LANIMRET: :lanimret,
-    }
-
-    # possible dimensions
-    #
-    # example usage:
-    # Aro::Cor::DMS[:DEV_TAROT]
-    DMS = {
-      DEV_TAROT: :dev_tarot,
-      RUBY_FACOT: :ruby_facot
-    }
-
     # ovar and ivar access
     #
     # example usage:
@@ -113,11 +90,11 @@ module Aro
     # types used in definition
     #
     # example usage:
-    # Aro::Cor::DEF_TYPES[:INT][:validator].call(unvalid, Aro::Cor::DEF[:DIMENSION])
+    # Aro::Cor::DEF_TYPES[:INT][:validator].call(unvalid, Aro::Cor::DEF[:])
     DEF_TYPES = {
       BOOL: {
         name: Aro::Cor::TYPES[:BOOL],
-        description: I18n.t("cor.type.bool_description"),
+        description: I18n.t("cor.types.bool_description"),
         converter: Proc.new{|v| v.kind_of?(TrueClass) ? true : false},
         validator: Proc.new{|unvalid, k, v|
           Aro::Cor.def_valid?(k, v) &&
@@ -126,7 +103,7 @@ module Aro
       },
       INT: {
         name: Aro::Cor::TYPES[:INT],
-        description: I18n.t("cor.type.int_description"),
+        description: I18n.t("cor.types.int_description"),
         converter: Proc.new{|v| v.to_i},
         validator: Proc.new{|unvalid, k, v|
           Aro::V.say("validating #{k} (#{Aro::Cor::DEF_TYPES[:INT][:name]})")
@@ -142,7 +119,7 @@ module Aro
       },
       STRING: {
         name: Aro::Cor::TYPES[:STRING],
-        description: I18n.t("cor.type.string_description"),
+        description: I18n.t("cor.types.string_description"),
         converter: Proc.new{|v| v.to_s},
         validator: Proc.new{|unvalid, k, v|
           Aro::Cor.def_valid?(k, v) &&
@@ -151,7 +128,7 @@ module Aro
       },
       VALUES: {
         name: Aro::Cor::TYPES[:VALUES],
-        description: I18n.t("cor.type.values_description"),
+        description: I18n.t("cor.types.values_description"),
         converter: Proc.new{|v| v.to_s},
         validator: Proc.new{|unvalid, k, v|
           Aro::Cor.def_valid?(k, v) &&
@@ -227,12 +204,6 @@ module Aro
           test: I18n.t("cor.env.test_description"),
         }
       },
-      VERBOSE: {
-        type: Aro::Cor::TYPES[:BOOL],
-        access: Aro::Cor::DEF_ACCESS[:WRITE],
-        value: Aro::Cor::BOOLS[:FALSE],
-        description: I18n.t("cor.verbose_description"),
-      },
       LOG_DATABASE: {
         type: Aro::Cor::TYPES[:BOOL],
         access: Aro::Cor::DEF_ACCESS[:WRITE],
@@ -245,82 +216,25 @@ module Aro
         value: nil,
         description: I18n.t("cor.oss_om_home.description"),
         possible_values: {
-          any_valid_path: I18n.t("cor.oss_om_home.any_valid_path_description"),
-        }
-      },
-      INTERFACE: {
-        type: Aro::Cor::TYPES[:VALUES],
-        implemented: false,
-        access: Aro::Cor::DEF_ACCESS[:WRITE],
-        value: Aro::Cor::INTERFACES[:TERMINAL],
-        description: I18n.t("cor.interface.description"),
-        possible_values: {
-          terminal: I18n.t("cor.interface.terminal_description"),
-          lanimret: I18n.t("cor.interface.lanimret_description")
+          path: I18n.t("cor.oss_om_home.path_description"),
         }
       },
-      DIMENSION: {
-        type: Aro::Cor::TYPES[:VALUES],
-        access: Aro::Cor::DEF_ACCESS[:WRITE],
-        value: Aro::Cor::DMS[:DEV_TAROT],
-        description: I18n.t("cor.dimension.description"),
-        possible_values: {
-          dev_tarot: I18n.t("cor.dimension.dev_tarot_description"),
-          ruby_facot: I18n.t("cor.dimension.ruby_facot_description"),
-        }
-      },
-      HEIGHT: {
-        type: Aro::Cor::TYPES[:INT],
-        access: Aro::Cor::DEF_ACCESS[:WRITE],
-        value: Aro::Mancy::NUMERALS[:XLII],
-        min: Aro::Mancy::NUMERALS[:I],
-        max: Aro::Mancy::NUMERALS[:MMXCVII],
-        description: I18n.t(
-          "cor.height_description",
-          min: Aro::Mancy::NUMERALS[:I],
-          max: Aro::Mancy::NUMERALS[:MMXCVII],
-        ),
-      },
-      WIDTH: {
-        type: Aro::Cor::TYPES[:INT],
-        access: Aro::Cor::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],
-        description: I18n.t(
-          "cor.width_description",
-          min: Aro::Mancy::NUMERALS[:I],
-          max: Aro::Mancy::NUMERALS[:MMXCVII],
-        ),
-      },
-      Z: {
-        type: Aro::Cor::TYPES[:INT],
-        access: Aro::Cor::DEF_ACCESS[:WRITE],
-        value: Aro::Mancy::NUMERALS[:I],
-        min: Aro::Mancy::NUMERALS[:I],
-        max: Aro::Mancy::NUMERALS[:MMXCVII],
-        description: I18n.t(
-          "cor.z_description",
-          min: Aro::Mancy::NUMERALS[:I],
-          max: Aro::Mancy::NUMERALS[:MMXCVII],
-        ),
-      },
-      Z_MAX: {
-        type: Aro::Cor::TYPES[:INT],
+      VERBOSE: {
+        type: Aro::Cor::TYPES[:BOOL],
         access: Aro::Cor::DEF_ACCESS[:WRITE],
-        value: Aro::Mancy::NUMERALS[:VII],
-        min: Aro::Mancy::NUMERALS[:I],
-        max: Aro::Mancy::NUMERALS[:XXII],
-        description: I18n.t(
-          "cor.z_max_description",
-          min: Aro::Mancy::NUMERALS[:I],
-          max: Aro::Mancy::NUMERALS[:XXII],
-        ),
+        value: Aro::Cor::BOOLS[:FALSE],
+        description: I18n.t("cor.verbose_description"),
       },
 
       #
       # => ovars
       #
+      OSS_OM_FILE: {
+        type: Aro::Cor::TYPES[:STRING],
+        access: Aro::Cor::DEF_ACCESS[:READ],
+        value: Aro::Mancy::NAME_FILE,
+        description: I18n.t("cor.aro_env.OSS_OM_FILE_description"),
+      },
       O: {
         type: Aro::Cor::TYPES[:INT],
         access: Aro::Cor::DEF_ACCESS[:READ],
@@ -351,70 +265,26 @@ module Aro
         value: Aro::Mancy::N,
         description: I18n.t("cor.aro_env.N_description"),
       },
-      NAME_FILE: {
-        type: Aro::Cor::TYPES[:STRING],
-        access: Aro::Cor::DEF_ACCESS[:READ],
-        value: Aro::Mancy::NAME_FILE,
-        description: I18n.t("cor.aro_env.NAME_FILE_description"),
-      },
-      I2097I: {
-        type: Aro::Cor::TYPES[:STRING],
-        access: Aro::Cor::DEF_ACCESS[:READ],
-        value: Aro::Mancy::I2097I,
-        description: I18n.t("cor.aro_env.I2097I_description"),
-      },
-      YES: {
-        type: Aro::Cor::TYPES[:STRING],
-        access: Aro::Cor::DEF_ACCESS[:READ],
-        value: Aro::Mancy::YES,
-        description: I18n.t("cor.aro_env.YES_description"),
-      },
-      ALL: {
-        type: Aro::Cor::TYPES[:STRING],
+      N: {
+        type: Aro::Cor::TYPES[:INT],
         access: Aro::Cor::DEF_ACCESS[:READ],
-        value: Aro::Mancy::ALL,
-        description: I18n.t("cor.aro_env.ALL_description"),
+        value: Aro::Mancy::V,
+        description: I18n.t("cor.aro_env.V_description"),
       },
     }
 
-    def load_env
-      self.base_lines_def = nil
+    def self.open!
+      cor_menu = Aro::Dom::DataBase.open_menu(:cor)
+      generate_cor_menu_items! if Aro::Mancy::S == cor_menu.menu_items.count
+      Aro::Dom::Ma_ain.open!(:cor)
+    end
+
+    def load_env!
       unless File.exist?(Aro::Cor.cor_filepath)
         generate_config
       end
 
       source_config
-      Aro::D.say("running in #{Aro::Cor.ivar(:ENV)} env.")
-
-      self.display_lines = Aro::Cor.base_lines
-    end
-
-    def self.base_lines(args = nil)
-      if self.instance.base_lines_def.nil? || args.present?
-        args = [] if args.nil?
-        # print Aro::Cor::DEF
-        lines = []
-        lines << "loaded config at: #{Aro::Cor.cor_filepath}"
-        lines << "<Aro::Cor::DEF>"
-        self.instance.use_less = false
-        case args[Aro::Mancy::S]&.to_sym
-        when :ivars
-          lines += Aro::Cor.ivars_dump
-        when :ovars
-          lines += Aro::Cor.ovars_dump
-        else
-          # print cor commands
-          self.instance.use_less = true
-          lines << ""
-          lines << I18n.t("constants.commands")
-          lines << ""
-          lines += Aro::Cmd.display_lines
-        end
-
-        self.instance.base_lines_def = lines
-      end
-
-      return self.instance.base_lines_def
     end
 
     def self.cor_filepath
@@ -428,19 +298,6 @@ module Aro
       Aro::Cor.ivar(:ENV) == Aro::Cor::ENVS[:TEST].to_s
     end
 
-    def self.discon
-      height = Aro::Cor.ivar(:HEIGHT).to_i
-      width = Aro::Cor.ivar(:WIDTH).to_i
-
-      result = {
-        HEIGHT: height,
-        WIDTH: width,
-        DIVIDER: :".".to_s
-      }
-
-      result
-    end
-
     # out vars
     def self.ovar(suffix)
       Aro::Cor::DEF[suffix][:value]
@@ -469,7 +326,7 @@ module Aro
       # set ruby ENV key value
       # only write to ruby ENV from here
       ENV[Aro::Cor.ivar_k(k.to_s)] = converted
-      Aro::P.say("#{k} set to #{converted}") unless converted.nil? || converted.empty?
+      Aro::D.say("#{k} set to #{converted}") unless converted.nil? || converted.empty?
       return true
     end
 
@@ -477,12 +334,7 @@ module Aro
       k = k.upcase.to_sym
 
       current_value = Aro::Cor.ivar(k)
-      if k == :DIMENSION &&
-        new_value == Aro::Cor::DMS[:DEV_TAROT].to_s &&
-        !Aro::T.is_dev_tarot_avail?
-        Aro::P.say("unable to set dimension dev_tarot. device not present.")
-        return
-      elsif k == :OSS_OM_HOME
+      if k == :OSS_OM_HOME
         unless Dir.exist?(new_value)
           Aro::P.say("cannot set #{k} to #{new_value}. the directory does not exist.")
         end
@@ -514,7 +366,6 @@ module Aro
       end
     end
 
-    # todo: add_to_docs
     def self.ivars_dump
       dump = []
       Aro::Cor::DEF.select{|k, v|
@@ -539,6 +390,7 @@ module Aro
     end
 
     def source_config
+      return unless File.exist?(Aro::Cor.cor_filepath)
       Aro::D.say(I18n.t("cor.source", name: Aro::Cor.cor_filepath))
       File.read(Aro::Cor.cor_filepath).split("\n").select{|line|
         line.match?(/export #{Aro::Cor::ARO_IVA_PREFIX}/)
@@ -565,7 +417,7 @@ module Aro
       }
     end
 
-    # from_memory true means write current config to file
+        # from_memory true means write current config to file
     def generate_config(from_memory = false)
       # todo: localize generated config text
       Aro::D.say(I18n.t("cor.generate", name: Aro::Cor.cor_filepath))
@@ -626,6 +478,30 @@ module Aro
       write_config(lines)
     end
 
+    private
+
+    def self.generate_cor_menu_items!
+      cor_menu = Aro::Dom::DataBase.open_menu(:cor)
+      return unless Aro::Mancy::S == cor_menu.menu_items.count
+
+      existing_item = cor_menu.menu_items.first
+      raise "missing existing item in #{self.name}.#{__method__}!" if existing_item.nil?
+      EXEC_METHODS.each{|method_name|
+        menu_item = existing_item || cor_menu.generate_new_item(method_name, for_type: :system)
+
+        cor_menu.rename_item(menu_item, method_name) unless existing_item.nil?
+        menu_item.aro_file.write!(
+          Aro::Dom::Store.build_exec_oss_om_params!(
+            self,
+            method_name,
+            "#{:cor} #{method_name}"
+          )
+        )
+        # clear existing item var
+        existing_item = nil unless existing_item.nil?
+      }
+    end
+
     def write_config(lines)
       File.open(Aro::Cor.cor_filepath, "w+") do |file|
         file.write(lines.join("\n"))
@@ -691,16 +567,16 @@ module Aro
       lines << "#   => Aro::Cor::DEF_TYPES: #{v[:type]}"
       case v[:type]
       when Aro::Cor::DEF_TYPES[:BOOL][:name]
-        lines << "#   => #{I18n.t("cor.type.bool_description")}"
+        lines << "#   => #{I18n.t("cor.types.bool_description")}"
       when Aro::Cor::DEF_TYPES[:INT][:name]
-        lines << "#   => #{I18n.t("cor.type.int_description")}"
+        lines << "#   => #{I18n.t("cor.types.int_description")}"
         lines << "#   => #{I18n.t("cor.minimum")}: #{v[:min]}"
         lines << "#   => #{I18n.t("cor.maximum")}: #{v[:max]}"
       when Aro::Cor::DEF_TYPES[:STRING][:name]
-        lines << "#   => #{I18n.t("cor.type.string_description")}"
+        lines << "#   => #{I18n.t("cor.types.string_description")}"
         lines << "#   => use \"double quotes\" if there are any spaces."
       when Aro::Cor::DEF_TYPES[:VALUES][:name]
-        lines << "#   => #{I18n.t("cor.type.values_description")}"
+        lines << "#   => #{I18n.t("cor.types.values_description")}"
         lines << "#   => #{I18n.t("cor.possible_values")}:"
         lines += lines_newline_comment
         v[:possible_values].each{|name, description|

data/sys/aro/settings/git.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+=begin
+
+  git.rb
+
+  aro dom git.
+
+  by i2097i
+
+=end
+
+module Aro
+  module Dom
+    class Git
+
+      EXEC_METHODS = [
+        :status,
+        :log,
+        :config
+      ]
+
+      def self.open!
+        generate_git_menu_items!
+        Aro::Dom::Ma_ain.open!(:git)
+      end
+
+      def self.status
+        Aro::P.say("system(git status)")
+        system(:"git status".to_s)
+      end
+
+      def self.log
+        Aro::P.say("system(git log)")
+        system(:"git log".to_s)
+      end
+
+      def self.config
+        Aro::P.say("system(git config list --local)")
+        system(:"git config list --local".to_s)
+      end
+
+      private
+
+      def self.generate_git_menu_items!
+        git_menu = Aro::Dom::DataBase.open_menu(:git)
+        return unless Aro::Mancy::S == git_menu.menu_items.count
+
+        existing_item = git_menu.menu_items.first
+        raise "missing existing item in #{self.name}.#{__method__}!" if existing_item.nil?
+        EXEC_METHODS.each{|method_name|
+          menu_item = existing_item || git_menu.generate_new_item(method_name, for_type: :system)
+
+          git_menu.rename_item(menu_item, method_name) unless existing_item.nil?
+          menu_item.aro_file.write!(
+            Aro::Dom::Store.build_exec_oss_om_params!(
+              self,
+              method_name,
+              "#{:git} #{method_name}"
+            )
+          )
+          # clear existing item var
+          existing_item = nil unless existing_item.nil?
+        }
+      end
+
+    end
+  end
+end

data/sys/aro/settings/ssh.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+=begin
+
+  ssh.rb
+
+  aro dom ssh.
+
+  by i2097i
+
+=end
+
+module Aro
+  module Dom
+    class Ssh
+      EXEC_METHODS = [
+        :print_public_key,
+      ]
+
+      ID_KEY_BASE = :id_oss_om
+
+      def self.open!
+        generate_ssh_menu_items!
+        Aro::Dom::Ma_ain.open!(:ssh)
+      end
+
+      def self.print_public_key
+        Aro::P.less(::File.read("#{id_key_path}.pub"))
+      end
+
+      def self.write_encrypted_file!(file_path, decrypted_json)
+        # todo: validations
+        #
+        # 1) encrypt decrypted_json
+        # 2) write encrypted contents
+        # 3) return success/failure
+        begin
+          # open and write
+          ::File.open(file_path, "w+") do |f|
+            f.write(
+              encrypt!(decrypted_json)
+            )
+          end
+        rescue StandardError => e
+          Aro::P.say("#{self.name}:#{__method__}")
+          Aro::P.say(e.inspect)
+          return e
+        end
+
+        return true
+      end
+
+      def self.decrypt_file!(file_path)
+        # 1) open file
+        # 2) decrypt contents
+        # 3) return decrypted contents
+        begin
+          # read and decrypt
+          decrypted_json = decrypt!(
+            JSON.parse(
+              ::File.read(file_path, encoding: "UTF-8")
+            )
+          )
+        rescue JSON::ParserError => e
+          Aro::P.say("#{self.name}:#{__method__}")
+          Aro::P.say(e.inspect)
+          return e
+        rescue StandardError => e
+          Aro::P.say("#{self.name}:#{__method__}")
+          Aro::P.say(e.inspect)
+          return e
+        end
+
+        decrypted_json
+      end
+
+      def self.id_key_path
+        ::File.join(Aro::Cor.ivar(:OSS_OM_HOME), ID_KEY_BASE.to_s)
+      end
+
+      private
+
+      def self.generate_ssh_menu_items!
+        ssh_menu = Aro::Dom::DataBase.open_menu(:ssh)
+        return unless Aro::Mancy::S == ssh_menu.menu_items.count
+        # todo: generate ssh menu items if needed here
+        existing_item = ssh_menu.menu_items.first
+        raise "missing existing item in #{self.name}.#{__method__}!" if existing_item.nil?
+        EXEC_METHODS.each{|method_name|
+          menu_item = existing_item || ssh_menu.generate_new_item(method_name, for_type: :system)
+
+          ssh_menu.rename_item(menu_item, method_name) unless existing_item.nil?
+          menu_item.aro_file.write!(
+            Aro::Dom::Store.build_exec_oss_om_params!(
+              self,
+              method_name,
+              "#{:ssh} #{method_name}"
+            )
+          )
+          # clear existing item var
+          existing_item = nil unless existing_item.nil?
+        }
+      end
+
+      def self.encrypt!(decrypted_json)
+        Aro::Dom::Ma_ain.i2097i_bookmark
+        puts __method__
+        puts :expects_decrypted_json
+
+        return decrypted_json
+      end
+
+      def self.decrypt!(encrypted_json)
+        Aro::Dom::Ma_ain.i2097i_bookmark
+        puts __method__
+        puts :expects_encrypted_json
+
+        return encrypted_json
+      end
+
+    end
+  end
+end