aro 0.1.9 → 0.2.1

data/sys/aos/aos.rb

@@ -13,38 +13,37 @@ require :aro.to_s
 module Aos
 
   def self.run
-    Aos::Db.new
-    Aos::Os::boot(Aos::you)
     begin
       Aos::Os.instance.run
     rescue Interrupt => e
-      Aos::run
+      Aos.run
     end
   end
 
-  def self.watch
-    Aos::Db.new
-    Aos::Os::boot(Aos::you)
-    Aos::Os::instance.render
-  end
-
-  def self.you
-    you = Aos::You.where(name: :you).first
-    you = Aos::You.create(name: :you, pwd: Dir.pwd) if you.nil?
-    you
+  def self.process
+    cmd = ARGV.join(" ")
+    Aro::D.say("processing cmd #{cmd}...")
+    Aos::Os::instance.process_cmd(cmd)
   end
 
   class Os
     include Singleton
 
-    attr_accessor :you, :running, :view
+    attr_accessor :you, :libs, :running, :view, :db, :display_lines
 
     A = :"@"
     STAR = :"*"
+    YOU = :you.to_s
+    YOU_FLAG = :"--you".to_s
     PS1 = :">[#{Aos::Os}]>: "
     DATE_FORMAT = "%A %d %b %Y %I:%M:%S %p"
 
     CMDS = {
+      AMG: {
+        key: :amg,
+        description: I18n.t("aos.commands.description.amg"),
+        usage: I18n.t("aos.commands.usage.amg"),
+      },
       CD: {
         key: :cd,
         description: I18n.t("aos.commands.description.cd"),
@@ -57,7 +56,7 @@ module Aos
         cmds: {
           SET: {
             key: :set,
-            description: I18n.t("aos.commands.description.config_set", prefix: CLI::Config::ARO_CONFIG_PREFIX),
+            description: I18n.t("aos.commands.description.config_set", prefix: Aro::Config::ARO_CONFIG_PREFIX),
             usage: I18n.t("aos.commands.usage.config_set"),
           }
         }
@@ -67,6 +66,11 @@ module Aos
         description: I18n.t("aos.commands.description.exit"),
         usage: I18n.t("aos.commands.usage.exit"),
       },
+      HELP: {
+        key: :help,
+        description: I18n.t("aos.commands.description.help"),
+        usage: I18n.t("aos.commands.usage.help"),
+      },
       LS: {
         key: :ls,
         description: I18n.t("aos.commands.description.ls"),
@@ -84,110 +88,252 @@ module Aos
       },
     }
 
-    def self.boot(you)
-      self.instance.you = you
-      self.instance.load_view
+    def self.osify(path, leading_slash = false)
+      return path unless Aro::Dom.in_arodom?
+      path_arr = path.split("/")
+      Aro::Dom::dom_root.split("/").each{|rdp| path_arr.delete(rdp)}
+      result = path_arr.join("/")
+      if leading_slash
+        result = "/" + result
+      end
+
+      result
+    end
+
+    def self.is_aos_command?(arg)
+      # determine if command is Aos::Os::CMDS
+      # passthrough to system if command is not in Aos::Os::CMDS
+      Aos::Os::CMDS.values.map{|v| v[:key]}.include?(arg.to_sym)
+    end
+
+    def self.you_flagd?
+      self.instance.you&.name != Aos::Os::YOU
+    end
+
+    def self.sanitize_you(cmd)
+      if cmd.present? && cmd.include?(Aos::Os::YOU_FLAG)
+        cmd_split = cmd.split(" ")
+        i = cmd_split.index(Aos::Os::YOU_FLAG)
+        cmd_split.delete_at(i)
+        cmd_split.delete_at(i)
+        cmd = cmd_split.join(" ")
+      end
+
+      cmd
+    end
+
+    def initialize
+      Aro::Config.instance.load
+      if Aro::Dom.in_arodom? && !Aro::Dom.is_initialized?
+        Aro::Dom.new.generate
+      end
+      @db = Aos::Db.new
+      load_libs
+      load_you
+    end
+
+    def load_libs
+      # todo: load from directory of libs.
+      # something like:
+      #
+      # Dir[lib_something_something].each do{|l| Aos::Lib.install(l)}
+
+      # for now static
+      Aos::Amg.load(:crs)
+    end
+
+    def load_you
+      return if @you.present?
+
+      you_name = Aos::Os::YOU
+      if ARGV.include?(Aos::Os::YOU_FLAG)
+        you_name = ARGV[ARGV.index(Aos::Os::YOU_FLAG) + Aro::Mancy::S]
+      end
+
+      @you = Aos::You.find_by(name: you_name)
+      @you = Aos::You.create(name: you_name, pwd: Dir.pwd) if @you.nil?
+
+      self.display_lines = [Aos::Os.osify(@you.pwd, true)]
+    end
+
+    def load_view
+      view_name = Aos::Os.osify(@you.pwd).split("/").last || :dom.to_s
+      view_cls = nil
+      begin
+        view_cls = (Aos::Vw.name + "::#{view_name.capitalize}").constantize
+      rescue
+        view_cls = Aos::Vw::Base
+      end
+
+      Dir.chdir(@you.pwd) do
+        if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
+          view_cls = Aos::Vw::Game
+        end
+      end
+
+      Aro::D.say("loading view #{view_cls}")
+      @view = view_cls
     end
 
     def render
