aro 0.2.6 → 0.2.7

data/sys/aro/store.rb

@@ -32,22 +32,70 @@ class Aro::Dom::Store
   def self.edit(aro_file, updates)
     return if aro_file.nil?
     unless ::File.exist?(aro_file.aro_file_path)
-      ::File.write(aro_file.aro_file_path, "{}")
+      ::File.write(aro_file.aro_file_path, {}.to_json)
     end
 
-    # todo: validate updates
+    Aro::Dom::Ma_ain.i2097i_bookmark
+    puts :todo_validate_updates_or_depricate
+    puts __method__
+
+
+    store_instance = Aro::Dom::Ma_ain.instance.get_store_for(aro_file)
+    updates.each{|k, v|
+
+      store_instance.save_key_value_pair(k, v)
+      Aro::P.say([
+        "reading in #{k} after setting to #{v} in #{aro_file.aro_file_path}",
+        "got value => #{store_instance.safe_get_key(k)}"
+      ])
+    }
+  end
+
+  def save_key_value_pair(k, v)
+    set_key(k, v)
+  end
+
+  def save_exec_oss_om_params!(oss_om_const, oss_om_method, label)
+    Aro::P.say(__method__)
     Aro::Dom::Ma_ain.instance.store_mutex.synchronize do
-      store_instance = Aro::Dom::Ma_ain.instance.get_store_for(aro_file)
-      updates.each{|k, v|
-        store_instance.set_key(k, v)
-        Aro::P.say([
-          "reading in #{k} after setting to #{v} in #{aro_file.aro_file_path}",
-          "got value => #{store_instance.get_key(k)}"
-        ])
+      built = self.class.build_exec_oss_om_params!(oss_om_const, oss_om_method, label)
+      built.each{|k, v| self.set_key(k, v)}
+    end
+  end
+
+  def self.build_exec_oss_om_params!(oss_om_const, oss_om_method, label)
+    Aro::P.say(__method__)
+    # {
+    #   action_name:,
+    #   action_key: Aro::Dom::Action::TYPES[:OSS_OM][:key],
+    #   action_params: {
+    #     aro_class_name:,
+    #     aro_class_method:
+    #   }
+    # }
+    raise "invalid oss_om_const!" unless Aro::Dom::Oss_OpenMenu::EXEC_CLASSES.include?(oss_om_const.name)
+    raise "invalid oss_om_method! #{oss_om_method}" unless oss_om_const.methods.include?(oss_om_method.to_sym)
+    {
+      action_name: label,
+      action_key: :exec_oss_om,
+      action_params: {
+        aro_class_name: oss_om_const.name,
+        aro_class_method: oss_om_method
       }
+    }
+  end
+
+  def safe_get_key(k)
+    safe_key = nil
+    Aro::Dom::Ma_ain.instance.store_mutex.synchronize do
+      safe_key = get_key(k)
     end
+
+    safe_key
   end
 
+  private
+
   def get_key(key)
     return if open_file_path.nil?
 
@@ -62,20 +110,19 @@ class Aro::Dom::Store
     # open storage
     @is_open = true
     storage_contents = {}
-    begin
+    @parser_error = Aro::Dom::Ssh.decrypt_file!(open_file_path)
+    unless @parser_error.kind_of?(StandardError) ||
+      StandardError.subclasses.include?(@parser_error.class)
+
+      # return value from Aro::Dom::Ssh.decrypt_file!
+      # is not an error.
+      storage_contents = @parser_error
       @parser_error = nil
-      # read storage
-      storage_contents = JSON.parse(
-        ::File.read(open_file_path, encoding: "UTF-8")
-      )
-    rescue StandardError => e
+    end
+
+    unless @parser_error.nil?
       @is_open = false
-      if @parser_error.nil?
-        @parser_error = e
-        return get_key(key)
-      else
-        raise @parser_error
-      end
+      raise @parser_error
     end
 
     # only update the cache value if present in storage
@@ -106,25 +153,25 @@ class Aro::Dom::Store
 
     # return if storage open
     # non-persisted cache values update next cycle
-    return if @is_open
+    return true if @is_open
 
     # open storage
     @is_open = true
     storage_contents = {}
-    begin
+
+    @parser_error = Aro::Dom::Ssh.decrypt_file!(open_file_path)
+    unless @parser_error.kind_of?(StandardError) ||
+      StandardError.subclasses.include?(@parser_error.class)
+
+      # return value from Aro::Dom::Ssh.decrypt_file!
+      # is not an error.
+      storage_contents = @parser_error
       @parser_error = nil
-      # read storage
-      storage_contents = JSON.parse(
-        ::File.read(open_file_path, encoding: "UTF-8")
-      )
-    rescue StandardError => e
+    end
+
+    unless @parser_error.nil?
       @is_open = false
-      if @parser_error.nil?
-        @parser_error = e
-        return get_key(key)
-      else
-        raise @parser_error
-      end
+      raise @parser_error
     end
 
     # update storage and cache
@@ -136,12 +183,16 @@ class Aro::Dom::Store
     }
 
     # write storage
