aro 0.1.6 → 0.1.8

data/sys/cli/deck.rb

@@ -0,0 +1,98 @@
+=begin
+  
+  deck.rb
+
+  process deck commands.
+
+  by i2097i
+
+=end
+
+module CLI
+  # cli entrypoint
+  def self.deck
+    action = CLI::ARGV1&.to_sym
+
+    if CLI::FLAGS[:HELP].include?(CLI::ARGV1)
+      # todo: breakout usage into subcommand-specific verbiage
+      CLI.usage::usage
+      exit(CLI::EXIT_CODES[:SUCCESS])
+    elsif CLI::ARGV1.nil?
+      # no args, open deck menu
+      Aro::Db.new
+      Aro::Deck.display_selection_menu
+    elsif action == CLI::CMDS[:DECK][:NEW]
+      CLI::Nterface.exit_error_missing_args! if CLI::ARGV2.nil?
+      deck = Aro::Deck.make(CLI::ARGV2.to_s)
+      Aro::P.say(I18n.t("cli.messages.deck_created_sucessfully", name: Aro::Mancy.game.name))
+      Aro::Deck.display_selection_menu
+    elsif CLI::CMDS[:DECK].values.include?(action)    
+      if Aro::Mancy.game.nil?
+        Aro::P.say(I18n.t("cli.errors.missing_deck", cmd: Aro::Mancy::I2097I))
+        exit(CLI::EXIT_CODES[:GENERAL_ERROR])
+      end
+
+      case action
+      when CLI::CMDS[:DECK][:EXPLORE]
+        Aro::Mancy.game.explore
+        exit(CLI::EXIT_CODES[:SUCCESS])
+      when CLI::CMDS[:DECK][:SHUFFLE]
+        Aro::P.say(I18n.t("cli.messages.shuffling", name: Aro::Mancy.game.name))
+        Aro::Mancy.game.shuffle
+      when CLI::CMDS[:DECK][:DRAW]
+        Aro::P.say(I18n.t("cli.messages.drawing", name: Aro::Mancy.game.name))
+        Aro::P.say(I18n.t("cli.messages.drawing_from_dimension", dimension: "#{CLI::Config.ivar(:DIMENSION)}"))
+        Aro::Mancy.game.draw(
+          is_dt_dimension: Aro::T::is_dev_tarot?,
+          z_max: CLI::Config.ivar(:Z_MAX).to_i,
+          z: CLI::Config.ivar(:Z)
+        )
+      when CLI::CMDS[:DECK][:REPLACE]
+        Aro::P.say(I18n.t("cli.messages.replacing_drawn", name: Aro::Mancy.game.name))
+        Aro::Mancy.game.replace
+      when CLI::CMDS[:DECK][:RESET]
+        if Aro::Mancy::YES.to_s != Aro::P.p.ask(I18n.t("cli.messages.confirmation_prompt", name: Aro::Mancy.game.name))
+          Aro::P.say(I18n.t("cli.messages.understood", name: Aro::Mancy.game.name))
+          exit(CLI::EXIT_CODES[:SUCCESS])
+        end
+
+        Aro::P.say(I18n.t("cli.messages.resetting", name: Aro::Mancy.game.name))
+        Aro::Mancy.game.reset
+      end
+
+      Aro::Mancy.game.show(**CLI::shoptions)
+    end
+  end
+  
+  # parse show options
+  # todo: better naming
+  def self.shoptions
+    show_options_count = Aro::Mancy::S
+    show_options_order = Aro::Log::ORDERING[:DESC]
+    
+    # Aro::P.say("ARGV.map{|a| a.to_sym} => #{ARGV.map{|a| a.to_sym}}")
+    
+    count_option_flags = ARGV.map{|a| a.to_sym} & CLI::FLAGS[:SHOW_COUNT]
+    # Aro::P.say("count_option_flags: #{count_option_flags}")
+    if count_option_flags.any?
+      # get the ARGV index element after flag index
+      show_options_count = ARGV[ARGV.index(count_option_flags.first.to_s) + 1]
+      show_options_count = show_options_count.to_i unless [0, nil].include?(show_options_count&.to_i)
+      # Aro::P.say("show_options_count: #{show_options_count}")
+    end
+
+    order_option_flags = ARGV.map{|a| a.to_sym} & CLI::FLAGS[:SHOW_ORDER]
+    # Aro::P.say("count_option_flags: #{order_option_flags}")
+    if order_option_flags.any?
+      # get the ARGV index element after flag index
+      show_options_order = ARGV[ARGV.index(order_option_flags.first.to_s) + 1].to_sym
+      Aro::P.say("show_options_order: #{show_options_order}")
+    end
+
+    {
+      count_n: show_options_count,
+      order_o: show_options_order
+    }
+  end
+
+end

