aro 0.2.1 → 0.2.2

data/sys/aos/aos.rb

@@ -29,7 +29,11 @@ module Aos
   class Os
     include Singleton
 
-    attr_accessor :you, :libs, :running, :view, :db, :display_lines
+    attr_accessor :display_lines,
+      :running,
+      :view,
+      :you,
+      :you_flag
 
     A = :"@"
     STAR = :"*"
@@ -53,13 +57,11 @@ 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: Aro::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,
@@ -102,12 +104,11 @@ module Aos
 
     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
+      self.instance.you_flag
     end
 
     def self.sanitize_you(cmd)
@@ -123,20 +124,21 @@ module Aos
     end
 
     def initialize
+      self.you_flag = false
       Aro::Config.instance.load
-      if Aro::Dom.in_arodom? && !Aro::Dom.is_initialized?
-        Aro::Dom.new.generate
-      end
-      @db = Aos::Db.new
-      load_libs
+      # 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_libs
-      # todo: load from directory of libs.
+    def load_ilibs
+      # todo: load from directory of ilibs.
       # something like:
       #
-      # Dir[lib_something_something].each do{|l| Aos::Lib.install(l)}
+      # Dir[lib_something_something].each do{|l| Aos::Ilib.install(l)}
 
       # for now static
       Aos::Amg.load(:crs)
@@ -145,22 +147,29 @@ module Aos
     def load_you
       return if @you.present?
 
-      you_name = Aos::Os::YOU
       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
 
-      @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
+
+      cls_name = (Aos::Vw.name + "::#{view_name.capitalize}")
+      Aro::D.say("attempting to load view class #{cls_name}")
       begin
-        view_cls = (Aos::Vw.name + "::#{view_name.capitalize}").constantize
+        view_cls = cls_name.constantize
       rescue
         view_cls = Aos::Vw::Base
       end
@@ -190,12 +199,12 @@ module Aos
     def process_cmd(cmd)
       Dir.chdir(@you.reload.pwd) do
         configure_readline
-        passthrough = main(cmd)
+        send_to_system_call = main(cmd)
         if Aro::Config.is_format_text?
           # IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
         end
         nothing = nil
-        if passthrough
+        if send_to_system_call
           nothing = system(cmd)
           Aos::S.say(nothing) if nothing.nil?
         end
@@ -203,6 +212,10 @@ module Aos
         if nothing.nil?
           render
         end
+
+        unless cmd.nil?
+          @you.generate_ilog(cmd)
+        end
       end
 
       CLI::EXIT_CODES[:SUCCESS]
@@ -263,51 +276,67 @@ module Aos
 
       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)
 
       # 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]
-            # inst
-            passthrough = handle_amg(args)
+            # 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[:HELP][:key]
-            # help
-            passthrough = handle_help(args)
-          when Aos::Os::CMDS[:CD][:key]
-            # cd
-            handle_cd(args)
           end
         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
+      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 passthrough
+      return send_to_system_call
     end
 
     def calc_ps1
@@ -345,6 +374,10 @@ module Aos
       Aos::Amg.process_cmd(args)
     end
 
+    def handle_data(args)
+      Aos::Data.process_cmd(args)
+    end
+
     def handle_help(args)
       redirect_to_room(Aro::Dom::WAITE)
       return false

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/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_libs.rb → 1765762724_create_ilibs.rb}

@@ -1,7 +1,7 @@
-class CreateLibs < ActiveRecord::Migration[8.1]
+class CreateIlibs < ActiveRecord::Migration[8.1]
 
   def self.up
-    create_table :libs do |t|
+    create_table :ilibs do |t|
       t.string :name, null: false
       t.string :so_path, null: false
       t.integer :status, default: Aro::Mancy::O
@@ -14,9 +14,9 @@ class CreateLibs < ActiveRecord::Migration[8.1]
   end
 
   def self.down
-    remove_index :libs, :name
-    remove_index :libs, :so_path
-    drop_table :libs
+    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

data/sys/aos/db.rb

@@ -9,14 +9,19 @@
 =end
 
 module Aos
-  class Db < Aro::Db
+  class Db
+    include Singleton
+
+    DATABASE_YML = :"database.yml"
     GEM_DB_PATH = :"sys/aos/db"
+    MIGRATIONS_DIR = :"db/migrate"
+    SCHEMA_FILE = :"schema.rb"
     SQL_FILE = :"aos.sql"
 
-    def initialize
+    def self.load(password = nil)
       Aos::Db.configure_logger
       if Aro::Dom.in_arodom?
-        set_up_aos
+        self.instance.set_up_aos(password)
       else
         Aro::P.say(I18n.t("cli.errors.not_in_aro" , cmd: Aro::Dom.name))
       end
@@ -31,7 +36,8 @@ module Aos
     end
 
     def self.base_aro_dir
