aro 0.1.2 → 0.1.4

data/bin/cli/deck.rb

@@ -17,63 +17,84 @@ module CLI
       exit(CLI::EXIT_CODES[:SUCCESS])
     elsif CLI::ARGV1.nil?
       # no args, open deck menu
-      Aro::Create.new(Aro::Database.get_name_from_namefile)
+      Aro::Create.new(Aro::Db.get_name_from_namefile)
       Aro::Deck.display_selection_menu
     elsif action == CLI::CREATE_DECK_ACTIONS[:CREATE]
-      Aro::Mancy.exit_error_missing_args! if CLI::ARGV2.nil?
+      CLI::Aroface.exit_error_missing_args! if CLI::ARGV2.nil?
       deck = Aro::Deck.make(CLI::ARGV2.to_s)
-      Aro::P.p.say(I18n.t("cli.messages.deck_created_sucessfully", name: deck.name))
+      Aro::P.say(I18n.t("cli.messages.deck_created_sucessfully", name: Aro::Mancy.game.name))
       Aro::Deck.display_selection_menu
-    elsif CLI::LOAD_DECK_ACTIONS.include?(action)
-      deck = CLI::get_deck
-
-      if action == CLI::LOAD_DECK_ACTIONS[:EXPLORE]
-        deck.explore
-      else
-        # assume shuffle or show, in which case show is always called
-        if action == CLI::LOAD_DECK_ACTIONS[:SHUFFLE]
-          Aro::P.p.say(I18n.t("cli.messages.shuffling", name: deck.name))
-          deck.shuffle
-        elsif action == CLI::LOAD_DECK_ACTIONS[:DRAW]
-          Aro::P.p.say(I18n.t("cli.messages.drawing", name: deck.name))
-          deck.draw
-        elsif action == CLI::LOAD_DECK_ACTIONS[:REPLACE]
-          Aro::P.p.say(I18n.t("cli.messages.replacing_drawn", name: deck.name))
-          deck.replace
-        elsif action == CLI::LOAD_DECK_ACTIONS[:RESET]
-          if Aro::AROYES != Aro::P.p.ask(I18n.t("cli.messages.confirmation_prompt", name: deck.name))
-            Aro::P.p.say(I18n.t("cli.messages.understood", name: deck.name))
-            exit(CLI::EXIT_CODES[:SUCCESS])
-          end
+    elsif CLI::LOAD_DECK_ACTIONS.include?(action)    
+      if Aro::Mancy.game.nil?
+        Aro::P.say(I18n.t("cli.errors.missing_deck"))
+        exit(CLI::EXIT_CODES[:GENERAL_ERROR])
+      end
 
-          Aro::P.p.say(I18n.t("cli.messages.resetting", name: deck.name))
-          deck.reset
+      case action
+      when CLI::LOAD_DECK_ACTIONS[:EXPLORE]
+        Aro::Mancy.game.explore
+        exit(CLI::EXIT_CODES[:SUCCESS])
+      when CLI::LOAD_DECK_ACTIONS[:SHUFFLE]
+        Aro::P.say(I18n.t("cli.messages.shuffling", name: Aro::Mancy.game.name))
+        Aro::Mancy.game.shuffle
+      when CLI::LOAD_DECK_ACTIONS[:DRAW]
+        Aro::P.say(I18n.t("cli.messages.drawing", name: Aro::Mancy.game.name))
+        Aro::P.p.say(I18n.t("cli.messages.drawing_from_dimension", dimension: "#{CLI::Config.var_value_with_suffix(:DIMENSION)}"))
+        Aro::Mancy.game.draw(
+          is_dt_dimension: CLI::Config.var_value_with_suffix(:DIMENSION).to_sym == CLI::Config::DMS[:DEV_TAROT],
+          z_max: CLI::Config.var_value_with_suffix(:Z_MAX).to_i,
+          z: CLI::Config.var_value_with_suffix(:Z)
+        )
+      when CLI::LOAD_DECK_ACTIONS[:REPLACE]
+        Aro::P.say(I18n.t("cli.messages.replacing_drawn", name: Aro::Mancy.game.name))
+        Aro::Mancy.game.replace
+      when CLI::LOAD_DECK_ACTIONS[:RESET]
+        if Aro::AROYES != Aro::P.p.ask(I18n.t("cli.messages.confirmation_prompt", name: Aro::Mancy.game.name))
+          Aro::P.say(I18n.t("cli.messages.understood", name: Aro::Mancy.game.name))
+          exit(CLI::EXIT_CODES[:SUCCESS])
         end
 