data/sys/cli/dom.rb

@@ -0,0 +1,37 @@
+=begin
+  
+  dom.rb
+
+  process dom commands.
+
+  by i2097i
+
+=end
+
+module CLI
+  def self.dom
+    if CLI::FLAGS[:HELP].include?(CLI::ARGV1)
+      CLI.usage::usage
+      exit(CLI::EXIT_CODES[:SUCCESS])
+    end
+
+    action = CLI::ARGV1&.to_sym
+
+    CLI::Nterface.exit_error_invalid_usage! unless !action.nil? &&
+      CLI::CMDS[:DOM].values.include?(action)
+
+    case action
+    when CLI::CMDS[:DOM][:INIT]
+      arodome = Aro::Dom.new
+      arodome.generate
+    when CLI::CMDS[:DOM][:NEW]
+      CLI::Nterface.exit_error_missing_args! if CLI::ARGV2.nil?
+      if Aro::Dom.in_arodom?
+        # todo: i18n
+        Aro::P.say("unable to create an arodome because you are already in arodom.")
+      else
+        Aro::Dom.create(CLI::ARGV2.to_s)
+      end
+    end
+  end
+end

data/sys/cli/nterface.rb

@@ -0,0 +1,31 @@
+=begin
+  
+  nterface.rb
+
+  cli nterface.
+
+  by i2097i
+
+=end
+
+module CLI
+  class Nterface
+    def self.exit_error_missing_args!
+      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy::I2097I))
+      Aro::P.say(I18n.t("cli.errors.missing_args", cmd: Aro::Mancy::I2097I))
+      exit(CLI::EXIT_CODES[:INVALID_ARG])
+    end
+
+    def self.exit_error_invalid_usage!
+      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy::I2097I))
+      Aro::P.say(I18n.t("cli.errors.invalid_usage", cmd: Aro::Mancy::I2097I))
+      exit(CLI::EXIT_CODES[:INVALID_ARG])
+    end
+
+    def self.exit_error_not_initialized!
+      Aro::P.say(I18n.t("cli.errors.header", cmd: Aro::Mancy::I2097I))
+      Aro::P.say(I18n.t("cli.errors.not_initialized", cmd: Aro::Mancy::I2097I))
+      exit(CLI::EXIT_CODES[:INVALID_ARG])
+    end
+  end
+end

data/{bin → sys}/cli/usage.rb

@@ -10,6 +10,6 @@
 
 module CLI
   def self.usage
-    Aro::P.less(I18n.t("cli.usage"))
+    Aro::P.less(I18n.t("usage.main"))
   end
 end

data/sys/cli.rb

@@ -0,0 +1,26 @@
+=begin
+  
+  cli
+
+  the very first file loaded.
+
+  by i2097i
+
+=end
+
+module CLI
+  # init config
+  CLI::Config.instance
+  
+  if CLI::CMDS[:DECK].values.include?(ARGV[0]&.to_sym)
+    # enable deck shortcut (skip typing deck while in-game)
+    ARGV0 = :deck
+    ARGV1 = ARGV[0]&.to_sym
+    ARGV2 = ARGV[1]&.to_sym
+  else
+    # default
+    ARGV0 = ARGV[0]&.to_sym
+    ARGV1 = ARGV[1]&.to_sym
+    ARGV2 = ARGV[2]&.to_sym
+  end
+end

data/sys/dom/d.rb

