aro 0.2.5 → 0.2.6

data/sys/aro/d.rb

@@ -15,12 +15,13 @@ module Aro
   class D < Aro::Prompt
     def self.say(message)
       return unless Aro::D.should_print?
-      super([">[#{Aro::Mancy::I2097I}]>: #{message}"])
+
+      super("#{Aro::Mancy.ps1_display(Aro::D.name)}#{normalize_message(message)}")
     end
 
     def self.should_print?
-      return false unless Aos::Cor.ivar(:ENV).present?
-      Aos::Cor::DBG_MODES.include?(Aos::Cor.ivar(:ENV)&.to_sym)
+      return false unless Aro::Cor.ivar(:ENV).present?
+      Aro::Cor::DBG_MODES.include?(Aro::Cor.ivar(:ENV)&.to_sym)
     end
   end
 end

data/sys/aro/db/migrate/1793913747_create_data_bases.rb

@@ -0,0 +1,13 @@
+class CreateDataBases < ActiveRecord::Migration[8.1]
+  def change
+    create_table :data_bases do |t|
+      t.string :unix_path, null: false
+      t.string :uuid, null: false
+
+      t.timestamps
+    end
+
+    add_index :data_bases, :uuid, unique: true
+    add_index :data_bases, :unix_path, unique: true
+  end
+end

data/sys/aro/db/migrate/1793913777_create_data_base_directories.rb

@@ -0,0 +1,14 @@
+class CreateDataBaseDirectories < ActiveRecord::Migration[8.1]
+  def change
+    create_table :data_base_directories do |t|
+      t.string :unix_path, null: false
+      t.belongs_to :data_base, null: false, foreign_key: true
+      t.string :uuid, null: false
+
+      t.timestamps
+    end
+
+    add_index :data_base_directories, :uuid, unique: true
+    add_index :data_base_directories, [:data_base_id, :unix_path], unique: true
+  end
+end

data/sys/aro/db/migrate/1793913796_create_data_base_files.rb

@@ -0,0 +1,12 @@
+class CreateDataBaseFiles < ActiveRecord::Migration[8.1]
+  def change
+    create_table :data_base_files do |t|
+      t.belongs_to :data_base_directory, null: false, foreign_key: true
+      t.string :uuid, null: false
+
+      t.timestamps
+    end
+
+    add_index :data_base_files, :uuid, unique: true
+  end
+end

data/sys/aro/db/migrate/1793913841_create_menus.rb

@@ -0,0 +1,11 @@
+class CreateMenus < ActiveRecord::Migration[8.1]
+  def change
+    create_table :menus do |t|
+      t.string :uuid, null: false
+
+      t.timestamps
+    end
+
+    add_index :menus, :uuid, unique: true
+  end
+end

data/sys/aro/db/migrate/1793913861_create_menu_items.rb

@@ -0,0 +1,14 @@
+class CreateMenuItems < ActiveRecord::Migration[8.1]
+  def change
+    create_table :menu_items do |t|
+      t.belongs_to :menu, null: false, foreign_key: true
+      t.string :uuid, null: false
+      t.string :tty_name
+
+      t.timestamps
+    end
+
+    add_index :menu_items, :uuid, unique: true
+    add_index :menu_items, [:menu_id, :tty_name], unique: true
+  end
+end

data/sys/aro/db.rb

@@ -8,92 +8,131 @@
 
 =end
 
-require_relative :"./mancy".to_s
-require_relative :"../aos/cor".to_s
-
 module Aro
   class Db
     include Singleton
 
+    attr_accessor :active_record_connection_instance
+    HEARTBEAT_DURATION = 11
     DATABASE_YML = :"database.yml"
-    GEM_DB_PATH = :"sys/aro/db"
-    MIGRATIONS_DIR = :"db/migrate"
     SCHEMA_FILE = :"schema.rb"
-    SQL_FILE = :"aro.sql"
+    SQL_FILE = :"base.sql"
+
+    def self.ensure_connected!
+      return if self.instance.connected?
 
-    def self.load
       Aro::Db.configure_logger
       if Aro::Mancy.in_aro?
         self.instance.setup_local_aro
       end
     end
 
+    def connected?
+      !self.active_record_connection_instance.nil? &&
+        self.active_record_connection_instance.connected?
+    end
+
     def self.configure_logger
-      if Aos::Cor.ivar(:LOG_ARO_DB).to_s == Aos::Cor::BOOLS[:TRUE].to_s
+      if Aro::Cor.ivar(:LOG_DATABASE).to_s == Aro::Cor::BOOLS[:TRUE].to_s
         ActiveRecord::Base.logger = Logger.new(STDOUT)
       else
         ActiveRecord::Base.logger = nil
       end
     end
 