-    ::File.open(open_file_path, "w+") do |f|
-      f.write(storage_contents.to_json)
+    write_result = Aro::Dom::Ssh.write_encrypted_file!(open_file_path, storage_contents.to_json)
+    unless write_result == true
+      @is_open = false
+      raise write_result
     end
 
     # close storage
     @is_open = false
     clear_cache! if @clear_flag
+
+    write_result
   end
 end

data/sys/aro/v.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
   
   v.rb

data/sys/aro.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
   
   aro.rb

data/sys/ma_ain.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+=begin
+
+  ma_ain.rb
+
+  aro dom ma_ain.
+
+  by i2097i
+
+=end
+
+module Aro
+  module Dom
+    class Ma_ain < Aro::Mancy
+      # inherits Singleton
+
+      # evolution planning
+      #
+      # Cor       (copy of Aro::Cor)
+      # Engine
+      # Designer
+      # Git
+      # Ssh
+      # Block     (copy of Aro::Dom::DataBase)
+      # Chain     (copy of Aro::Dom::Directory)
+      # Node      (copy of Aro::Dom::File)
+      # List      (copy of Aro::Dom::Menu)
+      # ListItem  (copy of Aro::Dom::MenuItem)
+      #
+      #
+
+      EXEC_METHODS = [
+        :exec_browse_data_bases!,
+        :exec_settings!,
+        :exec_quit!
+      ]
+
+      RUN_MODES = [
+        :design,
+        :run
+      ]
+
+      UNICODE_KEYS = {
+        bang:     "\u0021",
+        check:    "\u2713",
+        close:    "\u2A2F",
+        integral: "\u222B",
+        secure:   "\u266F",
+        unsecure: "\u266D",
+        yinyang:  "\u262F",
+      }
+
+      attr_accessor :current_menu, :previous_menu
+      attr_accessor :data_mutex, :store_mutex
+      attr_accessor :stores
+      # todo: unused currently. init instance with hashing algo stuff
+      attr_accessor :valid_settings
+      attr_accessor :run_mode
+
+      def reign!
+        begin
+          # default mode is :run
+          self.run_mode = Aro::Mancy::S
+          Aro::P.say("Aro::Dom::Oss_OpenMenu.install!")
+          if Aro::Dom::Oss_OpenMenu.install!
+            Aro::P.say("Aro::Dom::Oss_OpenMenu.boot!")
+            Aro::Dom::Oss_OpenMenu.boot!
+          else
+            Aro::P.say("installation failed. exiting now...")
+            exit
+          end
+          Aro::P.say("Aro::Dom::Designer.design")
+          Aro::Dom::Designer.design
+        rescue RuntimeError => e
+
+          Aro::P.say("#{e.class}! #{e.inspect}")
+          self.class.i2097i_bookmark
+          reign!
+        end
+      end
+
+      def initialize
+        self.data_mutex = Mutex.new
+        self.store_mutex = Mutex.new
+
+        @stores = {}
+      end
+
+      def self.i2097i_bookmark
+        return
+        Aro::P.less("\n#{UNICODE_KEYS[:bang] * Aro::Mancy::OS} <breakpoint> #{self.name}\n\n" +
+          Thread.current.backtrace[1..].reverse.map{|l|
+            l.gsub("#{Reiquire.gem_dir}", "").gsub(Aro::Mancy.root_dir, "")
+          }.last(Aro::Mancy::V).join("\n")
+        )
+        puts __method__
+      end
+
+      def self.init!
+        root_dir_path = Aro::Cor.ivar(:OSS_OM_HOME)
+        return false if root_dir_path.nil? || !Dir.exist?(root_dir_path)
+        Aro::P.say("#{self.name} initializing in #{root_dir_path}")
+        Aro::Mancy.init(root_dir_path)
+      end
+
+      def self.is_encrypted?
+        !Aro::Cor.ivar(:oss_om_ssh_key).nil? &&
+          !self.instance.valid_settings.nil?
+      end
+
+      def self.domain
+        self.instance.current_menu.nil? ? super : "#{Aro::Mancy.aro_mancy_name}#{Aro::Mancy::A}#{Aro::Dom::Ma_ain}"
+      end
+
+      def self.mini_hud_for(display_text = nil)
+        cryption_text = UNICODE_KEYS[
+          is_encrypted? ? :secure : :unsecure
+        ] + UNICODE_KEYS[:bang]
+
+        if is_encrypted?
+          cryption_text = "#{UNICODE_KEYS[:secure]}#{UNICODE_KEYS[:bang]}"
+        else
+          cryption_text = "#{UNICODE_KEYS[:unsecure]}#{UNICODE_KEYS[:bang]}"
+        end
+
+        mode_text = RUN_MODES[self.instance.run_mode || Aro::Mancy::O]
+        [
+          "(#{cryption_text})[#{mode_text}: ",
+          display_text
+        ].join("")
+      end
+
+      def self.ps1_display(cls_name = nil)
+        super(domain)
+      end
+
+      def self.open!(data_base = :ma_ain)
+        Aro::P.say("Aro::Dom::DataBase.open_menu(#{data_base})")
+        staged_menu = nil
+        begin
+          staged_menu = Aro::Dom::DataBase.open_menu(data_base)
+        rescue StandardError => e
+          raise "#{self.name} error opening data_base #{data_base}! #{e.inspect}"
+        end
+        self.instance.previous_menu = self.instance.current_menu
+        self.instance.current_menu = staged_menu
+      end
+
+      def self.back!
+        self.instance.current_menu = nil
+        open!
+      end
+
+      def self.toggle_run_mode
+        self.instance.run_mode = self.instance.run_mode == 0 ? 1 : 0
+      end
+
+      def self.running?
+        RUN_MODES[self.instance.run_mode || Aro::Mancy::O] == :run
+      end
+
+      def self.get_current_options
+        options = []
+
+        options << {back: :back, value: :back} unless self.instance.previous_menu.nil?
+
+        options << {name: "#{UNICODE_KEYS[:integral]}(#{Aro::Mancy::ARO_DIRECTORY})", value: :open_menu}
+
+        options += self.instance.current_menu.menu_items.select{|mi| mi.user?}.map{|mi| mi.as_tty}
+        options += self.instance.current_menu.menu_items.select{|mi| mi.system?}.map{|mi| mi.as_tty}
+
+        options
+      end
+
+      def self.exec_browse_data_bases!
+        Aro::Dom::Ma_ain.open!(:browse_data_bases)
+      end
+
+      def self.exec_settings!
+        Aro::Dom::Ma_ain.open!(:settings)
+      end
+
+      def self.exec_quit!
+        exit
+      end
+
+      def get_store_for(aro_file)
+        raise "invalid aro_file!" if aro_file.nil?
+
+        if @stores[aro_file.uuid].nil?
+          new_store = Aro::Dom::Store.new
+          new_store.open_file_path = aro_file.aro_file_path
+          @stores[aro_file.uuid] = new_store
+        end
+
+        return Aro::Dom::Ma_ain.instance.stores[aro_file.uuid]
+      end
+
+    end
+  end
+end

