aro 0.2.6 → 0.2.7

data/sys/aro/designer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   designer.rb
@@ -11,66 +13,72 @@
 module Aro
   module Dom
     class Designer
-      ACTION_LJUST = 22
-      CLASS_LJUST = 33
-
-      def self.design_aro
-        env_home_val = ENV[:HOME.to_s]
-        Aro::P.say(:"checking for bash env var $HOME in ruby ENV".to_s)
-        Aro::P.say(:"$HOME is set to #{env_home_val}".to_s)
-        abs_home = Aro::P.p.ask(:"use alternative aro_root? (empty to use $HOME): ".to_s)
-        raise "missing required value for aro_root!" if abs_home.nil? && env_home_val.nil?
-        aro_home_dir = abs_home || env_home_val
-        oss_om_base_dir = ::File.join(aro_home_dir, Aro::Mancy::ARO_DIRECTORY.to_s)
+      ACTION_LJUST = 27
+      VALUE_LJUST = 27
+      CLASS_LJUST = 27
+
+      def self.design_oss_om
+        oss_home_path = File.expand_path(Dir.pwd)
+        Aro::P.say("set up oss_om home directory in '#{oss_home_path}'?")
+        abs_home = Aro::Dom::Designer.get_new_value_from_user(
+          "leave empty to use '#{oss_home_path}' as home.",
+          "enter new path: "
+        )
+        raise "missing required value for oss_om home!" if abs_home.nil? && oss_home_path.nil?
+        oss_home_path = abs_home.nil? ? oss_home_path : File.expand_path(abs_home)
+        oss_om_base_dir = ::File.join(oss_home_path, Aro::Mancy::ARO_DIRECTORY.to_s)
         Aro::P.say("FileUtils.mkdir_p(#{oss_om_base_dir})")
         FileUtils.mkdir_p(oss_om_base_dir)
-        Aro::P.say("FileUtils.chdir(#{aro_home_dir})")
-        FileUtils.chdir(aro_home_dir) do
-          Aro::P.say("Aro::Cor.instance.load_env")
-          Aro::Cor.instance.load_env
-          Aro::P.say("Aro::Cor.set_ivar(:OSS_OM_HOME, #{File.absolute_path(aro_home_dir)})")
-          Aro::Cor.set_ivar(:OSS_OM_HOME, File.absolute_path(aro_home_dir))
-          Aro::P.say("Aro::Db.ensure_connected!")
-          Aro::Db.ensure_connected!
-          Aro::P.say("Aro::Mancy.init(#{aro_home_dir})")
-          Aro::Mancy.init(aro_home_dir)
-          Aro::P.say("Reiquire.reload_i18n!")
-          Reiquire.reload_i18n!
-          # design_menu(Aro::Dom::Menu.first)
-        end
 
-        if File.absolute_path(Dir.pwd) != Aro::Cor.ivar(:OSS_OM_HOME)
-          Aro::P.say("user needs to cd")
-          Aro::P.say("enter $ cd #{Aro::Cor.ivar(:OSS_OM_HOME)}")
+        Aro::P.say("Aro::Cor.set_ivar(:OSS_OM_HOME, #{oss_home_path})")
+        Aro::Cor.set_ivar(:OSS_OM_HOME, oss_home_path)
+
+        if ::File.expand_path(Dir.pwd) != Aro::Cor.ivar(:OSS_OM_HOME)
+          Aro::P.say("run the following commands to continue:")
+          Aro::P.say("$ cd #{Aro::Cor.ivar(:OSS_OM_HOME)} && oss_om")
+          Aro::P.say("exiting...")
           exit
+        else
+          # restarts Aro::Dom::Ma_ain.reign!
+          raise "needs install!"
         end
         design
       end
 
-
       def self.design
         if Aro::Cor.ivar(:OSS_OM_HOME).nil?
-          design_aro
+          design_oss_om
           return
         end
-        Aro::Dom::Ma_ain.instance.current_menu = Aro::Dom::DataBase.open_menu(:ma_ain)
 
+        Aro::P.say("Aro::Dom::Ma_ain.open!")
+        Aro::Dom::Ma_ain.open!
         loop do
