aro 0.1.9 → 0.2.0

data/locale/en.usage.yml

@@ -32,7 +32,7 @@ en:
             set
               sets an ivar to a specified value. the aro var prefix can be omitted.
 
-                $ config set <var_name> <var_value>
+                $ aro config set <var_name> <var_value>
 
         deck
           manage decks in the current room.
@@ -101,16 +101,10 @@ en:
               shuffles the current deck and generates a log record.
 
         dom
-          create or manage an arodome (ex: list game rooms)
+          arodom management.
 
           $ aro dom <commands>
 
-            note: passing no arguments displays the main dom.
-
-              example
-
-                $ aro dom
-
           SUBCOMMANDS
             init
               generate the arodome

data/locale/en.yml

@@ -32,6 +32,8 @@ en:
         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"
@@ -56,6 +58,7 @@ en:
       invalid_order: "the order specified for displaying logs in invalid. using default (desc)."
     messages:
       choose_card: "choose a card."
+      choose_deck: "choose a deck."
       confirmation_prompt: "input 'aroyes' to reset %{name}, or enter to cancel (cancel): "
       creating: "creating %{name}..."
       creation_attempt: "attempting to create aro table named %{name}..."

data/sys/aos/aos.rb

@@ -13,31 +13,23 @@ 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
+      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
+  def self.process
+    cmd = ARGV.join(" ")
+    Aro::D.say("processing cmd #{cmd}...")
+    Aos::Os::instance.process_cmd(cmd)
   end
 
   class Os
     include Singleton
 
-    attr_accessor :you, :running, :view
+    attr_accessor :you, :running, :view, :db
 
     A = :"@"
     STAR = :"*"
@@ -84,101 +76,168 @@ module Aos
       },
     }
 
-    def self.boot(you)
-      self.instance.you = you
-      self.instance.load_view
+    def initialize
+      if Aro::Dom.in_arodom? && !Aro::Dom.is_initialized?
+        Aro::Dom.new.generate
+      end
+      @db = Aos::Db.new
+      load_you
+    end
+
+    def load_you
+      @you = Aos::You.where(name: :you).first
+      @you = Aos::You.create(name: :you, pwd: Dir.pwd) if @you.nil?
+      Aro::D.say(@you.inspect)
+    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
+
+      Dir.chdir(@you.pwd) do
+        if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
+          view_cls = Aos::Vi::Game
+        end
+      end
+
+      Aro::D.say("loading view #{view_cls}")
+      @view = view_cls
+    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 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 render
-      return if view.nil?
-      Dir.chdir(you.pwd) do
-        view.show(you)
+      load_view
+      return if @view.nil?
+      Dir.chdir(@you.reload.pwd) do
+        if Aro::Mancy.in_aro? && Aro::Mancy.is_initialized?
+          system(:aro.to_s)
+        else
+          @view.show(@you)
+        end
       end
     end
 
-    def run
-      # run loop exit condition
-      self.running = true
+    def process_cmd(cmd)
+      Dir.chdir(@you.reload.pwd) do
+        passthrough = main(cmd)
+        if CLI::Config.is_format_text?
+          IO.console.goto(Aro::Mancy::O, Aro::Mancy::O)
+        end
+        if passthrough
+          system(cmd)
+          Aos::S.say("\n")
+        else
+          render
+        end
+      end
 
-      # set aos pwd
-      Dir.chdir(you.pwd)
+      CLI::EXIT_CODES[:SUCCESS]
+    end
 
+    def confgiure_readline
       # 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)}/)
+        Dir[@you.pwd + str + Aos::Os::STAR.to_s].grep(/^#{Regexp.escape(str)}/)
       }
+    end
 
-      # 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)
+    def run
+      # run condition
+      @running = true
+
+      original_stdout = $stdout
+      $stdout = StringIO.open do |out|
+        cmd = nil
+        loop do
+          # erase before cursor
+          IO.console.erase_screen(Aro::Mancy::S)
+          process_cmd(cmd)
+          IO.console.goto(CLI::Config.display_config[:HEIGHT], Aro::Mancy::O)
+          break unless @running && cmd = Readline.readline(calc_ps1, true)
         end
 
-        Aos::S.say(system(cmd)) if passthrough
+        out
       end
 
       CLI::EXIT_CODES[:SUCCESS]
+    ensure
+      $stdout = original_stdout
     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
+    def main(cmd)
+      # begin game loop
+      return false if cmd.nil?
 