data/sys/reiquire.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
   
   reiquire.rb
@@ -10,6 +12,10 @@
 
 module Reiquire
   def self.aro
+
+    # ensure i18n is initialized
+    initialize_i18n!
+
     # require runtime dependencies
     require_dependencies!
 
@@ -19,8 +25,7 @@ module Reiquire
     # configure locale
     configure_i18n
 
-    # ensure base migrations exist
-    copy_db_migrations_from_gem! if Aro::Mancy.in_aro?
+    require_relative "./ma_ain"
   end
 
   def self.requires(dirs)
@@ -48,34 +53,30 @@ module Reiquire
     File.join(gem_locale_dir, "*.yml")
   end
 
-  def self.copy_db_migrations_from_gem!
-    puts __method__
-    puts Aro::Cor.ivar(:OSS_OM_HOME)
-    return if Aro::Cor.ivar(:OSS_OM_HOME).nil? || oss_om_up_to_date?(
-      Aro::Db.gem_migrations_filepaths,
-      Aro::Db.migrations_filepaths
-    )
+  private
 
-    FileUtils.mkdir_p(Aro::Db.migrate_dir)
-    FileUtils.cp_r(
-      gem_migrations_path,
-      Aro::Db.migrate_dir
-    )
+
+  def self.require_dependencies!
+    [
+      :active_record,
+      :"active_record/schema_dumper",
+      :fileutils,
+      :"tty-font",
+      :"tty-prompt"
+    ].each{|d| require d.to_s}
   end
 