-        Aro::P.p.say(I18n.t("cli.messages.showing", name: deck.name))
-        deck.show
+        Aro::P.say(I18n.t("cli.messages.resetting", name: Aro::Mancy.game.name))
+        Aro::Mancy.game.reset
       end
+
+      Aro::Mancy.game.show(**CLI::Deck.shoptions)
     else
       CLI::usage
     end
   end
 
-  def self.get_deck
-    Aro::Create.new(Aro::Database.get_name_from_namefile)
-    deck = nil
-    if CLI::ARGV2.nil?
-      # assume current deck
-      deck = Aro::Deck.current_deck
-    else
-      deck = Aro::Deck.find_by(name: CLI::ARGV2)
-      deck = Aro::Deck.find_by(id: CLI::ARGV2) if deck.nil?
-    end
+  module Deck
+
+    # parse show options
+    def self.shoptions
+      show_options_count = Aro::Log::DEFAULT_COUNT
+      show_options_order = Aro::Log::ORDERING[:DESC]
+      
+      # Aro::P.say("ARGV.map{|a| a.to_sym} => #{ARGV.map{|a| a.to_sym}}")
+      
+      count_option_flags = ARGV.map{|a| a.to_sym} & CLI::FLAGS[:SHOW_COUNT]
+      # Aro::P.say("count_option_flags: #{count_option_flags}")
+      if count_option_flags.any?
+        # get the ARGV index element after flag index
+        show_options_count = ARGV[ARGV.index(count_option_flags.first.to_s) + 1]
+        show_options_count = show_options_count.to_i unless [0, nil].include?(show_options_count&.to_i)
+        # Aro::P.say("show_options_count: #{show_options_count}")
+      end
+
+      order_option_flags = ARGV.map{|a| a.to_sym} & CLI::FLAGS[:SHOW_ORDER]
+      # Aro::P.say("count_option_flags: #{order_option_flags}")
+      if order_option_flags.any?
+        # get the ARGV index element after flag index
+        show_options_order = ARGV[ARGV.index(order_option_flags.first.to_s) + 1].upcase.to_sym
+        Aro::P.say("show_options_order: #{show_options_order}")
+      end
 
-    if deck.nil?
-      Aro::P.p.say(I18n.t("cli.errors.missing_deck", cmd: "#{CLI::ARGV0} #{CLI::ARGV1} #{CLI::ARGV2}"))
-      exit(CLI::EXIT_CODES[:GENERAL_ERROR])
+      {
+        count_n: show_options_count,
+        order_o: show_options_order
+      }
     end
 
-    deck
   end
 end

data/bin/cli.rb

@@ -0,0 +1,39 @@
+require :aro.to_s
+[:cli].each do |dir|
+  Dir[
+    File.join(
+      __dir__,
+      dir.to_s,
+      :"**/*.rb".to_s
+    )
+  ].each { |file| require file}
+end
+
+# set environment variable
+ENV[:ARO_ENV.to_s] = :production.to_s
+# ENV[:ARO_ENV.to_s] = :development.to_s
+
+module CLI
+  if CLI::LOAD_DECK_ACTIONS.keys.map{|k| k.downcase.to_sym}.include?(ARGV[0]&.to_sym)
+    # enable deck shortcut (skip typing deck while in-game)
+    ARGV0 = :deck
+    ARGV1 = ARGV[0]&.to_sym
+    ARGV2 = ARGV[1]&.to_sym
+  else
+    # default
+    ARGV0 = ARGV[0]&.to_sym
+    ARGV1 = ARGV[1]&.to_sym
+    ARGV2 = ARGV[2]&.to_sym
+  end
+
+  class Aroface
+
+    def self.exit_error_missing_args!
+      Aro::P.say(I18n.t("cli.errors.header"))
+      Aro::P.say(I18n.t("cli.errors.missing_args", cmd: "#{CLI::ARGV0} #{CLI::ARGV1} #{CLI::ARGV2}".strip))
+      exit(CLI::EXIT_CODES[:INVALID_ARG])
+    end
+
+  end
+
+end

