aro 0.2.5 → 0.2.6

data/sys/aro/store.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+=begin
+
+  store.rb
+
+  json data store
+
+  by i2097i
+
+=end
+
+class Aro::Dom::Store
+  attr_accessor :is_open, :cache, :clear_flag, :parser_error, :open_file_path
+
+  def initialize
+    open_file_path = nil
+    clear_cache!
+  end
+
+  def clear_cache!
+    if @is_open
+      @clear_flag = true
+      return
+    end
+    @clear_flag = false
+    @is_open = false
+
+    @cache = {} # clear'd
+  end
+
+  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, "{}")
+    end
+
+    # todo: validate updates
+    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)}"
+        ])
+      }
+    end
+  end
+
+  def get_key(key)
+    return if open_file_path.nil?
+
+    key = key.to_s
+
+    # ensure default for key exists
+    @cache[key] = {value: nil, persisted: false} unless @cache.keys.include?(key)
+
+    # return cache value if storage open or the cache value is persisted
+    return @cache[key][:value] if @is_open || @cache[key][:persisted]
+
+    # open storage
+    @is_open = true
+    storage_contents = {}
+    begin
+      @parser_error = nil
+      # read storage
+      storage_contents = JSON.parse(
+        ::File.read(open_file_path, encoding: "UTF-8")
+      )
+    rescue StandardError => e
+      @is_open = false
+      if @parser_error.nil?
+        @parser_error = e
+        return get_key(key)
+      else
+        raise @parser_error
+      end
+    end
+
+    # only update the cache value if present in storage
+    if storage_contents.keys.include?(key)
+      @cache[key] = {value: storage_contents[key], persisted: true}
+    else
+      @cache[key][:persisted] = false
+    end
+
+    value = @cache[key][:value]
+    @is_open = false
+    clear_cache! if @clear_flag
+
+    return value
+  end
+
+  def set_key(key, value)
+    return if open_file_path.nil?
+
+    key = key.to_s
+
+    # ensure default for key exists
+    @cache[key] = {value: value, persisted: false} unless @cache.keys.include?(key)
+
+    # assign new cache value and set persisted to false
+    @cache[key][:value] = value
+    @cache[key][:persisted] = false
+
+    # return if storage open
+    # non-persisted cache values update next cycle
+    return if @is_open
+
+    # open storage
+    @is_open = true
+    storage_contents = {}
+    begin
+      @parser_error = nil
+      # read storage
+      storage_contents = JSON.parse(
+        ::File.read(open_file_path, encoding: "UTF-8")
+      )
+    rescue StandardError => e
+      @is_open = false
+      if @parser_error.nil?
+        @parser_error = e
+        return get_key(key)
+      else
+        raise @parser_error
+      end
+    end
+
+    # update storage and cache
+    ([key] + @cache.keys.select{|k|
+      !@cache[k][:persisted]
+    }).each{|k|
+      storage_contents[k] = @cache[k][:value]
+      @cache[k][:persisted] = true
+    }
+
+    # write storage
+    ::File.open(open_file_path, "w+") do |f|
+      f.write(storage_contents.to_json)
+    end
+
+    # close storage
+    @is_open = false
+    clear_cache! if @clear_flag
+  end
+end

data/sys/aro/v.rb

@@ -14,11 +14,11 @@ module Aro
   class V < Aro::D
     def self.say(message)
       return unless Aro::V.should_print?
-      super(message)
+      super(normalize_message(message))
     end
 
     def self.should_print?
-      Aos::Cor.ivar(:VERBOSE).to_s == Aos::Cor::BOOLS[:TRUE].to_s && super
+      Aro::Cor.ivar(:VERBOSE).to_s == Aro::Cor::BOOLS[:TRUE].to_s && super
     end
   end
 end

data/sys/aro/views/base.rb

@@ -0,0 +1,25 @@
+=begin
+  
+  views/base.rb
+
+  the base view (abstract or supposed to be).
+
+  by i2097i
+
+=end
+
+module Aro
+  module Views
+    class Base
+
+      def self.show
+        draw([])
+      end
+
+      def self.draw(lines)
+        Aro::P.say(lines)
+      end
+
+    end
+  end
+end

data/sys/aro/views/teck.rb

