aro 0.2.4 → 0.2.6

data/sys/aro/ma_ain.rb

@@ -0,0 +1,54 @@
+=begin
+
+  ma_ain.rb
+
+  aro dom ma_ain.
+
+  by i2097i
+
+=end
+
+module Aro
+  module Dom
+    class Ma_ain < Aro::Mancy
+      # inherits Singleton
+
+      attr_accessor :current_menu
+      attr_accessor :data_mutex, :store_mutex
+      attr_accessor :stores
+
+      def reign!
+        Aro::P.say("opening #{Aro::Dom::Designer.name}...")
+        Aro::Dom::Designer.design
+      end
+
+      def initialize
+        self.data_mutex = Mutex.new
+        self.store_mutex = Mutex.new
+        @stores = {}
+      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.ps1_display(cls_name = nil)
+        super(domain)
+      end
+
+      def get_store_for(aro_file)
+        return if aro_file.nil?
+
+        # todo validate aro_file
+        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/aro/mancy.rb

@@ -8,21 +8,25 @@
 
 =end
 
+#
+
 module Aro
   class Mancy
     include Singleton
 
-    attr_accessor :current
+    attr_accessor :current, :db_busy, :db_thread
 
+    A  = :"@"
     O  = 0
     S  = 1
     OS = 2
     E  = 3
     N  = 4
     V  = 5
-    PS1 = :">[#{Aro::Mancy.name}]>: "
+    DATE_FORMAT = "%A %d %b %Y %I:%M:%S %p"
     NAME_FILE = :".aro_space"
-    ARO_FILE = :".aro"
+    ARO_DIRECTORY = :".oss_om"
+
     I2097I = :i2097i
     YES = :aroyes
     ALL = :all
@@ -58,49 +62,46 @@ 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(name)
-      return false if Aro::Mancy.in_aro? || name.nil?
-
-      # explicitly only allow String/Symbol types for name
-      return false unless name.kind_of?(String) || name.kind_of?(Symbol)
-      name = name.to_s.strip
-      # create the new aro directory and database
-      if !Dir.exist?(name)
-        Aro::P.say(I18n.t("cli.messages.no_tecks"))
-        FileUtils.mkdir(name)
-      else
-        return false
-      end
-
-      Dir.chdir(name) do
-        Aos::Cor.instance.load
-        Aro::Mancy.init
-      end
+    def self.create(aro_name, is_test: false)
+      Aro::D.say(__method__)
+      Aro::D.say(:depricated)
       return true
     end
 
-    def self.init
-      unless Aro::Mancy.in_aro? || Aos::Cor.is_test?
-        Aro::P.say("init aro running in present directory...")
-        new_name = File.basename(Dir.pwd)
+    def self.init(root_dir_path)
+      unless Aro::Mancy.in_aro? || Aro::Cor.is_test?
+        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}")
         File.open(Aro::Mancy::NAME_FILE.to_s, "w") do |file|
           file.write(new_name)
+          file.write("\n")
         end
       end
+    end
 
-      Aro::Db.load
+    def self.root_dir
+      ::File.join(
+        Aro::Cor.ivar(:OSS_OM_HOME) || Dir.pwd,
+        Aro::Mancy::ARO_DIRECTORY.to_s
+      )
     end
 
     def self.is_initialized?
-      !Aro::Db.base_aro_dir.nil? && Dir.exist?(Aro::Db.base_aro_dir)
+      in_aro? && in_aro? && Aro::Db.instance.connected?
     end
 
     def self.in_aro?
@@ -108,11 +109,35 @@ module Aro
     end
 
     def self.domain
-      "#{Aro::Mancy}#{Aos::Os::A}#{Aro::Mancy.aro_mancy_name}"
+      is_initialized? ? "#{Aro::Mancy.aro_mancy_name}#{Aro::Mancy::A}#{Aro::Mancy}" : `whoami`.strip
     end
 
     def self.aro_mancy_name
       File.read(Aro::Mancy::NAME_FILE.to_s).strip
     end
