aro 0.1.7 → 0.1.9

data/sys/aos/aos.rb

@@ -0,0 +1,282 @@
+=begin
+
+  aos.rb
+
+  aos.
+
+  by i2097i
+
+=end
+
+require :aro.to_s
+
+module Aos
+
+  def self.run
+    Aos::Db.new
+    Aos::Os::boot(Aos::you)
+    begin
+      Aos::Os.instance.run
+    rescue Interrupt => e
+      Aos::run
+    end
+  end
+
+  def self.watch
+    Aos::Db.new
+    Aos::Os::boot(Aos::you)
+    Aos::Os::instance.render
+  end
+
+  def self.you
+    you = Aos::You.where(name: :you).first
+    you = Aos::You.create(name: :you, pwd: Dir.pwd) if you.nil?
+    you
+  end
+
+  class Os
+    include Singleton
+
+    attr_accessor :you, :running, :view
+
+    A = :"@"
+    STAR = :"*"
+    PS1 = :">[#{Aos::Os}]>: "
+    DATE_FORMAT = "%A %d %b %Y %I:%M:%S %p"
+
+    CMDS = {
+      CD: {
+        key: :cd,
+        description: I18n.t("aos.commands.description.cd"),
+        usage: I18n.t("aos.commands.usage.cd"),
+      },
+      CONFIG: {
+        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"),
+          }
+        }
+      },
+      EXIT: {
+        key: :exit,
+        description: I18n.t("aos.commands.description.exit"),
+        usage: I18n.t("aos.commands.usage.exit"),
+      },
+      LS: {
+        key: :ls,
+        description: I18n.t("aos.commands.description.ls"),
+        usage: I18n.t("aos.commands.usage.ls"),
+      },
+      LL: {
+        key: :ll,
+        description: I18n.t("aos.commands.description.ll"),
+        usage: I18n.t("aos.commands.usage.ll"),
+      },
+      PWD: {
+        key: :pwd,
+        description: I18n.t("aos.commands.description.pwd"),
+        usage: I18n.t("aos.commands.usage.pwd"),
+      },
+    }
+
+    def self.boot(you)
+      self.instance.you = you
+      self.instance.load_view
+    end
+
+    def render
+      return if view.nil?
+      Dir.chdir(you.pwd) do
+        view.show(you)
+      end
+    end
+
+    def run
+      # run loop exit condition
+      self.running = true
+
+      # set aos pwd
+      Dir.chdir(you.pwd)
+
+      # configure Readline
+      # 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[Dir.pwd + str + Aos::Os::STAR.to_s].grep(/^#{Regexp.escape(str)}/)
+      }
+
+      # begin game loop
+      while running && cmd = Readline.readline(calc_ps1, true)
+        next if cmd.nil?
+
+        # get args
+        args = cmd.split(" ")
+
+        next if handle_room_path(args[Aro::Mancy::O]) || handle_aro_override(args)
+
+        passthrough = !is_aos_command?(args[Aro::Mancy::O])
+
+        # process commands
+        case args[Aro::Mancy::O].to_sym
+        when Aos::Os::CMDS[:CONFIG][:key]
+          # config
+          handle_config(args)
+        when Aos::Os::CMDS[:LS][:key]
+          # ls
+          handle_ls(args)
+        when Aos::Os::CMDS[:LL][:key]
+          # ll
+          handle_ll(args)
+        when Aos::Os::CMDS[:PWD][:key]
+          # pwd
+          handle_pwd(args)
+        when Aos::Os::CMDS[:EXIT][:key]
+          # exit
+          handle_exit(args)
+        when Aos::Os::CMDS[:CD][:key]
+          # cd
+          handle_cd(args)
+        end
+
+        Aos::S.say(system(cmd)) if passthrough
+      end
+
+      CLI::EXIT_CODES[:SUCCESS]
+    end
+
+    def load_view
+      view_name = Aos::Os.osify(you.pwd).split("/").last || :dom.to_s
+      view_cls = nil
+      begin
+        view_cls = (Aos::Vi.name + "::#{view_name.capitalize}").constantize
+      rescue
+        view_cls = Aos::Vi::Base
+      end
+
+      Aro::D.say("loading view #{view_cls}")
+      self.view = view_cls
+    end
+
+    def calc_ps1
+      you_pwd = Aos::Os::osify(you.pwd)
+      "#{Aos::Os::PS1}#{you_pwd.empty? ? "" : "#{you_pwd}:"}$ "
+    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 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 handle_room_path(arg)
+      # search for reserved room path
+      handled = false
+      room_path = Aro::Dom.room_path(arg)
+      if !room_path.empty?
+        handled = true
+        you.update(pwd: File.join(
+          File.dirname(Aro::Dom.ethergeist_path),
+          room_path
+        ))
+      end
+      handled
+    end
+
+    def handle_aro_override(args)
+      # run all aro commands in aos context
+      handled = false
+      if args[0].include?(:aro.to_s)
+        # passthrough aro cmd with aos appended
+        handled = true
+        system("#{args.join(" ")} #{:aos.to_s}")
+      end
+      handled
+    end
+
+    def handle_config(args)
+      if args[1].nil?
+        # show settings
+        you.update(pwd:
+          File.join(
+            File.dirname(Aro::Dom.ethergeist_path),
+            Aro::Dom::SETUP.to_s,
+            Aro::Dom::SETTINGS.to_s
+          )
+        )
+      else
+        CLI::Config.process_config_command(args)
+      end
+    end
+
+    def handle_ls(args)
+      Aos::S.say(Dir[File.join(Dir.pwd, (args[1] || "") + Aos::Os::STAR.to_s)].map{|p| "/" + Aos::Os::osify(p)}.join("\n"))
+    end
+
+    def handle_ll(args)
+      Aos::S.say(Dir.glob(File.join(Dir.pwd, (args[1] || "") + Aos::Os::STAR.to_s), File::FNM_DOTMATCH).map{|p| "/" + Aos::Os::osify(p)}.join("\n"))
+    end
+
+    def handle_pwd(args)
+      osified = "/" + Aos::Os::osify(you.pwd)
+      Aos::S.say(osified)
+    end
+
+    def handle_exit(args)
+      Aos::S.say("#{Aos::Os} is exiting...")
+      self.running = false
+    end
+
+    def handle_cd(args)
+      if args[1].nil? || args[1] == "~/"
+        # no arg takes you to arodom root
+        you.update(pwd: File.dirname(Aro::Dom.ethergeist_path))
+      else
+        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}.")
+          else
+            # todo: support dots in paths
+            # this only supports moving one level up
+
+            pwd_arr = you.pwd.split("/")
+            new_pwd = (pwd_arr.first(pwd_arr.length - 1)).join("/")
+
+            you.update(pwd: new_pwd)
+          end
+        else
+          # this particular block needs to be better
+          if args[1][0] == "/"
+            Aro::V.say("handling cd to root (/) arg...")
+            Aro::V.say(Aro::Dom::dom_root)
+            Aro::V.say(args[1][1..])
+            args[1] = args[1][1..]
+            new_pwd = File.join(Aro::Dom.dom_root, args[1])
+            if Dir.exist?(new_pwd)
+              you.update(pwd: new_pwd)
+            end
+          elsif Dir.exist?(args[1]) && args[1] != Aro::Dom::DOT.to_s
+            new_pwd = File.join(you.pwd, args[1])
+            Aro::V.say("new_pwd: #{new_pwd}")
+            you.update(pwd: new_pwd)
+          else
+            Aos::S.say("that directory is invalid.")
+          end
+        end
+      end
+    end
+  end
+end