@@ -0,0 +1,30 @@
+=begin
+
+  vws/games/game.rb
+
+  the game view.
+
+  by i2097i
+
+=end
+
+require_relative :"../models/teck".to_s
+require_relative :"./base".to_s
+
+module Aro
+  module Views
+    class Teck < Aro::Views::Base
+
+      def self.show
+        # if Aro::Mancy.teck.nil?
+        #   draw(["no teck loaded...exiting..."])
+        #   return
+        # end
+
+        # Aro::P.say(:"Aro::Dom::Ma_ain.run".to_s)
+        # draw(Aro::Dom::Ma_ain.run)
+      end
+
+    end
+  end
+end

data/sys/aro.rb

@@ -9,8 +9,7 @@
 =end
 
 require_relative :reiquire.to_s
-Reiquire::aro
 
 module Aro
-
+  Reiquire::aro
 end

data/sys/cli/constants.rb

@@ -25,13 +25,12 @@ module CLI
 
   CMDS = {
     ARO: {
+      CONSOLE: :console,
       CREATE: :create,
       COR: :cor,
       TECK: :teck,
-      DOM: :dom,
       INIT: :init,
     },
-    COR: {}, # see Aos::Cor
     TECK: {
       DRAW: :draw,
       EXPLORE: :explore,
@@ -41,10 +40,6 @@ module CLI
       SHOW: :show,
       SHUFFLE: :shuffle,
     },
-    DOM: {
-      INIT: :init,
-      NEW: :new,
-    },
   }
   
 end

data/sys/cli/create.rb

@@ -13,11 +13,11 @@ module CLI
     CLI::Nterface.exit_error_missing_args!(:var_aro_name) if CLI::ARGV1.nil?
     
     name = CLI::ARGV1&.to_s
-    Aro::P.say(I18n.t("cli.messages.creation_attempt", name: name))
+    Aro::P.say(I18n.t("messages.creation_attempt", name: name))
     if Aro::Mancy.create(name)
-      Aro::P.say(I18n.t("cli.messages.creation_success", name: name))
+      Aro::P.say(I18n.t("messages.creation_success", name: name))
     else
-      Aro::P.say(I18n.t("cli.messages.creation_failure", name: name))
+      Aro::P.say(I18n.t("messages.creation_failure", name: name))
     end
   end
 end

data/sys/cli/nterface.rb

@@ -11,26 +11,26 @@
 module CLI
   class Nterface
     def self.exit_error_not_found!(arg)
-      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy))
-      Aro::P.say(I18n.t("cli.errors.not_found", cmd: arg))
+      Aro::P.say(I18n.t("errors.header", cmd: Aro::Mancy))
+      Aro::P.say(I18n.t("errors.not_found", cmd: arg))
       exit(CLI::EXIT_CODES[:INVALID_ARG])
     end
 
     def self.exit_error_missing_args!(arg)
-      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy))
-      Aro::P.say(I18n.t("cli.errors.missing_args", cmd: arg))
+      Aro::P.say(I18n.t("errors.header", cmd: Aro::Mancy))
+      Aro::P.say(I18n.t("errors.missing_args", cmd: arg))
       exit(CLI::EXIT_CODES[:INVALID_ARG])
     end
 
     def self.exit_error_invalid_usage!
-      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy))
-      Aro::P.say(I18n.t("cli.errors.invalid_usage", cmd: Aro::Mancy))
+      Aro::P.say(I18n.t("errors.header", cmd: Aro::Mancy))
+      Aro::P.say(I18n.t("errors.invalid_usage", cmd: Aro::Mancy))
       exit(CLI::EXIT_CODES[:GENERAL_ERROR])
     end
 
     def self.exit_error_not_initialized!
-      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy))
-      Aro::P.say(I18n.t("cli.errors.not_initialized", cmd: Aro::Mancy))
+      Aro::P.say(I18n.t("errors.header", cmd: Aro::Mancy))
+      Aro::P.say(I18n.t("errors.not_initialized", cmd: Aro::Mancy))
       exit(CLI::EXIT_CODES[:GENERAL_ERROR])
     end
   end

data/sys/cli/teck.rb

@@ -10,30 +10,30 @@
 
 module CLI
   def self.teck
