aro 0.2.1 → 0.2.3

data/sys/aos/vws/welcome.rb

@@ -13,7 +13,54 @@ require_relative :"./base".to_s
 module Aos
   module Vw
     class Welcome < Aos::Vw::Base
+      def self.show
+        lines = []
 
+        dc = Aos::Cor.display_configuration
+        width = dc[:WIDTH]
+
+        lines << "welcome to #{Aro::Dom.ethergeist_name}".center(width)
+        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
   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/migrate/{1763374647_create_decks.rb → 1763374647_create_tecks.rb}

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

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

@@ -0,0 +1,20 @@
+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/db.rb

@@ -8,44 +8,45 @@
 
 =end
 
+require_relative :"./mancy".to_s
+require_relative :"../aos/cor".to_s
+
 module Aro
   class Db
+    include Singleton
+
     DATABASE_YML = :"database.yml"
     GEM_DB_PATH = :"sys/aro/db"
     MIGRATIONS_DIR = :"db/migrate"
     SCHEMA_FILE = :"schema.rb"
-    SQL_FILE = :"database.sql"
+    SQL_FILE = :"aro.sql"
 
-    def initialize
+    def self.load
       Aro::Db.configure_logger
-      if Aro::Mancy.in_aro?
-        setup_local_aro
+      Mutex.new.synchronize do
+        if Aro::Mancy.in_aro?
+          self.instance.setup_local_aro
+        end
       end
     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
       end
     end
 
-    def connect(name)
-      ActiveRecord::Base.establish_connection(config)
-    end
-
-    def config
-      @config ||= YAML.load_file(db_config_filepath)
-    end
-
     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
@@ -54,6 +55,7 @@ module Aro
 
       # 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
 
@@ -63,22 +65,29 @@ 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
+      ActiveRecord::Base.establish_connection(
+        YAML.load_file(db_config_filepath)
+      )
+    end
+
     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
-      Aro::Config.instance.load
+    def self.teck
       if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
-        Aro::Mancy.init
-        self.game = Aro::Deck.current_deck
+        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,28 +71,32 @@ 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_decks"))
+        Aro::P.say(I18n.t("cli.messages.no_tecks"))
         FileUtils.mkdir(name)
       else
         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
-      Aro::Db.new
+      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
 
     def self.is_initialized?
@@ -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/{models/deck.rb → aro/models/teck.rb}

@@ -1,45 +1,46 @@
 =begin
 
-  deck.rb
+  teck.rb
 
-  deck object.
+  teck object.
 
   by i2097i
 
 =end
 
 require :base64.to_s
-require_relative :"../shr/t".to_s
+require_relative :"./base_model".to_s
 
-class Aro::Deck < ActiveRecord::Base
-  has_many :logs
+class Aro::Teck < ActiveRecord::Base
+  has_many :tlogs
 
-  DECK_FILE = :".deck"
+  TECK_FILE = :".aro_teck"
   CARD_DELIM = :","
 
   before_create :populate_cards
   after_commit :generate_log
 
   def self.make(new_name)
+    Aro::Db.load
     return nil unless Aro::Mancy.is_initialized?
-    Aro::Db.new
-    new_deck = Aro::Deck.create(name: new_name)
-    Aro::Deck.select_deck(new_deck) if Aro::Deck.current_deck.nil?
-    new_deck
+    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::Deck::CARD_DELIM.to_s)
+    I18n.t("cards.index").map{|c| "+#{c}"}.join(Aro::Teck::CARD_DELIM.to_s)
   end
 
   def populate_cards
-    self.cards = Aro::Deck.fresh_cards
+    Aro::Db.load
+    self.cards = Aro::Teck.fresh_cards
   end
 
   def generate_log
-    prev_cards = Base64::decode64(logs.last.card_data) if logs.any?
+    prev_cards = Base64::decode64(tlogs.last.card_data) if tlogs.any?
     if (prev_cards.present? && prev_cards != cards) || (prev_cards.nil? || prev_cards.empty?)
