aro 0.2.1 → 0.2.3

data/locale/en.yml

@@ -4,61 +4,20 @@ en:
     very_important: "VERY IMPORTANT! %{dev_tarot}"
     # VERY IMPORTANT!
 
-    config:
-      aro_env:
-        O_description: "read-only env var for holding O."
-        S_description: "read-only env var for holding S."
-        OS_description: "read-only env var for holding OS."
-        E_description: "read-only env var for holding E."
-        N_description: "read-only env var for holding N"
-        PS1_description: "read-only env var for holding default PS1."
-        NAME_FILE_description: "read-only env var for name file."
-        I2097I_description: "read-only env var for i2097i."
-        YES_description: "read-only env var for 'aroyes'."
-        ALL_description: "read-only env var for 'all'."
-      dimension:
-        description: "selected dimension of aro space."
-        dev_tarot_description: "reads from /dev/tarot device if available."
-        ruby_facot_description: "generated ruby_facot (facade randomness)."
-      format:
-        description: "aro output format."
-        text_description: "show aro responses in text format (default)"
-        json_description: "show aro responses in json format."
-      height_description: "display height. valid range: (${min}-${max})"
-      width_description: "display width. valid range: (${min}-${max})"
-      env:
-        description: "aro run environment."
-        development_description: "basic development logs and features."
-        production_description: "game logging only."
-        test_description: "logging and features tailored for tests."
-      verbose_description: "enable verbose logging in development env."
-      log_aos_db_description: "show aos database transactions."
-      log_aro_db_description: "show aro database transactions"
-      generate: "generating default config file at %{name}."
-      source: "installing ivars from %{name}..."
-      maximum: "max"
-      minimum: "min"
-      possible_values: "possible values"
-      type:
-        bool_description: "true or false."
-        int_description: "a primitive decimal-less numeric."
-        string_description: "a blank-space-terminated string of characters."
-        values_description: "an enumerated type."
-      z_description: "sleep time between attempts to read /dev/tarot. valid range (%{min}-%{max})"
-      z_max_description: "max number of z long sleeps before giving up. valid range (%{min}-%{max})"
     errors:
       header: "%{cmd} says there was a problem."
       invalid_usage: "%{cmd} says you're not supposed to be here."
       missing_args: "%{cmd} says missing required argument(s)."
-      missing_deck: "%{cmd} says no deck selected. use 'aro deck' to select one or 'aro deck new <name>' to create one."
+      missing_teck: "%{cmd} says no teck selected. use 'aro teck' to select one or 'aro teck new <name>' to create one."
       not_in_aro: "%{cmd} says you are not in aro space. that command will not work here."
       not_in_aos: "%{cmd} says you are not in aos space. that command will not work here."
+      not_initialized_dom: "%{cmd} says you need to initialize dom. $ aro dom init <root_username> <root_password>"
       not_initialized: "%{cmd} says you need to initialize aro. run 'aro init' to do so"
     warnings:
-      invalid_order: "the order specified for displaying logs in invalid. using default (desc)."
+      invalid_order: "the order specified for displaying tlogs in invalid. using default (desc)."
     messages:
       choose_card: "choose a card."
-      choose_deck: "choose a deck."
+      choose_teck: "choose a teck."
       confirmation_prompt: "input 'aroyes' to reset %{name}, or enter to cancel (cancel): "
       creating: "creating %{name}..."
       creation_attempt: "attempting to create aro table named %{name}..."
@@ -71,8 +30,8 @@ en:
           $ cd %{name}
 
         see aro --help for usage.
-      deck_created_sucessfully: "%{name} deck created successfully"
-      deck_selected: "%{name} deck selected in the %{room} room."
+      teck_created_sucessfully: "%{name} teck created successfully"
+      teck_selected: "%{name} teck selected in the %{room} room."
       drawing: "drawing a card from %{name}"
       drawing_from_dimension: "in the the %{dimension} dimension..."
       ruby_facot_random: |
@@ -80,12 +39,12 @@ en:
         for more information visit:
           https://github.com/arowmancy/dev_tarot
       history_drawn: "drawn cards"