data/sys/aos/db.rb

@@ -0,0 +1,80 @@
+=begin
+
+  db.rb
+
+  database for aos room.
+
+  by i2097i
+
+=end
+
+module Aos
+  class Db < Aro::Db
+    DATABASE_YML = :"database.yml"
+    SQL_FILE = :"database.sql"
+    SCHEMA_FILE = :"schema.rb"
+    MIGRATIONS_DIR = :"db/migrate"
+
+    def initialize
+      # ActiveRecord::Base.logger = Logger.new(STDOUT)
+      if Aro::Dom.in_arodom?
+        set_up_aos
+      else
+        Aro::P.say(I18n.t("cli.errors.not_in_aro" , cmd: Aro::Dom.name))
+      end
+    end
+
+    def self.base_aro_dir
+      Aro::Dom.ethergeist_path
+    end
+
+    def db_config_filepath
+      File.join(Aos::Db.base_aro_dir, Aos::Db::DATABASE_YML.to_s)
+    end
+
+    def set_up_aos
+      name = Aro::Dom.ethergeist_name
+      return if name.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)
+        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)
+        end
+      end
+
+      connect(name)
+      migrate(name)
+    end
+
+    def migrate(name)
+      local_migrate_dir = File.join(Aos::Db.base_aro_dir, Aos::Db::MIGRATIONS_DIR.to_s)
+      unless Dir.exist?(local_migrate_dir)
+        gem_dir = Dir[Gem.loaded_specs[:aro.to_s]&.full_gem_path || '.'].first
+        FileUtils.cp_r(File.join(gem_dir, "db"), 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, Aos::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/s.rb

@@ -0,0 +1,25 @@
+=begin
+
+  s.rb
+
+  s logger for i2097i.
+
+  by i2097i
+
+=end
+
+require_relative :"../shr/prompt".to_s
+
+module Aos
+  class S < Aro::Prompt
+    def self.say(message)
+      return unless Aos::S.should_print?
+      Aro::P::p.say(message)
+    end
+
+    def self.should_print?
+      true
+    end
+  end
+end
+

data/sys/aos/views/base.rb

@@ -0,0 +1,155 @@
+=begin
+  
+  views/base.rb
+
+  the base view (abstract).
+
+  by i2097i
+
+=end
+
+require :aro.to_s
+
+module Aos
+  module Vi
+    class Base
+      BAR = :"|".to_s
+      MARGIN_V = Aro::Mancy::S
+      MARGIN_H = Aro::Mancy::S
+
+      def self.show(model)
+        unless Aro::Mancy.game.nil?
+          Aro::Mancy.game.show
+          return
+        end
+
+        # default view
+        draw([self.name], model)
+      end
+
+      def self.draw(lines, you = nil)
+        return false unless lines.kind_of?(Array)
+
+        dc = CLI::Config.display_config
+        height = dc[:HEIGHT]
+        width = dc[:WIDTH]
+
+        # lines printed
+        printed = Aro::Mancy::O
+
+        # max printable lines
+        # vertical margins
+        max_lines = height - Aos::Vi::Base::MARGIN_V * Aro::Mancy::OS
+        # footer
+        max_lines = max_lines + Aro::Mancy::S
+
+        # header
+        Aro::Mancy::S.times do |i|
+          printed += Aro::Mancy::OS
+          Aos::S.say("".center(width, dc[:DIVIDER]))
+          printed += Aro::Mancy::OS
+          Aos::S.say("".center(width))
+          Aos::S.say("\n")
+        end
+
+        half = ((width - self.name.length) / Aro::Mancy::OS.to_f).ceil
+        domain = Aro::Dom.in_arodom? ? Aro::Dom::domain : Aro::Mancy.domain
+        clock = Time.now.strftime(Aos::Os::DATE_FORMAT)
+        printed += Aro::Mancy::S
+        Aos::S.say(
+          (
+            domain.ljust(half) + self.name.to_s.upcase
+          ).ljust(width - clock.length) + clock
+        )
+
+        Aro::Mancy::S.times do
+          printed += Aro::Mancy::S
+          Aos::S.say("".center(width, dc[:DIVIDER]))
+        end
+
+        # top vertical margin
+        Aos::Vi::Base::MARGIN_V.times do
+          printed += Aro::Mancy::S
+          print_regular_line("")
+        end
+
+        # yield => print lines
+        lines.each{|line|
+          next if printed == max_lines
+
+          printed += Aro::Mancy::S
+          print_regular_line(line)
+        }
+
+        # fill empty space
+        while printed < max_lines
+          printed += Aro::Mancy::S
+          print_regular_line("")
+        end
+
+        # bottom vertical margin
+        Aos::Vi::Base::MARGIN_V.times do
+          printed += Aro::Mancy::S
+          Aos::S.say("[#{Aos::Os} v#{Aro::VERSION.to_s}]".center(width, :"-".to_s))
+        end
+
+        # footer
+        dimension = (Aro::T.is_dev_tarot? ? Aro::T::DEV_TAROT : Aro::T::RUBY_FACOT)
+        dt = Aro::T.read_dev_tarot.strip[Aro::Mancy::S..]
+        display_dim = "#{dt.rjust(Aro::Mancy::V)} :<[#{dimension}]<"
+        Aos::S.say(
+          (
+            ">#{domain}>#{Aos::Os::osify(you&.pwd || Dir.pwd)}"
+          ).ljust(width - display_dim.length) + display_dim
+        )
+        Aos::S.say("".center(width, dc[:DIVIDER]))
+
+        # debug logging
+        Aro::D.say("invalid printed height: #{height}, printed: #{printed}") if printed != height
+
+        # explicitly return true
+        true
+      end
+
+      def self.viewport_width
+        dc = CLI::Config.display_config
+        width = dc[:WIDTH]
+        bar_width = (Aos::Vi::Base::BAR.length * Aro::Mancy::OS)
+        h_margin_width = (Aos::Vi::Base::MARGIN_H * Aro::Mancy::OS)
+
+        (width - (bar_width + h_margin_width))
+      end
+
+      def self.print_regular_line(line)
+        hm = Aos::Vi::Base::MARGIN_H
+        bar = Aos::Vi::Base::BAR
+        hm_space = " " * Aos::Vi::Base::MARGIN_H
+        just = CLI::Config.display_config[:WIDTH] - (hm_space.length + bar.length)
+        Aos::S.say((bar + hm_space + (line || "")).ljust(just) + hm_space + bar)
+      end
+
+      def self.lines_for_cmd(cmd)
+        just_cmds = Aro::Mancy::NUMERALS[:IX]
+        cmd_lines = []
+        key_proc = Proc.new{|k| "$ #{k}"}
+        desc_proc = Proc.new{|desc| "#{"desc:".rjust(just_cmds)} #{desc}"}
+        usage_proc = Proc.new{|usage| "#{"usage:".rjust(just_cmds)} #{usage}"}
+
+        cmd_lines << key_proc.call(cmd[:key])
+        cmd_lines << desc_proc.call(cmd[:description])
+        cmd_lines << usage_proc.call(cmd[:usage])
+        (cmd[:cmds] || []).each{|k, v|
+          cmd_lines << key_proc.call("#{cmd[:key]} #{v[:key]}")
+          cmd_lines << desc_proc.call(v[:description])
+          cmd_lines << usage_proc.call(v[:usage])
+        }
+
+        cmd_lines
+      end
+
+      def self.debug_log(lines)
+        Aro::V.say(lines)
+      end
+    end
+  end
+end

data/sys/aos/views/dom.rb

@@ -0,0 +1,36 @@
+=begin
+  
+  views/dom.rb
+
+  the dom view.
+
+  by i2097i
+
+=end
+
+require_relative :"./base".to_s
+
+module Aos
+  module Vi
+    class Dom < Aos::Vi::Base
+
+      def self.show(model)
+        lines = []
+        lines << I18n.t("aos.views.dom.title")
+        lines << I18n.t("aos.views.dom.description")
+        lines << ""
+        lines << I18n.t("aos.constants.commands")
+        Aos::Os::CMDS.keys.sort.each{|cmd|
+          lines += lines_for_cmd(Aos::Os::CMDS[cmd])
+        }
+
+        lines << ""
+        lines << I18n.t("aos.views.dom.quick_navigation")
+        lines << ""
+        lines << "  =>  #{Aro::Dom::D.reserved_words.join("  ")}"
+        lines << ""
+        draw(lines, model)
+      end
+    end
+  end
+end

data/sys/aos/views/games/abpps.rb

@@ -0,0 +1,21 @@
+=begin
+
+  views/games/abpps.rb
+
+  the apbbs view.
+
+  by i2097i
+
+=end
+
+require_relative :"./game".to_s
+
+module Aos
+  module Vi
+    class Abpps < Aos::Vi::Game
+      def self.show(model)
+        draw(super, model)
+      end
+    end
+  end
+end

data/sys/aos/views/games/game.rb

@@ -0,0 +1,114 @@
+=begin
+
+  views/games/game.rb
+
+  the game view.
+
+  by i2097i
+
+=end
+
+require_relative :"../../../models/deck".to_s
+require_relative :"../base".to_s
+
+module Aos
+  module Vi
+    class Game < Aos::Vi::Base
+
+      DECK_PARAMS = [
+        :deck,
+        :h_logs,
+        :count_n,
+        :order_o,
+      ]
+
+      def self.show(model)
+        unless Aro::Mancy.game.nil?
+          Aro::Mancy.game.show
+          return
+        end
+
+        lines = []
+        lines << I18n.t("aos.views.game.title").center(viewport_width)
+        lines << I18n.t("aos.views.game.description").center(viewport_width)
+
+        room_def = Aro::Dom::D::WINGS[:GAMES].values.filter{|gr|
+          "#{Aos::Vi.name}::#{gr[:name].to_s.downcase.capitalize}" == self.name
+        }.first
+        unless room_def.nil?
+          lines << I18n.t("aos.views.game.is_the", name: room_def[:name].to_s)
+          lines << I18n.t("aos.views.game.designed_for", description: room_def[:description])
+        end
+
+        draw(lines, model)
+      end
+
+      def self.show_game(model)
+        mk = model.keys
+        dp = Aos::Vi::Game::DECK_PARAMS
+        return nil unless (mk & dp).count == dp.count
+        return nil unless model.values.all?{|v| v != nil}
+
+        deck = model[:deck]
+        h_logs = model[:h_logs]
+        count_n = model[:count_n]
+        order_o = model[:order_o]
+
+        dc = CLI::Config.display_config
+        width = dc[:WIDTH] = viewport_width
+        divider = dc[:DIVIDER] * viewport_width
+        lines = []
+        lines << "#{deck.name.upcase.center(width)}"
+        h_logs.each_with_index{|l, i|
+          lines << divider
+          lines << ""
+          timestamp = l.created_at.strftime(CLI::Config::DATE_FORMAT)
+          of_text = "#{order_o.to_sym == Aro::Log::ORDERING[:DESC] ? deck.logs.count - i : 1 + i} of #{deck.logs.count}"
+          lines << of_text.ljust(width - timestamp.length) + timestamp
+          lines << divider
+          cards = Base64::decode64(l.card_data).split(Aro::Deck::CARD_DELIM.to_s)
+          if !cards.nil? && cards.any?
+            lines << ""
+            lines += self.get_display_for_cards(cards)
+            lines << divider
+          end
+
+          drawn_cards = Base64::decode64(l.drawn_data).split(Aro::Deck::CARD_DELIM.to_s)
+          if !drawn_cards.nil? && drawn_cards.any?
+            lines << ""
+            lines << I18n.t("cli.messages.history_drawn").center(width)
+            lines << divider
+            lines << ""
+            lines += self.get_display_for_cards(
+              drawn_cards
+            )
+            lines << ""
+            lines << divider
+          end
+        }
+        if count_n == Aro::Mancy::S
+          draw(lines)
+        else
+          Aro::P.less(lines.join("\n"))
+        end
+      end
+
+      def self.get_display_for_cards(input = [])
+        columns = CLI::Config.display_config[:COLUMNS].to_i
+        lines = []
+        return lines unless input.any?
+        card_line = ""
+        input.each_with_index{|c, i|
+          s = (i + Aro::Mancy::S) % [Aro::Mancy::S, columns].max
+          card_line += c.ljust(columns)
+          if Aro::Mancy::O == s || i == input.count - Aro::Mancy::S
+            lines << card_line
+            card_line = ""
+          end
+        }
+        lines << ""
+        lines
+      end
+    end
+  end
+end