data/checksums/aro-0.1.4.gem.sha512

@@ -0,0 +1 @@
+5a6af41ca8e0e2eee62a129aca162bc709d5c3ded0c4ec7b6326fa6768d949313f320bd659cf00d5a0056c1adced4898fdd6d9c91c2a79f7d06018cc9cc61ad7

data/lib/aro/create.rb

@@ -1,29 +1,28 @@
 module Aro
   class Create
-    def initialize(name = nil)
-      name = name&.strip
+    attr_accessor :initialized
 
-      error_msg = nil
+    def initialize(name)
+      self.initialized = false
 
-      # is a non-empty string
-      error_msg = I18n.t("cli.errors.missing_args", cmd: "aro create") if name.nil? || !name.kind_of?(String) || name.empty?
+      if !name.nil? && (
+        name.kind_of?(String) ||
+        name.kind_of?(Symbol)
+      )
+        # explicitly only allow String/Symbol types for name
+        name = name.to_s.strip
 
-      # display error and abort
-      unless error_msg.nil?
-        Aro::P.p.say(error_msg)
-        Aro::Mancy.exit_error_missing_args!
-      end
+        # create the new aro directory and database
+        if Aro::Db.get_name_from_namefile.nil? && !Dir.exist?(name)
+          Aro::P.say(I18n.t("cli.messages.no_decks"))
+          create_cmd = "mkdir #{name}"
+          Aro::P.say("#{create_cmd} (result: #{system(create_cmd)})")
+        end
 
-      # create the new aro directory and database
-      if Aro::Database.get_name_from_namefile.nil? && !Dir.exist?(name)
-        Aro::P.p.say(I18n.t("cli.messages.no_decks"))
-        create_cmd = "mkdir #{name}"
-        Aro::P.p.say(create_cmd)
-        system(create_cmd)
+        # create database
+        Aro::Db.new(name) 
+        self.initialized = true       
       end
-
-      # create database
-      Aro::Database.new(name)
     end
 
   end

data/lib/aro/{database.rb → db.rb}

@@ -1,28 +1,27 @@
 require :active_record.to_s
 require :base64.to_s
 require :yaml.to_s
+require :fileutils.to_s
 
 module Aro
-  class Database
+  class Db
     CONFIG_FILE = "database.yml"
     SQL_FILE = "database.sql"
     SCHEMA_FILE = "schema.rb"
     MIGRATIONS_DIR = "db/migrate"
-    NAME_FILE = ".name"
 
     def initialize(name = nil)
       # show queries in stout
       ActiveRecord::Base.logger = Logger.new(STDOUT) if ENV[:ARO_ENV.to_s] == :development.to_s
 
       # generate .name file
-      if name.nil? && Aro::Database.is_aro_dir?
+      if name.nil? && Aro::Mancy.is_aro_dir?
         # pwd is in aro directory, use name file
         name = get_name_from_namefile
-      elsif !name.nil? && !Aro::Database.is_aro_dir?
+      elsif !name.nil? && !Aro::Mancy.is_aro_dir?
         # first use, pwd is not in aro directory yet
-        echo_cmd = "echo #{name} >> #{name}/#{NAME_FILE}"
-        Aro::P.p.say(echo_cmd)
-        system(echo_cmd)
+        echo_cmd = "echo #{name} >> #{name}/#{Aro::Mancy::NAME_FILE}"
+        Aro::P.say("#{echo_cmd} (result: #{system(echo_cmd)})")
       end
 
       if name.nil?
@@ -41,44 +40,39 @@ module Aro
       @config ||= YAML.load_file(db_config_filepath(name))
     end
 
-    def base_aro_dir(name)
-      "#{Aro::Database.is_aro_dir? ? "." : name}/#{Aro::DIRS[:ARO].call}"
+    def self.base_aro_dir(name)
+      "#{Aro::Mancy.is_aro_dir? ? "." : name}/#{Aro::DIRS[:ARO].call}"
     end
 
     def db_config_filepath(name)