-      no_decks: |
-        no decks created yet.
+      no_tecks: |
+        no tecks created yet.
 
         use the following command to create one:
 
-          $ aro deck new <deck_name>
+          $ aro teck new <teck_name>
 
         see aro --help for usage.
       showing: "showing %{name} [count:%{count}, order:%{order}]..."
@@ -93,4 +52,4 @@ en:
       replacing_drawn: "replacing all drawn cards to %{name}..."
       resetting: "resetting %{name}'s cards..."
       understood: "%{name} says: 'understood.'"
-      welcome: "welcome.to.the.%{name}."
+      welcome: "summoned %{name}"

data/sys/aos/abot.rb

@@ -0,0 +1,256 @@
+=begin
+
+  abot.rb
+
+  abot.
+
+  by i2097i
+
+=end
+
+module Aos
+  class Abot
+    include Singleton
+
+    attr_accessor :display_lines
+
+    CMDS = {
+      AGODO: {
+        key: :agodo,
+        description: I18n.t("abot.commands.description.agodo"),
+        usage: I18n.t("abot.commands.usage.agodo"),
+      },
+      DEREZ: {
+        key: :derez,
+        description: I18n.t("abot.commands.description.derez"),
+        usage: I18n.t("abot.commands.usage.derez"),
+      },
+      RATE: {
+        key: :rate,
+        description: I18n.t("abot.commands.description.rate"),
+        usage: I18n.t("abot.commands.usage.rate"),
+      },
+      STOP: {
+        key: :stop,
+        description: I18n.t("abot.commands.description.stop"),
+        usage: I18n.t("abot.commands.usage.stop"),
+      },
+      START: {
+        key: :start,
+        description: I18n.t("abot.commands.description.start"),
+        usage: I18n.t("abot.commands.usage.start"),
+      },
+    }
+
+    def self.cron_pid_file
+      return "" if Aro::Dom.dom_root.nil? || Aro::Dom.room_path(:abot).nil?
+      File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:abot), "abot.pid")
+    end
+
+    def self.cron
+      Aro::D.say("abot cron is disabled currently. you can still manage them but they do not run.")
+      not_currently_enabled = true
+      return if not_currently_enabled || File.exist?(Aos::Abot.cron_pid_file)
+
+      abot_pid = fork {
+        log = File.open(File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:abot), "abot.log"), "w+")
+        STDOUT.reopen(log)
+        STDERR.reopen(log)
+        STDOUT.sync = true
+        loop do
+          Aos::Agodo.where(power: :on).each{|a|
+            a.godo
+          }
+          sleep(Aro::Mancy::S)
+        end
+      }
+      Process.detach(abot_pid)
+      File.open(Aos::Abot.cron_pid_file, "w+") do |f|
+        f.write(abot_pid)
+      end
+    end
+
+    def self.terminate
+      if File.exist?(Aos::Abot.cron_pid_file)
+        system("kill -9 #{File.read(Aos::Abot.cron_pid_file)}")
+        FileUtils.rm(Aos::Abot.cron_pid_file)
+      end
+    end
+
+    def self.process_cmd(args)
+      if args[Aro::Mancy::S].nil?
+        Aos::Abot.abot
+        return true
+      elsif CLI::FLAGS[:HELP].include?(args[Aro::Mancy::S].to_sym)
+        self.instance.display_lines = [I18n.t("abot.usage")]
+        return true
+      end
+
+      processed = false
+      # clear display
+      self.instance.display_lines = []
+      case args[Aro::Mancy::S].to_sym
+      when Aos::Abot::CMDS[:AGODO][:key]
+        Aos::Abot.agodo(args)
+        processed = true
+      when Aos::Abot::CMDS[:DEREZ][:key]
+        Aos::Abot.derez(args[Aro::Mancy::OS])
+        processed = true
+      when Aos::Abot::CMDS[:RATE][:key]
+        Aos::Abot.rate(args)
+        processed = true
+      when Aos::Abot::CMDS[:STOP][:key]
+        Aos::Abot.stop(args[Aro::Mancy::OS])
+        processed = true
+      when Aos::Abot::CMDS[:START][:key]
+        Aos::Abot.start(args[Aro::Mancy::OS])
+        processed = true
+      else
+        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
+      end
+
+      return processed
+    end
+
+    def self.abot
+      self.instance.display_lines = Aos::Abot.base_lines
+    end
+
+    # create and list agodos
+    def self.agodo(args)
+      if args[Aro::Mancy::OS].nil?
+        # list agodos
+        self.instance.display_lines = Aos::Abot.agodo_lines
+        return
+      end
+
+      if !args[Aro::Mancy::OS].nil? &&
+        !args[Aro::Mancy::E].nil? &&
+        !args[Aro::Mancy::N].nil?
+        # create mode
+        # abot agodo <go> <do> <rate>
+        arg_go = args[Aro::Mancy::OS]
+        arg_do = args[Aro::Mancy::E]
+        arg_rate = args[Aro::Mancy::N]
+
+        agodo_record = Aos::Agodo.new
+        agodo_record.go = arg_go
+        agodo_record.do = arg_do
+        agodo_record.rate = arg_rate
+        if agodo_record.save
+          self.instance.display_lines << "successfully created an agodo named #{agodo_record.you.name}."
+          self.instance.display_lines += Aos::Abot.agodo_lines
+        else
+          self.instance.display_lines += agodo_record.errors.to_a.map(&:downcase)
+        end
+      else
+        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
+      end
+    end
+
+    # update agodo rate
+    def self.rate(args)
+      agodo_you = Aos::You.find_by(
+        name: args[Aro::Mancy::OS]&.strip&.upcase
+      )
+
+      if !agodo_you.nil? &&
+        Aos::Cor.int_valid?(args[Aro::Mancy::E]&.to_i)
+        agodo_record = agodo_you.agodo
+        agodo_record.update(rate: args[Aro::Mancy::E].to_i)
+        self.instance.display_lines << "#{agodo_record.you.name} rate updated."
+        self.instance.display_lines += Aos::Abot.agodo_lines
+      else
+        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
+      end
+    end
+
+    # destroy an agodo
+    def self.derez(agodo_name)
+      n = agodo_name&.strip&.upcase
+      agodo_you = Aos::You.find_by(name: n)
+      unless agodo_you.nil?
+        self.instance.display_lines << "derezing #{agodo_you.name} agodo."
+        agodo_record = agodo_you.agodo
+        agodo_record&.destroy
+        agodo_you.ilogs.destroy_all
+        agodo_you.destroy
+        requery = Aos::You.find_by(name: n)
+        if requery.nil? && requery&.agodo.nil?
+          self.instance.display_lines << "successfully destroyed #{n} agodo."
+        else
+          self.instance.display_lines << "unable to destroyed the #{n} agodo."
+        end
+      else
+        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
+      end
+    end
+
+    # power off an agodo
+    def self.stop(agodo_name)
+      agodo_you = Aos::You.find_by(
+        name: agodo_name&.strip&.upcase
+      )
+      unless agodo_you.nil?
+        agodo_record = agodo_you.agodo
+        agodo_record.update(power: :off)
+        self.instance.display_lines << "#{agodo_record.you.name} stopped."
+        self.instance.display_lines += Aos::Abot.agodo_lines
+      else
+        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
+      end
+    end
+
+    # power on an agodo
+    def self.start(agodo_name)
+      agodo_you = Aos::You.find_by(
+        name: agodo_name&.strip&.upcase
+      )
+      unless agodo_you.nil?
+        agodo_record = agodo_you.agodo
+        agodo_record.update(power: :on)
+
+        self.instance.display_lines << "#{agodo_record.you.name} started."
+        self.instance.display_lines += Aos::Abot.agodo_lines
+      else
+        self.instance.display_lines = [I18n.t("abot.messages.invalid_agodo_cmd")]
+      end
+    end
+
+    # abot help
+    def self.base_lines
+      # print abot commands
+      lines = []
+      lines << ""
+      lines << I18n.t("aos.constants.commands")
+      lines += Aos::Vw::Base.lines_for_cmd(Aos::Os::CMDS[:ABOT])
+      lines << I18n.t("aos.constants.subcommands")
+      Aos::Abot::CMDS.keys.each{|k|
+        lines += Aos::Vw::Base.lines_for_cmd(Aos::Abot::CMDS[k])
+      }
+      lines << ""
+
+      lines
+    end
+
+    # show agodos
+    def self.agodo_lines(agodos = nil)
+      # list input agodos
+      lines = []
+      lines << ""
+      agodos ||= Aos::Agodo.all
+      unless agodos.any?
+        lines << I18n.t("abot.messages.no_agodos")
+      else
+        lines << I18n.t("abot.messages.listing_agodos")
+        agodos.each{|a|
+          lines += a.you.get_lines
+          lines += a.get_lines
+        }
+      end
+      lines << ""
+
+      lines
+    end
+  end
+end