-      Aro::D.say("loading view #{view_cls}")
-      self.view = view_cls
-    end
+      # get args
+      args = cmd.split(" ")
+      return false if args[0].nil?
+      return false if args[0] == :aos.to_s
 
-    def calc_ps1
-      you_pwd = Aos::Os::osify(you.pwd)
-      "#{Aos::Os::PS1}#{you_pwd.empty? ? "" : "#{you_pwd}:"}$ "
-    end
+      # reconfigure for updates to pwd
+      # todo: not working for tab completion
+      confgiure_readline
 
-    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("/")
+      args = handle_aro_override(args)
+
+      passthrough = !Aos::Os.is_aos_command?(args[Aro::Mancy::O]) ||
+        args.include?(:aos.to_s)
+
+      return false if handle_room_path(args[Aro::Mancy::O])
+
+      # set aos pwd
+      unless passthrough
+        Dir.chdir(@you.pwd) do
+          # process commands
+          case args[Aro::Mancy::O].to_sym
+          when Aos::Os::CMDS[:CONFIG][:key]
+            # config
+            passthrough = 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
+            passthrough = true
+            handle_exit(args)
+          when Aos::Os::CMDS[:CD][:key]
+            # cd
+            handle_cd(args)
+          end
+        end
+      end
+
+      return passthrough
     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)
+    def calc_ps1
+      you_pwd = Aos::Os::osify(@you.pwd)
+      "#{Aos::Os::PS1}" # #{you_pwd.empty? ? "" : "#{you_pwd}:"}$ "
     end
 
     def handle_room_path(arg)
@@ -187,7 +246,7 @@ module Aos
       room_path = Aro::Dom.room_path(arg)
       if !room_path.empty?
         handled = true
-        you.update(pwd: File.join(
+        @you.update(pwd: File.join(
           File.dirname(Aro::Dom.ethergeist_path),
           room_path
         ))
@@ -196,66 +255,59 @@ module Aos
     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}")
+        args = "#{args.join(" ")} #{:aos.to_s}".split(" ")
       end
-      handled
+      args
     end
 
     def handle_config(args)
+      passthrough = false
       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
-          )
-        )
+        passthrough = true
+        CLI::Config.dump_config.each{|l| Aos::S.say(l)}
       else
         CLI::Config.process_config_command(args)
       end
+      passthrough
     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"))
+      Aos::S.say(Dir.glob(File.join(@you.pwd, (args[1] || "") + Aos::Os::STAR.to_s), File::FNM_EXTGLOB).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"))
+      Aos::S.say(Dir.glob(File.join(@you.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)
+      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
+      @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))
+        @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
+          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("/")
+            pwd_arr = @you.pwd.split("/")
             new_pwd = (pwd_arr.first(pwd_arr.length - 1)).join("/")
 
-            you.update(pwd: new_pwd)
+            @you.update(pwd: new_pwd)
           end
         else
           # this particular block needs to be better
@@ -266,12 +318,12 @@ module Aos
             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)
+              @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])
+            new_pwd = File.join(@you.pwd, args[1])
             Aro::V.say("new_pwd: #{new_pwd}")
-            you.update(pwd: new_pwd)
+            @you.update(pwd: new_pwd)
           else
             Aos::S.say("that directory is invalid.")
           end

data/sys/aos/db.rb

@@ -11,12 +11,12 @@
 module Aos
   class Db < Aro::Db
     DATABASE_YML = :"database.yml"
-    SQL_FILE = :"database.sql"
+    SQL_FILE = :"aos.sql"
     SCHEMA_FILE = :"schema.rb"
     MIGRATIONS_DIR = :"db/migrate"
 
     def initialize
-      # ActiveRecord::Base.logger = Logger.new(STDOUT)
+      Aos::Db.configure_logger
       if Aro::Dom.in_arodom?
         set_up_aos
       else
@@ -24,6 +24,14 @@ module Aos
       end
     end
 
+    def self.configure_logger
+      if CLI::Config.ivar(:LOG_AOS_DB).to_s == CLI::Config::BOOLS[:TRUE].to_s
+        ActiveRecord::Base.logger = Logger.new(STDOUT)
+      else
+        ActiveRecord::Base.logger = nil
+      end
+    end
+
     def self.base_aro_dir
       Aro::Dom.ethergeist_path
     end

data/sys/aos/views/base.rb

@@ -13,49 +13,50 @@ require :aro.to_s
 module Aos
   module Vi
     class Base
-      BAR = :"|".to_s
+      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(model)
-        unless Aro::Mancy.game.nil?
-          Aro::Mancy.game.show
-          return
-        end
-
-        # default view
         draw([self.name], model)
       end
 
