aro 0.2.6 → 0.2.7

data/locale/en.cmd.yml

@@ -1,34 +0,0 @@
-en:
-  cmd:
-    commands:
-      console_description: "open irb with aro"
-      console_usage: "$ aro console"
-      create_description: "create and init an aro space."
-      create_usage: "$ aro create var_name"
-      cor_description: "aro cor unix env bindings."
-      cor_usage: "$ aro cor [-h | --help]"
-      data_description: "aro data commands."
-      data_usage: "$ aro data [-h | --help]"
-      teck_description: "aro teck commands."
-      teck_usage: "aro teck [-h | --help]"
-      init_description: "sets up the .aro directory that contains database and cor"
-      init_usage: "$ aro init"
-    subcommands:
-      ivars_description: "print ivars"
-      ivars_usage: "$ aro cor ivars"
-      ovars_description: "print ovars"
-      ovars_usage: "$ aro cor ovars"
-      draw_description: "draw a card from the current teck."
-      draw_usage: "$ aro draw; or $ aro teck draw"
-      explore_description: "explore the tarot."
-      explore_usage: "$ aro explore OR $ aro teck explore"
-      teck_new_description: "todo: new_description"
-      teck_new_usage: "$ aro teck new teck_name"
-      replace_description: "todo: replace_description"
-      replace_usage: "$ aro replace OR $ aro teck replace"
-      reset_description: "todo: reset_description"
-      reset_usage: "$ aro reset OR $ aro teck reset"
-      show_description: "todo: show_description"
-      show_usage: "$ aro show OR $ aro teck show"
-      shuffle_description: "todo: shuffle_description"
-      shuffle_usage: "$ aro shuffle OR $ aro teck shuffle"

data/locale/en.usage.yml

@@ -1,142 +0,0 @@
-en: 
-  usage:
-    cor: |
-      aro cor management.
-
-        $ aro cor [-h | --help]
-
-        $ aro cor var_name var_value
-
-      basic usage:
-
-        no params prints the cor (writable) ivars.
-
-          $ aro cor [ivars|ovars]
-
-        param var_name prints the var named var_name.
-
-          $ aro cor var_name
-
-        param var_name & param var_value updates a var named var_name with var_value.
-
-          $ aro cor var_name var_value
-
-    main: |
-      SUMMARY
-
-        aro.
-
-      SYNOPSIS
-
-        aro [-v | --version] [-h | --help] [(+|-)(T|C|S|P|W)(var_numeral)] var_command
-
-          quickstart or tldr; example:
-
-            $ aro create var_name && cd var_name && aro teck new var_teck_name && aro
-
-          card lookup example:
-
-            $ aro +TXXI
-
-          or, equivalently:
-
-            $ aro +txxi
-
-      COMMANDS
-        create
-          create and init an aro space named var_name:
-
-            $ aro create var_name
-
-        init
-          sets up the .aro directory that contains database and cor
-
-          note:
-            this runs by default after create and has no effect if init is complete.
-
-        cor
-          aro cor unix env bindings.
-
-            $ aro cor [-h | --help]
-
-        teck
-          aro teck commands.
-
-            $ aro teck [-h | --help]
-
-        data
-          aro data commands.
-
-            $ aro data [-h | --help]
-
-
-      aro by i2097i is copyright (2026)
-    teck: |
-      aro teck
-        manage tecks in the aro space.
-
-          $ aro teck var_command
-
-        passing no params opens the selection menu.
-
-        note:
-
-          teck subcommands do not require typing 'teck'. for example,
-
-          $ aro teck show
-
-          is the same thing as:
-
-          $ aro show
-
-        COMMANDS
-          draw
-            draw a random card from the current teck.
-
-          explore
-            allows user to browse each card in the current teck.
-
-          new
-            create a new teck with the specified name.
-
-              example:
-
-                $ aro teck new var_name
-
-          replace
-            replaces all drawn cards FIFO and puts them on the bottom of
-            the teck. this will preserve all card orientations.
-
-          reset
-            completely reset the teck. replace all drawn and reset order.
-            all orientations will be set to upright. you must enter 'aroyes'
-            to continue.
-
-          show
-            displays the current teck's log record(s).
-
-            the default behavior is to display only the most recent log record.
-
-            note:
-
-              'less' is automatically used to view text output log count > 1
-
-            OPTIONS
-
-              [-n | --count]  specify number of teck tlogs to show.
-
-                                default is 1 (latest/current state)
-
-                                passing 'all' display all tlogs
-
-              [-o | --order]  specify the output order of the log records.
-
-                                default is 'desc'
-
-                                possible values: ['asc', 'desc']
-
-          shuffle
-            shuffles the current teck and generates a log record.
-
-
-      aro by i2097i is copyright (2026)