data/sys/aos/amg.rb

@@ -17,13 +17,13 @@ module Aos
     CMDS = {
       INST: {
         key: :inst,
-        description: I18n.t("aos.amg.commands.description.inst"),
-        usage: I18n.t("aos.amg.commands.usage.inst"),
+        description: I18n.t("amg.commands.description.inst"),
+        usage: I18n.t("amg.commands.usage.inst"),
       },
       INSTUN: {
         key: :instun,
-        description: I18n.t("aos.amg.commands.description.instun"),
-        usage: I18n.t("aos.amg.commands.usage.instun"),
+        description: I18n.t("amg.commands.description.instun"),
+        usage: I18n.t("amg.commands.usage.instun"),
       },
     }
 
@@ -42,51 +42,51 @@ module Aos
       case args[Aro::Mancy::S].to_sym
       when Aos::Amg::CMDS[:INST][:key]
         unless args[Aro::Mancy::OS].nil?
-          lib_name = args[Aro::Mancy::OS]
-          lib = Aos::Lib.find_by(name: lib_name)
-          unless lib.nil?
-            if lib.installed?
-              self.instance.display_lines << "#{lib_name} lib is already installed."
+          ilib_name = args[Aro::Mancy::OS]
+          ilib = Aos::Ilib.find_by(name: ilib_name)
+          unless ilib.nil?
+            if ilib.installed?
+              self.instance.display_lines << I18n.t("amg.messages.already_installed", name: ilib_name)
             else