-          selected_menu_item_uuid = Aro::P.p.select(
+          selected_menu_item_uuid = Aro::P.default_select(
             "#{Aro::Dom::Ma_ain.instance.current_menu.localized_name}",
-            [{name: :open_menu, value: :open_menu}] + Aro::Dom::Ma_ain.instance.current_menu.menu_items.map{|mi| mi.as_tty},
-            show_help: :always,
-            cycle: true,
-            per_page: 11
+            Aro::Dom::Ma_ain.get_current_options
           )
 
-          if selected_menu_item_uuid == :open_menu
-            Aro::Dom::Designer.design_menu(Aro::Dom::Ma_ain.instance.current_menu)
-          else
-            Aro::Dom::Designer.design_menu_item(
-              selected_menu_item_uuid,
+          case selected_menu_item_uuid.to_sym
+          when :back
+            # todo: call_stack_bread_crumbs
+            Aro::Dom::Ma_ain.back!
+          when :open_menu
+            design_menu(
               Aro::Dom::Ma_ain.instance.current_menu
             )
+          else
+            if Aro::Dom::Ma_ain.running?
+              selected_menu_item = Aro::Dom::Ma_ain.instance.current_menu.menu_items.find_by(
+                uuid: selected_menu_item_uuid
+              )
+              selected_menu_item.run!
+            else
+              design_menu_item(
+                selected_menu_item_uuid,
+                Aro::Dom::Ma_ain.instance.current_menu
+              )
+            end
           end
         end
       end
@@ -100,54 +108,69 @@ module Aro
         new_name = get_new_value_from_user(
           "#{__method__} #{Aro::Dom::MenuItem.name} for menu: '#{I18n.t(menu.full_i18n_path)}'"
         )
+
         unless new_name.nil? ||
           new_name.empty? ||
           new_name.kind_of?(FalseClass)
 
-          menu_item = menu.menu_items.create(tty_name: Aro::Dom::Locale.i18n_keyify_text(new_name))
-          Aro::Dom::Locale.add_i18n_key(
-            new_name,
-            library_name: :menu_items,
-            new_i18n_display_key: menu_item.uuid,
-          )
+          new_item = menu.generate_new_item(new_name)
+          raise "error generating new item!" if new_item.nil?
+
+          design_menu_item(new_item.uuid, menu)
         else
           Aro::P.say("#{new_name.inspect} is invalid")
+          design_menu(menu)
         end
-
-        design_menu(menu)
       end
 
       def self.design_menu(menu = nil)
         return create_menu if menu.nil?
 
-        # action,class,value
+        item_mapper = Proc.new{|mi|
+          {
+            name: "(edit_item)".ljust(ACTION_LJUST) +
+              "#{mi.localized_name}".ljust(VALUE_LJUST) +
+              "#{mi.class.name}(#{mi.id})".ljust(CLASS_LJUST),
+            value: mi.uuid
+          }
+        }
+
+        # action,value,class
         options = [
           {
             name: :back,
             value: :back
           },
+          {
+            name: "(#{Aro::Dom::Ma_ain::UNICODE_KEYS[:yinyang]}) toggle_run_mode".ljust(ACTION_LJUST) +
+              ":#{Aro::Dom::Ma_ain::RUN_MODES[Aro::Dom::Ma_ain.instance.run_mode || Aro::Mancy::O]}".ljust(VALUE_LJUST) +
+              "available_modes: #{Aro::Dom::Ma_ain::RUN_MODES.to_s}".ljust(CLASS_LJUST),
+            value: :toggle_run_mode
+          },
+          {
+            name: "(#{Aro::Dom::Ma_ain::UNICODE_KEYS[:yinyang]}) open_shell".ljust(ACTION_LJUST) +
+              "open a bash session".ljust(VALUE_LJUST),
+            value: :open_shell
+          },
           {
             name: "(edit_title)".ljust(ACTION_LJUST) +
-              "#{menu.class.name}(#{menu.id})".ljust(CLASS_LJUST) +
-              "#{menu.localized_name}",
+              "#{menu.localized_name}".ljust(VALUE_LJUST) +
+              "#{menu.class.name}(#{menu.id})".ljust(CLASS_LJUST),
             value: :edit_title
           }
-        ] + menu.menu_items.map{|mi|
-          {
-            name: "(edit_item)".ljust(ACTION_LJUST) +
-              "#{mi.class.name}(#{mi.id})".ljust(CLASS_LJUST) +
-              "#{mi.localized_name}",
-            value: mi.uuid
-          }
-        } + [
+        ] +
+          menu.menu_items.select{|mi| mi.user?}.map{|mi| item_mapper.call(mi)} +
+          menu.menu_items.select{|mi| mi.system?}.map{|mi| item_mapper.call(mi)} +
+        [
           {
             name: "(create_item)".ljust(ACTION_LJUST) +
+              "add new item to #{menu.localized_name}".ljust(VALUE_LJUST) +
               "#{Aro::Dom::MenuItem.name}(+)".ljust(CLASS_LJUST),
             value: :create_item
           }
         ]
 
-        v = Aro::P.p.select(
+        v = Aro::P.default_select(
           I18n.t("open_menu.edit_menu_localized_name", localized_name: menu.localized_name),
           options
         )
@@ -172,6 +195,12 @@ module Aro
           create_menu_item(menu)
         when :back
           return
+        when :toggle_run_mode
+          Aro::Dom::Ma_ain.toggle_run_mode
+          return
+        when :open_shell
+          Aro::P.say("starting bash session for #{`whoami`.strip}")
+          system(:bash.to_s)
         else
           design_menu_item(v, menu)
         end
@@ -182,22 +211,6 @@ module Aro
 
         menu_item = menu.menu_items.find_by(uuid: menu_item_uuid)
 
-        # new_name = get_new_value_from_user(
-        #   "rename #{menu_item.class} '#{I18n.t(menu_item.full_i18n_path)}'"
-        # )
-        # unless new_name.nil? ||
-        #   new_name.empty? ||
-        #   new_name.kind_of?(FalseClass)
-
-        #   Aro::Dom::Locale.update_i18n_key(
-        #     new_name,
-        #     menu_item.uuid,
-        #     library_name: :menu_items
-        #   )
-        # else
-        #   Aro::P.say("#{new_name.inspect} is invalid")
-        # end
-
         # action,class,value
         options = [
           {
@@ -206,18 +219,19 @@ module Aro
           },
           {
             name: "(edit_title)".ljust(ACTION_LJUST) +
-              "#{menu_item.class.name}(#{menu_item.id})".ljust(CLASS_LJUST) +
-              "#{menu_item.localized_name}",
+              "#{menu_item.localized_name}".ljust(VALUE_LJUST) +
+              "#{menu_item.class.name}(#{menu_item.id})".ljust(CLASS_LJUST),
             value: :edit_title
           },
           {
             name: "(edit_action)".ljust(ACTION_LJUST) +
+              "#{menu_item.action_display_text}".ljust(VALUE_LJUST) +
               "Aro::Dom::MenuItem::Action(+)".ljust(CLASS_LJUST),
             value: :edit_action
           }
         ]
 
-        v = Aro::P.p.select(
+        v = Aro::P.default_select(
           I18n.t("open_menu.edit_menu_item_localized_name", localized_name: menu_item.localized_name),
           options
         )
@@ -240,39 +254,94 @@ module Aro
             Aro::P.say("#{new_name.inspect} is invalid")
           end
         when :edit_action
-          puts "this is where i am working"
-          return
+          design_action_for(menu_item)
         when :back
           return
         end
+      end
+
+      def self.edit_action_for(menu_item)
+        action_name = menu_item.store.safe_get_key("action_name")&.to_sym
+
+        raise "missing action!" if action_name.nil?
+
+        options = [
+          {
+            name: :back,
+            value: :back
+          },
+          {
+            name: "(edit_type)".ljust(ACTION_LJUST) +
+              "#{menu_item.action_storage_key}".ljust(VALUE_LJUST) +
+              "#{Aro::Dom::Action.name}(#{action_name})".ljust(CLASS_LJUST),
+            value: :edit_type
+          },
+          {
+            name: "(edit_method)".ljust(ACTION_LJUST) +
+              "#{menu_item.action_display_text}".ljust(VALUE_LJUST) +
+              "Aro::Dom::MenuItem::Action(#{action_name})".ljust(CLASS_LJUST),
+            value: :edit_method
+          }
+        ]
+        v = Aro::P.default_select(
+          I18n.t("open_menu.edit_action_for_menu_item", localized_name: menu_item.localized_name, action_name: action_name),
+          options
+        )
 
-        # this is for updating data stores
-        # todo:
-        #   Aro::P.say([
-        #     to_s,
-        #     "=> writing property :tty_name => '#{new_name}'",
-        #     "=> to #{menu_item.aro_file.class}(#{menu_item.aro_file.uuid})",
-        #     "=> in #{Aro::Dom::DataBase.name} #{menu_item.aro_file.aro_file_path}",
-        #     "=> for #{menu_item.class}(#{menu_item.uuid})"
-        #   ].join("\n"))
-
-        #   menu_item.aro_file.write!({tty_name: new_name})
+        case v.to_sym
+        when :edit_type
+          design_action_for(menu_item, overwrite: true)
+        when :edit_method
+          # todo: case when for oss_om_entry types here
+          Aro::Dom::Oss_OpenMenu.create_exec_oss_om_entry_for(menu_item)
+        end
       end
 
-      private
+      def self.design_action_for(menu_item, overwrite: false)
+        return if menu_item.nil?
+        return edit_action_for(menu_item) if menu_item.actionable? && !overwrite
+
+        # action,class,value
+        options = [
+          {
+            name: :back,
+            value: :back
+          }
+        ] + Aro::Dom::Action::TYPES.keys.map{|k|
+          {
+            name: "(#{k})".ljust(ACTION_LJUST) +
+              "#{menu_item.localized_name}".ljust(VALUE_LJUST) +
+              "#{menu_item.class.name}(#{menu_item.id})".ljust(CLASS_LJUST),
+            value: k
+          }
+        }
+
+        v = Aro::P.default_select(
+          I18n.t("open_menu.design_action_for_menu_item", localized_name: menu_item.localized_name),
+          options
+        )
+
+        case v.to_sym
+        when :back
+          return
+        else
+          Aro::Dom::Action.create(v, menu_item)
+        end
+      end
 
-      def self.get_new_value_from_user(ask_text)
+      def self.get_new_value_from_user(ask_text, prompt_text_override = nil)
         Aro::P.say(__method__)
         new_val = nil
         user_cancelled = false
         while new_val.nil? && !user_cancelled
           Aro::P.say(ask_text)
-          new_val = Aro::P.p.ask(I18n.t("open_menu.get_new_value_from_user"))
+          puts "\n"
+          new_val = Aro::P.p.ask(prompt_text_override || I18n.t("open_menu.get_new_value_from_user"))
           user_cancelled = new_val.nil? || new_val.empty?
           new_val = nil if user_cancelled
         end
 
-        return user_cancelled if user_cancelled
+        return nil if user_cancelled
         return new_val
       end
 

data/sys/aro/locale.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   locale.rb
@@ -73,7 +75,7 @@ module Aro
 
       def self.i18n_valuify_text(text)
         # gsub non-word characters with " "
-        text.gsub(/[\W]/, " ")
+        text.to_s.gsub(/[\W]/, " ")
       end
 
       private
@@ -123,7 +125,7 @@ module Aro
           Aro::P.say("Psych.load_file(#{library_filepath})")
           loaded_file = Psych.load_file(library_filepath)
         rescue Psych::SyntaxError => e
-          Aro::P.say(I18n.t("errors.locale_load_error", named: library_name))
+          Aro::P.say(I18n.t("open_menu.errors.locale_load_error", named: library_name))
           Aro::P.say(e.inspect)
           Aro::P.say(e.message)
           return nil

data/sys/aro/mancy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
   
   aro.rb
@@ -13,9 +15,6 @@
 module Aro
   class Mancy
     include Singleton
-
-    attr_accessor :current, :db_busy, :db_thread
-
     A  = :"@"
     O  = 0
     S  = 1
@@ -24,7 +23,7 @@ module Aro
     N  = 4
     V  = 5
     DATE_FORMAT = "%A %d %b %Y %I:%M:%S %p"
-    NAME_FILE = :".aro_space"
+    NAME_FILE = :".oss_om_space"
     ARO_DIRECTORY = :".oss_om"
 
     I2097I = :i2097i
@@ -62,19 +61,6 @@ module Aro
       MMXCVII: Aro::Mancy::I2097I[Aro::Mancy::S..Aro::Mancy::N].to_i,
     }
 
-    def remember!
-      # start monitoring
-      self.start_db_thread
-    end
-
-    def self.teck
-      self.init(root_dir)
-      if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
-        self.instance.current = Aro::Teck.current_teck
-      end
-      self.instance.current
-    end
-
     def self.create(aro_name, is_test: false)
       Aro::D.say(__method__)
       Aro::D.say(:depricated)
@@ -82,7 +68,7 @@ module Aro
     end
 
     def self.init(root_dir_path)
-      unless Aro::Mancy.in_aro? || Aro::Cor.is_test?
+      unless Aro::Mancy.in_aro?
         Aro::P.say("init aro running in #{root_dir_path} directory...")
         new_name = File.basename(root_dir_path)
         Aro::P.say("echo #{new_name} > #{Aro::Mancy::NAME_FILE.to_s}")
@@ -91,6 +77,7 @@ module Aro
           file.write("\n")
         end
       end
+      return true
     end
 
     def self.root_dir
@@ -101,7 +88,7 @@ module Aro
     end
 
     def self.is_initialized?
-      in_aro? && in_aro? && Aro::Db.instance.connected?
+      in_aro? && Aro::Db.instance.connected?
     end
 
     def self.in_aro?
@@ -119,25 +106,5 @@ module Aro
     def self.ps1_display(cls_name = nil)
       :">[#{cls_name || Aro::Mancy.domain || aro_mancy_name}]>: ".to_s
     end
-
-    private
-
-    def start_db_thread
-      return if @db_busy
-      @db_busy = true
-      self.db_thread&.exit
-      self.db_thread&.kill
-      self.db_thread = Thread.new do
-        loop do
-          @db_busy = true
-          Aro::V.say(Aro::Mancy.instance.db_thread.inspect)
-          Aro::V.say(__method__)
-          Aro::Db.ensure_connected!
-          @db_busy = false
-          sleep(Aro::Db::HEARTBEAT_DURATION)
-        end
-      end
-    end
-
   end
 end

data/sys/aro/models/concerns/tar_go_for_root_sec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+=begin
+
+  tar_go_for_root_sec.rb
+
+  oss_om encryption system
+
+  by i2097i
+
+=end
+
+module Aro
+  module Dom
+    module TarGoForRootSec
+      extend ActiveSupport::Concern
+
+      # todo: implement tar_go_for_root_sec
+      # currently only for Aro::Dom::MenuItem
+
+      included do
+        before_create :do_encryption_stuff
+        before_commit :do_encryption_stuff
+      end
+
+      private
+
+      def do_encryption_stuff
+        Aro::P.say(__method__)
+        Aro::P.say("todo: #{self.class.name}")
+        Aro::P.say(self.class.inspect)
+        Aro::Dom::Ma_ain.i2097i_bookmark
+      end
+    end
+  end
+end
+

data/sys/aro/models/concerns/uuid.rb

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

data/sys/aro/models/data_base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   data.rb
@@ -32,6 +34,15 @@ class Aro::Dom::DataBase < ActiveRecord::Base
       )
     end
 
+    case menu_sym
+    when :ma_ain
+      menu.generate_ma_ain!
+    when :settings
+      menu.generate_settings!
+    else
+      menu.generate_user_default!
+    end
+
     # return the menu
     return menu
   end
@@ -40,9 +51,28 @@ class Aro::Dom::DataBase < ActiveRecord::Base
     Aro::Dom::DataBase.find_or_create_by(unix_path: Aro::Dom::Menu.table_name)
   end
 
-  def self.sync_menu_item(menu_item)
-    # todo:
-    puts "todo: #{__method__} #{menu_item.inspect}"
+  def self.sync_menu_item!(menu_item, localized_name)
+    raise "missing menu_item!" unless !menu_item.nil? &&
+      menu_item.kind_of?(Aro::Dom::MenuItem)
+
+    Aro::Dom::Locale.update_i18n_key(
+      localized_name,
+      menu_item.uuid,
+      library_name: :menu_items
+    )
+
+    # set up by system menus
+    return true if menu_item.system?
+
+    # ensure default menu_item.aro_file exists
+    # for user-created menu items
+    menu_item.aro_file.write!(
+      Aro::Dom::Store.build_exec_oss_om_params!(
+        Aro::Dom::Oss_OpenMenu,
+        :name, # defaults to Aro::Dom::Oss_OpenMenu.name
+        menu_item.localized_name
+      )
+    )
   end
 
   def self.ensure_data_base_exist!
@@ -57,11 +87,6 @@ class Aro::Dom::DataBase < ActiveRecord::Base
 
   def self.ensure_data_base_git!
     ensure_data_base_exist! unless Dir.exist?(root_aro_unix_data_dir)
-    FileUtils.chdir(root_aro_unix_data_dir) do
-      Aro::P.say("todo:")
-      Aro::P.say(__method__)
-      # system("git init")
-    end
   end
 
   def unix_path_valid?

data/sys/aro/models/directory.rb

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

data/sys/aro/models/file.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   row.rb
@@ -13,7 +15,7 @@ class Aro::Dom::DataBase::File < ActiveRecord::Base
   self.table_name = :data_base_files
   belongs_to :data_base_directory, class_name: "Aro::Dom::DataBase::Directory"
 
-  def write!(updates = {})
+  def write!(updates)
     Aro::Dom::Store.edit(self, updates)
   end