-    Aro::Mancy.init
+    Aro::Mancy.init(Aro::Mancy.root_dir)
     action = CLI::ARGV1&.to_sym
     if CLI::FLAGS[:HELP].include?(action)
       CLI.usage_teck
       exit(CLI::EXIT_CODES[:SUCCESS])
-    elsif action.nil? || action == :aos
+    elsif action.nil?
       # no args, open teck menu
       if Aro::Mancy.in_aro?
         Aro::Teck.display_selection_menu
       else
-        Aro::P.say(I18n.t("cli.errors.not_in_aro" , cmd: Aro::Mancy::I2097I))
+        Aro::P.say(I18n.t("errors.not_in_aro" , cmd: Aro::Mancy::I2097I))
       end
     elsif action == CLI::CMDS[:TECK][:NEW]
       CLI::Nterface.exit_error_missing_args!(:var_teck_name) if CLI::ARGV2.nil?
       if Aro::Mancy.in_aro?
         teck = Aro::Teck.make(CLI::ARGV2.to_s)
-        Aro::P.say(I18n.t("cli.messages.teck_created_sucessfully", name: teck.name))
+        Aro::P.say(I18n.t("messages.teck_created_sucessfully", name: teck.name))
         Aro::Teck.display_selection_menu
       else
-        Aro::P.say(I18n.t("cli.errors.not_in_aro" , cmd: Aro::Mancy::I2097I))
+        Aro::P.say(I18n.t("errors.not_in_aro" , cmd: Aro::Mancy::I2097I))
       end
     elsif CLI::CMDS[:TECK].values.include?(action)
       if Aro::Mancy.teck.nil?
-        Aro::P.say(I18n.t("cli.errors.missing_teck", cmd: Aro::Mancy::I2097I))
+        Aro::P.say(I18n.t("errors.missing_teck", cmd: Aro::Mancy::I2097I))
         exit(CLI::EXIT_CODES[:GENERAL_ERROR])
       end
 
@@ -42,28 +42,27 @@ module CLI
         Aro::Mancy.teck.explore
         exit(CLI::EXIT_CODES[:SUCCESS])
       when CLI::CMDS[:TECK][:SHUFFLE]
-        Aro::P.say(I18n.t("cli.messages.shuffling", name: Aro::Mancy.teck.name))
+        Aro::P.say(I18n.t("messages.shuffling", name: Aro::Mancy.teck.name))
         Aro::Mancy.teck.shuffle
       when CLI::CMDS[:TECK][:DRAW]
-        Aos::Cor.instance.load
-        Aro::P.say(I18n.t("cli.messages.drawing", name: Aro::Mancy.teck.name))
-        Aro::P.say(I18n.t("cli.messages.drawing_from_dimension", dimension: "#{Aos::Cor.ivar(:DIMENSION)}"))
+        Aro::Cor.instance.load_env
+        Aro::P.say(I18n.t("messages.drawing", name: Aro::Mancy.teck.name))
+        Aro::P.say(I18n.t("messages.drawing_from_dimension", dimension: "#{Aro::Cor.ivar(:DIMENSION)}"))
         Aro::Mancy.teck.draw(
-          is_dt_dimension: Aro::T::is_dev_tarot?,
-          z_max: Aos::Cor.ivar(:Z_MAX).to_i,
-          z: Aos::Cor.ivar(:Z)
+          z_max: Aro::Cor.ivar(:Z_MAX).to_i,
+          z: Aro::Cor.ivar(:Z)
         )
       when CLI::CMDS[:TECK][:REPLACE]
-        Aro::P.say(I18n.t("cli.messages.replacing_drawn", name: Aro::Mancy.teck.name))
+        Aro::P.say(I18n.t("messages.replacing_drawn", name: Aro::Mancy.teck.name))
         Aro::Mancy.teck.replace
       when CLI::CMDS[:TECK][:RESET]
-        Aro::P.say("#{I18n.t("cli.messages.confirmation_prompt", name: Aro::Mancy.teck.name)}")
-        if Aro::Mancy::YES.to_s != Aos::S.p.ask("\n#{Aro::Mancy::PS1}$")
-          Aro::P.say(I18n.t("cli.messages.understood", name: Aro::Mancy.teck.name))
+        Aro::P.say("#{I18n.t("messages.confirmation_prompt", name: Aro::Mancy.teck.name)}")
+        if Aro::Mancy::YES.to_s != Aro::P.p.ask("\n#{Aro::Mancy.ps1_display}$")
+          Aro::P.say(I18n.t("messages.understood", name: Aro::Mancy.teck.name))
           exit(CLI::EXIT_CODES[:SUCCESS])
         end
 