data/sys/aro/cmd.rb

@@ -1,96 +0,0 @@
-=begin
-
-  cmd.rb
-
-  cmd interface.
-
-  by i2097i
-
-=end
-
-module Aro
-  class Cmd
-    include Singleton
-
-    CMDS = {
-      CONSOLE: {
-        key: :console,
-        description: I18n.t("cmd.commands.console_description"),
-        usage: I18n.t("cmd.commands.console_usage")
-      },
-      CREATE: {
-        key: :create,
-        description: I18n.t("cmd.commands.create_description"),
-        usage: I18n.t("cmd.commands.create_usage")
-      },
-      COR: {
-        key: :cor,
-        description: I18n.t("cmd.commands.cor_description"),
-        usage: I18n.t("cmd.commands.cor_usage"),
-        subcommands: {
-          IVARS: {
-            key: :ivars,
-            description: I18n.t("cmd.subcommands.ivars_description"),
-            usage: I18n.t("cmd.subcommands.ivars_usage")
-          },
-          OVARS: {
-            key: :ovars,
-            description: I18n.t("cmd.subcommands.ovars_description"),
-            usage: I18n.t("cmd.subcommands.ovars_usage")
-          }
-        }
-      },
-      TECK: {
-        key: :teck,
-        description: I18n.t("cmd.commands.teck_description"),
-        usage: I18n.t("cmd.commands.teck_usage"),
-        subcommands: {
-          DRAW: {
-            key: :draw,
-            description: I18n.t("cmd.subcommands.draw_description"),
-            usage: I18n.t("cmd.subcommands.draw_usage")
-          },
-          EXPLORE: {
-            key: :explore,
-            description: I18n.t("cmd.subcommands.explore_description"),
-            usage: I18n.t("cmd.subcommands.explore_usage")
-          },
-          NEW: {
-            key: :new,
-            description: I18n.t("cmd.subcommands.teck_new_description"),
-            usage: I18n.t("cmd.subcommands.teck_new_usage")
-          },
-          REPLACE: {
-            key: :replace,
-            description: I18n.t("cmd.subcommands.replace_description"),
-            usage: I18n.t("cmd.subcommands.replace_usage")
-          },
-          RESET: {
-            key: :reset,
-            description: I18n.t("cmd.subcommands.reset_description"),
-            usage: I18n.t("cmd.subcommands.reset_usage")
-          },
-          SHOW: {
-            key: :show,
-            description: I18n.t("cmd.subcommands.show_description"),
-            usage: I18n.t("cmd.subcommands.show_usage")
-          },
-          SHUFFLE: {
-            key: :shuffle,
-            description: I18n.t("cmd.subcommands.shuffle_description"),
-            usage: I18n.t("cmd.subcommands.shuffle_usage")
-          }
-        }
-      },
-      INIT: {
-        key: :init,
-        description: I18n.t("cmd.commands.init_description"),
-        usage: I18n.t("cmd.commands.init_usage")
-      }
-    }
-
-    def self.display_lines
-      JSON.pretty_generate(CMDS).split("\n")
-    end
-  end
-end

data/sys/aro/db/migrate/1763374647_create_tecks.rb

@@ -1,20 +0,0 @@
-class CreateTecks < ActiveRecord::Migration[8.1]
-
-  def self.up
-    create_table :tecks do |t|
-      t.string :name
-      t.string :cards, null: false, default: ""
-      t.string :drawn, null: false, default: ""
-
-      t.timestamps
-    end
-
-    add_index :tecks, :name, unique: true
-  end
-
-  def self.down
-    remove_index :tecks, :name
-    drop_table :tecks
-  end
-
-end

