aro 0.1.7 → 0.1.9

data/sys/cli/dom.rb

@@ -10,36 +10,35 @@
 
 module CLI
   def self.dom
-    action = CLI::ARGV1&.to_sym
-
-    CLI::Nterface.exit_error_invalid_usage! unless CLI::CMDS[:DOM].values.include?(action)
-
     if CLI::FLAGS[:HELP].include?(CLI::ARGV1)
       CLI.usage::usage
       exit(CLI::EXIT_CODES[:SUCCESS])
-    elsif CLI::ARGV1.nil?
-      # no args, default dom action
-      Aro::Dom.map
     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][:MAP]
-      Aro::Dom.map
     when CLI::CMDS[:DOM][:INIT]
-      arodome = Aro::Dom.new
-      arodome.generate
+      if Aro::Dom.is_initialized?
+        Aro::P.say(I18n.t("dom.errors.failed_already_initialized"))
+      elsif Aro::Dom.in_arodom? && !Aro::Dom.is_initialized?
+        arodome = Aro::Dom.new
+        arodome.generate
+      else
+        CLI::Nterface.exit_error_invalid_usage!
+      end
     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.")
+        Aro::P.say(I18n.t("dom.errors.failed_already_in_arodom"))
+      elsif Aro::Mancy.in_aro?
+        Aro::P.say(I18n.t("dom.errors.failed_in_aro_space"))
       else
         Aro::Dom.create(CLI::ARGV2.to_s)
       end
-    else
-      if CLI::CMDS[:DOM].values.include?(action) 
-        # todo: 
-      end
     end
   end
 end

data/sys/cli/nterface.rb

@@ -21,5 +21,11 @@ module CLI
       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/sys/dom/d.rb

@@ -12,54 +12,60 @@ require_relative :dom.to_s
 
 module Aro
   class Dom::D
-    # definition of rooms in each layout section
+    def self.reserved_words
+      reserved = []
+      Aro::Dom::D::LAYOUT.values.each{|wing|
+        reserved << wing[:name].to_s
+        wing[:rooms].each{|room| reserved << room[:name].to_s}
+      }
+
+      reserved.sort
+    end
+
+    # definition of rooms in each layout wing
     WINGS = {
       WELCOME: {
         WAITE: {
           name: Aro::Dom::WAITE,
-          description: "sign up."
-        },
-        WELCOME: { 
-          name: Aro::Dom::WELCOME,
-          description: "sign in."
+          description: I18n.t("dom.rooms.waite.description"),
         },
         WINNER: {
           name: Aro::Dom::WINNER,
-          description: "win."
+          description: I18n.t("dom.rooms.winner.description"),
         },
       },
       GAMES: {
         ABPPS: {
           name: Aro::Dom::ABPPS,
-          description: "artificial beings."
+          description: I18n.t("dom.rooms.abpps.description"),
         },
         HBPPS: {
           name: Aro::Dom::HBPPS,
-          description: "human beings."
+          description: I18n.t("dom.rooms.hbpps.description"),
         },
         SHPPS: {
           name: Aro::Dom::SHPPS,
-          description: "human and artificial beings."
+          description: I18n.t("dom.rooms.shpps.description"),
         },
         VIPPS: {
           name: Aro::Dom::VIPPS,
-          description: "very important - 100% /dev/tarot users."
+          description: I18n.t("dom.rooms.vipps.description"),
         },
       },
       KNOW: { 
         LIBRARY: {
           name: Aro::Dom::LIBRARY,
-          description: "definition management."
+          description: I18n.t("dom.rooms.library.description"),
         },
         TEMPLE: {
           name: Aro::Dom::TEMPLE,
-          description: "mindfulness management."
+          description: I18n.t("dom.rooms.temple.description"),
         },
       },
       SETUP: {
         SETTINGS: {
           name: Aro::Dom::SETTINGS,
-          description: "user settings and configuration."
+          description: I18n.t("dom.rooms.settings.description"),
         },
       },
     }