@@ -0,0 +1,101 @@
+=begin
+  
+  d.rb
+
+  dom definition.
+
+  by i2097i
+
+=end
+
+require_relative :dom.to_s
+
+module Aro
+  class Dom::D
+    # definition of rooms in each layout section
+    WINGS = {
+      WELCOME: {
+        WAITE: {
+          name: Aro::Dom::WAITE,
+          description: "sign up."
+        },
+        WINNER: {
+          name: Aro::Dom::WINNER,
+          description: "win."
+        },
+      },
+      GAMES: {
+        ABPPS: {
+          name: Aro::Dom::ABPPS,
+          description: "artificial beings."
+        },
+        HBPPS: {
+          name: Aro::Dom::HBPPS,
+          description: "human beings."
+        },
+        SHPPS: {
+          name: Aro::Dom::SHPPS,
+          description: "human and artificial beings."
+        },
+        VIPPS: {
+          name: Aro::Dom::VIPPS,
+          description: "very important - 100% /dev/tarot users."
+        },
+      },
+      KNOW: { 
+        LIBRARY: {
+          name: Aro::Dom::LIBRARY,
+          description: "definition management."
+        },
+        TEMPLE: {
+          name: Aro::Dom::TEMPLE,
+          description: "mindfulness management."
+        },
+      },
+      SETUP: {
+        SETTINGS: {
+          name: Aro::Dom::SETTINGS,
+          description: "user settings and configuration."
+        },
+      },
+    }
+
+    # overall layout
+    LAYOUT = {
+      WELCOME: {
+        name: Aro::Dom::WELCOME,
+        description: "sign up process.",
+        rooms: [
+          Aro::Dom::D::WINGS[:WELCOME][:WAITE],
+          Aro::Dom::D::WINGS[:WELCOME][:WINNER],
+        ]
+      },
+      GAMES: {
+        name: Aro::Dom::GAMES,
+        description: "aroflie game rooms.",
+        rooms: [
+          Aro::Dom::D::WINGS[:GAMES][:ABPPS],
+          Aro::Dom::D::WINGS[:GAMES][:HBPPS],
+          Aro::Dom::D::WINGS[:GAMES][:SHPPS],
+          Aro::Dom::D::WINGS[:GAMES][:VIPPS],
+        ],
+      },
+      KNOW: {
+        name: Aro::Dom::KNOW,
+        description: "information space.",
+        rooms: [
+          Aro::Dom::D::WINGS[:KNOW][:LIBRARY],
+          Aro::Dom::D::WINGS[:KNOW][:TEMPLE]
+        ],
+      },
+      SETUP: {
+        name: Aro::Dom::SETUP,
+        description: "user configuration space.",
+        rooms: [
+          Aro::Dom::D::WINGS[:SETUP][:SETTINGS]
+        ],
+      }
+    }
+
+  end
+end

data/sys/dom/dom.rb