-  private
 
   def self.copy_locale_files_from_gem!
-    puts __method__
-    puts Aro::Cor.ivar(:OSS_OM_HOME)
+    Aro::D.say(__method__)
     return if Aro::Cor.ivar(:OSS_OM_HOME).nil? || oss_om_up_to_date?(
       gem_locales_filepaths,
       Aro::Dom::Locale.locales_filepaths
     )
 
-    oss_wtf = File.join(Aro::Mancy.root_dir, :locale.to_s, :locale.to_s)
-    if Dir.exist?(oss_wtf)
-      FileUtils.rm_rf(oss_wtf)
+    file_utils_wtf = File.join(Aro::Mancy.root_dir, :locale.to_s, :locale.to_s)
+    if Dir.exist?(file_utils_wtf)
+      FileUtils.rm_rf(file_utils_wtf)
       oss_om_up_to_date!(
         gem_locales_filepaths,
         Aro::Dom::Locale.locale_dir
@@ -91,47 +92,34 @@ module Reiquire
   end
 
   def self.oss_om_up_to_date!(gem_filepaths, oss_om_dir)
-    puts __method__
+    Aro::D.say(__method__)
     gem_files_abs = Dir[gem_filepaths].map{|fp| File.absolute_path(fp)}
-    puts "gem_files_abs: #{gem_files_abs}"
+    Aro::D.say("gem_files_abs: #{gem_files_abs}")
     
-    puts "FileUtils.mkdir_p(#{oss_om_dir})"
+    Aro::D.say("FileUtils.mkdir_p(#{oss_om_dir})")
     FileUtils.mkdir_p(oss_om_dir)
     gem_files_abs.each{|gfa|
-      puts "FileUtils.cp(#{File.basename(gfa)}, #{File.basename(oss_om_dir)})"
+      Aro::D.say("FileUtils.cp(#{File.basename(gfa)}, #{File.basename(oss_om_dir)})")
       FileUtils.cp(gfa, oss_om_dir)
     }
   end
 
   def self.oss_om_up_to_date?(gem_filepaths, oss_om_filepaths)
-    puts __method__
+    Aro::P.say(__method__)
     file_names = Dir[oss_om_filepaths].map{|fp| File.basename(fp)}
-    puts "file_names: #{file_names}"
+    Aro::D.say("file_names: #{file_names}")
     gem_file_names = Dir[gem_filepaths].map{|fp| File.basename(fp)}
-    puts "gem_file_names: #{gem_file_names}"
-    mfs_all = gem_file_names.all?{|gfn|
+    Aro::D.say("gem_file_names: #{gem_file_names}")
+    up_to_date = gem_file_names.all?{|gfn|
       file_names.include?(gfn)
     }
-    puts "mfs_all: #{mfs_all}"
-    mfs_all
+    Aro::P.say("up_to_date: #{up_to_date}")
+    up_to_date
   end
 
   def self.require_reiquires!
     # require sys folders
-    Reiquire::requires([:shr, :aro, :cli])
-
-    # require cli module
-    require_relative :"./cli".to_s
-  end
-
-  def self.require_dependencies!
-    [
-      :active_record,
-      :"active_record/schema_dumper",
-      :fileutils,
-      :i18n,
-      :"tty-prompt"
-    ].each{|d| require d.to_s}
+    Reiquire::requires([:shr, :aro])
   end
 
   def self.gem_dir
@@ -140,8 +128,16 @@ module Reiquire
     ].first
   end
 
+  def self.initialize_i18n!
+    require :i18n.to_s
+    aro_i18n_library = File.join(gem_dir, :locale.to_s, "*.yml")
+    I18n.load_path += Dir[aro_i18n_library]
+    I18n.available_locales = [:en]
+    I18n.default_locale = :en
+    I18n.reload!
+  end
+
   def self.configure_i18n
-    Aro::D.say(__method__)
     gem_dir_variable = gem_dir
     copy_locale_files_from_gem!
     aro_i18n_library = File.join(gem_dir_variable, :locale.to_s, "*.yml")
@@ -153,17 +149,8 @@ module Reiquire
       aro_i18n_library = File.join(Aro::Dom::Locale.locale_dir, "*.yml")
     end
     I18n.load_path += Dir[aro_i18n_library]
-
     I18n.available_locales = [:en]
     I18n.default_locale = :en
-    Aro::D.say("I18n.load_path")
-    Aro::D.say(I18n.load_path)
-    Aro::D.say("I18n.available_locales")
-    Aro::D.say(I18n.available_locales)
-    Aro::D.say("I18n.default_locale")
-    Aro::D.say(I18n.default_locale)
-    Aro::D.say("I18n.reload!")
-    Aro::D.say(I18n.reload!)
   end
 
 end

data/sys/shr/prompt.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   prompt.rb
@@ -26,6 +28,10 @@ module Aro
       Aro::Cor::BOOLS[:TRUE]
     end
 
+    def self.ask(message)
+      gets message
+    end
+
     def self.say(message)
       p.say(normalize_message(message))
     end
@@ -36,7 +42,6 @@ module Aro
 
     def self.normalize_message(message)
       return message.join("\n") if message.kind_of?(Array)
-
       message
     end
   end

data/sys/shr/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
   
   version.rb
@@ -9,13 +11,10 @@
 =end
 
 module Aro
-  VERSION = :"0.2.6"
+  VERSION = :"0.2.7"
   RELEASE_NOTES = [
-    :removes_aos,
-    :removes_ino,
-    :reduces_ruby_4_0_7_to_3_4_7,
-    :adds_menus_and_data,
-    :removes_aro_cli,
-    :adds_oss_om
-  ].join("\n:")
+    :galvinizes_foss_om_utility,
+    :creates_foss_om_foundation,
+    :removes_tecks
+  ].join(" | ")
 end