aro 0.2.0 → 0.2.2

data/sys/aos/aos.rb

@@ -29,14 +29,25 @@ module Aos
   class Os
     include Singleton
 
-    attr_accessor :you, :running, :view, :db
+    attr_accessor :display_lines,
+      :running,
+      :view,
+      :you,
+      :you_flag
 
     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"),
@@ -46,19 +57,22 @@ module Aos
         key: :config,
         description: I18n.t("aos.commands.description.config"),
         usage: I18n.t("aos.commands.usage.config"),
-        cmds: {
-          SET: {
-            key: :set,
-            description: I18n.t("aos.commands.description.config_set", prefix: CLI::Config::ARO_CONFIG_PREFIX),
-            usage: I18n.t("aos.commands.usage.config_set"),
-          }
-        }
+      },
+      DATA: {
+        key: :data,
+        description: I18n.t("aos.commands.description.data"),
+        usage: I18n.t("aos.commands.usage.data"),
       },
       EXIT: {
         key: :exit,
         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 +90,93 @@ module Aos
       },
     }
 
-    def initialize
-      if Aro::Dom.in_arodom? && !Aro::Dom.is_initialized?
-        Aro::Dom.new.generate
+    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
+      Aos::Os::CMDS.values.map{|v| v[:key]}.include?(arg.to_sym)
+    end
+
+    def self.you_flagd?
+      self.instance.you_flag
+    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
-      @db = Aos::Db.new
+
+      cmd
+    end
+
+    def initialize
+      self.you_flag = false
+      Aro::Config.instance.load
+      # if Aro::Dom.in_arodom? && !Aro::Dom.is_initialized?
+        # Aro::Dom.new.generate unless Aro::Mancy.in_aro?
+      # end
+      Aos::Db.load
+      load_ilibs
       load_you
     end
 
+    def load_ilibs
+      # todo: load from directory of ilibs.
+      # something like:
+      #
+      # Dir[lib_something_something].each do{|l| Aos::Ilib.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?
+
+      if ARGV.include?(Aos::Os::YOU_FLAG)
+        self.you_flag = true
+        you_name = ARGV[ARGV.index(Aos::Os::YOU_FLAG) + Aro::Mancy::S]
+        @you = Aos::You.find_by(name: you_name)
+        if @you.nil?
+          @you = Aos::You.create(name: you_name)
+        end
+      else
+        # todo: make more secure
+        @you = Aos::You.find_by(access: :root)
+      end
+
+      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
+
+      cls_name = (Aos::Vw.name + "::#{view_name.capitalize}")
+      Aro::D.say("attempting to load view class #{cls_name}")
       begin
-        view_cls = (Aos::Vi.name + "::#{view_name.capitalize}").constantize
+        view_cls = cls_name.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 +184,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,35 +191,54 @@ 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
-        passthrough = main(cmd)
-        if CLI::Config.is_format_text?
-          IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
+        configure_readline
+        send_to_system_call = main(cmd)
+        if Aro::Config.is_format_text?
+          # IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
         end
-        if passthrough
-          system(cmd)
-          Aos::S.say("\n")
-        else
+        nothing = nil
+        if send_to_system_call
+          nothing = system(cmd)
+          Aos::S.say(nothing) if nothing.nil?
+        end
+
+        if nothing.nil?
           render
         end
+
+        unless cmd.nil?
+          @you.generate_ilog(cmd)
+        end
       end
 
       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 +251,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,58 +270,93 @@ 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]) ||
+      # send to "system" call in process_cmd method
+      # if args[Aro::Mancy::O] is not in Aos::Os::CMDS
+      send_to_system_call = !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
+      unless send_to_system_call
         Dir.chdir(@you.pwd) do
           # process commands
           case args[Aro::Mancy::O].to_sym
+          when Aos::Os::CMDS[:AMG][:key]
+            # amg
+            send_to_system_call = handle_amg(args)
+          when Aos::Os::CMDS[:CD][:key]
+            # cd
+            handle_cd(args)
           when Aos::Os::CMDS[:CONFIG][:key]
             # config
-            passthrough = handle_config(args)
-          when Aos::Os::CMDS[:LS][:key]
-            # ls
-            handle_ls(args)
+            send_to_system_call = handle_config(args)
+          when Aos::Os::CMDS[:DATA][:key]
+            # data
+            send_to_system_call = handle_data(args)
+          when Aos::Os::CMDS[:EXIT][:key]
+            # exit
+            send_to_system_call = true
+            handle_exit(args)
+          when Aos::Os::CMDS[:HELP][:key]
+            # help
+            send_to_system_call = handle_help(args)
           when Aos::Os::CMDS[:LL][:key]
             # ll
             handle_ll(args)