-              Aos::Amg.install(lib)
-              if lib.reload.installed?
-                self.instance.display_lines << "#{lib_name} installed successfully."
+              Aos::Amg.install(ilib)
+              if ilib.reload.installed?
+                self.instance.display_lines << I18n.t("amg.messages.install_success", name: ilib_name)
                 self.instance.display_lines += self.inst_lines
                 return true
               else
-                self.instance.display_lines << "failed to install #{lib_name}."
+                self.instance.display_lines << I18n.t("amg.messages.install_failure", name: ilib_name)
               end
             end
           else
-            self.instance.display_lines << "could not find #{lib_name} lib."
+            self.instance.display_lines << I18n.t("amg.messages.cannot_locate", name: ilib_name)
           end
         else
-          # list installed libs
+          # list installed ilibs
           Aos::Amg.inst
           return true
         end
       when Aos::Amg::CMDS[:INSTUN][:key]
         unless args[Aro::Mancy::OS].nil?
-          lib_name = args[Aro::Mancy::OS]
-          lib = Aos::Lib.find_by(name: lib_name)
-          unless lib.nil?
-            if lib.available?
-              self.instance.display_lines << "#{lib_name} lib is not installed."
+          ilib_name = args[Aro::Mancy::OS]
+          ilib = Aos::Ilib.find_by(name: ilib_name)
+          unless ilib.nil?
+            if ilib.available?
+              self.instance.display_lines << I18n.t("amg.messages.not_installed", name: ilib_name)
             else
-              Aos::Amg.uninstall(lib)
-              if lib.reload.available?
-                self.instance.display_lines << "#{lib_name} uninstalled successfully."
+              Aos::Amg.uninstall(ilib)
+              if ilib.reload.available?
+                self.instance.display_lines << I18n.t("amg.messages.uninstall_success", name: ilib_name)
                 self.instance.display_lines += self.instun_lines
                 return true
               else