-    def self.base_aro_dir
-      base_aro_file = Aro::Mancy::ARO_FILE.to_s
-      return "#{base_aro_file}_#{Aos::Cor::ENVS[:TEST]}" if Aos::Cor.is_test?
+    def self.base_db_dir
+      db_dir = File.join(Aro::Mancy.root_dir, :db.to_s)
+      return "#{db_dir}_#{Aro::Cor::ENVS[:TEST]}" if Aro::Cor.is_test?
+      db_dir
+    end
+
+    def self.migrate_dir
+      File.join(Aro::Db.base_db_dir, :migrate.to_s)
+    end
 
-      base_aro_file
+    def self.sql_filepath
+      File.join(Aro::Db.base_db_dir, Aro::Db::SQL_FILE.to_s)
     end
 
     def db_config_filepath
-      @db_config_filepath ||= File.join(Aro::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
+      File.join(Aro::Db.base_db_dir, Aro::Db::DATABASE_YML.to_s)
     end
 
     def setup_local_aro
-      name = Aro::Mancy.in_aro? ? Aro::Mancy.aro_mancy_name : nil
-      return if name.nil? || name.to_sym == Aos::Os::CMDS[:ABOT][:key]
+      aro_name = Aro::Mancy.in_aro? ? Aro::Mancy.aro_mancy_name : nil
+      # todo: exit here if error
+      return if aro_name.nil?
 
       # create local .aro/ directory
-      unless File.exist?(Aro::Db.base_aro_dir)
-        Aro::P.say("creating #{Aro::Mancy::ARO_FILE.to_s} directory...")
-        FileUtils.mkdir(Aro::Db.base_aro_dir)
+      unless File.exist?(Aro::Db.base_db_dir)
+        Aro::P.say("creating #{Aro::Db.base_db_dir} directory...")
+        FileUtils.mkdir_p(Aro::Db.base_db_dir)
       end
 
       unless File.exist?(db_config_filepath)
+        pw = Aro::P.p.ask(I18n.t("messages.base_db_password_prompt", aro_name: aro_name, sql_filepath: self.class.sql_filepath))
+        pw = aro_name unless pw.present?
         # create database config yaml file
         c = {
           adapter: :sqlite3.to_s,
-          database: File.join(Aro::Db.base_aro_dir, Aro::Db::SQL_FILE.to_s),
-          username: name,
-          password: name,
-          pool: Aos::Os::DB_POOL
+          database: self.class.sql_filepath,
+          username: aro_name,
+          password: pw,
+          pool: 11
         }.to_yaml
         File.open(db_config_filepath, "w") do |file|
           file.write(c)
         end
+        Aro::P.say("set #{self.class.sql_filepath} password to #{pw}")
+        Aro::P.say(Psych.load_file(db_config_filepath))
       end
 
       connect
-      migrate(name)
+      migrate
     end
 
     def connect
-      ActiveRecord::Base.establish_connection(
+      self.active_record_connection_instance = ActiveRecord::Base.establish_connection(
         YAML.load_file(db_config_filepath)
       )
+      Aro::D.say("#{self}#{__method__}#{self.active_record_connection_instance.inspect}")
+    end
+
+    def self.migrations_filepaths
+      File.join(Aro::Db.migrate_dir, "*.rb")
     end
 
-    def migrate(name)
-      local_migrate_dir = File.join(Aro::Db.base_aro_dir, Aro::Db::MIGRATIONS_DIR.to_s)
-      unless Dir.exist?(local_migrate_dir)
-        gem_dir = Dir[Reiquire::GEM_PATH || '.'].first
-        FileUtils.cp_r(File.join(gem_dir, Aro::Db::GEM_DB_PATH.to_s), Aro::Db.base_aro_dir)
+    def self.gem_migrations_filepaths
+      File.join(Reiquire.gem_migrations_path, :migrate.to_s, "*.rb")
+    end
+
+    def migrate
+      puts __method__
+      migration_file_names = Dir[self.class.migrations_filepaths].map{|fp| File.basename(fp)}
+      puts "migration_file_names: #{migration_file_names}"
+      gem_migration_file_names = Dir[self.class.gem_migrations_filepaths].map{|fp| File.basename(fp)}
+      puts "gem_migration_file_names: #{gem_migration_file_names}"
+      mfs_all = gem_migration_file_names.all?{|gmf|
+        migration_file_names.include?(gmf)
+      }
+      puts "mfs_all: #{mfs_all}"
+
+      unless Dir.exist?(Aro::Db.migrate_dir) && mfs_all
+        puts "Reiquire.copy_db_migrations_from_gem!"
+        puts "ls #{Aro::Db.migrate_dir}"
+        puts migration_file_names
+        Reiquire.copy_db_migrations_from_gem! 
       end
 
-      migration_version = Dir["#{local_migrate_dir}/*.rb"].map{|n|
-        Pathname.new(n).basename.to_s.split("_")[0].to_i
+      migration_version = migration_file_names.map{|n|
+        n.to_s.split("_")[0].to_i
       }.max
-      ActiveRecord::MigrationContext.new(local_migrate_dir).migrate(migration_version)
+      ActiveRecord::MigrationContext.new(Aro::Db.migrate_dir).migrate(migration_version)
+      dump_schema!
+    end
 
-      filename = File.join(Aro::Db.base_aro_dir, Aro::Db::SCHEMA_FILE.to_s)
+    def dump_schema!
+      filename = File.join(Aro::Db.base_db_dir, Aro::Db::SCHEMA_FILE.to_s)
       File.open(filename, "w+") do |f|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, f)
       end

data/sys/aro/designer.rb

@@ -0,0 +1,281 @@
+=begin
+
+  designer.rb
+
+  aro dom designer.
+
+  by i2097i
+
+=end
+
+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)
+        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)}")
+          exit
+        end
+        design
+      end
+
+
+      def self.design
+        if Aro::Cor.ivar(:OSS_OM_HOME).nil?
+          design_aro
+          return
+        end
+        Aro::Dom::Ma_ain.instance.current_menu = Aro::Dom::DataBase.open_menu(:ma_ain)
+
+        loop do
+          selected_menu_item_uuid = Aro::P.p.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
+          )
+
+          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,
+              Aro::Dom::Ma_ain.instance.current_menu
+            )
+          end
+        end
+      end
+
+      def self.create_menu
+        new_name = get_new_value_from_user(
+          "#{Aro::Dom::Menu.name} #{I18n.t("open_menu.designer.#{__method__}")}"
+        )
+
+        unless new_name.nil? ||
+            new_name.empty? ||
+            new_name.kind_of?(FalseClass)
+
+          # create menu active record with i18n_display_key
+          new_menu = Aro::Dom::DataBase.open_menu(Aro::Dom::Locale.i18n_keyify_text(new_name))
+
+          # open new menu in designer
+          design_menu(new_menu)
+        else
+          Aro::P.say("#{new_name.inspect} is invalid")
+        end
+      end
+
+      def self.create_menu_item(menu)
+        return create_menu if menu.nil?
+
+        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,
+          )
+        else
+          Aro::P.say("#{new_name.inspect} is invalid")
+        end
+
+        design_menu(menu)
+      end
+
+      def self.design_menu(menu = nil)
+        return create_menu if menu.nil?
+
+        # action,class,value
+        options = [
+          {
+            name: :back,
+            value: :back
+          },
+          {
+            name: "(edit_title)".ljust(ACTION_LJUST) +
+              "#{menu.class.name}(#{menu.id})".ljust(CLASS_LJUST) +
+              "#{menu.localized_name}",
+            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
+          }
+        } + [
+          {
+            name: "(create_item)".ljust(ACTION_LJUST) +
+              "#{Aro::Dom::MenuItem.name}(+)".ljust(CLASS_LJUST),
+            value: :create_item
+          }
+        ]
+
+        v = Aro::P.p.select(
+          I18n.t("open_menu.edit_menu_localized_name", localized_name: menu.localized_name),
+          options
+        )
+
+        case v.to_sym
+        when :edit_title
+          new_name = get_new_value_from_user(
+            "rename #{menu.class} '#{menu.localized_name}'"
+          )
+          unless new_name.nil? ||
+            new_name.empty? ||
+            new_name.kind_of?(FalseClass)
+
+            Aro::Dom::Locale.update_i18n_key(
+              new_name,
+              menu.uuid
+            )
+          else
+            Aro::P.say("#{new_name.inspect} is invalid")
+          end
+        when :create_item
+          create_menu_item(menu)
+        when :back
+          return
+        else
+          design_menu_item(v, menu)
+        end
+      end
+
+      def self.design_menu_item(menu_item_uuid = nil, menu)
+        return create_menu_item(menu) if menu_item_uuid.nil?
+
+        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 = [
+          {
+            name: :back,
+            value: :back
+          },
+          {
+            name: "(edit_title)".ljust(ACTION_LJUST) +
+              "#{menu_item.class.name}(#{menu_item.id})".ljust(CLASS_LJUST) +
+              "#{menu_item.localized_name}",
+            value: :edit_title
+          },
+          {
+            name: "(edit_action)".ljust(ACTION_LJUST) +
+              "Aro::Dom::MenuItem::Action(+)".ljust(CLASS_LJUST),
+            value: :edit_action
+          }
+        ]
+
+        v = Aro::P.p.select(
+          I18n.t("open_menu.edit_menu_item_localized_name", localized_name: menu_item.localized_name),
+          options
+        )
+
+        case v.to_sym
+        when :edit_title
+          new_name = get_new_value_from_user(
+            "rename #{menu_item.class} '#{menu_item.localized_name}'"
+          )
+          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
+        when :edit_action
+          puts "this is where i am working"
+          return
+        when :back
+          return
+        end
+
+        # 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})
+      end
+
+      private
+
+      def self.get_new_value_from_user(ask_text)
+        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"))
+          user_cancelled = new_val.nil? || new_val.empty?
+          new_val = nil if user_cancelled
+        end
+
+        return user_cancelled if user_cancelled
+        return new_val
+      end
+
+    end
+  end
+end