-      logs.create(
+      tlogs.create(
         card_data: Base64::encode64(cards || ""),
         drawn_data: Base64::encode64(drawn || "")
       )
@@ -47,28 +48,29 @@ class Aro::Deck < ActiveRecord::Base
   end
 
   def self.display_selection_menu
-    unless Aro::Deck.any?
-      Aro::P.say(I18n.t("cli.messages.no_decks"))
+    unless Aro::Teck.any?
+      Aro::P.say(I18n.t("cli.messages.no_tecks"))
       exit(CLI::EXIT_CODES[:SUCCESS])
     end
-    c_d = Aro::Deck.current_deck
-    Aro::Deck.all.each do |d|
+    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_deck(deck)
-    return unless deck.present?
-    Aro::P.say(I18n.t("cli.messages.deck_selected", name: deck.name, room: Aro::Mancy::aro_mancy_name))
-    File.open(Aro::Deck::DECK_FILE.to_s, "w") do |file|
-      file.write(deck.id)
+  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(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_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)
+  def self.current_teck
+    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,54 +78,55 @@ class Aro::Deck < ActiveRecord::Base
     card.gsub(/[+-]/, "").strip
   end
 
-  def show(count_n: Aro::Mancy::S, order_o: Aro::Log::ORDERING[:DESC])
+  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 = logs.count
+        count_n = tlogs_count
       else
         count_n = Aro::Mancy::S
       end
     end
-    count_n = [[Aro::Mancy::S, count_n.to_i].max, logs.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}")
 
-    unless Aro::Log::ORDERING.values.include?(order_o)
+    unless Aro::Tlog::ORDERING.values.include?(order_o)
       Aro::P.say(I18n.t("cli.warnings.invalid_order"))
-      order_o = Aro::Log::ORDERING[:DESC]
+      order_o = Aro::Tlog::ORDERING[:DESC]
     end
 
     # perform query
-    h_logs = logs.order(created_at: order_o).first(count_n)
+    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("h_logs.count: #{h_logs.count}")
+    # Aro::V.say("tlog_records.count: #{tlog_records.count}")
 
-    # for now tests just expect text output
-    return h_logs 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({
-      deck: self,
-      h_logs: h_logs,
+    Aos::Vw::Teck.show_game({
+      teck: self,
+      tlog_records: tlog_records,
       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(
+    # allows user to browse each card in the current teck.
+    answer = Aos::S.p.select(
       Aro::Mancy::PS1.to_s + 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::Config.display_configuration[:HEIGHT] - Aro::Mancy::S,
+      cards.split(Aro::Teck::CARD_DELIM.to_s).map{|c| [I18n.t("cards.#{Aro::Teck.card_strip(c)}.name"), c]}.to_h,
+      per_page: Aos::Cor.display_configuration[: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::Deck.card_strip(answer)}")
+    definition = I18n.t("cards.#{Aro::Teck.card_strip(answer)}")
     indent = Aro::Mancy::N
     Aro::P.say(definition[:name])
     Aro::P.say(definition[:summary])
@@ -135,27 +138,27 @@ class Aro::Deck < ActiveRecord::Base
   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))
+    # 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 deck. replace all drawn and reset order.
+    # completely reset the teck. replace all drawn and reset order.
     # all orientations will be set to upright.
-    update(cards: Aro::Deck.fresh_cards, drawn: "")
+    update(cards: Aro::Teck.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) || []
+    # 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::Deck::CARD_DELIM.to_s))
+    update(drawn: "", cards: cards_arr.join(Aro::Teck::CARD_DELIM.to_s))
   end
 
   def draw(is_dt_dimension: true, z_max: 7, z: 1)
@@ -166,11 +169,11 @@ class Aro::Deck < ActiveRecord::Base
     dev_tarot = nil
 
     # get cards
-    cards_arr = cards.split(Aro::Deck::CARD_DELIM.to_s) || []
+    cards_arr = cards.split(Aro::Teck::CARD_DELIM.to_s) || []
     # get abs_cards
-    abs_cards_arr = cards_arr.map{|c| Aro::Deck.card_strip(c)}
+    abs_cards_arr = cards_arr.map{|c| Aro::Teck.card_strip(c)}
     # get drawn
-    drawn_arr = drawn&.split(Aro::Deck::CARD_DELIM.to_s) || []
+    drawn_arr = drawn&.split(Aro::Teck::CARD_DELIM.to_s) || []
 
     if cards_arr.empty?
       Aro::P.say("there are no cards left to draw.")
@@ -219,8 +222,8 @@ class Aro::Deck < ActiveRecord::Base
 
     # update database 
     update(
-      cards: cards_arr.join(Aro::Deck::CARD_DELIM.to_s),
-      drawn: drawn_arr.join(Aro::Deck::CARD_DELIM.to_s)
+      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

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

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?
-      Aro::P::p.say(">[VERBOSE]>: #{message}\n")
+      super(message)
     end
 
     def self.should_print?
-      Aro::Config.ivar(:VERBOSE).to_s == Aro::Config::BOOLS[:TRUE].to_s && super
+      Aos::Cor.ivar(:VERBOSE).to_s == Aos::Cor::BOOLS[:TRUE].to_s && super
     end
   end
 end

data/sys/cli/constants.rb

@@ -24,21 +24,15 @@ module CLI
   }
 
   CMDS = {
-    AOS: {
-      RUN: :run,
-      WATCH: :watch,
-    },
     ARO: {
       CREATE: :create,
-      CONFIG: :config,
-      DECK: :deck,
+      COR: :cor,
+      TECK: :teck,
       DOM: :dom,
       INIT: :init,
     },
-    CONFIG: {
-      # ...
-    },
-    DECK: {
+    COR: {}, # see Aos::Cor
+    TECK: {
       DRAW: :draw,
       EXPLORE: :explore,
       NEW: :new,

data/sys/cli/create.rb

@@ -1,15 +1,14 @@
 =begin
   
-  aro.rb
+  create.rb
 
-  process aro commands.
+  create aro space.
 
   by i2097i
 
 =end
 
 module CLI
-  # cli entrypoint
   def self.create
     CLI::Nterface.exit_error_missing_args! if CLI::ARGV1.nil?