aro 0.2.2 → 0.2.4

data/sys/aos/data.rb

@@ -82,12 +82,12 @@ module Aos
       # list input ilogs
       lines = []
       lines << ""
-      iilogs = Aos::Ilog.all
-      unless iilogs.any?
+      ilogs = Aos::Ilog.all
+      unless ilogs.any?
         lines << I18n.t("data.messages.no_ilogs")
       else
         lines << I18n.t("data.messages.listing_ilogs")
-        iilogs.each{|il|
+        ilogs.each{|il|
           lines += il.get_lines
         }
       end

data/sys/aos/db/migrate/1765148774_create_yous.rb

@@ -4,7 +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.integer :access, default: Aro::Mancy::S
 
       t.timestamps
 

data/sys/aos/db/migrate/1765933985_create_agodos.rb

@@ -0,0 +1,22 @@
+class CreateAgodos < ActiveRecord::Migration[8.1]
+
+  def self.up
+    create_table :agodos do |t|
+      t.integer :power, default: Aro::Mancy::O
+      t.belongs_to :you, null: false, foreign_key: true
+      t.string :home
+      t.string :go, null: false
+      t.string :do, null: false, default: ""
+
+      # rate is commands-per-minute (default 1)
+      t.integer :rate, default: Aro::Mancy::S
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :agodos
+  end
+
+end

data/sys/aos/db/migrate/1766203888_create_fpxies.rb

@@ -0,0 +1,18 @@
+class CreateFpxies < ActiveRecord::Migration[8.1]
+
+  def self.up
+    create_table :fpxies do |t|
+      t.belongs_to :you, null: false, foreign_key: true
+      t.string :cmd, null: false
+
+      t.timestamps
+    end
+
+    add_index :fpxies, [:you_id, :cmd], unique: true
+  end
+
+  def self.down
+    drop_table :fpxies
+  end
+
+end

data/sys/aos/db.rb

@@ -19,16 +19,16 @@ module Aos
     SQL_FILE = :"aos.sql"
 
     def self.load(password = nil)
-      Aos::Db.configure_logger
-      if Aro::Dom.in_arodom?
-        self.instance.set_up_aos(password)
-      else
-        Aro::P.say(I18n.t("cli.errors.not_in_aro" , cmd: Aro::Dom.name))
+      Mutex.new.synchronize do
+        if Aro::Dom.in_arodom?
+          Aos::Db.configure_logger
+          self.instance.set_up_aos(password)
+        end
       end
     end
 
     def self.configure_logger
-      if Aro::Config.ivar(:LOG_AOS_DB).to_s == Aro::Config::BOOLS[:TRUE].to_s
+      if Aos::Cor.ivar(:LOG_AOS_DB).to_s == Aos::Cor::BOOLS[:TRUE].to_s
         ActiveRecord::Base.logger = Logger.new(STDOUT)
       else
         ActiveRecord::Base.logger = nil
@@ -36,19 +36,16 @@ module Aos
     end
 
     def self.base_aro_dir
-      # Aro::Dom.ethergeist_path
       File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:data))
     end
 
     def db_config_filepath
       # intentionally using Aro::Db::DATABASE_YML here