data/sys/aro/db/migrate/1763432541_create_tlogs.rb

@@ -1,20 +0,0 @@
-class CreateTlogs < ActiveRecord::Migration[8.1]
-
-  def self.up
-    create_table :tlogs do |t|
-      t.string :card_data
-      t.string :drawn_data
-
-      t.timestamps
-    end
-
-    add_column :tlogs, :teck_id, :integer
-    add_index :tlogs, :teck_id
-  end
-
-  def self.down
-    remove_index :tlogs, :teck_id
-    drop_table :tlogs
-  end
-
-end

data/sys/aro/ma_ain.rb

@@ -1,54 +0,0 @@
-=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/models/teck.rb

@@ -1,251 +0,0 @@
-=begin
-
-  teck.rb
-
-  teck object.
-
-  by i2097i
-
-=end
-
-require :base64.to_s
-
-class Aro::Teck < ActiveRecord::Base
-  has_many :tlogs
-
-  TECK_FILE = :".aro_teck"
-  CARD_DELIM = :","
-
-  before_create :populate_cards
-  after_commit :generate_log
-
-  def self.make(new_name)
-    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?
-    new_teck
-  end
-
-  def self.fresh_cards
-    I18n.t("cards.index").map{|c| "+#{c}"}.join(Aro::Teck::CARD_DELIM.to_s)
-  end
-
-  def populate_cards
-    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?)
-
-      tlogs.create(
-        card_data: Base64::encode64(cards || ""),
-        drawn_data: Base64::encode64(drawn || "")
-      )
-    end
-  end
-
-  def self.display_selection_menu
-    unless Aro::Teck.any?
-      Aro::P.say(I18n.t("messages.no_tecks"))
-      exit(CLI::EXIT_CODES[:SUCCESS])
-    end
-    c_d = Aro::Teck.current_teck
-    Aro::Teck.all.each do |d|
-      Aro::P.say("#{d.id == c_d.id ? :*.to_s : " "}#{d.id}): #{d.name}")
-    end
-  end
-
-  def self.select_teck(teck)
-    return unless teck.present?
-    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
-    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
-
-  def self.card_strip(card)
-    card.gsub(/[+-]/, "").strip
-  end
-
-  def show(count_n: Aro::Mancy::S, order_o: Aro::Tlog::ORDERING[:DESC])
-    tlogs_count = tlogs.count
-    unless count_n.kind_of?(Numeric) && count_n.to_i > Aro::Mancy::O
-      if count_n&.to_s&.to_sym == Aro::Mancy::ALL
-        count_n = tlogs_count
-      else
-        count_n = Aro::Mancy::S
-      end
-    end
-    count_n = [[Aro::Mancy::S, count_n.to_i].max, tlogs_count].min
-    Aro::V.say("count_n: #{count_n}")
-    Aro::V.say("order_o: #{order_o}")
-
-    unless Aro::Tlog::ORDERING.values.include?(order_o)
-      Aro::P.say(I18n.t("warnings.invalid_order"))
-      order_o = Aro::Tlog::ORDERING[:DESC]
-    end
-
-    # perform query
-    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 Aro::Cor.is_test?
-
-    Aro::D.say(I18n.t("messages.showing", name: name, count: count_n, order: order_o))
-
-    Aro::Views::Teck.show
-  end
-
-  def explore
-    # allows user to browse each card in the current teck.
-    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: TTY::Screen.height - Aro::Mancy::OS,
-      cycle: true,
-      default: Aro::Mancy::S
-    )
-
-    Aro::Teck.print_card(answer)
-  end
-
-  def self.print_card(card_code)
-    card_code = card_code.to_s.upcase
-    orientation = "+"
-    if card_code.include?("-")
-      orientation = "-"
-    end
-
-    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 << "".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])
-    output << "".ljust(width, divider)
-    Aro::P.say("#{card_code}\n#{output.map{|l| l.center(width)}.join("\n")}")
-  end
-
-  def shuffle
-    # shuffles the current teck and generates a log record.
-    update(cards: cards.split(Aro::Teck::CARD_DELIM.to_s).shuffle.join(Aro::Teck::CARD_DELIM.to_s))
-  end
-
-  def reset
-    # completely reset the teck. replace all drawn and reset order.
-    # all orientations will be set to upright.
-    update(cards: Aro::Teck.fresh_cards, drawn: "")
-  end
-
-  def replace
-    # replaces all drawn cards FIFO and puts them on the bottom of
-    # the teck. this will preserve all card orientations.
-    cards_arr = cards.split(Aro::Teck::CARD_DELIM.to_s) || []
-    drawn_arr = drawn&.split(Aro::Teck::CARD_DELIM.to_s) || []
-
-    # append each drawn card to cards
-    drawn_arr.each{|dc| cards_arr << dc }
-
-    # clear drawn
-    update(drawn: "", cards: cards_arr.join(Aro::Teck::CARD_DELIM.to_s))
-  end
-
-  def draw(z_max: 7, z: 1)
-    # the true card
-    abs_dev_tarot = nil
-
-    # oriented card
-    dev_tarot = nil
-
-    # get cards
-    cards_arr = cards.split(Aro::Teck::CARD_DELIM.to_s) || []
-    # get abs_cards
-    abs_cards_arr = cards_arr.map{|c| Aro::Teck.card_strip(c)}
-    # get drawn
-    drawn_arr = drawn&.split(Aro::Teck::CARD_DELIM.to_s) || []
-
-    if cards_arr.empty?
-      Aro::P.say("there are no cards left to draw.")
-      return
-    end
-    sleeps = 0
-    sleeps_max = z_max
-
-    # find a card that is not already drawn
-    while sleeps <= sleeps_max && dev_tarot.nil? do
-      # use fallback randomness if /dev/tarot unavailable
-      unless Aro::T.is_dev_tarot? && Aro::T.is_dev_tarot_avail?
-        dev_tarot = Aro::T.summon_ruby_facot.split("")
-      else
-        # preferred randomness
-        read_value = Aro::T.read_dev_tarot&.strip&.split("")
-        if read_value.count >= Aro::Mancy::N - 1
-          dev_tarot = read_value
-        end
-      end
-      
-      unless dev_tarot.nil?
-        abs_dev_tarot = dev_tarot[Aro::Mancy::S] + Aro::Mancy::NUMERALS.key(
-          dev_tarot.join("")[Aro::Mancy::OS..].to_i
-        ).to_s
-        if abs_cards_arr.include?(abs_dev_tarot)
-          # dev_tarot is valid
-          dev_tarot = dev_tarot[Aro::Mancy::O] + abs_dev_tarot
-        else
-          dev_tarot = nil
-        end
-      end
-
-      if dev_tarot.nil?
-        # dev_tarot is invalid
-        sleeps += 1
-        sleep(z.to_i)
-      end
-    end
-
-    # remove from cards
-    cards_arr.delete(cards_arr.select{|c| c.include?(abs_dev_tarot)}.first)
-
-    # insert dev_tarot to drawn
-    drawn_arr << dev_tarot
-    Aro::Teck.print_card(dev_tarot)
-
-    # update database 
-    update(
-      cards: cards_arr.join(Aro::Teck::CARD_DELIM.to_s),
-      drawn: drawn_arr.join(Aro::Teck::CARD_DELIM.to_s)
-    )
-  end
-end

data/sys/aro/models/tlog.rb

@@ -1,21 +0,0 @@
-=begin
-
-  tlog.rb
-
-  teck tlog object.
-
-  by i2097i
-
-=end
-
-require_relative :"./teck".to_s
-
-class Aro::Tlog < ActiveRecord::Base
-  belongs_to :teck
-
-  ORDERING = {
-    ASC: :asc,
-    DESC: :desc
-  }
-
-end

data/sys/aro/views/base.rb

@@ -1,25 +0,0 @@
-=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

@@ -1,30 +0,0 @@
-=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