+
+    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/uuid.rb

@@ -0,0 +1,29 @@
+=begin
+
+  uuid.rb
+
+  basic uuid generator for active record
+
+  by i2097i
+
+=end
+
+require "securerandom"
+
+module Aro::Dom::Uuid
+  extend ActiveSupport::Concern
+
+  included do
+    before_create :generate_uuid
+  end
+
+  private
+
+  def generate_uuid
+    self.uuid = SecureRandom.send([
+      :uuid,
+      :uuid_v7,
+      :uuid_v4
+    ].sample) if self.uuid.nil?
+  end
+end

data/sys/aro/models/data_base.rb

@@ -0,0 +1,97 @@
+=begin
+
+  data.rb
+
+  aro dom data.
+
+  by i2097i
+
+=end
+
+class Aro::Dom::DataBase < ActiveRecord::Base
+  include Aro::Dom::Uuid
+  self.table_name = :data_bases
+
+  has_many :data_base_directories, class_name: "Aro::Dom::DataBase::Directory"
+
+  after_commit :sync
+
+  def self.open_menu(menu_sym)
+    # get the menu directory
+    data_base_directory = menu_data_base.data_base_directories.find_or_create_by(
+      unix_path: menu_sym
+    )
+
+    menu = Aro::Dom::Menu.find_by(uuid: data_base_directory.uuid)
+    if menu.nil?
+      # find or create the new menu
+      menu = Aro::Dom::Menu.create(uuid: data_base_directory.uuid)
+      Aro::Dom::Locale.add_i18n_key(
+        menu_sym.to_s,
+        new_i18n_display_key: menu.uuid
+      )
+    end
+
+    # return the menu
+    return menu
+  end
+
+  def self.menu_data_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}"
+  end
+
+  def self.ensure_data_base_exist!
+    unless Dir.exist?(root_aro_unix_data_dir)
+      Aro::P.say(__method__)
+      Aro::P.say("creating #{root_aro_unix_data_dir}")
+      FileUtils.mkdir(root_aro_unix_data_dir)
+      ensure_data_base_git!
+    end
+  end
+
+
+  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?
+    unix_path.kind_of?(String) && !unix_path.empty?
+  end
+
+  def aro_data_base_path
+    ::File.join(Aro::Dom::DataBase.root_aro_unix_data_dir, unix_path)
+  end
+
+  def self.root_aro_unix_data_dir
+    ::File.join(Aro::Mancy.root_dir, table_name)
+  end
+
+  def ensure_unix_exists!
+    raise "unix_path invalid! #{(unix_path)}" unless unix_path_valid?
+    unless Dir.exist?(aro_data_base_path)
+      Aro::P.say(__method__)
+      Aro::P.say("creating #{aro_data_base_path}")
+      FileUtils.mkdir(aro_data_base_path)
+      ::File.write(::File.join(aro_data_base_path, ".uuid"), uuid)
+    end
+  end
+
+  private
+
+  def sync
+    Aro::Dom::Ma_ain.instance.data_mutex.synchronize do
+      self.class.ensure_data_base_git!
+      ensure_unix_exists!
+    end
+  end
+end

data/sys/aro/models/directory.rb

@@ -0,0 +1,44 @@
+=begin
+
+  data.rb
+
+  aro dom table.
+
+  by i2097i
+
+=end
+
+class Aro::Dom::DataBase::Directory < ActiveRecord::Base
+  include Aro::Dom::Uuid
+  self.table_name = :data_base_directories
+  belongs_to :data_base, class_name: "Aro::Dom::DataBase"
+
+  has_many :data_base_files, class_name: "Aro::Dom::DataBase::File"
+
+  after_create :sync
+  after_commit :sync
+
+  def ensure_unix_exists!
+    unless Dir.exist?(aro_directory_path)
+      Aro::P.say("creating #{Aro::Dom::DataBase::Directory} for #{aro_directory_path}")
+      FileUtils.mkdir(aro_directory_path)
+      ::File.write(::File.join(aro_directory_path, ".uuid"), uuid)
+    end
+  end
+
+  def aro_directory_path
+    ::File.join(data_base.aro_data_base_path, unix_path)
+  end
+
+  def schema
+    ::File.join(aro_directory_path, :def_directory, ".json")
+  end
+
+  private
+
+  def sync
+    Aro::Dom::Ma_ain.instance.data_mutex.synchronize do
+      ensure_unix_exists!
+    end
+  end
+end