-        Aro::P.say(I18n.t("cli.messages.resetting", name: Aro::Mancy.teck.name))
+        Aro::P.say(I18n.t("messages.resetting", name: Aro::Mancy.teck.name))
         Aro::Mancy.teck.reset
       end
       Aro::Mancy.teck.show(**CLI::shoptions)

data/sys/cli/usage.rb

@@ -10,18 +10,14 @@
 
 module CLI
 
-  def self.usage_dom
-    Aro::P.less(I18n.t("usage.dom"))
-  end
-
-  def self.usage_ino
-    Aro::P.less(I18n.t("usage.ino"))
-  end
-
   def self.usage_main
     Aro::P.less(I18n.t("usage.main"))
   end
 
+  def self.usage_cor
+    Aro::P.less(I18n.t("usage.cor"))
+  end
+
   def self.usage_teck
     Aro::P.less(I18n.t("usage.teck"))
   end

data/sys/cli.rb

@@ -9,7 +9,6 @@
 =end
 
 module CLI
-  # todo: make this filtering better. dom uses :new as well
   if CLI::CMDS[:TECK].values.filter{|k| ![:new].include?(k)}.include?(ARGV[0]&.to_sym)
     # enable teck shortcut (skip typing teck while in-game)
     ARGV0 = :teck

data/sys/reiquire.rb

@@ -8,41 +8,162 @@
 
 =end
 
-# dependencies
-require :active_record.to_s
-require :"active_record/schema_dumper".to_s
-require :base64.to_s
-require :ffi.to_s
-require :fileutils.to_s
-require :"io/console".to_s
-require :i18n.to_s
-require :"net/http".to_s
-require :readline.to_s
-require :"tty-prompt".to_s
-require :yaml.to_s
-
 module Reiquire
-  GEM_PATH = Gem.loaded_specs[:aro.to_s]&.full_gem_path
-
   def self.aro
-    # configure I18n
+    # require runtime dependencies
+    require_dependencies!
 
-    I18n.load_path += Dir["#{Reiquire::GEM_PATH}/locale/*.yml"]
-    I18n.available_locales = [:en]
-    I18n.default_locale = :en
+    # require aro library
+    require_reiquires!
 
-    # require sys folders
-    Reiquire::requires([:shr, :aro, :aos, :dom, :cli])
+    # configure locale
+    configure_i18n
 
-    # require cli module
-    require_relative :"./cli".to_s
+    # ensure base migrations exist
+    copy_db_migrations_from_gem! if Aro::Mancy.in_aro?
   end
 
   def self.requires(dirs)
     dirs.each{|d|
       Dir[
-        File.join(__dir__, d.to_s, :"**/*.rb".to_s)
-      ].each { |f| require f}
+        File.join(__dir__, d.to_s, :"**/**/*.rb".to_s)
+      ].each { |f| require f }
     }
   end
+
+  def self.reload_i18n!
+    copy_locale_files_from_gem!
+    configure_i18n
+  end
+
+  def self.gem_migrations_path
+    File.join(gem_dir, :"sys/aro/db".to_s)
+  end
+
+  def self.gem_locale_dir
+    File.join(gem_dir, :locale.to_s)
+  end
+
+  def self.gem_locales_filepaths
+    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
+    )
+
+    FileUtils.mkdir_p(Aro::Db.migrate_dir)
+    FileUtils.cp_r(
+      gem_migrations_path,
+      Aro::Db.migrate_dir
+    )
+  end
+
+  private
+
+  def self.copy_locale_files_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?(
+      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)
+      oss_om_up_to_date!(
+        gem_locales_filepaths,
+        Aro::Dom::Locale.locale_dir
+      )
+      return
+    end
+
+    FileUtils.mkdir_p(Aro::Dom::Locale.locale_dir)
+    FileUtils.cp_r(
+      gem_locale_dir,
+      Aro::Dom::Locale.locale_dir
+    )
+  end
+
+  def self.oss_om_up_to_date!(gem_filepaths, oss_om_dir)
+    puts __method__
+    gem_files_abs = Dir[gem_filepaths].map{|fp| File.absolute_path(fp)}
+    puts "gem_files_abs: #{gem_files_abs}"
+    
+    puts "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)})"
+      FileUtils.cp(gfa, oss_om_dir)
+    }
+  end
+
+  def self.oss_om_up_to_date?(gem_filepaths, oss_om_filepaths)
+    puts __method__
+    file_names = Dir[oss_om_filepaths].map{|fp| File.basename(fp)}
+    puts "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|
+      file_names.include?(gfn)
+    }
+    puts "mfs_all: #{mfs_all}"
+    mfs_all
+  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}
+  end
+
+  def self.gem_dir
+    Dir[
+      Gem.loaded_specs[Aro.to_s.downcase]&.full_gem_path
+    ].first
+  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")
+    if Aro::Mancy.is_initialized?
+      I18n.load_path = I18n.load_path.select{|lp|
+        # stop using gem locales if in_aro?
+        !gem_dir_variable.include?(lp)
+      }
+      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

