aro 0.2.0 → 0.2.1

data/sys/aos/aos.rb

@@ -29,14 +29,21 @@ module Aos
   class Os
     include Singleton
 
-    attr_accessor :you, :running, :view, :db
+    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"),
@@ -49,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"),
           }
         }
@@ -59,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"),
@@ -76,32 +88,86 @@ module Aos
       },
     }
 
+    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
-      @you = Aos::You.where(name: :you).first
-      @you = Aos::You.create(name: :you, pwd: Dir.pwd) if @you.nil?
-      Aro::D.say(@you.inspect)
+      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::Vi.name + "::#{view_name.capitalize}").constantize
+        view_cls = (Aos::Vw.name + "::#{view_name.capitalize}").constantize
       rescue
-        view_cls = Aos::Vi::Base
+        view_cls = Aos::Vw::Base
       end
 
       Dir.chdir(@you.pwd) do
         if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
-          view_cls = Aos::Vi::Game
+          view_cls = Aos::Vw::Game
         end
       end
 
@@ -109,19 +175,6 @@ module Aos
       @view = view_cls
     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("/")
-    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 render
       load_view
       return if @view.nil?
@@ -129,21 +182,25 @@ module Aos
         if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
           system(:aro.to_s)
         else
-          @view.show(@you)
+          @view.show
         end
       end
     end
 
     def process_cmd(cmd)
       Dir.chdir(@you.reload.pwd) do
+        configure_readline
         passthrough = main(cmd)
-        if CLI::Config.is_format_text?
-          IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
+        if Aro::Config.is_format_text?
+          # IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
         end
+        nothing = nil
         if passthrough
-          system(cmd)
-          Aos::S.say("\n")
-        else
+          nothing = system(cmd)
+          Aos::S.say(nothing) if nothing.nil?
+        end
+
+        if nothing.nil?
           render
         end
       end
@@ -151,13 +208,24 @@ module Aos
       CLI::EXIT_CODES[:SUCCESS]
     end
 
-    def confgiure_readline
+    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[@you.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
 
@@ -170,10 +238,10 @@ module Aos
         cmd = nil
         loop do
           # erase before cursor
-          IO.console.erase_screen(Aro::Mancy::S)
           process_cmd(cmd)
-          IO.console.goto(CLI::Config.display_config[:HEIGHT], Aro::Mancy::O)
+          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
 
         out
@@ -189,26 +257,23 @@ module Aos
       return false if cmd.nil?
 
       # get args
-      args = cmd.split(" ")
+      args = Aos::Os.sanitize_you(cmd).split(" ")
       return false if args[0].nil?
       return false if args[0] == :aos.to_s
 
-      # reconfigure for updates to pwd
-      # todo: not working for tab completion
-      confgiure_readline
-
       args = handle_aro_override(args)
 
       passthrough = !Aos::Os.is_aos_command?(args[Aro::Mancy::O]) ||
         args.include?(:aos.to_s)
 
-      return false if handle_room_path(args[Aro::Mancy::O])
-
       # 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)
@@ -225,6 +290,9 @@ module Aos
             # 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)
@@ -232,15 +300,34 @@ module Aos
         end
       end
 
+      # 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}:"}$ "
+      "#{Aos::Os::PS1}"
+    end
+
+    def handle_aro_override(args)
+      if args[0].include?(:aro.to_s)
+        args = "#{args.join(" ")} #{:aos.to_s}".split(" ")
+      end
+      args
+    end
+
+    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)
@@ -254,36 +341,30 @@ module Aos
       handled
     end
 
-    def handle_aro_override(args)
-      if args[0].include?(:aro.to_s)
-        args = "#{args.join(" ")} #{:aos.to_s}".split(" ")
-      end
-      args
+    def handle_amg(args)
+      Aos::Amg.process_cmd(args)
     end
 
-    def handle_config(args)
-      passthrough = false
-      if args[1].nil?
-        # show settings
-        passthrough = true
-        CLI::Config.dump_config.each{|l| Aos::S.say(l)}
-      else
-        CLI::Config.process_config_command(args)
-      end
-      passthrough
+    def handle_help(args)
+      redirect_to_room(Aro::Dom::WAITE)
+      return false
     end
 
     def handle_ls(args)