+          when Aos::Os::CMDS[:LS][:key]
+            # ls
+            handle_ls(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[:CD][:key]
-            # cd
-            handle_cd(args)
           end
         end
       end
 
-      return passthrough
+      if send_to_system_call
+        # process ilib commands
+        ilib = Aos::Ilib.find_by(
+          name: args[Aro::Mancy::O],
+          status: :installed
+        )
+        unless ilib.nil?
+          self.display_lines = [ilib.usage]
+          send_to_system_call = false
+        end
+
+        # if system is going to run, but redirect happens,
+        # cancel system run.
+        if redirect_to_room(args[Aro::Mancy::O])
+          send_to_system_call = false
+        end
+      end
+
+      return send_to_system_call
     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_room_path(arg)
+    def handle_config(args)
+      Aro::Config.process_config_command(args)
+      return true
+    end
+
+    def redirect_to_room(arg)
       # search for reserved room path
       handled = false
       room_path = Aro::Dom.room_path(arg)
@@ -254,36 +370,34 @@ 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_data(args)
+      Aos::Data.process_cmd(args)
+    end
+
+    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 +413,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 +439,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/data.rb

@@ -0,0 +1,117 @@
+=begin
+
+  data.rb
+
+  aos data management.
+
+  by i2097i
+
+=end
+
+module Aos
+  class Data
+    include Singleton
+
+    attr_accessor :display_lines
+
+    CMDS = {
+      ILOGS: {
+        key: :ilogs,
+        description: I18n.t("data.commands.description.ilogs"),
+        usage: I18n.t("data.commands.usage.ilogs"),
+      },
+      YOUS: {
+        key: :yous,
+        description: I18n.t("data.commands.description.yous"),
+        usage: I18n.t("data.commands.usage.yous"),
+      },
+    }
+
+    def initialize
+      self.display_lines = Aos::Data.base_lines
+    end
+
+    def self.process_cmd(args)
+      self.instance.display_lines = []
+      if args[Aro::Mancy::S].nil? ||
+        CLI::FLAGS[:HELP].include?(args[Aro::Mancy::S].to_sym)
+        Aos::Data.data
+        return true
+      end
+
+      case args[Aro::Mancy::S].to_sym
+      when Aos::Data::CMDS[:ILOGS][:key]
+        Aos::Data.ilogs
+        return true
+      when Aos::Data::CMDS[:YOUS][:key]
+        Aos::Data.yous
+        return true
+      end
+
+      return false
+    end
+
+    def self.ilogs
+      self.instance.display_lines = Aos::Data.ilog_lines
+    end
+
+    def self.yous
+      self.instance.display_lines = Aos::Data.you_lines
+    end
+
+    def self.data
+      self.instance.display_lines = Aos::Data.base_lines
+    end
+
+    def self.base_lines
+      # print data commands
+      lines = []
+      lines << ""
+      lines << I18n.t("aos.constants.commands")
+      lines += Aos::Vw::Base.lines_for_cmd(Aos::Os::CMDS[:DATA])
+      lines << I18n.t("aos.constants.subcommands")
+      Aos::Data::CMDS.keys.each{|k|
+        lines += Aos::Vw::Base.lines_for_cmd(Aos::Data::CMDS[k])
+      }
+      lines << ""
+
+      lines
+    end
+
+    def self.ilog_lines
+      # list input ilogs
+      lines = []
+      lines << ""
+      iilogs = Aos::Ilog.all
+      unless iilogs.any?
+        lines << I18n.t("data.messages.no_ilogs")
+      else
+        lines << I18n.t("data.messages.listing_ilogs")
+        iilogs.each{|il|
+          lines += il.get_lines
+        }
+      end
+      lines << ""
+
+      lines
+    end
+
+    def self.you_lines
+      # list yous
+      lines = []
+      lines << ""
+      yous = Aos::You.all
+      unless yous.any?
+        lines << I18n.t("data.messages.no_yous")
+      else
+        lines << I18n.t("data.messages.listing_yous")
+        yous.each{|y|
+          lines += y.get_lines
+        }
+      end
+      lines << ""
+
+      lines
+    end
+  end
+end

data/{db → sys/aos/db}/migrate/1765148774_create_yous.rb

@@ -4,6 +4,7 @@ class CreateYous < ActiveRecord::Migration[8.1]
     create_table :yous do |t|
       t.string :name, null: false
       t.string :pwd
+      t.integer :access, default: Aro::Mancy::O
 
       t.timestamps
 

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

@@ -0,0 +1,22 @@
+class CreateIlibs < ActiveRecord::Migration[8.1]
+
+  def self.up
+    create_table :ilibs 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 :ilibs, :name
+    remove_index :ilibs, :so_path
+    drop_table :ilibs
+  end
+
+end

data/sys/aos/db/migrate/1765907766_create_ilogs.rb

@@ -0,0 +1,18 @@
+class CreateIlogs < ActiveRecord::Migration[8.1]
+
+  def self.up
+    create_table :ilogs do |t|
+      t.belongs_to :you, null: false, foreign_key: true
+      t.string :cmd, null: false
+      t.string :pwd, null: false
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    remove_index :ilogs, :pwd
+    drop_table :ilogs
+  end
+
+end