-                self.instance.display_lines << "failed to uninstall #{lib_name}."
+                self.instance.display_lines << I18n.t("amg.messages.uninstall_failure", name: ilib_name)
               end
             end
           else
-            self.instance.display_lines << "could not find #{lib_name} lib."
+            self.instance.display_lines << I18n.t("amg.messages.cannot_locate", name: ilib_name)
           end
         else
-          # list available libs
+          # list available ilibs
           Aos::Amg.instun
           return true
         end
@@ -95,18 +95,18 @@ module Aos
       return false
     end
 
-    def self.load(lib)
-      Aos::Lib.find_or_create_by(name: lib)
+    def self.load(ilib_name)
+      Aos::Ilib.find_or_create_by(name: ilib_name)
     end
 
-    def self.install(lib)
-      return unless lib.kind_of?(Aos::Lib)
-      lib.installed!
+    def self.install(ilib)
+      return unless ilib.kind_of?(Aos::Ilib)
+      ilib.installed!
     end
 
-    def self.uninstall(lib)
-      return unless lib.kind_of?(Aos::Lib)
-      lib.available!
+    def self.uninstall(ilib)
+      return unless ilib.kind_of?(Aos::Ilib)
+      ilib.available!
     end
 
     def self.inst
@@ -137,20 +137,15 @@ module Aos
     end
 
     def self.inst_lines
-      # list installed libs
+      # list installed ilibs
       lines = []
       lines << ""
-      installed_libs = Aos::Lib.where(status: :installed)
-      unless installed_libs.any?
-        lines << I18n.t("aos.amg.lib.none_installed")
+      installed_ilibs = Aos::Ilib.where(status: :installed)
+      unless installed_ilibs.any?
+        lines << I18n.t("amg.messages.none_installed")
       else
-        lines << I18n.t("aos.amg.lib.listing_installed")
-        installed_libs.each_with_index{|lib, i|
-          lines << "[#{i + Aro::Mancy::S} of #{Aos::Lib.count}]"
-          lines << "name: #{lib.name}"
-          lines << "path: " + lib.so_path.split("/").last(Aro::Mancy::N).join("/")
-          lines << "usage: #{lib.usage}"
-        }
+        lines << I18n.t("amg.messages.listing_installed")
+        lines += Aos::Amg.ilib_lines(installed_ilibs)
       end
       lines << ""
 
@@ -158,25 +153,32 @@ module Aos
     end
 
     def self.instun_lines
-      # list installed libs
+      # list installed ilibs
       lines = []
       lines << ""
-      available_libs = Aos::Lib.where(status: :available)
-      unless available_libs.any?
-        lines << I18n.t("aos.amg.lib.none_available")
+      available_ilibs = Aos::Ilib.where(status: :available)
+      unless available_ilibs.any?
+        lines << I18n.t("amg.messages.none_available")
       else
-        lines << I18n.t("aos.amg.lib.listing_available")
-        available_libs.each_with_index{|lib, i|
-          lines << "[#{i + Aro::Mancy::S} of #{Aos::Lib.count}]"
-          lines << "name: #{lib.name}"
-          lines << "path: " + lib.so_path.split("/").last(Aro::Mancy::N).join("/")
-          lines << "usage: #{lib.usage}"
-        }
+        lines << I18n.t("amg.messages.listing_available")
+        lines += Aos::Amg.ilib_lines(available_ilibs)
       end
       lines << ""
 
       lines
     end
 
+    def self.ilib_lines(ilibs)
+      lines = []
+      ilibs.each_with_index{|ilib, i|
+        lines << "[#{i + Aro::Mancy::S} of #{ilibs.count}]"
+        lines << I18n.t("amg.messages.ilib_name", name: ilib.name)
+        lines << I18n.t("amg.messages.ilib_path", path: ilib.so_path.split("/").last(Aro::Mancy::N).join("/"))
+        lines << I18n.t("amg.messages.ilib_usage", usage: ilib.usage)
+      }
+
+      lines
+    end
+
   end
 end