+      def self.get_json(lines, you = nil)
+        {
+          body: lines,
+          you: you&.to_json,
+          domain: self.get_domain,
+          clock: self.get_clock,
+          dimension: self.get_dimension,
+          dev_tarot: self.get_dt,
+        }
+      end
+
       def self.draw(lines, you = nil)
+        unless CLI::Config.is_format_text?
+          Aos::S.say(self.get_json(lines, you))
+          return true
+        end
+
         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
+        print_aos_div
 
         # 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
+        domain = self.get_domain
+        clock = self.get_clock
         Aos::S.say(
           (
             domain.ljust(half) + self.name.to_s.upcase
@@ -63,54 +64,64 @@ module Aos
         )
 
         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("")
+          Aos::S.say(get_body_line(""))
         end
 
         # yield => print lines
         lines.each{|line|
-          next if printed == max_lines
-
-          printed += Aro::Mancy::S
-          print_regular_line(line)
+          Aos::S.say(get_body_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))
+          Aos::S.say("[#{Aos::Os} v#{Aro::VERSION.to_s}]".center(width))
         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}]<"
+        display_dim = self.get_display_dimension
         Aos::S.say(
           (
-            ">#{domain}>#{Aos::Os::osify(you&.pwd || Dir.pwd)}"
+            ">[#{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
 
+        print_aos_div
         # explicitly return true
         true
       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..]
+      end
+
+      def self.get_dimension
+        (Aro::T.is_dev_tarot? ? Aro::T::DEV_TAROT : Aro::T::RUBY_FACOT)
+      end
+
+      def self.get_domain
+        Aro::Dom.in_arodom? ? Aro::Dom::domain : Aro::Mancy.domain
+      end
+
+      def self.get_clock
+        Time.now.strftime(Aos::Os::DATE_FORMAT)
+      end
+
+      def self.print_aos_div
+        Aro::Mancy::S.times do
+          Aos::S.say("\n")
+          Aos::S.say("".center(CLI::Config.display_config[:WIDTH], "="))
+        end
+      end
+
       def self.viewport_width
         dc = CLI::Config.display_config
         width = dc[:WIDTH]
@@ -120,12 +131,12 @@ module Aos
         (width - (bar_width + h_margin_width))
       end
 
-      def self.print_regular_line(line)
+      def self.get_body_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)
+        (bar + hm_space + (line || "")).ljust(just) + hm_space + bar
       end
 
       def self.lines_for_cmd(cmd)

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

@@ -55,8 +55,8 @@ module Aos
         order_o = model[:order_o]
 
         dc = CLI::Config.display_config
-        width = dc[:WIDTH] = viewport_width
-        divider = dc[:DIVIDER] * viewport_width
+        width = count_n == Aro::Mancy::S ? viewport_width : dc[:WIDTH]
+        divider = dc[:DIVIDER] * width
         lines = []
         lines << "#{deck.name.upcase.center(width)}"
         h_logs.each_with_index{|l, i|
@@ -94,7 +94,9 @@ module Aos
       end
 
       def self.get_display_for_cards(input = [])
-        columns = CLI::Config.display_config[:COLUMNS].to_i
+        columns = Aos::Vi::Base::COL_POW.call(
+          CLI::Config.display_config[:WIDTH].to_i
+        )
         lines = []
         return lines unless input.any?
         card_line = ""

data/sys/aos/you.rb

@@ -10,10 +10,10 @@
 
 module Aos
   class You < ActiveRecord::Base
-    after_commit :update_aos_pwd
+    # after_commit :update_aos_pwd
 
-    def update_aos_pwd
-      Dir.chdir(pwd)
-    end
+    # def update_aos_pwd
+    #   Dir.chdir(pwd)
+    # end
   end
 end

data/sys/aro/db.rb

@@ -16,11 +16,17 @@ module Aro
     MIGRATIONS_DIR = :"db/migrate"
 
     def initialize
-      # ActiveRecord::Base.logger = Logger.new(STDOUT)
+      Aro::Db.configure_logger
       if Aro::Mancy.in_aro?
         setup_local_aro
+      end
+    end
+
+    def self.configure_logger
+      if CLI::Config.ivar(:LOG_ARO_DB).to_s == CLI::Config::BOOLS[:TRUE].to_s
+        ActiveRecord::Base.logger = Logger.new(STDOUT)
       else
-        Aro::P.say(I18n.t("cli.errors.not_in_aro" , cmd: Aro::Mancy::I2097I))
+        ActiveRecord::Base.logger = nil
       end
     end