@@ -23,15 +23,21 @@ module Aro
     end
 
     def self.should_print?
-      Aos::Cor::BOOLS[:TRUE]
+      Aro::Cor::BOOLS[:TRUE]
     end
 
     def self.say(message)
-      Aos::Os.say(message)
+      p.say(normalize_message(message))
     end
 
     def self.less(message)
       IO.popen("less -X", "w") { |f| f.puts(message) }
     end
+
+    def self.normalize_message(message)
+      return message.join("\n") if message.kind_of?(Array)
+
+      message
+    end
   end
 end

data/sys/shr/t.rb

@@ -15,8 +15,8 @@ module Aro
     RUBY_FACOT = :"Ruby::Facot".to_s
 
     def self.is_dev_tarot?
-      user_setting_true = Aos::Cor.ivar(:DIMENSION)&.to_sym == Aos::Cor::DMS[:DEV_TAROT]
-      Aro::T.is_dev_tarot_avail? && (user_setting_true || Aos::Cor.ivar(:DIMENSION).nil?)
+      user_setting_true = Aro::Cor.ivar(:DIMENSION)&.to_sym == Aro::Cor::DMS[:DEV_TAROT]
+      Aro::T.is_dev_tarot_avail? && (user_setting_true || Aro::Cor.ivar(:DIMENSION).nil?)
     end
 
     def self.is_dev_tarot_avail?
@@ -30,7 +30,7 @@ module Aro
         # VERY IMPORTANT!
         File.open(Aro::T::DEV_TAROT_FILE.to_s, "r"){|dtf| dt = dtf.read(Aro::Mancy::N).strip}
         # VERY IMPORTANT!
-        Aro::V.say(I18n.t("cli.very_important", dev_tarot: dt))
+        Aro::V.say(I18n.t("very_important", dev_tarot: dt))
       else
         Aro::D.say("error: #{Aro::T::DEV_TAROT_FILE.to_s} not installed.")
       end
@@ -46,7 +46,7 @@ module Aro
 
     # summon ruby_facot
     def self.summon_ruby_facot(include_o = true)
-      Aro::D.say(I18n.t("cli.messages.ruby_facot_random"))
+      Aro::D.say(I18n.t("messages.ruby_facot_random"))
       ruby_facot = I18n.t("cards.index").map{|c| "+#{c}"}.sample.split("")
 
       # get orientation
@@ -62,7 +62,7 @@ module Aro
         # => character[0]: orientation
         # => character[1]: suit
 
-        # the first two characters in the dev_tarot format designate the
+        # the first two characters in the dev_tarot format designate the rf os
         !ruby_facot.first(Aro::Mancy::OS).include?(c)
       }.join("").to_sym
       rf += Aro::Mancy::NUMERALS[symm].to_s

data/sys/shr/version.rb

@@ -9,6 +9,13 @@
 =end
 
 module Aro
-  VERSION = :"0.2.5"
-  RELEASE_NOTES = :"this version".to_s + [].join(",")
+  VERSION = :"0.2.6"
+  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:")
 end

data/tasks/make.rake

@@ -1,4 +1,5 @@
 desc "rake install && rspec"
 task :make do
-  exec "rake install && rspec --backtrace"
+  exec "rake install && bundle info aro"
+  #exec "rake install && rspec --backtrace"
 end