data/sys/aro/locale.rb

@@ -0,0 +1,136 @@
+=begin
+
+  locale.rb
+
+  aro dom locale.
+
+  by i2097i
+
+=end
+
+module Aro
+  module Dom
+    class Locale
+
+      def self.add_i18n_key(user_input_text, library_name: :menus, new_i18n_display_key: nil)
+        Aro::P.say(__method__)
+        library_yaml = load_library(library_name: library_name)
+        new_i18n_display_key = i18n_keyify_text(user_input_text) if new_i18n_display_key.nil?
+
+        library_yaml[
+          I18n.default_locale.to_s
+        ][
+          library_name.to_s
+        ][
+          new_i18n_display_key
+        ] = i18n_valuify_text(user_input_text)
+
+        # update library_yaml with new_i18n_display_key
+        write_library!(library_named(library_name), library_yaml)
+
+        # return new i18n_display_key
+        return new_i18n_display_key
+      end
+
+      def self.update_i18n_key(user_input_text, i18n_path, library_name: :menus)
+        raise I18n.t("open_menu.errors.invalid_i18n_path") if i18n_path&.to_s.empty?
+        Aro::P.say(__method__)
+        library_yaml = load_library(library_name: library_name)
+        if library_yaml.nil?
+          Aro::D.say("todo: handle parse error")
+          return
+        end
+        Aro::V.say("before:")
+        Aro::V.say(library_yaml.inspect)
+        if library_yaml[I18n.default_locale.to_s][i18n_path].nil?
+          add_i18n_key(user_input_text, library_name: library_name, new_i18n_display_key: i18n_path)
+          return
+        end
+
+        library_yaml[
+          I18n.default_locale.to_s
+        ][
+          library_name.to_s
+        ][
+          i18n_path
+        ] = i18n_valuify_text(user_input_text)
+
+        write_library!(library_named(library_name), library_yaml)
+      end
+
+      def self.locale_dir
+        ::File.join(Aro::Mancy.root_dir, :locale.to_s)
+      end
+
+      def self.locales_filepaths
+        ::File.join(locale_dir, "*.yml")
+      end
+
+      def self.i18n_keyify_text(text)
+        # downcase'd, gsub non-word characters with "_"
+        text.downcase.gsub(/[\W]/, "_")
+      end
+
+      def self.i18n_valuify_text(text)
+        # gsub non-word characters with " "
+        text.gsub(/[\W]/, " ")
+      end
+
+      private
+
+      def self.write_library!(library_path, library_yaml)
+        # todo: validate yaml
+        ::File.open(library_path, "w+") {|f|
+          f.write(library_yaml.to_yaml)
+        }
+        Reiquire.configure_i18n
+      end
+
+      def self.valid_library!(library_yaml, library_name: :menus)
+        if library_yaml.nil?
+          FileUtils.rm_rf(locale_dir)
+          Reiquire.configure_i18n
+          return false
+        end
+        puts library_yaml.inspect
+
+        default_locale = library_yaml[
+          I18n.default_locale.to_s
+        ]
+        raise "default_locale!" if default_locale.nil?
+        library = default_locale[library_name.to_s]
+        library_yaml[
+          I18n.default_locale.to_s
+        ][
+          library_name.to_s
+        ] = {} if library.nil?
+
+        library_yaml
+      end
+
+      def self.library_named(library_name)
+        ::File.join(locale_dir, "#{I18n.default_locale}.#{library_name}.yml")
+      end
+
+      def self.load_library(library_name: :menus)
+        library_filepath = library_named(library_name)
+        unless ::File.exist?(library_filepath)
+          FileUtils.touch(library_filepath)
+        end
+
+        loaded_file = nil
+        begin
+          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(e.inspect)
+          Aro::P.say(e.message)
+          return nil
+        end
+
+        return valid_library!(loaded_file, library_name: library_name)
+      end
+    end
+  end
+end