-      return if view.nil?
-      Dir.chdir(you.pwd) do
-        view.show(you)
+      load_view
+      return if @view.nil?
+      Dir.chdir(@you.reload.pwd) do
+        if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
+          system(:aro.to_s)
+        else
+          @view.show
+        end
       end
     end
 
-    def run
-      # run loop exit condition
-      self.running = true
+    def process_cmd(cmd)
+      Dir.chdir(@you.reload.pwd) do
+        configure_readline
+        passthrough = main(cmd)
+        if Aro::Config.is_format_text?
+          # IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
+        end
+        nothing = nil
+        if passthrough
+          nothing = system(cmd)
+          Aos::S.say(nothing) if nothing.nil?
+        end
 
-      # set aos pwd
-      Dir.chdir(you.pwd)
+        if nothing.nil?
+          render
+        end
+      end
+
+      CLI::EXIT_CODES[:SUCCESS]
+    end
 
+    def configure_readline
       # configure Readline
-      # Readline.completion_append_character = "/"
+      Readline.completion_append_character = "/"
       Readline.completion_proc = Proc.new{|str|
-        # todo: the reserved_words search is working but the || case is not
-        Aro::Dom::D.reserved_words.grep(/^#{Regexp.escape(str)}/) ||
-        Dir[Dir.pwd + str + Aos::Os::STAR.to_s].grep(/^#{Regexp.escape(str)}/)
+        # Aro::V.say(str)
+        dir_matcher = @you.pwd + "/" + str + Aos::Os::STAR.to_s
+        dir_listing = Dir.glob(dir_matcher, File::FNM_DOTMATCH).map{|d| Aos::Os.osify(d)}
+        r_str = Regexp.escape(str)
+
+        # Aro::V.say(dir_listing.join(" ")) if dir_listing.any?
+        # checks pwd
+        matches = dir_listing.grep(/^#{r_str}/)
+        if matches.any?
+          matches
+        else
+          # checks reserved words
+          Aro::Dom::D.reserved_words.grep(/^#{r_str}/)
+        end
       }
+    end
 
-      # begin game loop
-      while running && cmd = Readline.readline(calc_ps1, true)
-        next if cmd.nil?
-
-        # get args
-        args = cmd.split(" ")
-
-        next if handle_room_path(args[Aro::Mancy::O]) || handle_aro_override(args)
-
-        passthrough = !is_aos_command?(args[Aro::Mancy::O])
-
-        # process commands
-        case args[Aro::Mancy::O].to_sym
-        when Aos::Os::CMDS[:CONFIG][:key]
-          # config
-          handle_config(args)
-        when Aos::Os::CMDS[:LS][:key]
-          # ls
-          handle_ls(args)
-        when Aos::Os::CMDS[:LL][:key]
-          # ll
-          handle_ll(args)
-        when Aos::Os::CMDS[:PWD][:key]
-          # pwd
-          handle_pwd(args)
-        when Aos::Os::CMDS[:EXIT][:key]
-          # exit
-          handle_exit(args)
-        when Aos::Os::CMDS[:CD][:key]
-          # cd
-          handle_cd(args)
+    def run
+      # run condition
+      @running = true
+
+      original_stdout = $stdout
+      $stdout = StringIO.open do |out|
+        cmd = nil
+        loop do
+          # erase before cursor
+          process_cmd(cmd)
+          IO.console.goto(Aro::Config.display_configuration[:HEIGHT], Aro::Mancy::O)
+          break unless @running && cmd = Readline.readline(calc_ps1, true)
+          IO.console.erase_screen(Aro::Mancy::S)
         end
 
-        Aos::S.say(system(cmd)) if passthrough
+        out
       end
 
       CLI::EXIT_CODES[:SUCCESS]
+    ensure
+      $stdout = original_stdout
     end
 
-    def load_view
-      view_name = Aos::Os.osify(you.pwd).split("/").last || :dom.to_s
-      view_cls = nil
-      begin
-        view_cls = (Aos::Vi.name + "::#{view_name.capitalize}").constantize
-      rescue
-        view_cls = Aos::Vi::Base
+    def main(cmd)
+      # begin game loop
+      return false if cmd.nil?
+
+      # get args
+      args = Aos::Os.sanitize_you(cmd).split(" ")
+      return false if args[0].nil?
+      return false if args[0] == :aos.to_s
+
+      args = handle_aro_override(args)
+
+      passthrough = !Aos::Os.is_aos_command?(args[Aro::Mancy::O]) ||
+        args.include?(:aos.to_s)
+
+      # set aos pwd
+      unless passthrough
+        Dir.chdir(@you.pwd) do
+          # process commands
+          case args[Aro::Mancy::O].to_sym
+          when Aos::Os::CMDS[:AMG][:key]
+            # inst
+            passthrough = handle_amg(args)
+          when Aos::Os::CMDS[:CONFIG][:key]
+            # config
+            passthrough = handle_config(args)
+          when Aos::Os::CMDS[:LS][:key]
+            # ls
+            handle_ls(args)
+          when Aos::Os::CMDS[:LL][:key]
+            # ll
+            handle_ll(args)
+          when Aos::Os::CMDS[:PWD][:key]
+            # pwd
+            handle_pwd(args)
+          when Aos::Os::CMDS[:EXIT][:key]
+            # exit
+            passthrough = true
+            handle_exit(args)
+          when Aos::Os::CMDS[:HELP][:key]
+            # help
+            passthrough = handle_help(args)
+          when Aos::Os::CMDS[:CD][:key]
+            # cd
+            handle_cd(args)
+          end
+        end
       end
 
-      Aro::D.say("loading view #{view_cls}")
-      self.view = view_cls
+      # if system is going to run
+      # but redirect happens
+      # cancel system run
+      if passthrough && redirect_to_room(args[Aro::Mancy::O])
+        return false
+      end
+
+      return passthrough
     end
 
     def calc_ps1
-      you_pwd = Aos::Os::osify(you.pwd)
-      "#{Aos::Os::PS1}#{you_pwd.empty? ? "" : "#{you_pwd}:"}$ "
+      you_pwd = Aos::Os::osify(@you.pwd)
+      "#{Aos::Os::PS1}"
     end
 
-    def self.osify(path)
-      return path unless Aro::Dom.in_arodom?
-      path_arr = path.split("/")
-      Aro::Dom::dom_root.split("/").each{|rdp| path_arr.delete(rdp)}
-      path_arr.join("/")
+    def handle_aro_override(args)
+      if args[0].include?(:aro.to_s)
+        args = "#{args.join(" ")} #{:aos.to_s}".split(" ")
+      end
+      args
     end
 
-    def is_aos_command?(arg)
-      # determine if command is Aos::Os::CMDS
-      # passthrough to system if command is not in Aos::Os::CMDS
-      Aos::Os::CMDS.values.map{|v| v[:key]}.include?(arg.to_sym)
+    def handle_config(args)
+      Aro::Config.process_config_command(args)
+      return true
     end
 
-    def handle_room_path(arg)
+    def redirect_to_room(arg)
       # search for reserved room path
       handled = false
       room_path = Aro::Dom.room_path(arg)
       if !room_path.empty?
         handled = true
-        you.update(pwd: File.join(
+        @you.update(pwd: File.join(
           File.dirname(Aro::Dom.ethergeist_path),
           room_path
         ))
@@ -195,67 +341,54 @@ module Aos
       handled
     end
 
-    def handle_aro_override(args)
-      # run all aro commands in aos context
-      handled = false
-      if args[0].include?(:aro.to_s)
-        # passthrough aro cmd with aos appended
-        handled = true
-        system("#{args.join(" ")} #{:aos.to_s}")
-      end
-      handled
+    def handle_amg(args)
+      Aos::Amg.process_cmd(args)
     end
 
-    def handle_config(args)
-      if args[1].nil?
-        # show settings
-        you.update(pwd:
-          File.join(
-            File.dirname(Aro::Dom.ethergeist_path),
-            Aro::Dom::SETUP.to_s,
-            Aro::Dom::SETTINGS.to_s
-          )
-        )
-      else
-        CLI::Config.process_config_command(args)
-      end
+    def handle_help(args)
+      redirect_to_room(Aro::Dom::WAITE)
+      return false
     end
 
     def handle_ls(args)
-      Aos::S.say(Dir[File.join(Dir.pwd, (args[1] || "") + Aos::Os::STAR.to_s)].map{|p| "/" + Aos::Os::osify(p)}.join("\n"))
+      self.display_lines = [
+        Dir.glob(File.join(@you.pwd, (args[1] || "") + Aos::Os::STAR.to_s), File::FNM_EXTGLOB).map{|p| "/" + Aos::Os::osify(p)}.join("\n")
+      ]
     end
 
     def handle_ll(args)
-      Aos::S.say(Dir.glob(File.join(Dir.pwd, (args[1] || "") + Aos::Os::STAR.to_s), File::FNM_DOTMATCH).map{|p| "/" + Aos::Os::osify(p)}.join("\n"))
+      self.display_lines = [
+        Dir.glob(File.join(@you.pwd, (args[1] || "") + Aos::Os::STAR.to_s), File::FNM_DOTMATCH).map{|p| Aos::Os::osify(p.strip, true)}.join("\n")
+      ]
     end
 
     def handle_pwd(args)
-      osified = "/" + Aos::Os::osify(you.pwd)
-      Aos::S.say(osified)
+      osified = "/" + Aos::Os::osify(@you.pwd)
+      self.display_lines = [osified]
     end
 
     def handle_exit(args)
       Aos::S.say("#{Aos::Os} is exiting...")
-      self.running = false
+      @running = false
     end
 
     def handle_cd(args)
       if args[1].nil? || args[1] == "~/"
         # no arg takes you to arodom root
-        you.update(pwd: File.dirname(Aro::Dom.ethergeist_path))
+        @you.update(pwd: File.dirname(Aro::Dom.ethergeist_path))
       else
         if args[1].include?(Aro::Dom::DOTT.to_s)
           # going up
-          if File.dirname(Aro::Dom.ethergeist_path) == you.pwd
-            Aos::S.say("within #{Aos::Os}, one cannot leave the #{Aro::Dom}.")
+          if File.dirname(Aro::Dom.ethergeist_path) == @you.pwd
+            self.display_lines = ["within #{Aos::Os}, one cannot leave the #{Aro::Dom}."]
           else
             # todo: support dots in paths
             # this only supports moving one level up
 
-            pwd_arr = you.pwd.split("/")
+            pwd_arr = @you.pwd.split("/")
             new_pwd = (pwd_arr.first(pwd_arr.length - 1)).join("/")
 
-            you.update(pwd: new_pwd)
+            @you.update(pwd: new_pwd)
           end
         else
           # this particular block needs to be better
@@ -266,14 +399,14 @@ module Aos
             args[1] = args[1][1..]
             new_pwd = File.join(Aro::Dom.dom_root, args[1])
             if Dir.exist?(new_pwd)
-              you.update(pwd: new_pwd)
+              @you.update(pwd: new_pwd)
             end
           elsif Dir.exist?(args[1]) && args[1] != Aro::Dom::DOT.to_s
-            new_pwd = File.join(you.pwd, args[1])
+            new_pwd = File.join(@you.pwd, args[1])
             Aro::V.say("new_pwd: #{new_pwd}")
-            you.update(pwd: new_pwd)
+            @you.update(pwd: new_pwd)
           else
-            Aos::S.say("that directory is invalid.")
+            self.display_lines = ["that directory is invalid."]
           end
         end
       end

data/sys/aos/db/migrate/1765762724_create_libs.rb

@@ -0,0 +1,22 @@
+class CreateLibs < ActiveRecord::Migration[8.1]
+
+  def self.up
+    create_table :libs do |t|
+      t.string :name, null: false
+      t.string :so_path, null: false
+      t.integer :status, default: Aro::Mancy::O
+
+      t.timestamps
+
+      t.index :name, unique: true
+      t.index :so_path, unique: true
+    end
+  end
+
+  def self.down
+    remove_index :libs, :name
+    remove_index :libs, :so_path
+    drop_table :libs
+  end
+
+end

data/sys/aos/db.rb

@@ -2,7 +2,7 @@
 
   db.rb
 
-  database for aos room.
+  database for aos.
 
   by i2097i
 
@@ -10,13 +10,11 @@
 
 module Aos
   class Db < Aro::Db
-    DATABASE_YML = :"database.yml"
-    SQL_FILE = :"database.sql"
-    SCHEMA_FILE = :"schema.rb"
-    MIGRATIONS_DIR = :"db/migrate"
+    GEM_DB_PATH = :"sys/aos/db"
+    SQL_FILE = :"aos.sql"
 
     def initialize
-      # ActiveRecord::Base.logger = Logger.new(STDOUT)
+      Aos::Db.configure_logger
       if Aro::Dom.in_arodom?
         set_up_aos
       else
@@ -24,12 +22,21 @@ module Aos
       end
     end
 
+    def self.configure_logger
+      if Aro::Config.ivar(:LOG_AOS_DB).to_s == Aro::Config::BOOLS[:TRUE].to_s
+        ActiveRecord::Base.logger = Logger.new(STDOUT)
+      else
+        ActiveRecord::Base.logger = nil
+      end
+    end
+
     def self.base_aro_dir
       Aro::Dom.ethergeist_path
     end
 
     def db_config_filepath
-      File.join(Aos::Db.base_aro_dir, Aos::Db::DATABASE_YML.to_s)
+      # intentionally using Aro::Db::DATABASE_YML here
+      File.join(Aos::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
     end
 
     def set_up_aos
@@ -60,10 +67,10 @@ module Aos
     end
 
     def migrate(name)
-      local_migrate_dir = File.join(Aos::Db.base_aro_dir, Aos::Db::MIGRATIONS_DIR.to_s)
+      local_migrate_dir = File.join(Aos::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, "db"), Aos::Db::base_aro_dir)
+        FileUtils.cp_r(File.join(gem_dir, Aos::Db::GEM_DB_PATH.to_s), Aos::Db::base_aro_dir)
       end
 
       migration_version = Dir["#{local_migrate_dir}/*.rb"].map{|n|
@@ -71,7 +78,7 @@ module Aos
       }.max
       ActiveRecord::MigrationContext.new(local_migrate_dir).migrate(migration_version)
 
-      filename = File.join(Aos::Db.base_aro_dir, Aos::Db::SCHEMA_FILE.to_s)
+      filename = File.join(Aos::Db.base_aro_dir, Aro::Db::SCHEMA_FILE.to_s)
       File.open(filename, "w+") do |f|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, f)
       end