aro 0.2.5 → 0.2.6

data/sys/aos/data.rb

@@ -1,117 +0,0 @@
-=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 << ""
-      ilogs = Aos::Ilog.all
-      unless ilogs.any?
-        lines << I18n.t("data.messages.no_ilogs")
-      else
-        lines << I18n.t("data.messages.listing_ilogs")
-        ilogs.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

@@ -1,20 +0,0 @@
-class CreateYous < ActiveRecord::Migration[8.1]
-
-  def self.up
-    create_table :yous do |t|
-      t.string :name, null: false
-      t.string :pwd
-      t.integer :access, default: Aro::Mancy::S
-
-      t.timestamps
-
-      t.index :name, unique: true
-    end
-  end
-
-  def self.down
-    remove_index :yous, :name
-    drop_table :yous
-  end
-
-end

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

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/migrate/1765933985_create_agodos.rb

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,105 +0,0 @@
-=begin
-
-  db.rb
-
-  database for aos.
-
-  by i2097i
-
-=end
-
-module Aos
-  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 self.load(password = nil)
-      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 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
-      end
-    end
-
-    def self.base_aro_dir
-      File.join(Aro::Dom.dom_root, Aro::Dom.room_path(:data))
-    end
-
-    def db_config_filepath
-      # intentionally using Aro::Db::DATABASE_YML here
-      @db_config_filepath = File.join(Aos::Db.base_aro_dir, Aro::Db::DATABASE_YML.to_s)
-    end
-
-    def set_up_aos(password)
-      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)
-      end
-
-      unless File.exist?(db_config_filepath)
-        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: Aro::Dom.ethergeist_name,
-              password: password,
-              pool: Aos::Os::DB_POOL
-            }.to_yaml)
-          end
-        else
-          Aro::D.say("unable to create database without root password.")
-        end
-      end
-
-      if File.exist?(db_config_filepath)
-        connect
-        migrate
-      else
-        Aro::D.say("unable to set up database without root password.")
-      end
-    end
-
-    def connect
-      ActiveRecord::Base.establish_connection(
-        YAML.load_file(db_config_filepath)
-      )
-    end
-
-    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[Reiquire::GEM_PATH || '.'].first
-        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|
-        Pathname.new(n).basename.to_s.split("_")[0].to_i
-      }.max
-      ActiveRecord::MigrationContext.new(local_migrate_dir).migrate(migration_version)
-
-      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
-    end
-  end
-end

data/sys/aos/flie.rb

@@ -1,144 +0,0 @@
-=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

@@ -1,103 +0,0 @@
-=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
-
-  def create_home_directory
-    Aro::Dom.instance.generate_agodo_home(self)
-  end
-
-  def home
-    File.join(Aro::Dom.room_path(Aro::Dom::ABOT), Aos::Abot::AGODOS_DIR.to_s, self.you.name)
-  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

@@ -1,26 +0,0 @@
-=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/ilib.rb

@@ -1,46 +0,0 @@
-=begin
-
-  ilib.rb
-
-  aos ilib object.
-
-  by i2097i
-
-=end
-
-# installed lib modules section
-
-module CRS
-  SO_FILE = :"libcrs.so".to_s
-  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
-end
-
-# installed lib modules section
-
-class Aos::Ilib < ActiveRecord::Base
-  before_create :set_so_path
-
-  enum :status, [
-    :available,
-    :installed,
-  ]
-
-  def usage
-    # todo: each ffi lib should expose a 'usage' method
-    CRS.hello.strip
-  end
-
-  private
-
-  def set_so_path
-    # todo make configurable for other modules
-    self.so_path = CRS::SO_PATH
-  end
-end

data/sys/aos/models/ilog.rb

@@ -1,27 +0,0 @@
-=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.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).ljust(Aro::Mancy::NUMERALS[:XIV])
-        )
-      ]
-    end
-  end
-end