-      "#{base_aro_dir(name)}/#{CONFIG_FILE}"
+      "#{Aro::Db.base_aro_dir(name)}/#{CONFIG_FILE}"
     end
 
     def db_filepath(name)
-      "#{base_aro_dir(name)}/#{SQL_FILE}"
-    end
-
-    def self.is_aro_dir?
-      File.exist?(NAME_FILE)
+      "#{Aro::Db.base_aro_dir(name)}/#{SQL_FILE}"
     end
 
     def self.get_name_from_namefile
-      Aro::Database.is_aro_dir? ? File.read(NAME_FILE).strip : nil
+      Aro::Mancy.is_aro_dir? ? File.read(Aro::Mancy::NAME_FILE).strip : nil
     end
 
     def setup_local_aro(name = nil, force = false)
       # create local .aro/ directory
-      unless File.exist?(base_aro_dir(name)) || force
-        if File.exist?(base_aro_dir(name)) && force
-          rm_cmd = "rm -rf #{base_aro_dir(name)}"
-          Aro::P.p.say(rm_cmd)
+      unless File.exist?(Aro::Db.base_aro_dir(name)) || force
+        if File.exist?(Aro::Db.base_aro_dir(name)) && force
+          rm_cmd = "rm -rf #{Aro::Db.base_aro_dir(name)}"
+          Aro::P.say(rm_cmd)
           system(rm_cmd)
         end
 
-        mk_cmd = "mkdir #{base_aro_dir(name)}"
-        Aro::P.p.say(mk_cmd)
-        system(mk_cmd)
+        mk_cmd = "mkdir #{Aro::Db.base_aro_dir(name)}"
+        Aro::P.say("#{mk_cmd} (result: #{system(mk_cmd)})")
       end
 
       # create database config yaml file
       c = {
         adapter: :sqlite3.to_s,
-        database: "#{Aro::Database.is_aro_dir? ? "." : name}/#{Aro::DIRS[:ARO].call}/#{SQL_FILE}",
+        database: "#{Aro::Db.base_aro_dir(name)}/#{SQL_FILE}",
         username: name,
         password: name
       }.to_yaml
@@ -91,11 +85,11 @@ module Aro
     end
 
     def setup(name)
-      local_migrate_dir = "#{base_aro_dir(name)}/#{MIGRATIONS_DIR}"
+      local_migrate_dir = "#{Aro::Db.base_aro_dir(name)}/#{MIGRATIONS_DIR}"
       unless Dir.exist?(local_migrate_dir)
         gem_dir = Dir[Gem.loaded_specs[:aro.to_s]&.full_gem_path || '.'].first
-        cp_cmd = "cp -R #{gem_dir}/db #{base_aro_dir(name)}"
-        Aro::P.p.say(cp_cmd)
+        cp_cmd = "cp -R #{gem_dir}/db #{Aro::Db.base_aro_dir(name)}"
+        Aro::P.say(cp_cmd)
         system(cp_cmd)
       end
 
@@ -104,7 +98,7 @@ module Aro
       }.max
       ActiveRecord::MigrationContext.new(local_migrate_dir).migrate(migration_version)
       require 'active_record/schema_dumper'
-      filename = "#{base_aro_dir(name)}/#{SCHEMA_FILE}"
+      filename = "#{Aro::Db.base_aro_dir(name)}/#{SCHEMA_FILE}"
       File.open(filename, "w+") do |f|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, f)
       end

data/lib/aro/i18n.rb

@@ -1,14 +1,12 @@
-# frozen_string_literal: true
-
 require :i18n.to_s
 
 module Aro
-  # ...
-end
+  LOCALE_DIR = :locale
 
-locale_path = Gem.loaded_specs[:aro.to_s]&.full_gem_path
-if Aro::IS_TEST.call
-  locale_path = Dir.pwd
-end
-I18n.load_path += Dir["#{locale_path}/locale/*.yml"]
-I18n.default_locale = :en
+  locale_path = Gem.loaded_specs[:aro.to_s]&.full_gem_path
+  if Aro::IS_TEST.call
+    locale_path = Dir.pwd
+  end
+  I18n.load_path += Dir["#{locale_path}/#{LOCALE_DIR}/*.yml"]
+  I18n.default_locale = :en
+end