-      File.join(Aos::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
+      @db_config_filepath = File.join(Aos::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
     end
 
     def set_up_aos(password)
-      name = Aro::Dom.ethergeist_name
-      return if name.nil?
-
+      ActiveRecord::Base.connection_pool.flush! unless password.nil?
       # create local /.ethergeist directory
       unless File.exist?(Aos::Db.base_aro_dir)
         FileUtils.mkdir(Aos::Db.base_aro_dir)
@@ -63,8 +60,9 @@ module Aos
             file.write({
               adapter: :sqlite3.to_s,
               database: db_file_path,
-              username: name,
+              username: Aro::Dom.ethergeist_name,
               password: password,
+              pool: Aos::Os::DB_POOL
             }.to_yaml)
           end
         else
@@ -73,23 +71,23 @@ module Aos
       end
 
       if File.exist?(db_config_filepath)
-        connect(name)
-        migrate(name)
+        connect
+        migrate
       else
         Aro::D.say("unable to set up database without root password.")
       end
     end
 
-    def connect(name)
+    def connect
       ActiveRecord::Base.establish_connection(
         YAML.load_file(db_config_filepath)
       )
     end
 
-    def migrate(name)
+    def migrate
       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
+        gem_dir = Dir[Reiquire::GEM_PATH || '.'].first
         FileUtils.cp_r(File.join(gem_dir, Aos::Db::GEM_DB_PATH.to_s), Aos::Db::base_aro_dir)
       end
 

data/sys/aos/flie.rb

@@ -0,0 +1,144 @@
+=begin
+
+  flie.rb
+
+  aos flie management.
+
+  by i2097i
+
+=end
+
+module Aos
+  class Flie
+    include Singleton
+
+    attr_accessor :display_lines, :pxy_running
+
+    CMDS = {
+      PXY: {
+        key: :pxy,
+        description: I18n.t("flie.commands.description.pxy"),
+        usage: I18n.t("flie.commands.usage.pxy"),
+      },
+    }
+
+    def initialize
+      self.pxy_running = false
+      self.display_lines = Aos::Flie.base_lines
+    end
+
+    PXY_CMDS = {
+      CREATE: :create,
+      LIST: :list,
+      DEREZ: :derez,
+      HELP: :help,
+      EXIT: :exit,
+    }
+    def self.pxy
+      Aos::Os.say(I18n.t("flie.messages.enter_email"))
+      Aos::Os.say("\n")
+      em = Aos::S.p.ask("#{Aos::Os::PS1}")
+      if you = Aos::You.find_by(name: em)
+        Aos::Os.instance.display_lines = []
+        self.instance.pxy_running = true
+        self.instance.display_lines = [I18n.t("flie.messages.pxy_starting")]
+        while self.instance.pxy_running
+          answer = Aos::S.p.select(
+            Aos::Os::PS1.to_s + I18n.t("flie.messages.main_menu", name: you.name),
+            Aos::Flie::PXY_CMDS,
+            default: Aro::Mancy::S
+          )
+
+          case answer.to_sym
+          when Aos::Flie::PXY_CMDS[:CREATE]
+            Aos::Os.say(I18n.t("flie.messages.enter_cmd"))
+            Aos::Os.say("\n")
+            cmd = Aos::S.p.ask("#{Aos::Os::PS1}")
+            you.fpxies.create(cmd: cmd)
+            self.instance.display_lines = you.fpxies.map{|f| f.get_lines.join("\n")}
+          when Aos::Flie::PXY_CMDS[:LIST]
+            if you.fpxies.any?
+              self.instance.display_lines = you.fpxies.map{|f| f.get_lines.join("\n")}
+            else
+              self.instance.display_lines = [I18n.t("flie.messages.no_fpxies")]
+            end
+          when Aos::Flie::PXY_CMDS[:DEREZ]
+            unless you.fpxies.any?
+              self.instance.display_lines = [I18n.t("flie.messages.no_fpxies")]
+            else
+              derez_answer = Aos::S.p.select(
+                Aos::Os::PS1.to_s + I18n.t("flie.messages.derez_menu"),
+                ([[:cancel, Aro::Mancy::O]] + you.fpxies.map{|f| [f.cmd, f.id]}).to_h,
+                default: Aro::Mancy::S
+              )
+              unless derez_answer == Aro::Mancy::O
+                you.fpxies.find_by(id: derez_answer)&.destroy
+                you.reload
+                self.instance.display_lines = [I18n.t("flie.messages.fpxy_derez_success")]
+              end
+            end
+          when Aos::Flie::PXY_CMDS[:HELP]
+            Aos::Flie.flie
+          when Aos::Flie::PXY_CMDS[:EXIT]
+            self.instance.pxy_running = false
+          end
+
+          Aos::Os.instance.render
+        end
+
+        # exit display
+        Aos::Flie.flie
+        self.instance.display_lines += [I18n.t("flie.messages.pxy_exited")]
+      else
+        self.instance.display_lines += [I18n.t("flie.messages.invalid_email")]
+      end
+
+    end
+
+    def self.pxies(email_address)
+      self.instance.get_pxies_for_email_address(email_address)
+    end
+
+    def get_pxies_for_email_address(email_address)
+      you = Aos::You.find_by(name: email_address)
+      return you.fpxies.to_a unless you.nil?
+      return []
+    end
+
+    def self.flie
+      self.instance.display_lines = Aos::Flie.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::Flie.flie
+        return true
+      end
+
+      case args[Aro::Mancy::S].to_sym
+      when Aos::Flie::CMDS[:PXY][:key]
+        Aos::Flie.pxy
+        return true
+      end
+
+      return false
+    end
+
+    def self.base_lines
+      # print flie commands
+      lines = []
+      lines << ""
+      lines << I18n.t("aos.constants.commands")
+      lines += Aos::Vw::Base.lines_for_cmd(Aos::Os::CMDS[:FLIE])
+      lines << I18n.t("aos.constants.subcommands")
+      Aos::Flie::CMDS.keys.each{|k|
+        lines += Aos::Vw::Base.lines_for_cmd(Aos::Flie::CMDS[k])
+      }
+      lines << ""
+
+      lines
+    end
+  end
+end

data/sys/aos/models/agodo.rb

@@ -0,0 +1,95 @@
+=begin
+
+  agodo.rb
+
+  agodo object.
+
+  by i2097i
+
+=end
+
+require :base64.to_s
+
+class Aos::Agodo < ActiveRecord::Base
+  belongs_to :you
+  validate :run_validations
+
+  enum :power, [
+    :off,
+    :on
+  ]
+
+  def godo
+    godos_per_minute = Aro::Mancy::NUMERALS[:LX].to_f / rate.to_f
+    # todo: this is awful
+    if Time.now - updated_at >= godos_per_minute
+      system("#{:aos} #{self.go} #{Aos::Os::YOU_FLAG} #{self.you.name}")
+      system("#{:aos} #{self.do.gsub("_", " ")} #{Aos::Os::YOU_FLAG} #{self.you.name}")
+      system("#{:aos} #{self.home.nil? ? "cd" : self.home} #{Aos::Os::YOU_FLAG} #{self.you.name}")
+      reload.touch
+    end
+  end
+
+  def get_lines
+    [
+      I18n.t(
+        "abot.agodo.display",
+        power: Aos::Agodo::powers[self.power],
+        go: self.go,
+        do: self.do,
+        rate: self.rate,
+        home: self.home.nil? ? "/" : Aos::Os.osify(self.home)
+      )
+    ]
+  end
+
+  private
+
+  def create_you
+    # todo: deal with potential name clashes
+    self.you = Aos::You.create(
+      access: :agodo,
+      pwd: Aos::Os.instance.you.pwd,
+      name: [
+        Aro::T.read_dev_tarot(false),
+        Aro::T.summon_ruby_facot(false),
+        rand(99..999)
+      ].join("_").strip
+    )
+    self.home = self.you.pwd.split("/").last
+    if self.home == Aro::Dom.ethergeist_name
+      self.home = nil
+    end
+    Aro::P.say("spawned agodo named #{you.name}")
+  end
+
+  def run_validations
+    # validate args
+    room_path = Aro::Dom.room_path(self.go)
+    unless !room_path.nil? && !room_path.empty?
+      errors.add(
+        :go,
+        :invalid,
+        message: I18n.t("abot.messages.invalid_go")
+      )
+    end
+
+    # unless errors.empty? && Aos::Os.is_aos_command?(self.do)
+    #   errors.add(
+    #     :do,
+    #     :invalid,
+    #     message: I18n.t("abot.messages.invalid_do")
+    #   )
+    # end
+
+    unless errors.empty? && Aos::Cor.int_valid?(self.rate)
+      errors.add(
+        :rate,
+        :invalid,
+        message: I18n.t("abot.messages.invalid_rate")
+      )
+    end
+
+    create_you if self.you.nil? && errors.empty?
+  end
+end

data/sys/aos/models/fpxy.rb

@@ -0,0 +1,26 @@
+=begin
+
+  fpxy.rb
+
+  aos fpxy object.
+
+  by i2097i
+
+=end
+
+module Aos
+  class Fpxy < ActiveRecord::Base
+    # table_name :fpxies
+    belongs_to :you
+
+    def get_lines
+      [
+        I18n.t(
+          "flie.fpxies.display",
+          you: self.you.name.ljust(Aro::Mancy::NUMERALS[:XIV]),
+          cmd: self.cmd.ljust(Aro::Mancy::NUMERALS[:XXXVII])
+        )
+      ]
+    end
+  end
+end

data/sys/aos/models/ilog.rb

@@ -16,10 +16,10 @@ module Aos
       [
         I18n.t(
           "data.ilogs.display",
-          you: self.you.name,
-          cmd: self.cmd,
+          you: self.you.name.ljust(Aro::Mancy::NUMERALS[:XIV]),
+          cmd: self.cmd.ljust(Aro::Mancy::NUMERALS[:XXXVII]),
           timestamp: self.created_at.strftime(Aos::Os::DATE_FORMAT),
-          pwd: Aos::Os.osify(self.pwd)
+          pwd: Aos::Os.osify(self.pwd).ljust(Aro::Mancy::NUMERALS[:XIV])
         )
       ]
     end

data/sys/aos/models/you.rb

@@ -11,14 +11,21 @@
 module Aos
   class You < ActiveRecord::Base
     has_many :ilogs
+    has_one :agodo
+    has_many :fpxies
+
     before_validation :set_pwd
+    before_create :create_home_directory
     after_update :clear_aos_display
 
     enum :access, [
+      :agodo,
       :user,
       :root,
     ]
 
+    ARO_SRT_FILE = :".aro_srt"
+
     def generate_ilog(cmd)
       ilogs.create(
         pwd: Aos::Os.osify(pwd),
@@ -26,25 +33,70 @@ module Aos
       )
     end
 
+    def fpx
+      {
+        name: self.name,
+        home: self.home,
+        pwd: self.pwd,
+        stream_bytes: File.stat(stream_file).size
+      }
+    end
+
+    def home!
+      h = home
+      Aro::D.say("#{__method__}#{Aos::Os::A}#{h}")
+      update(pwd: h)
+    end
+
+    def home?
+      self.pwd == self.home
+    end
+
+    def home
+      File.join(
+        Aro::Dom::dom_root,
+        Aro::Dom.room_path(root? ? Aro::Dom::COR : Aro::Dom::HOME),
+        root? ? "" : self.name
+      )
+    end
+
     def get_lines
       [
         I18n.t(
           "data.yous.display",
-          name: name,
-          access: Aos::You::accesses[access],
-          pwd: Aos::Os.osify(pwd)
+          name: name&.ljust(Aro::Mancy::NUMERALS[:XIV]),
+          access: access&.ljust(Aro::Mancy::NUMERALS[:XIV]),
+          pwd: Aos::Os.osify(pwd)&.ljust(Aro::Mancy::NUMERALS[:XIV])
         )
       ]
     end
 
+    def stream(lines)
+      File.open(stream_file, "a+") do |aro_srt|
+        aro_srt.write(lines.join("\n"))
+        aro_srt.write("\n")
+      end
+    end
+
     private
 
     def set_pwd
       self.pwd = Dir.pwd if self.pwd.nil?
     end
 
+    def stream_file
+      File.join(self.home, Aos::You::ARO_SRT_FILE.to_s)
+    end
+
+    def create_home_directory
+      return if root? || agodo? || Dir.exist?(File.join(Aro::Dom.room_path(Aro::Dom::HOME), self.name))
+      Aro::Dom.instance.generate_room(Aro::Dom::D::LAYOUT[:HOME], {name: self.name.to_sym})
+    end
+
     def clear_aos_display
-      Aos::Os.instance.display_lines = [Aos::Os.osify(pwd, true)]
+      return unless Aos::Os.instance.you == self || Aos::Os.instance.you_flag == self
+      Aos::Os.instance.display_lines ||= []
+      Aos::Os.instance.display_lines << ">" + Aos::Os.osify(pwd, true)
     end
   end
 end

data/sys/aos/s.rb

@@ -14,7 +14,8 @@ module Aos
   class S < Aro::Prompt
     def self.say(message)
       return unless Aos::S.should_print?
-      Aro::P::p.say(message)
+      # todo: stream this
+      Aos::S.p.say(message)
     end
 
     def self.should_print?

data/sys/aos/vws/base.rb

@@ -12,21 +12,30 @@ module Aos
   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
-        draw([self.name])
+        draw([
+          "the #{self.name} room.",
+          "",
+          "getting directory listing...",
+          "",
+          Aos::Os.instance.get_ls([])
+        ])
       end
 
       def self.draw(body_lines)
         return false unless body_lines.kind_of?(Array)
         lines = []
-        dc = Aro::Config.display_configuration
-        height = dc[:HEIGHT]
+
+        dc = Aos::Cor.discon
         width = dc[:WIDTH]
 
+        if Aro::Dom.in_arodom?
+          lines += get_main_divider(width, true)
+        end
+
         # top vertical margin
         Aos::Vw::Base::MARGIN_V.times do
           lines << get_body_line("")
@@ -37,39 +46,73 @@ module Aos
           lines << get_body_line(line)
         }
 
-        lines += get_aos_display_lines if Aro::Dom.in_arodom?
+        if Aro::Dom.in_arodom?
+          lines += get_aos_display_lines
+        end
 
         # print everything
-        Aos::S.say(lines.join("\n"))
+
+        Aro::Prompt.say(lines)
 
         # explicitly return true
         true
       end
 
+      def self.get_main_divider(width, clock = false)
+        left = "#{Aos::Os::PS1}"
+        if clock
+          left = "#{left}#{get_domain} >"
+        else
+          left = "#{left}v#{Aro::VERSION} >"
+        end
+        right = "< " + (clock ? get_clock : get_display_dimension.strip)
+        lines = []
+        lines << ""
+        lines << left.ljust(width - right.length, "-".to_s) + right
+        lines << ""
+        lines
+      end
+
       def self.get_aos_display_lines
         # current Aos::Os output
+
+        width = Aos::Cor.discon[:WIDTH]
         lines = []
+        Aos::Db.load
+
+        the_you = Aos::Os.instance.you_flag || Aos::Os.instance.you
+        Aro::V.say(Aos::Os.you_name_from_flag_arg)
+        Aro::V.say(the_you.inspect)
+        present_users = Aos::You.order(
+          name: :asc
+        ).where(
+          pwd: the_you.pwd,
+          access: [:agodo, :user]
+        ).map{|y|
+          (the_you == y ? Aos::Os::STAR.to_s : "") +
+          y.name
+        }
+
+        if present_users.any?
+          lines << "[ yous in the room ]".center(width)
+          lines << ("[  " + present_users.join("    ") + "  ]").center(width)
+        end
+        lines << ":you_are_root".center(width) if the_you.root?
+        Aos::Os.instance.display_lines ||= []
         unless Aos::Os.instance.display_lines.empty?
-          dc = Aro::Config.display_configuration
-          width = dc[:WIDTH]
-          lines << "".center(width)
-          display_dim = get_display_dimension
+          lines << ""
           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
+          Aos::Os.instance.display_lines = []
+          lines << ""
         end
-
+        lines += get_main_divider(width)
         lines
       end
 
       def self.get_display_dimension
-        "#{self.get_dt.rjust(Aro::Mancy::V)} :<[#{self.get_dimension}]<"
-      end
-
-      def self.get_dt
-        Aro::T.read_dev_tarot.strip[Aro::Mancy::S..]
+        "#{Aro::T.read_dev_tarot(true).rjust(Aro::Mancy::V)} :<[#{self.get_dimension}]<"
       end
 
       def self.get_dimension
@@ -77,7 +120,7 @@ module Aos
       end
 
       def self.get_domain
-        Aro::Dom.in_arodom? ? Aro::Dom::domain : Aro::Mancy.domain
+        Aro::Mancy.in_aro? ? Aro::Mancy.domain : Aro::Dom.domain
       end
 
       def self.get_clock
@@ -85,7 +128,7 @@ module Aos
       end
 
       def self.viewport_width
-        dc = Aro::Config.display_configuration
+        dc = Aos::Cor.discon
         width = dc[:WIDTH]
         bar_width = (Aos::Vw::Base::BAR.length * Aro::Mancy::OS)
         h_margin_width = (Aos::Vw::Base::MARGIN_H * Aro::Mancy::OS)
@@ -97,7 +140,7 @@ module Aos
         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)
+        just = Aos::Cor.discon[:WIDTH] - (hm_space.length + bar.length)
         (bar + hm_space + (line || "")).ljust(just) + hm_space + bar
       end
 
@@ -111,10 +154,6 @@ module Aos
         lines << ""
         lines
       end
-
-      def self.debug_log(lines)
-        Aro::V.say(lines)
-      end
     end
   end
 end