-      Aro::Dom.ethergeist_path
+      # Aro::Dom.ethergeist_path
+      File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:data))
     end
 
     def db_config_filepath
@@ -39,7 +45,7 @@ module Aos
       File.join(Aos::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
     end
 
-    def set_up_aos
+    def set_up_aos(password)
       name = Aro::Dom.ethergeist_name
       return if name.nil?
 
@@ -49,21 +55,35 @@ module Aos
       end
 
       unless File.exist?(db_config_filepath)
-        Aro::D.say("creating database: #{db_config_filepath}")
-        # create database config yaml file
-        c = {
-          adapter: :sqlite3.to_s,
-          database: File.join(Aos::Db.base_aro_dir, Aos::Db::SQL_FILE.to_s),
-          username: name,
-          password: name
-        }.to_yaml
-        File.open(db_config_filepath, "w") do |file|
-          file.write(c)
+        unless password.nil?
+          Aro::D.say("creating database: #{db_config_filepath}")
+          # create database config yaml file
+          db_file_path = File.join(Aos::Db.base_aro_dir, Aos::Db::SQL_FILE.to_s)
+          File.open(db_config_filepath, "w") do |file|
+            file.write({
+              adapter: :sqlite3.to_s,
+              database: db_file_path,
+              username: name,
+              password: password,
+            }.to_yaml)
+          end
+        else
+          Aro::D.say("unable to create database without root password.")
         end
       end
 
-      connect(name)
-      migrate(name)
+      if File.exist?(db_config_filepath)
+        connect(name)
+        migrate(name)
+      else
+        Aro::D.say("unable to set up database without root password.")
+      end
+    end
+
+    def connect(name)
+      ActiveRecord::Base.establish_connection(
+        YAML.load_file(db_config_filepath)
+      )
     end
 
     def migrate(name)

data/sys/{shr/lib/lib.rb → aos/models/ilib.rb}

@@ -1,19 +1,22 @@
 =begin
 
-  lib.rb
+  ilib.rb
 
-  aos lib object.
+  aos ilib object.
 
   by i2097i
 
 =end
 
-# todo: put in separate file and require it
 # installed lib modules section
 
 module CRS
   SO_FILE = :"libcrs.so".to_s
-  SO_PATH = File.join(File.dirname(__dir__), :lib.to_s, :crs.to_s, CRS::SO_FILE)
+  SO_PATH = File.join(
+    Reiquire::GEM_PATH,
+    :"sys/shr/ilib/crs".to_s,
+    CRS::SO_FILE
+  )
   extend FFI::Library
   ffi_lib CRS::SO_PATH
   attach_function :hello, [], :string
@@ -21,7 +24,7 @@ end
 
 # installed lib modules section
 
-class Aos::Lib < ActiveRecord::Base
+class Aos::Ilib < ActiveRecord::Base
   before_create :set_so_path
 
   enum :status, [
@@ -37,7 +40,7 @@ class Aos::Lib < ActiveRecord::Base
   private
 
   def set_so_path
-    # todo make configurable
+    # todo make configurable for other modules
     self.so_path = CRS::SO_PATH
   end
 end

data/sys/aos/models/ilog.rb

@@ -0,0 +1,27 @@
+=begin
+
+  ilog.rb
+
+  aos ilog object.
+
+  by i2097i
+
+=end
+
+module Aos
+  class Ilog < ActiveRecord::Base
+    belongs_to :you
+
+    def get_lines
+      [
+        I18n.t(
+          "data.ilogs.display",
+          you: self.you.name,
+          cmd: self.cmd,
+          timestamp: self.created_at.strftime(Aos::Os::DATE_FORMAT),
+          pwd: Aos::Os.osify(self.pwd)
+        )
+      ]
+    end
+  end
+end

data/sys/aos/models/you.rb

@@ -0,0 +1,50 @@
+=begin
+
+  you.rb
+
+  aos you object.
+
+  by i2097i
+
+=end
+
+module Aos
+  class You < ActiveRecord::Base
+    has_many :ilogs
+    before_validation :set_pwd
+    after_update :clear_aos_display
+
+    enum :access, [
+      :user,
+      :root,
+    ]
+
+    def generate_ilog(cmd)
+      ilogs.create(
+        pwd: Aos::Os.osify(pwd),
+        cmd: cmd
+      )
+    end
+
+    def get_lines
+      [
+        I18n.t(
+          "data.yous.display",
+          name: name,
+          access: Aos::You::accesses[access],
+          pwd: Aos::Os.osify(pwd)
+        )
+      ]
+    end
+
+    private
+
+    def set_pwd
+      self.pwd = Dir.pwd if self.pwd.nil?
+    end
+
+    def clear_aos_display
+      Aos::Os.instance.display_lines = [Aos::Os.osify(pwd, true)]
+    end
+  end
+end