data/lib/aro/prompt.rb

@@ -14,6 +14,10 @@ module Aro
       P.instance.prompt
     end
 
+    def self.say(message)
+      Aro::P::p.say(">[#{Aro::Mancy::PS1}::#{Time.now.to_i}]>: #{message}")
+    end
+
     def self.less(display_text = "")
       IO.popen("less -X", "w") { |f| f.puts display_text }
     end

data/lib/aro/version.rb

@@ -1,4 +1,4 @@
 module Aro
-  VERSION = :"0.1.2"
-  RELEASE_NOTES = :"fixed bug with deck create."
+  VERSION = :"0.1.4"
+  RELEASE_NOTES = :"add multiple config variables, add much improved randomness"
 end

data/lib/aro.rb

@@ -16,20 +16,23 @@ module Aro
 
     attr_accessor :game
 
+    OS = 2
+    PS1 = Aro::Mancy.name
+    NAME_FILE = :".name".to_s
+    I2097I = :i2097i
+
     def initialize
-      Aro::Create.new(Aro::Database.get_name_from_namefile)
+      Aro::Create.new(Aro::Db.get_name_from_namefile)
       self.game = Aro::Deck.current_deck
     end
 
-    def self.exit_error_missing_args!
-      Aro::P.p.say(I18n.t("cli.errors.header"))
-      Aro::P.p.say(I18n.t("cli.errors.missing_args", cmd: "#{CLI::ARGV0} #{CLI::ARGV1} #{CLI::ARGV2}"))
-      exit(CLI::EXIT_CODES[:INVALID_ARG])
-    end
-
     def self.game
       Mancy.instance.game
     end
+
+    def self.is_aro_dir?
+      File.exist?(Aro::Mancy::NAME_FILE)
+    end
   end
 end
 

data/lib/models/deck.rb

@@ -9,7 +9,7 @@ class Aro::Deck < ActiveRecord::Base
   DEV_TAROT_FILE = "/dev/tarot"
 
   # update this for # of cards you will draw
-  DRAW_COUNT = 10
+  DRAW_COUNT = 7
   
   # do not modify
   DISPLAY_WIDTH = Aro::Deck::DRAW_COUNT*Aro::Deck::DRAW_COUNT
@@ -52,7 +52,7 @@ class Aro::Deck < ActiveRecord::Base
 
   def self.display_selection_menu
     unless Aro::Deck.any?
-      Aro::P.p.say(I18n.t("cli.messages.no_decks"))
+      Aro::P.say(I18n.t("cli.messages.no_decks"))
       exit(CLI::EXIT_CODES[:SUCCESS])
     end
 
@@ -76,27 +76,40 @@ class Aro::Deck < ActiveRecord::Base
     end
   end
 
-  def self.read_dev_tarot
-    dt = nil
-    return dt unless File.exist?(Aro::Deck::DEV_TAROT_FILE)
-
-    File.open(Aro::Deck::DEV_TAROT_FILE, "r"){|dtf| dt = dtf.read(4)}
-  end
-
   def self.card_strip(card)
     card.gsub(/[+-]/, "").strip
   end
 
-  def show
-    # displays the current deck's cards in their current order.
-    h_text = I18n.t("cli.messages.history_title", deck: name)
-    h_text += "\n"
+  def show(count_n: Aro::Log::DEFAULT_COUNT, order_o: Aro::Log::ORDERING[:DESC])
+    unless count_n.kind_of?(Numeric) && count_n > 0
+      if count_n&.to_s&.downcase&.to_sym == Aro::Log::ALL
+        count_n = logs.count
+      else
+        count_n = Aro::Log::DEFAULT_COUNT
+      end
+    end
+    count_n = [count_n.to_i, logs.count].min
+
+    unless Aro::Log::ORDERING.include?(order_o&.to_s&.upcase&.to_sym)
+      Aro::P.say(I18n.t("cli.warnings.invalid_order"))
+      order_o = Aro::Log::ORDERING[:DESC]
+    end
+
+    # perform query
+    h_logs = logs.order(created_at: order_o.to_s.downcase).first(count_n)
+
+    # for now tests just expect text output
+    return h_logs if Aro::IS_TEST.call
+
+    Aro::P.say(I18n.t("cli.messages.showing", name: name, count: count_n, order: order_o))
+    
+    h_text = "\n"
     h_text += Aro::Deck::HISTORY_SEPARATOR + "\n\n"
     h_text += "#{name.upcase.center(Aro::Deck::DISPLAY_WIDTH)}\n\n"