data/sys/aro/models/file.rb

@@ -0,0 +1,27 @@
+=begin
+
+  row.rb
+
+  aro dom data file.
+
+  by i2097i
+
+=end
+
+class Aro::Dom::DataBase::File < ActiveRecord::Base
+  include Aro::Dom::Uuid
+  self.table_name = :data_base_files
+  belongs_to :data_base_directory, class_name: "Aro::Dom::DataBase::Directory"
+
+  def write!(updates = {})
+    Aro::Dom::Store.edit(self, updates)
+  end
+
+  def aro_file_path
+    ::File.join(
+      data_base_directory.aro_directory_path,
+      "#{uuid}.json"
+    )
+  end
+
+end

data/sys/aro/models/menu.rb

@@ -0,0 +1,27 @@
+=begin
+
+  menu.rb
+
+  aro dom menu.
+
+  by i2097i
+
+=end
+
+class Aro::Dom::Menu < ActiveRecord::Base
+  include Aro::Dom::Uuid
+
+  has_many :menu_items, class_name: "Aro::Dom::MenuItem"
+
+  def localized_name
+    I18n.t(full_i18n_path)
+  end
+
+  def full_i18n_path
+    "#{self.class.table_name}.#{uuid}"
+  end
+
+  def directory
+    Aro::Dom::DataBase::Directory.find_by(uuid: uuid)
+  end
+end

data/sys/aro/models/menu_item.rb

@@ -0,0 +1,47 @@
+=begin
+
+  menu.rb
+
+  aro dom menu item.
+
+  by i2097i
+
+=end
+
+class Aro::Dom::MenuItem < ActiveRecord::Base
+  include Aro::Dom::Uuid
+  belongs_to :menu, class_name: "Aro::Dom::Menu"
+
+  after_create :sync
+
+  def as_tty
+    {name: localized_name, value: uuid}
+  end
+
+  def localized_name
+    I18n.t(full_i18n_path)
+  end
+
+  def full_i18n_path
+    "#{self.class.table_name}.#{uuid}"
+  end
+
+  def aro_directory
+    return if menu.nil?
+    Aro::Dom::DataBase::Directory.find_by(uuid: menu.uuid)
+  end
+
+  def aro_file
+    return if aro_directory.nil?
+    Aro::Dom::DataBase::File.find_or_create_by(
+      uuid: uuid,
+      data_base_directory: aro_directory
+    )
+  end
+
+  private
+
+  def sync
+    Aro::Dom::DataBase.sync_menu_item(self)
+  end
+end

data/sys/aro/models/teck.rb

@@ -9,7 +9,6 @@
 =end
 
 require :base64.to_s
-require_relative :"./base_model".to_s
 
 class Aro::Teck < ActiveRecord::Base
   has_many :tlogs
@@ -21,7 +20,6 @@ class Aro::Teck < ActiveRecord::Base
   after_commit :generate_log
 
   def self.make(new_name)
-    Aro::Db.load
     return nil unless Aro::Mancy.is_initialized?
     new_teck = Aro::Teck.create(name: new_name)
     Aro::Teck.select_teck(new_teck) if Aro::Teck.current_teck.nil?
@@ -33,13 +31,14 @@ class Aro::Teck < ActiveRecord::Base
   end
 
   def populate_cards
-    Aro::Db.load
     self.cards = Aro::Teck.fresh_cards
   end
 
   def generate_log
     prev_cards = Base64::decode64(tlogs.last.card_data) if tlogs.any?