-      Aos::S.say(Dir.glob(File.join(@you.pwd, (args[1] || "") + Aos::Os::STAR.to_s), File::FNM_EXTGLOB).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(@you.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)
+      self.display_lines = [osified]
     end
 
     def handle_exit(args)
@@ -299,7 +380,7 @@ module Aos
         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}.")
+            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
@@ -325,7 +406,7 @@ module Aos
             Aro::V.say("new_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,10 +10,8 @@
 
 module Aos
   class Db < Aro::Db
-    DATABASE_YML = :"database.yml"
+    GEM_DB_PATH = :"sys/aos/db"
     SQL_FILE = :"aos.sql"
-    SCHEMA_FILE = :"schema.rb"
-    MIGRATIONS_DIR = :"db/migrate"
 
     def initialize
       Aos::Db.configure_logger
@@ -25,7 +23,7 @@ module Aos
     end
 
     def self.configure_logger
-      if CLI::Config.ivar(:LOG_AOS_DB).to_s == CLI::Config::BOOLS[:TRUE].to_s
+      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
@@ -37,7 +35,8 @@ module Aos
     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
@@ -68,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|
@@ -79,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

data/sys/aos/{views → vws}/base.rb

@@ -1,6 +1,6 @@
 =begin
   
-  views/base.rb
+  vws/base.rb
 
   the base view (abstract).
 
@@ -11,21 +11,21 @@
 require :aro.to_s
 
 module Aos
-  module Vi
+  module Vw
     class Base
       BAR = :"".to_s
       COL_POW = Proc.new{|n| n.pow(Aro::Mancy::S.to_f / Aro::Mancy::OS.to_f).to_i}
       MARGIN_V = Aro::Mancy::S
       MARGIN_H = Aro::Mancy::S
 
-      def self.show(model)
-        draw([self.name], model)
+      def self.show
+        draw([self.name])
       end
 
-      def self.get_json(lines, you = nil)
+      def self.get_json(lines)
         {
           body: lines,
-          you: you&.to_json,
+          you: Aos::Os.instance.you.to_json,
           domain: self.get_domain,
           clock: self.get_clock,
           dimension: self.get_dimension,
@@ -33,68 +33,78 @@ module Aos
         }
       end
 
-      def self.draw(lines, you = nil)
-        unless CLI::Config.is_format_text?
-          Aos::S.say(self.get_json(lines, you))
+      def self.draw(body_lines)
+        unless Aro::Config.is_format_text?
+          Aos::S.say(self.get_json(lines))
           return true
         end
 
-        return false unless lines.kind_of?(Array)
-
-        dc = CLI::Config.display_config
+        return false unless body_lines.kind_of?(Array)
+        lines = []
+        dc = Aro::Config.display_configuration
         height = dc[:HEIGHT]
         width = dc[:WIDTH]
 
-        print_aos_div
-
         # header
-        Aro::Mancy::S.times do |i|
-          Aos::S.say("".center(width, dc[:DIVIDER]))
-          Aos::S.say("".center(width))
-          Aos::S.say("\n")
-        end
+        # lines << "".center(width, "=")
+        # lines << "".center(width)
 
-        half = ((width - self.name.length) / Aro::Mancy::OS.to_f).ceil
-        domain = self.get_domain
-        clock = self.get_clock
-        Aos::S.say(
-          (
-            domain.ljust(half) + self.name.to_s.upcase
-          ).ljust(width - clock.length) + clock
-        )
-
-        Aro::Mancy::S.times do
-          Aos::S.say("".center(width, dc[:DIVIDER]))
-        end
+        # half = ((width - self.name.length) / Aro::Mancy::OS.to_f).ceil
+        # domain = self.get_domain
+        # clock = self.get_clock
+        # lines << (
+        #   (
+        #     domain.ljust(half) + self.name.to_s.upcase
+        #   ).ljust(width - clock.length) + clock
+        # )
+
+        # lines << "".center(width, dc[:DIVIDER])
 
         # top vertical margin
-        Aos::Vi::Base::MARGIN_V.times do
-          Aos::S.say(get_body_line(""))
+        Aos::Vw::Base::MARGIN_V.times do
+          lines << get_body_line("")
         end
 
         # yield => print lines
-        lines.each{|line|
-          Aos::S.say(get_body_line(line))
+        body_lines.each{|line|
+          lines << get_body_line(line)
         }
 
-        # bottom vertical margin
-        Aos::Vi::Base::MARGIN_V.times do
-          Aos::S.say("[#{Aos::Os} v#{Aro::VERSION.to_s}]".center(width))
-        end
+        lines += get_aos_display_lines
 
         # footer
-        display_dim = self.get_display_dimension
-        Aos::S.say(
-          (
-            ">[#{domain}]>#{Aos::Os::osify(you&.pwd || Dir.pwd)}"
-          ).ljust(width - display_dim.length) + display_dim
-        )
-
-        print_aos_div
+        # display_dim = self.get_display_dimension
+        # lines << (
+        #   (
+        #     ">[#{domain}]>#{Aos::Os::osify(Aos::Os.instance.you&.pwd || Dir.pwd)}"
+        #   ).ljust(width - display_dim.length) + display_dim
+        # )
+
+        # print everything
+        Aos::S.say(lines.join("\n"))
+
         # explicitly return true
         true
       end
 
+      def self.get_aos_display_lines
+        # current Aos::Os output
+        lines = []
+        unless Aos::Os.instance.display_lines.empty?
+          dc = Aro::Config.display_configuration
+          width = dc[:WIDTH]
+          lines << "".center(width)
+          display_dim = get_display_dimension
+          Aos::Os.instance.display_lines.each{|line|
+            lines << line
+          }
+          lines << "".center(width)
+          lines << "v#{Aro::VERSION.to_s}".ljust(width - display_dim.length) + display_dim
+          # lines << "".center(width, "=")
+        end
+        lines
+      end
+
       def self.get_display_dimension
         "#{self.get_dt.rjust(Aro::Mancy::V)} :<[#{self.get_dimension}]<"
       end
@@ -115,27 +125,20 @@ module Aos
         Time.now.strftime(Aos::Os::DATE_FORMAT)
       end
 
-      def self.print_aos_div
-        Aro::Mancy::S.times do
-          Aos::S.say("\n")
-          Aos::S.say("".center(CLI::Config.display_config[:WIDTH], "="))
-        end
-      end
-
       def self.viewport_width
-        dc = CLI::Config.display_config
+        dc = Aro::Config.display_configuration
         width = dc[:WIDTH]
-        bar_width = (Aos::Vi::Base::BAR.length * Aro::Mancy::OS)
-        h_margin_width = (Aos::Vi::Base::MARGIN_H * Aro::Mancy::OS)
+        bar_width = (Aos::Vw::Base::BAR.length * Aro::Mancy::OS)
+        h_margin_width = (Aos::Vw::Base::MARGIN_H * Aro::Mancy::OS)
 
         (width - (bar_width + h_margin_width))
       end
 
       def self.get_body_line(line)
-        hm = Aos::Vi::Base::MARGIN_H
-        bar = Aos::Vi::Base::BAR
-        hm_space = " " * Aos::Vi::Base::MARGIN_H
-        just = CLI::Config.display_config[:WIDTH] - (hm_space.length + bar.length)
+        hm = Aos::Vw::Base::MARGIN_H
+        bar = Aos::Vw::Base::BAR
+        hm_space = " " * Aos::Vw::Base::MARGIN_H
+        just = Aro::Config.display_configuration[:WIDTH] - (hm_space.length + bar.length)
         (bar + hm_space + (line || "")).ljust(just) + hm_space + bar
       end
 

data/sys/aos/{views → vws}/dom.rb

@@ -1,6 +1,6 @@
 =begin
   
-  views/dom.rb
+  vws/dom.rb
 
   the dom view.
 
@@ -11,25 +11,22 @@
 require_relative :"./base".to_s
 
 module Aos
-  module Vi
-    class Dom < Aos::Vi::Base
+  module Vw
+    class Dom < Aos::Vw::Base
 
-      def self.show(model)
+      def self.show
         lines = []
         lines << I18n.t("aos.views.dom.title")
         lines << I18n.t("aos.views.dom.description")
         lines << ""
         lines << I18n.t("aos.constants.commands")
-        Aos::Os::CMDS.keys.sort.each{|cmd|
-          lines += lines_for_cmd(Aos::Os::CMDS[cmd])
-        }
-
+        lines += lines_for_cmd(Aos::Os::CMDS[:HELP])
         lines << ""
         lines << I18n.t("aos.views.dom.quick_navigation")
         lines << ""
         lines << "  =>  #{Aro::Dom::D.reserved_words.join("  ")}"
         lines << ""
-        draw(lines, model)
+        draw(lines)
       end
     end
   end