@@ -0,0 +1,161 @@
+=begin
+  
+  d.rb
+
+  aro and dom.
+
+  by i2097i
+
+=end
+
+require_relative :"../aos/s".to_s
+
+module Aro
+  class Dom
+    PS1 = Aro::Dom.name
+    DOT = :"."
+    DOTT = :"#{DOT}#{DOT}"
+    ETHERGEIST = :ethergeist
+    ETHER_FILE = :".#{Aro::Dom::ETHERGEIST}"
+
+    # < root found_space
+    ARODOME = :arodome
+
+    # < user found_spaces
+    WELCOME = :welcome
+    GAMES = :games
+    KNOW = :know
+    SETUP = :setup
+
+    # > welcome found_spaces
+    WAITE = :waite
+    WINNER = :winner
+    
+    # > game found_spaces
+    ABPPS = :abpps
+    HBPPS = :hbpps
+    SHPPS = :shpps
+    VIPPS = :vipps
+
+    # > know found_spaces
+    LIBRARY = :library
+    TEMPLE = :temple
+    # ...
+
+    # > setup found_spaces
+    SETTINGS = :settings
+    # ...
+
+    def self.create(name)
+      if Dir.exist?(name) || File.exist?(name)
+        # todo: i18n
+        Aro::Dom::P.say("unable to create arodome at #{name}. file or directory already exists.")
+      end
+
+      # todo: i18n
+      Aro::Dom::P.say("creating arodome named #{name}")
+      FileUtils.mkdir(name)
+      ether_file_path = "#{name}/#{Aro::Dom::ETHER_FILE}"
+      FileUtils.mkdir(ether_file_path)
+      File.open(File.join(ether_file_path, Aro::Mancy::NAME_FILE.to_s), "w+") do |file|
+        file.write(name)
+      end
+
+      # todo: i18n
+      Aro::Dom::P.say("#{name} arodome created. enter the following commands to begin.")
+      Aro::Dom::P.say("$ cd #{name}")
+      Aro::Dom::P.say("$ aro dom init")
+    end
+
+    def self.in_arodom?
+      !Aro::Dom.ethergeist_path.nil?
+    end
+
+    def self.room_path(needle)
+      return nil if needle.nil?
+      needle = needle.to_s.strip
+      found_space = nil
+      found_room = nil
+      Aro::Dom::D::LAYOUT.values.each{|layout|
+        next unless found_room.nil?
+        found_space = layout[:name].to_s
+        if found_space == needle
+          found_room = found_space
+          found_space = nil
+        else
+          layout[:rooms].each{|room|
+            if room[:name].to_s == needle
+              found_room = room[:name].to_s
+            end
+          }
+        end
+      }
+      found_space = nil if found_room.nil?
+
+      [found_space, found_room].compact.join("/")
+    end
+
+    def self.ethergeist_path
+      path = nil
+      search_path = Dir.pwd.split("/").reject{|p| p.empty?}
+      search_pwd = "/"
+
+      search_path.any?{|step|
+        search_pwd = File.join(search_pwd, step)
+        ls = Dir.glob("#{search_pwd}/#{ETHER_FILE}", File::FNM_DOTMATCH)
+        
+        path = ls.first if ls.any?
+        !path.nil?
+      }
+
+      return path
+    end
+
+    def self.dom_root
+      File.dirname(Aro::Dom::ethergeist_path)
+    end
+
+    def generate
+      return unless Aro::Dom.in_arodom?
+
+      # todo: add file permissions to Aro::Dom::ARODOME and all WINGS
+
+      Aro::Dom::P.say("generating wings...")
+      Aro::Dom::D::LAYOUT.values.each{|w| generate_wing w}
+      
+      Aro::Dom::P.say("#{Aro::Dom.name} initialization complete!")
+    end
+
+    def generate_wing(wing)
+      return unless Aro::Dom::D::LAYOUT.values.include?(wing)
+
+      Aro::Dom::P.say("generating the #{wing[:name]} wing...")
+      FileUtils.mkdir(wing[:name].to_s)
+
+      wing[:rooms].each{|r| generate_room(wing, r)}
+    end
+
+    def generate_room(wing, room)
+      return unless Aro::Dom::D::WINGS[wing[:name].upcase].values.include?(room)
+
+      Aro::Dom::P.say("generating the #{room[:name]} room.")
+
+      room_path = File.join(wing[:name].to_s, room[:name].to_s)
+      FileUtils.mkdir(room_path)
+
+      if wing[:name] == Aro::Dom::GAMES
+        File.open(File.join(room_path, Aro::Mancy::NAME_FILE.to_s), "w+") do |f|
+          f.write(room[:name])
+        end
+      end
+    end
+
+    def self.ethergeist_name
+      File.read(
+        File.join(
+          Aro::Dom.ethergeist_path, Aro::Mancy::NAME_FILE.to_s
+        )
+      )
+    end
+  end 
+end # aroadhome

data/sys/dom/p.rb

@@ -0,0 +1,17 @@
+=begin
+  
+  p.rb
+
+  p logger for dom space.
+
+  by i2097i
+
+=end
+
+module Aro
+  class Dom::P < Aro::Prompt
+    def self.say(message)
+      Aro::Dom::P.p.say(">[#{Aro::Dom::PS1}]>: #{message}")
+    end
+  end
+end

data/sys/models/deck.rb