-    logs.reverse.each_with_index{|l, i|
+    h_logs.each_with_index{|l, i|
       h_text += Aro::Deck::HISTORY_SEPARATOR + "\n"
       h_text += l.created_at.strftime(Aro::Deck::DATE_FORMAT).center(Aro::Deck::DISPLAY_WIDTH) + "\n"
-      h_text += "#{logs.count - i} of #{logs.count}".rjust(Aro::Deck::DISPLAY_WIDTH) + "\n"
+      h_text += "#{order_o.to_sym == Aro::Log::ORDERING[:DESC] ? logs.count - i : 1 + i} of #{logs.count}".rjust(Aro::Deck::DISPLAY_WIDTH) + "\n"
       h_text += Aro::Deck::HISTORY_SEPARATOR + "\n\n"
       h_text += get_display_for_cards(
         Base64::decode64(l.card_data).split(Aro::Deck::CARD_DELIM)
@@ -112,13 +125,19 @@ class Aro::Deck < ActiveRecord::Base
           drawn_cards
         )
         h_text += "\n"
+        h_text += Aro::Deck::HISTORY_SEPARATOR + "\n"
       end
-    }
 
-    # for now tests just expect text output
-    return h_text if Aro::IS_TEST.call
+      3.times do
+        h_text += Aro::Deck::HISTORY_SEPARATOR + "\n"
+      end
+    }
 
-    Aro::P.less(h_text)
+    if count_n == Aro::Log::DEFAULT_COUNT
+      Aro::P.say(h_text)
+    else
+      Aro::P.less(h_text)
+    end
   end
 
   def get_display_for_cards(input = []) # todo:, print_nums: false)
@@ -145,8 +164,7 @@ class Aro::Deck < ActiveRecord::Base
       default: 1
     )
 
-    # TODO: display this nicer
-    Aro::P.p.say(I18n.t("cards.#{Aro::Deck.card_strip(answer)}"))
+    Aro::P.say(I18n.t("cards.#{Aro::Deck.card_strip(answer)}"))
   end
 
   def shuffle
@@ -173,48 +191,97 @@ class Aro::Deck < ActiveRecord::Base
     update(drawn: "", cards: cards_arr.join(Aro::Deck::CARD_DELIM))
   end
 
-  def draw
-    # draw a random card from the current deck.
+  # read dev_tarot
+  def self.read_dev_tarot
+    dt = nil
+    return dt unless File.exist?(Aro::Deck::DEV_TAROT_FILE)
+
+    File.open(Aro::Deck::DEV_TAROT_FILE, "r"){|dtf| dt = dtf.read(4)}
+    
+    # VERY IMPORTANT!
+    Aro::P.say(I18n.t("cli.very_important", dev_tarot: dt))
+    return dt
+  end
+
+  # summon ruby_facot
+  def summon_ruby_facot(cards_arr)
+    Aro::P.say(I18n.t("cli.messages.ruby_facot_random"))
+    ruby_facot = cards_arr.sample.split("")
+
+    # get orientation
+    ruby_facot_str = ["+","-"].sample
+
+    # get suite
+    ruby_facot_str += ruby_facot[1]
+
+    # calculate the sym
+    symm = ruby_facot.select{|c|
+      # loops through the characters in ruby_facot
+      # return all characters not matching:
+      # => character[0]: orientation
+      # => character[1]: suite 
+
+      # the first two characters in the dev_tarot format designate the
+      !ruby_facot.first(Aro::Mancy::OS).include?(c)
+    }.join("").to_sym
+    ruby_facot_str += Aro::NUMERALS[symm].to_s
+
+    # return ruby_facot_str
+    ruby_facot_str
+  end
+
+  def draw(is_dt_dimension: true, z_max: 7, z: 1)    
+    # the true card
+    abs_dev_tarot = nil
+
+    # oriented card
     dev_tarot = nil
 
