aro 0.2.2 → 0.2.4

data/sys/aos/vws/dom.rb

@@ -23,7 +23,7 @@ module Aos
         lines << ""
         lines << I18n.t("aos.views.dom.quick_navigation")
         lines << ""
-        lines << "  =>  #{Aro::Dom::D.reserved_words.join("  ")}"
+        lines << "  =>  #{Aro::Dom::D.reserved_words(Aos::Os.instance.you.root?).join("  ")}"
         lines << ""
         draw(lines)
       end

data/sys/aos/vws/games/abot.rb

@@ -0,0 +1,21 @@
+=begin
+
+  vws/games/abot.rb
+
+  the abot view.
+
+  by i2097i
+
+=end
+
+require_relative :"../base".to_s
+
+module Aos
+  module Vw
+    class Abot < Aos::Vw::Base
+      def self.show
+        draw(Aos::Abot.instance.display_lines)
+      end
+    end
+  end
+end

data/sys/aos/vws/games/{game.rb → teck.rb}

@@ -13,24 +13,26 @@ require_relative :"../base".to_s
 
 module Aos
   module Vw
-    class Game < Aos::Vw::Base
+    class Teck < Aos::Vw::Base
 
-      DECK_PARAMS = [
+      TECK_PARAMS = [
         :teck,
         :tlog_records,
         :count_n,
         :order_o,
       ]
 
+      DIV_CHAR = :"."
+
       def self.show
-        unless Aro::Mancy.game.nil?
-          Aro::Mancy.game.show
+        unless Aro::Mancy.teck.nil?
+          Aro::Mancy.teck.show
           return
         end
 
         lines = []
-        lines << I18n.t("aos.views.game.title").center(viewport_width)
-        lines << I18n.t("aos.views.game.description").center(viewport_width)
+        lines << I18n.t("aos.views.game.title").center(Aos::Vw::Base.viewport_width)
+        lines << I18n.t("aos.views.game.description").center(Aos::Vw::Base.viewport_width)
 
         room_def = Aro::Dom::D::WINGS[:GAMES].values.filter{|gr|
           "#{Aos::Vw.name}::#{gr[:name].to_s.downcase.capitalize}" == self.name
@@ -44,32 +46,38 @@ module Aos
       end
 
       def self.show_game(model)
+        Aro::Db.load
         mk = model.keys
-        dp = Aos::Vw::Game::DECK_PARAMS
+        dp = Aos::Vw::Teck::TECK_PARAMS
         return nil unless (mk & dp).count == dp.count
         return nil unless model.values.all?{|v| v != nil}
 
         teck = model[:teck]
         tlog_records = model[:tlog_records]
+        teck_tlog_count = teck.tlogs.count
         count_n = model[:count_n]
         order_o = model[:order_o]
 
-        dc = Aro::Config.display_configuration
-        width = count_n == Aro::Mancy::S ? viewport_width : dc[:WIDTH]
-        divider = dc[:DIVIDER] * width
+        divider = "".ljust(
+          Aos::Vw::Base.viewport_width,
+          Aos::Vw::Teck::DIV_CHAR.to_s
+        )
         lines = []
         lines << divider
-        lines << "#{teck.name.upcase.center(width)}"
+        lines << ""
+        lines << "#{teck.name.upcase.center(Aos::Vw::Base.viewport_width)}"
         tlog_records.each_with_index{|l, i|
           lines << divider
           lines << ""
-          timestamp = l.created_at.strftime(Aro::Config::DATE_FORMAT)
-          of_text = "#{order_o.to_sym == Aro::Tlog::ORDERING[:DESC] ? teck.tlogs.count - i : 1 + i} of #{teck.tlogs.count}"
-          lines << of_text.ljust(width - timestamp.length) + timestamp
+          timestamp = l.created_at.strftime(Aos::Cor::DATE_FORMAT)
+          of_text = "#{order_o.to_sym == Aro::Tlog::ORDERING[:DESC] ? teck_tlog_count - i : 1 + i} of #{teck_tlog_count}"
+          lines << Aos::Vw::Base.get_body_line(
+            of_text.ljust(Aos::Vw::Base.viewport_width - timestamp.length - Aro::Mancy::OS) + timestamp
+          )
           lines << divider
           cards = Base64::decode64(l.card_data).split(Aro::Teck::CARD_DELIM.to_s)
           if !cards.nil? && cards.any?
-            # lines << ""
+            lines << ""
             lines += self.get_display_for_cards(cards)
             # lines << divider
           end
@@ -77,7 +85,7 @@ module Aos
           drawn_cards = Base64::decode64(l.drawn_data).split(Aro::Teck::CARD_DELIM.to_s)
           if !drawn_cards.nil? && drawn_cards.any?
             lines << ""
-            lines << I18n.t("cli.messages.history_drawn").center(width)
+            lines << I18n.t("cli.messages.history_drawn").center(Aos::Vw::Base.viewport_width)
             lines << divider
             lines << ""
             lines += self.get_display_for_cards(
@@ -95,20 +103,19 @@ module Aos
       end
 
       def self.get_display_for_cards(input = [])
-        columns = Aos::Vw::Base::COL_POW.call(
-          Aro::Config.display_configuration[:WIDTH].to_i
-        )
+        return input unless input.any?
+        width = Aos::Cor.discon[:WIDTH]
+        c_width = Aro::Mancy::NUMERALS[:XI]
+        columns = (width / c_width).to_i
         lines = []
-        return lines unless input.any?
-        card_line = ""
-        input.each_with_index{|c, i|
-          s = (i + Aro::Mancy::S) % [Aro::Mancy::S, columns].max
-          card_line += c.ljust(columns)
-          if Aro::Mancy::O == s || i == input.count - Aro::Mancy::S
-            lines << card_line
-            card_line = ""
+        while input.any?
+          line = []
+          columns.times do
+            next if input[Aro::Mancy::O].nil?
+            line << input.delete_at(Aro::Mancy::O).center(c_width)
           end
-        }
+          lines << line.join("")
+        end
         lines << ""
         lines
       end

data/sys/aos/vws/home.rb

@@ -0,0 +1,23 @@
+=begin
+
+  vws/root/home.rb
+
+  the home view.
+
+  by i2097i
+
+=end
+
+require_relative :"./base".to_s
+
+module Aos
+  module Vw
+    class Home < Aos::Vw::Base
+      def self.show
+        if Aos::Os.instance.you.home?
+          draw(Aos::Cor.instance.display_lines)
+        end
+      end
+    end
+  end
+end

data/sys/aos/vws/root/config.rb

@@ -1,8 +1,8 @@
 =begin
   
-  vws/root/config.rb
+  vws/root/cor.rb
 
-  the config view.
+  the cor view.
 
   by i2097i
 
@@ -12,9 +12,9 @@ require_relative :"../base".to_s
 
 module Aos
   module Vw
-    class Config < Aos::Vw::Base
+    class Cor < Aos::Vw::Base
       def self.show
-        draw(Aro::Config.instance.display_lines)
+        draw(Aos::Cor.instance.display_lines)
       end
     end
   end

data/sys/aos/vws/root/flie.rb

@@ -0,0 +1,21 @@
+=begin
+
+  vws/root/flie.rb
+
+  the flie view.
+
+  by i2097i
+
+=end
+
+require_relative :"../base".to_s
+
+module Aos
+  module Vw
+    class Flie < Aos::Vw::Base
+      def self.show
+        draw(Aos::Flie.instance.display_lines)
+      end
+    end
+  end
+end

data/sys/aos/vws/welcome.rb

@@ -16,13 +16,49 @@ module Aos
       def self.show
         lines = []
 
-        dc = Aro::Config.display_configuration
-        height = dc[:HEIGHT]
+        dc = Aos::Cor.discon
         width = dc[:WIDTH]
 
-
         lines << "welcome to #{Aro::Dom.ethergeist_name}".center(width)
-        lines <<
+        lines << ""
+        hwidth = width - (Aos::Vw::Base::MARGIN_H * Aro::Mancy::OS)
+        lines << "".ljust(hwidth, dc[:DIVIDER])
+        lines << "map".center(hwidth)
+        lines << "".ljust(hwidth, dc[:DIVIDER])
+        lines << ""
+        yous = Aos::You.where(pwd: Aro::Dom.dom_root)
+        dom_line = "#{Aro::Dom.ethergeist_name}"
+        dom_line += (yous.any? ? " [#{yous.map{|y| y.name}.join(" ")}]" : "")
+        lines << dom_line
+        Aro::Dom::D::LAYOUT.values.each{|wing|
+          yous = Aos::You.where(pwd: File.join(Aro::Dom.dom_root, wing[:name].to_s))
+          wing_line = "".ljust(Aro::Mancy::NUMERALS[:IV])
+          wing_line += wing[:name].to_s
+          wing_line += (yous.any? ? " [#{yous.map{|y| y.name}.join(" ")}]" : "")
+          lines << wing_line
+          wing[:rooms].each{|room|
+            yous = Aos::You.where(pwd: File.join(Aro::Dom.dom_root, Aro::Dom.room_path(room[:name])))
+            room_line = "".ljust(Aro::Mancy::NUMERALS[:VIII])
+            room_line += room[:name].to_s
+            room_line += (yous.any? ? " [#{yous.map{|y| y.name}.join(" ")}]" : "")
+            lines << room_line
+          }
+        }
+        lines << ""
+
+        yous = Aos::You.order(access: :desc).all
+        if yous.empty?
+          lines << "no yous."
+        else
+          lines << "".ljust(hwidth, dc[:DIVIDER])
+          lines << "roster".center(hwidth)
+          lines << "".ljust(hwidth, dc[:DIVIDER])
+          lines << ""
+          yous.each{|y|
+            next if y.root? && !Aos::Os.instance.you.root?
+            lines += y.get_lines.map{|l| l.center(hwidth)}
+          }
+        end
         draw(lines)
       end
     end

data/sys/aro/d.rb

@@ -9,16 +9,18 @@
 =end
 
 require_relative :"../shr/prompt".to_s
+require :aro.to_s
 
 module Aro
   class D < Aro::Prompt
     def self.say(message)
       return unless Aro::D.should_print?
-      Aro::P::p.say(">[#{Aro::Mancy::I2097I}]>: #{message}\n")
+      super([">[#{Aro::Mancy::I2097I}]>: #{message}"])
     end
 
     def self.should_print?
-      Aro::Mancy::ARO_ENV_DEBUG_MODES[Aro::Mancy::O].to_s == ENV[:ARO_ENV.to_s]
+      return false unless Aos::Cor.ivar(:ENV).present?
+      Aos::Cor::DBG_MODES.include?(Aos::Cor.ivar(:ENV)&.to_sym)
     end
   end
 end

data/sys/aro/db.rb

@@ -8,6 +8,9 @@
 
 =end
 
+require_relative :"./mancy".to_s
+require_relative :"../aos/cor".to_s
+
 module Aro
   class Db
     include Singleton
@@ -26,7 +29,7 @@ module Aro
     end
 
     def self.configure_logger
-      if Aro::Config.ivar(:LOG_ARO_DB).to_s == Aro::Config::BOOLS[:TRUE].to_s
+      if Aos::Cor.ivar(:LOG_ARO_DB).to_s == Aos::Cor::BOOLS[:TRUE].to_s
         ActiveRecord::Base.logger = Logger.new(STDOUT)
       else
         ActiveRecord::Base.logger = nil
@@ -35,19 +38,22 @@ module Aro
 
     def self.base_aro_dir
       base_aro_file = Aro::Mancy::ARO_FILE.to_s
-      Aro::Config.is_test? ? "#{base_aro_file}_test" : base_aro_file
+      return "#{base_aro_file}_#{Aos::Cor::ENVS[:TEST]}" if Aos::Cor.is_test?
+
+      base_aro_file
     end
 
     def db_config_filepath
-      File.join(Aro::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
+      @db_config_filepath ||= File.join(Aro::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
     end
 
     def setup_local_aro
       name = Aro::Mancy.in_aro? ? Aro::Mancy.aro_mancy_name : nil
-      return if name.nil?
+      return if name.nil? || name.to_sym == Aos::Os::CMDS[:ABOT][:key]
 
       # create local .aro/ directory
       unless File.exist?(Aro::Db.base_aro_dir)
+        Aro::P.say("creating #{Aro::Mancy::ARO_FILE.to_s} directory...")
         FileUtils.mkdir(Aro::Db.base_aro_dir)
       end
 
@@ -57,18 +63,19 @@ module Aro
           adapter: :sqlite3.to_s,
           database: File.join(Aro::Db.base_aro_dir, Aro::Db::SQL_FILE.to_s),
           username: name,
-          password: name
+          password: name,
+          pool: Aos::Os::DB_POOL
         }.to_yaml
         File.open(db_config_filepath, "w") do |file|
           file.write(c)
         end
       end
 
-      connect(name)
+      connect
       migrate(name)
     end
 
-    def connect(name)
+    def connect
       ActiveRecord::Base.establish_connection(
         YAML.load_file(db_config_filepath)
       )
@@ -77,8 +84,8 @@ module Aro
     def migrate(name)
       local_migrate_dir = File.join(Aro::Db.base_aro_dir, Aro::Db::MIGRATIONS_DIR.to_s)
       unless Dir.exist?(local_migrate_dir)
-        gem_dir = Dir[Gem.loaded_specs[:aro.to_s]&.full_gem_path || '.'].first
-        FileUtils.cp_r(File.join(gem_dir, Aro::Db::GEM_DB_PATH.to_s), Aro::Db::base_aro_dir)
+        gem_dir = Dir[Reiquire::GEM_PATH || '.'].first
+        FileUtils.cp_r(File.join(gem_dir, Aro::Db::GEM_DB_PATH.to_s), Aro::Db.base_aro_dir)
       end
 
       migration_version = Dir["#{local_migrate_dir}/*.rb"].map{|n|

data/sys/aro/mancy.rb

@@ -12,7 +12,7 @@ module Aro
   class Mancy
     include Singleton
 
-    attr_accessor :game
+    attr_accessor :current
 
     O  = 0
     S  = 1
@@ -21,14 +21,12 @@ module Aro
     N  = 4
     V  = 5
     PS1 = :">[#{Aro::Mancy.name}]>: "
-    NAME_FILE = :".name"
+    NAME_FILE = :".aro_space"
     ARO_FILE = :".aro"
     I2097I = :i2097i
     YES = :aroyes
     ALL = :all
 
-    ARO_ENV_DEBUG_MODES = [:development, :test]
-
     NUMERALS = {
       O:       0,
       I:       1,
@@ -55,20 +53,16 @@ module Aro
       XXII:    22,
       XXXVII:  37,
       XLII:    42,
+      LX:      60,
       C:       100,
       MMXCVII: Aro::Mancy::I2097I[Aro::Mancy::S..Aro::Mancy::N].to_i,
     }
 
-    def initialize
+    def self.teck
       if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
-        Aro::Config.instance.load
-        Aro::Mancy.init
-        self.game = Aro::Teck.current_teck
+        self.instance.current = Aro::Teck.current_teck
       end
-    end
-
-    def self.game
-      Aro::Mancy.instance.game
+      self.instance.current
     end
 
     def self.create(name)
@@ -77,7 +71,6 @@ module Aro
       # 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"))
@@ -86,18 +79,23 @@ module Aro
         return false
       end
 
-      # create name file
-      File.open(File.join(name, Aro::Mancy::NAME_FILE.to_s), "w+") do |file|
-        file.write(name)
-      end
-
       Dir.chdir(name) do
+        Aos::Cor.instance.load
         Aro::Mancy.init
       end
       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)
+        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)
+        end
+      end
+
       Aro::Db.load
     end
 
@@ -114,8 +112,6 @@ module Aro
     end
 
     def self.aro_mancy_name
-      return nil unless Aro::Mancy.in_aro?
-
       File.read(Aro::Mancy::NAME_FILE.to_s).strip
     end
   end

data/sys/aro/models/base_model.rb

@@ -0,0 +1,13 @@
+=begin
+
+  aro/base_model.rb
+
+  aro base_model object.
+
+  by i2097i
+
+=end
+
+class Aro::BaseModel < ActiveRecord::Base
+
+end

data/sys/aro/models/teck.rb

@@ -9,19 +9,20 @@
 =end
 
 require :base64.to_s
+require_relative :"./base_model".to_s
 
 class Aro::Teck < ActiveRecord::Base
   has_many :tlogs
 
-  DECK_FILE = :".teck"
+  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?
     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?
     new_teck
@@ -32,6 +33,7 @@ class Aro::Teck < ActiveRecord::Base
   end
 
   def populate_cards
+    Aro::Db.load
     self.cards = Aro::Teck.fresh_cards
   end
 
@@ -46,6 +48,7 @@ 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"))
       exit(CLI::EXIT_CODES[:SUCCESS])
@@ -59,14 +62,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(Aro::Teck::DECK_FILE.to_s, "w") do |file|
+    File.open(File.join(Aro::Db.base_aro_dir, Aro::Teck::TECK_FILE.to_s), "w") do |file|
       file.write(teck.id)
     end
   end
 
   def self.current_teck
-    if File.exist?(DECK_FILE.to_s)
-      current_teck_id = File.read(DECK_FILE.to_s)
+    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))
       return Aro::Teck.find_by(id: current_teck_id)
     end
   end
@@ -76,14 +80,15 @@ class Aro::Teck < ActiveRecord::Base
   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
+        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
+    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}")
 
@@ -93,17 +98,18 @@ class Aro::Teck < ActiveRecord::Base
     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 text output
-    return tlog_records if Aro::Config.is_test?
+    # for now tests just expect count
+    return tlog_records if Aos::Cor.is_test?
 
     Aro::D.say(I18n.t("cli.messages.showing", name: name, count: count_n, order: order_o))
 
-    Aos::Vw::Game.show_game({
+    Aos::Vw::Teck.show_game({
       teck: self,
       tlog_records: tlog_records,
       count_n: count_n,
@@ -113,24 +119,33 @@ class Aro::Teck < ActiveRecord::Base
 
   def explore
     # allows user to browse each card in the current teck.
-    answer = Aro::P.p.select(
+    answer = Aos::S.p.select(
       Aro::Mancy::PS1.to_s + I18n.t("cli.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: Aro::Config.display_configuration[:HEIGHT] - Aro::Mancy::S,
+      per_page: Aos::Cor.discon[:HEIGHT] - Aro::Mancy::S,
       cycle: true,
       default: Aro::Mancy::S
     )
-    # {name: "four of swords", tag_list: ["lord of rest from strife", "libra", "jupiter", "introspection", "recuperation", "regain strength", "rest", "solitude", "stability"], reversed_tag_list: ["lord of rest from strife", "libra", "jupiter", "burnt out", "inundated", "need a break", "overwhelmed"], summary: "", reversed_summary: ""}
-    definition = I18n.t("cards.#{Aro::Teck.card_strip(answer)}")
-    indent = Aro::Mancy::N
-    Aro::P.say(definition[:name])
-    Aro::P.say(definition[:summary])
-    Aro::P.say("tags:")
-    definition[:tag_list].sort.each{|tl| Aro::P.say("".rjust(indent) + tl)}
-    Aro::P.say(definition[:reversed_summary])
-    Aro::P.say("reverse tags:")
-    definition[:reversed_tag_list].sort.each{|tl| Aro::P.say("".rjust(indent) + tl)}
+
+    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
+
+    definition = I18n.t("cards.#{Aro::Teck.card_strip(card_code)}")
+    output = []
+    output << orientation + definition[:name]
+    output += definition["#{orientation}tags".to_sym].sort
+    # 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")}")
   end
 
   def shuffle
@@ -181,7 +196,7 @@ class Aro::Teck < ActiveRecord::Base
     # 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)
+      unless Aro::T.is_dev_tarot? && Aro::T.is_dev_tarot_avail?
         dev_tarot = Aro::T.summon_ruby_facot.split("")
       else
         # preferred randomness
@@ -215,6 +230,8 @@ 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/models/tlog.rb

@@ -11,10 +11,11 @@
 require_relative :"./teck".to_s
 
 class Aro::Tlog < ActiveRecord::Base
-  belongs_to :teck, :class_name => :"#{Aro::Teck.name}".to_s
+  belongs_to :teck
 
   ORDERING = {
     ASC: :asc,
     DESC: :desc
   }
+
 end

data/sys/aro/p.rb

@@ -17,7 +17,7 @@ module Aro
       if Aro::Mancy.in_aro? && !Aro::T.is_dev_tarot?
         Aro::R.say(message)
       else
-        Aro::P::p.say("#{Aro::Mancy::PS1}#{message}")
+        super(["#{Aro::Mancy::PS1}#{message}"])
       end
     end
   end

data/sys/aro/r.rb

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