-    if (prev_cards.present? && prev_cards != cards) || (prev_cards.nil? || prev_cards.empty?)
+    if (prev_cards.present? && prev_cards != cards) ||
+      (prev_cards.nil? || prev_cards.empty?)
+
       tlogs.create(
         card_data: Base64::encode64(cards || ""),
         drawn_data: Base64::encode64(drawn || "")
@@ -48,9 +47,8 @@ class Aro::Teck < ActiveRecord::Base
   end
 
   def self.display_selection_menu
-    Aro::Db.load
     unless Aro::Teck.any?
-      Aro::P.say(I18n.t("cli.messages.no_tecks"))
+      Aro::P.say(I18n.t("messages.no_tecks"))
       exit(CLI::EXIT_CODES[:SUCCESS])
     end
     c_d = Aro::Teck.current_teck
@@ -61,16 +59,15 @@ class Aro::Teck < ActiveRecord::Base
 
   def self.select_teck(teck)
     return unless teck.present?
-    Aro::P.say(I18n.t("cli.messages.teck_selected", name: teck.name, room: Aro::Mancy::aro_mancy_name))
-    File.open(File.join(Aro::Db.base_aro_dir, Aro::Teck::TECK_FILE.to_s), "w") do |file|
+    Aro::P.say(I18n.t("messages.teck_selected", name: teck.name, room: Aro::Mancy::aro_mancy_name))
+    File.open(File.join(Aro::Mancy.root_dir, Aro::Teck::TECK_FILE.to_s), "w") do |file|
       file.write(teck.id)
     end
   end
 
   def self.current_teck
-    Aro::Db.load
-    if File.exist?(File.join(Aro::Db.base_aro_dir, TECK_FILE.to_s))
-      current_teck_id = File.read(File.join(Aro::Db.base_aro_dir, TECK_FILE.to_s))
+    if File.exist?(File.join(Aro::Mancy.root_dir, TECK_FILE.to_s))
+      current_teck_id = File.read(File.join(Aro::Mancy.root_dir, TECK_FILE.to_s))
       return Aro::Teck.find_by(id: current_teck_id)
     end
   end
@@ -93,37 +90,31 @@ class Aro::Teck < ActiveRecord::Base
     Aro::V.say("order_o: #{order_o}")
 
     unless Aro::Tlog::ORDERING.values.include?(order_o)
-      Aro::P.say(I18n.t("cli.warnings.invalid_order"))
+      Aro::P.say(I18n.t("warnings.invalid_order"))
       order_o = Aro::Tlog::ORDERING[:DESC]
     end
 
     # perform query
-    Aro::Db.load
     tlog_records = tlogs.order(created_at: order_o).first(count_n)
 
     # todo: this is doing more work than it needs to. needs debugging.
     # Aro::V.say("tlog_records.count: #{tlog_records.count}")
 
     # for now tests just expect count
-    return tlog_records if Aos::Cor.is_test?
+    return tlog_records if Aro::Cor.is_test?
 
-    Aro::D.say(I18n.t("cli.messages.showing", name: name, count: count_n, order: order_o))
+    Aro::D.say(I18n.t("messages.showing", name: name, count: count_n, order: order_o))
 
-    Aos::Vw::Teck.show_game({
-      teck: self,
-      tlog_records: tlog_records,
-      count_n: count_n,
-      order_o: order_o
-    })
+    Aro::Views::Teck.show
   end
 
   def explore
     # allows user to browse each card in the current teck.
-    answer = Aos::S.p.select(
-      Aro::Mancy::PS1.to_s + I18n.t("cli.messages.choose_card"),
+    answer = Aro::P.p.select(
+      Aro::Mancy::ps1_display.to_s + I18n.t("messages.choose_card"),
       # formatted for tty-prompt gem
       cards.split(Aro::Teck::CARD_DELIM.to_s).map{|c| [I18n.t("cards.#{Aro::Teck.card_strip(c)}.name"), c]}.to_h,
-      per_page: Aos::Cor.discon[:HEIGHT] - Aro::Mancy::S,
+      per_page: TTY::Screen.height - Aro::Mancy::OS,
       cycle: true,
       default: Aro::Mancy::S
     )
@@ -138,14 +129,33 @@ class Aro::Teck < ActiveRecord::Base
       orientation = "-"
     end
 
-    definition = I18n.t("cards.#{Aro::Teck.card_strip(card_code)}")
+    Aro::P.say(I18n.t("messages.printing_card", card: card_code))
+    width = Aro::Cor.discon[:WIDTH]
+    divider = Aro::Cor.discon[:DIVIDER]
+    card_lookup = Aro::Teck.card_strip(card_code)
+    suit_lookup = card_lookup[Aro::Mancy::O]
+    definition = I18n.t("cards.#{card_lookup}")
+    suit_definition = I18n.t("suits.#{suit_lookup}")
     output = []
-    output << orientation + definition[:name]
-    output += definition["#{orientation}tags".to_sym].sort
+    output << "".ljust(width, divider)
+    output << ""
+    output << "(#{orientation}) #{definition[:name].upcase}"
+    output << ""
+    unless suit_definition.nil?
+      suit_definition[:summary].split(".").each{|sentence| output << sentence + ".\n"}
+      output << suit_definition[:tags].sort.join(" | ")
+    end
+    output << "".ljust(width, divider)
+    output << ""
+    card_tags = definition["#{orientation}tags".to_sym].sort
+    max_word = card_tags.max_by{|t| t.length}.length
+    card_tags.each{|t|
+      output << t.center(max_word)
+    }
     # todo: add an actual summary
     # Aro::P.say(definition["#{orientation}summary".to_sym])
-    width = Aos::Cor.discon[:WIDTH]
-    Aro::P.say("#{card_code}\n#{output.map{|l| l.center(width, Aos::Cor.discon[:DIVIDER])}.join("\n")}")
+    output << "".ljust(width, divider)
+    Aro::P.say("#{card_code}\n#{output.map{|l| l.center(width)}.join("\n")}")
   end
 
   def shuffle
@@ -172,7 +182,7 @@ class Aro::Teck < ActiveRecord::Base
     update(drawn: "", cards: cards_arr.join(Aro::Teck::CARD_DELIM.to_s))
   end
 
-  def draw(is_dt_dimension: true, z_max: 7, z: 1)
+  def draw(z_max: 7, z: 1)
     # the true card
     abs_dev_tarot = nil
 
@@ -231,7 +241,6 @@ class Aro::Teck < ActiveRecord::Base
     # insert dev_tarot to drawn
     drawn_arr << dev_tarot
     Aro::Teck.print_card(dev_tarot)
-    Aro::Db.load
 
     # update database 
     update(

data/sys/aro/p.rb

@@ -14,10 +14,13 @@ require_relative :"./r".to_s
 module Aro
   class P < Aro::Prompt
     def self.say(message)
-      if Aro::Mancy.in_aro? && !Aro::T.is_dev_tarot?
-        Aro::R.say(message)
+      if Aro::Dom::Ma_ain.instance.nil? &&
+        Aro::Mancy.in_aro? &&
+        !Aro::T.is_dev_tarot?
+
+        Aro::R.say(normalize_message(message))
       else
-        super(["#{Aro::Mancy::PS1}#{message}"])
+        super("#{Aro::Dom::Ma_ain.ps1_display || Aro::Mancy.ps1_display}#{normalize_message(message)}")
       end
     end
   end

data/sys/aro/r.rb

@@ -12,9 +12,8 @@ require_relative :"../shr/prompt".to_s
 
 module Aro
   class R < Aro::Prompt
-    PS1 = :">[#{Aro::T::RUBY_FACOT}]>:"
     def self.say(message)
-      super(["#{Aro::R::PS1} #{message}"])
+      super("#{Aro::Mancy.ps1_display(Aro::R.name)} #{normalize_message(message)}")
     end
   end
 end