+    # get cards
+    cards_arr = cards.split(Aro::Deck::CARD_DELIM) || []
+    # get abs_cards
+    abs_cards_arr = cards_arr.map{|c| Aro::Deck.card_strip(c)}
+    # get drawn
+    drawn_arr = drawn&.split(Aro::Deck::CARD_DELIM) || []
+
+    # use fallback randomness if /dev/tarot unavailable
+    if !is_dt_dimension || !File.exist?(Aro::Deck::DEV_TAROT_FILE)
+      dev_tarot = summon_ruby_facot(cards_arr)
+      abs_dev_tarot = Aro::Deck.card_strip(dev_tarot)
+    end
+
+    sleeps = 0
+    sleeps_max = z_max
+
     # find a card that is not already drawn
-    while dev_tarot.nil? do
+    while sleeps <= sleeps_max && dev_tarot.nil? do
       # preferred randomness
-      dev_tarot = nil # Aro::Deck.read_dev_tarot&.strip&.split("")
-      
-      cards_arr = cards.split(Aro::Deck::CARD_DELIM) || []
-      cards_arr_stripped = cards_arr.map{|c| Aro::Deck.card_strip(c)}
-
-      if dev_tarot.nil?
-        # assume user does not have /dev/tarot device.
-        # generate random facade
-        facade = cards_arr.sample.split("")
-        dev_tarot = (
-          facade.first(2).join("") + 
-          Aro::NUMERALS[
-            facade.select{|c| !facade.first(2).include?(c)}.join("").to_sym
-          ].to_s
-        ).split("")
-      end
-
-      dev_tarot_converted = dev_tarot[1] + Aro::NUMERALS.key(
-        dev_tarot.select{|c| !dev_tarot.first(2).include?(c)}.join("").to_i
-      ).to_s
-      if cards_arr_stripped.include?(dev_tarot_converted)
-        # dev_tarot is valid
-        drawn_arr = drawn&.split(Aro::Deck::CARD_DELIM) || []
-        dev_tarot = dev_tarot[0] + dev_tarot_converted
-        drawn_arr << dev_tarot
-        cards_arr.delete_at(cards_arr_stripped.index(dev_tarot_converted))
-        update(
-          cards: cards_arr.join(Aro::Deck::CARD_DELIM),
-          drawn: drawn_arr.join(Aro::Deck::CARD_DELIM)
-        )
+      dev_tarot = Aro::Deck.read_dev_tarot&.strip&.split("")
+      if dev_tarot.present?
+        abs_dev_tarot = dev_tarot[1] + Aro::NUMERALS.key(
+          dev_tarot.select{|c| !dev_tarot.first(2).include?(c)}.join("").to_i
+        ).to_s
+        if abs_cards_arr.include?(abs_dev_tarot)
+          # dev_tarot is valid
+          dev_tarot = dev_tarot[0] + abs_dev_tarot
+        end
       else
         # dev_tarot is invalid
-        dev_tarot = nil
-        sleep(1)
+        sleeps += 1
+        sleep(z)
       end
     end
+
+    # remove from cards
+    cards_arr.delete(cards_arr.select{|c| c.include?(abs_dev_tarot)}.first)
+
+    # insert dev_tarot to drawn
+    drawn_arr << dev_tarot
+
+    # update database 
+    update(
+      cards: cards_arr.join(Aro::Deck::CARD_DELIM),
+      drawn: drawn_arr.join(Aro::Deck::CARD_DELIM)
+    )
   end
-end
+end

data/lib/models/log.rb

@@ -1,5 +1,12 @@
-require_relative './deck'
+require_relative :"./deck".to_s
 
 class Aro::Log < ActiveRecord::Base
+  ALL = :all
+  DEFAULT_COUNT = 1
+  ORDERING = {
+    ASC: :ASC,
+    DESC: :DESC
+  }
+
   belongs_to :deck, :class_name => :"Aro::Deck".to_s
 end