@@ -0,0 +1,218 @@
+=begin
+
+  deck.rb
+
+  deck object.
+
+  by i2097i
+
+=end
+
+require :base64.to_s
+require_relative :"../shr/t".to_s
+
+class Aro::Deck < ActiveRecord::Base
+  has_many :logs
+
+  DECK_FILE = :".deck"
+  CARD_DELIM = :","
+
+  before_create :populate_cards
+  after_commit :generate_log
+
+  def self.make(new_name)
+    return nil unless Aro::Mancy.is_initialized?
+    Aro::Db.new
+    new_deck = Aro::Deck.create(name: new_name)
+    if Aro::Deck.current_deck.nil?
+      File.open(Aro::Deck::DECK_FILE.to_s, "w") do |file|
+        file.write(new_deck.id)
+      end
+    end
+    new_deck
+  end
+
+  def self.fresh_cards
+    I18n.t("cards.index").map{|c| "+#{c}"}.join(Aro::Deck::CARD_DELIM.to_s)
+  end
+
+  def populate_cards
+    self.cards = Aro::Deck.fresh_cards
+  end
+
+  def generate_log
+    prev_cards = Base64::decode64(logs.last.card_data) if logs.any?
+    if prev_cards.present? && prev_cards != cards || prev_cards.nil?
+      logs.create(
+        card_data: Base64::encode64(cards),
+        drawn_data: Base64::encode64(drawn || "")
+      )
+    end
+  end
+
+  def self.display_selection_menu
+    unless Aro::Deck.any?
+      Aro::P.say(I18n.t("cli.messages.no_decks"))
+      exit(CLI::EXIT_CODES[:SUCCESS])
+    end
+
+    selection = Aro::P.p.select("choose a deck:") do |menu|
+      Aro::Deck.all.each{|d|
+        if d.id == Aro::Deck.current_deck&.id
+          menu.default d.id
+        end
+        menu.choice(d.name, d.id)
+      }
+    end
+    File.open(Aro::Deck::DECK_FILE.to_s, "w") do |file|
+      file.write(selection)
+    end
+  end
+
+  def self.current_deck
+    if File.exist?(DECK_FILE.to_s)
+      current_deck_id = File.read(DECK_FILE.to_s)
+      return Aro::Deck.find_by(id: current_deck_id)
+    end
+  end
+
+  def self.card_strip(card)
+    card.gsub(/[+-]/, "").strip
+  end
+
+  def show(count_n: Aro::Mancy::S, order_o: Aro::Log::ORDERING[:DESC])
+    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 = logs.count
+      else
+        count_n = Aro::Mancy::S
+      end
+    end
+    count_n = [[Aro::Mancy::S, count_n.to_i].max, logs.count].min
+    Aro::V.say("count_n: #{count_n}")
+    Aro::V.say("order_o: #{order_o}")
+
+    unless Aro::Log::ORDERING.values.include?(order_o)
+      Aro::P.say(I18n.t("cli.warnings.invalid_order"))
+      order_o = Aro::Log::ORDERING[:DESC]
+    end
+
+    # perform query
+    h_logs = logs.order(created_at: order_o).first(count_n)
+
+    # todo: this is doing more work than it needs to. needs debugging.
+    # Aro::V.say("h_logs.count: #{h_logs.count}")
+
+    # for now tests just expect text output
+    return h_logs if CLI::Config.is_test?
+
+    Aro::P.say(I18n.t("cli.messages.showing", name: name, count: count_n, order: order_o))
+
+    Aos::Vi::Deck.show({
+      deck: self,
+      h_logs: h_logs,
+      count_n: count_n,
+      order_o: order_o
+    })
+  end
+
+  def explore
+    # allows user to browse each card in the current deck.
+    answer = Aro::P.p.select(
+      I18n.t("cli.messages.choose_card"),
+      # formatted for tty-prompt gem
+      cards.split(Aro::Deck::CARD_DELIM.to_s).map{|c| [I18n.t("cards.#{Aro::Deck.card_strip(c)}.name"), c]}.to_h,
+      per_page: Aro::Mancy::NUMERALS[:VII],
+      cycle: true,
+      default: Aro::Mancy::S
+    )
+
+    Aro::P.say(I18n.t("cards.#{Aro::Deck.card_strip(answer)}"))
+  end
+
+  def shuffle
+    # shuffles the current deck and generates a log record.
+    update(cards: cards.split(Aro::Deck::CARD_DELIM.to_s).shuffle.join(Aro::Deck::CARD_DELIM.to_s))
+  end
+
+  def reset
+    # completely reset the deck. replace all drawn and reset order.
+    # all orientations will be set to upright.
+    update(cards: Aro::Deck.fresh_cards, drawn: "")
+  end
+
+  def replace
+    # replaces all drawn cards FIFO and puts them on the bottom of
+    # the deck. this will preserve all card orientations.
+    cards_arr = cards.split(Aro::Deck::CARD_DELIM.to_s) || []
+    drawn_arr = drawn&.split(Aro::Deck::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::Deck::CARD_DELIM.to_s))
+  end
+
+  def draw(is_dt_dimension: true, z_max: 7, z: 1)    
+    # the true card
+    abs_dev_tarot = nil
+
+    # oriented card
+    dev_tarot = nil
+
+    # get cards
+    cards_arr = cards.split(Aro::Deck::CARD_DELIM.to_s) || []
+    # get abs_cards
+    abs_cards_arr = cards_arr.map{|c| Aro::Deck.card_strip(c)}
+    # get drawn
+    drawn_arr = drawn&.split(Aro::Deck::CARD_DELIM.to_s) || []
+
+    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
+      if !is_dt_dimension || !File.exist?(Aro::T::DEV_TAROT_FILE.to_s)
+        dev_tarot = Aro::T.summon_ruby_facot(cards_arr).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
+
+    # update database 
+    update(
+      cards: cards_arr.join(Aro::Deck::CARD_DELIM.to_s),
+      drawn: drawn_arr.join(Aro::Deck::CARD_DELIM.to_s)
+    )
+  end
+end