@@ -68,16 +74,15 @@ module Aro
     LAYOUT = {
       WELCOME: {
         name: Aro::Dom::WELCOME,
-        description: "sign up process.",
+        description: I18n.t("dom.wings.welcome.description"),
         rooms: [
           Aro::Dom::D::WINGS[:WELCOME][:WAITE],
-          Aro::Dom::D::WINGS[:WELCOME][:WELCOME],
           Aro::Dom::D::WINGS[:WELCOME][:WINNER],
         ]
       },
       GAMES: {
         name: Aro::Dom::GAMES,
-        description: "aroflie game rooms.",
+        description: I18n.t("dom.wings.games.description"),
         rooms: [
           Aro::Dom::D::WINGS[:GAMES][:ABPPS],
           Aro::Dom::D::WINGS[:GAMES][:HBPPS],
@@ -87,7 +92,7 @@ module Aro
       },
       KNOW: {
         name: Aro::Dom::KNOW,
-        description: "information space.",
+        description: I18n.t("dom.wings.know.description"),
         rooms: [
           Aro::Dom::D::WINGS[:KNOW][:LIBRARY],
           Aro::Dom::D::WINGS[:KNOW][:TEMPLE]
@@ -95,7 +100,7 @@ module Aro
       },
       SETUP: {
         name: Aro::Dom::SETUP,
-        description: "user configuration space.",
+        description: I18n.t("dom.wings.setup.description"),
         rooms: [
           Aro::Dom::D::WINGS[:SETUP][:SETTINGS]
         ],

data/sys/dom/dom.rb

@@ -8,9 +8,11 @@
 
 =end
 
+require_relative :"../aos/s".to_s
+
 module Aro
   class Dom
-    PS1 = Aro::Dom.name
+    PS1 = :">[#{Aro::Dom.name}]>: "
     DOT = :"."
     DOTT = :"#{DOT}#{DOT}"
     ETHERGEIST = :ethergeist
@@ -46,12 +48,11 @@ module Aro
 
     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.")
+        Aro::Dom::P.say(I18n.t("dom.errors.failed_directory_exists", name: name))
+        return
       end
 
-      # todo: i18n
-      Aro::Dom::P.say("creating arodome named #{name}")
+      Aro::Dom::P.say(I18n.t("dom.messages.creating_arodome", name: name))
       FileUtils.mkdir(name)
       ether_file_path = "#{name}/#{Aro::Dom::ETHER_FILE}"
       FileUtils.mkdir(ether_file_path)
@@ -59,51 +60,87 @@ module Aro
         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")
+      Aro::Dom::P.say(I18n.t("dom.messages.arodome_created", name: name))
     end
 
     def self.in_arodom?
-      pwd_path = Dir.pwd.split("/").reject{|p| p.empty?}
-      pwd = "/"
+      !Aro::Dom.ethergeist_path.nil?
+    end
+
+    def self.is_initialized?
+      File.exist?(File.join(Aro::Dom::ethergeist_path, Aos::Db::SQL_FILE.to_s))
+    end
+
+    def self.domain
+      "#{Aro::Dom}#{Aos::Os::A}#{Aro::Dom.ethergeist_name}"
+    end
 
-      pwd_path.any?{|step|
-        pwd = File.join(pwd, step)
-        ls = Dir.glob("#{pwd}/#{ETHER_FILE}", File::FNM_DOTMATCH)
-        ls.any?
+    def self.dom_root
+      Aro::Dom.in_arodom? ? File.dirname(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
-      # todo: traverse up pwd and locate etherfile/.name
-      # pwd_path = Dir.pwd.split("/").reject{|p| p.empty?}
-      # pwd = "/"
+      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?
+      }
 
-      # for now assume in arodome root
-      File.join(Aro::Dom::ETHER_FILE.to_s, Aro::Mancy::NAME_FILE.to_s)
+      return path
     end
 
-    def dom_root
-      # todo:
+    def self.ethergeist_name
+      return nil unless Aro::Dom.in_arodom?
+
+      File.read(
+        File.join(
+          Aro::Dom.ethergeist_path, Aro::Mancy::NAME_FILE.to_s
+        )
+      )
     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::P.say(I18n.t("dom.messages.generating_wings"))
       Aro::Dom::D::LAYOUT.values.each{|w| generate_wing w}
-      
-      Aro::Dom::P.say("#{Aro::Dom.name} initialization complete!")
+      Aos::Db::new
+      Aro::Dom::P.say(I18n.t("dom.messages.initialization_complete", name: Aro::Dom.name))
     end
 
     def generate_wing(wing)
       return unless Aro::Dom::D::LAYOUT.values.include?(wing)
-
-      Aro::Dom::P.say("generating the #{wing[:name]} wing...")
+      Aro::Dom::P.say(I18n.t("dom.messages.generating_wing", wing: wing[:name].to_s))
       FileUtils.mkdir(wing[:name].to_s)
 
       wing[:rooms].each{|r| generate_room(wing, r)}
@@ -112,7 +149,8 @@ module Aro
     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.")
+      Aro::Dom::P.say(I18n.t("dom.messages.generating_room", room: room[:name].to_s))
+
       room_path = File.join(wing[:name].to_s, room[:name].to_s)
       FileUtils.mkdir(room_path)
 
@@ -123,72 +161,12 @@ module Aro
       end
     end
 
-    def self.map
-      return unless Aro::Dom.in_arodom?
-
-      dc = CLI::Config.display_config
-      width = dc[:WIDTH]
-      divider = dc[:DIVIDER] * width + "\n"
-
-      map_str = "\n"
-      map_str += divider
-
-      # todo: ethergeist_path
-      map_name = File.read(Aro::Dom.ethergeist_path).upcase
-      Aro::V.say("map_name: #{map_name}")
-      title_divider = dc[:DIVIDER] * ((width - map_name.length) / Aro::Mancy::OS)
-      map_str += (title_divider + map_name).ljust(width, dc[:DIVIDER]) + "\n"
-      map_str += divider
-
-
-
-      Aro::P.say(map_str)
+    def self.ethergeist_name
+      File.read(
+        File.join(
+          Aro::Dom.ethergeist_path, Aro::Mancy::NAME_FILE.to_s
+        )
+      )
     end
-  end 
+  end
 end # aroadhome
-
-=begin
------------------------------------------------------------------------------
------------------------------------------------------------------------------
--------------------------------ARODOME MAP-----------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                 GAMES                                     |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|    WELCOME                                                   KNOW         |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                   .                                       |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|      ..                                                      SETUP        |
-|                                                                           |
-|                                                                           |
-|                                                                           |
-|                                                                           |
------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-
-
-=end

data/sys/dom/p.rb

@@ -11,7 +11,7 @@
 module Aro
   class Dom::P < Aro::Prompt
     def self.say(message)
-      Aro::Dom::P.p.say(">[#{Aro::Dom::PS1}]>: #{message}")
+      Aro::Dom::P.p.say("#{Aro::Dom::PS1}#{message}")
     end
   end
 end

data/sys/models/deck.rb

@@ -1,3 +1,13 @@
+=begin
+
+  deck.rb
+
+  deck object.
+
+  by i2097i
+
+=end
+
 require :base64.to_s
 require_relative :"../shr/t".to_s
 
@@ -11,6 +21,7 @@ class Aro::Deck < ActiveRecord::Base
   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?
@@ -31,9 +42,9 @@ class Aro::Deck < ActiveRecord::Base
 
   def generate_log
     prev_cards = Base64::decode64(logs.last.card_data) if logs.any?
-    if prev_cards.present? && prev_cards != cards || prev_cards.nil?
+    if (prev_cards.present? && prev_cards != cards) || (prev_cards.nil? || prev_cards.empty?)
       logs.create(
-        card_data: Base64::encode64(cards),
+        card_data: Base64::encode64(cards || ""),
         drawn_data: Base64::encode64(drawn || "")
       )
     end
@@ -80,6 +91,7 @@ class Aro::Deck < ActiveRecord::Base
     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]
@@ -94,20 +106,14 @@ class Aro::Deck < ActiveRecord::Base
     # 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))
+    Aro::D.say(I18n.t("cli.messages.showing", name: name, count: count_n, order: order_o))
 
-    h_text = Aro::Vi::Deck.generate({
+    Aos::Vi::Game.show_game({
       deck: self,
       h_logs: h_logs,
       count_n: count_n,
       order_o: order_o
     })
-
-    if count_n == Aro::Mancy::S
-      Aro::Vi::Deck.draw(h_text)
-    else
-      Aro::P.less(h_text)
-    end
   end
 
   def explore
@@ -140,7 +146,7 @@ class Aro::Deck < ActiveRecord::Base
     # 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 }
 
@@ -148,7 +154,7 @@ class Aro::Deck < ActiveRecord::Base
     update(drawn: "", cards: cards_arr.join(Aro::Deck::CARD_DELIM.to_s))
   end
 
-  def draw(is_dt_dimension: true, z_max: 7, z: 1)    
+  def draw(is_dt_dimension: true, z_max: 7, z: 1)
     # the true card
     abs_dev_tarot = nil
 
@@ -162,6 +168,10 @@ class Aro::Deck < ActiveRecord::Base
     # get drawn
     drawn_arr = drawn&.split(Aro::Deck::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
 
@@ -169,7 +179,7 @@ class Aro::Deck < ActiveRecord::Base
     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("")
+        dev_tarot = Aro::T.summon_ruby_facot.split("")
       else
         # preferred randomness
         read_value = Aro::T.read_dev_tarot&.strip&.split("")

data/sys/models/log.rb

@@ -1,10 +1,20 @@
+=begin
+
+  log.rb
+
+  log object.
+
+  by i2097i
+
+=end
+
 require_relative :"./deck".to_s
 
 class Aro::Log < ActiveRecord::Base
+  belongs_to :deck, :class_name => :"#{Aro::Deck.name}".to_s
+
   ORDERING = {
     ASC: :asc,
     DESC: :desc
   }
-
-  belongs_to :deck, :class_name => :"#{Aro::Deck.name}".to_s
 end

data/sys/reiquire.rb

@@ -14,6 +14,7 @@ require :"active_record/schema_dumper".to_s
 require :base64.to_s
 require :fileutils.to_s
 require :i18n.to_s
+require :readline.to_s
 require :"tty-prompt".to_s
 require :yaml.to_s
 
@@ -29,7 +30,7 @@ module Reiquire
     I18n.default_locale = :en    
 
     # require all aro folders
-    Reiquire::requires [:aro, :cli, :dom, :models, :shr, :views]
+    Reiquire::requires [:aro, :cli, :dom, :models, :shr, :views, :aos]
 
     # require cli module
     require_relative :"./cli".to_s
@@ -38,7 +39,7 @@ module Reiquire
   def self.requires(dirs)
     dirs.each{|d|
       Dir[
-        File.join(__dir__, d.to_s, :"**/*.rb".to_s)
+        File.join(__dir__, d.to_s, :"**/**/*.rb".to_s)
       ].each { |f| require f}
     }
   end

data/sys/shr/prompt.rb

@@ -1,5 +1,5 @@
 =begin
-  
+
   prompt.rb
 
   base logger for aro.
@@ -19,15 +19,23 @@ module Aro
     end
 
     def self.p
-      P.instance.prompt
+      Aro::Prompt.instance.prompt
+    end
+
+    def self.should_print?
+      CLI::Config::BOOLS[:TRUE]
+    end
+
+    def self.should_print?
+      CLI::Config::BOOLS[:TRUE]
     end
 
     def self.say(message)
       raise :override_me.to_s
     end
 
-    def self.less(display_text = "")
-      IO.popen("less -X", "w") { |f| f.puts display_text }
+    def self.less(message)
+      IO.popen("less -X", "w") { |f| f.puts(message) }
     end
   end
 end

data/sys/shr/t.rb

@@ -11,7 +11,7 @@
 module Aro
   module T
     DEV_TAROT_FILE = :"/dev/tarot"
-
+    DEV_TAROT = :"Dev::Tarot".to_s
     RUBY_FACOT = :"Ruby::Facot".to_s
 
     def self.is_dev_tarot?
@@ -21,19 +21,21 @@ module Aro
     # read dev_tarot
     def self.read_dev_tarot
       dt = nil
-      return dt unless File.exist?(Aro::T::DEV_TAROT_FILE.to_s)
-
-      File.open(Aro::T::DEV_TAROT_FILE.to_s, "r"){|dtf| dt = dtf.read(Aro::Mancy::N)}
-      
-      # VERY IMPORTANT!
-      Aro::P.say(I18n.t("cli.very_important", dev_tarot: dt))
+      if Aro::T.is_dev_tarot? && File.exist?(Aro::T::DEV_TAROT_FILE.to_s)
+        File.open(Aro::T::DEV_TAROT_FILE.to_s, "r"){|dtf| dt = dtf.read(Aro::Mancy::N)}
+        # VERY IMPORTANT!
+        Aro::V.say(I18n.t("cli.very_important", dev_tarot: dt))
+      else
+        Aro::V.say("warning: summoning ruby_facot in #{__method__}")
+        dt = Aro::T.summon_ruby_facot unless Aro::T.is_dev_tarot?
+      end
       return dt
     end
 
     # summon ruby_facot
-    def self.summon_ruby_facot(cards_arr)
-      Aro::P.say(I18n.t("cli.messages.ruby_facot_random"))
-      ruby_facot = cards_arr.sample.split("")
+    def self.summon_ruby_facot
+      Aro::D.say(I18n.t("cli.messages.ruby_facot_random"))
+      ruby_facot = I18n.t("cards.index").map{|c| "+#{c}"}.sample.split("")
 
       # get orientation
       ruby_facot_str = ["+","-"].sample

data/sys/shr/version.rb

@@ -9,10 +9,10 @@
 =end
 
 module Aro
-  VERSION = :"0.1.7"
+  VERSION = :"0.1.9"
   RELEASE_NOTES = :"this version".to_s + [
-    "adds views",
-    "adds ivars and ovars",
-    "adds verbose logging",
+    "adds improved views.",
+    "adds aro gameplay within an arodome game room.",
+    "adds ability to set config ivars from aos."
   ].join(",")
 end