aro 0.1.6 → 0.1.8

data/bin/cli/deck.rb

@@ -1,100 +0,0 @@
-=begin
-  
-  deck.rb
-
-  process deck commands.
-
-  by i2097i
-
-=end
-
-module CLI
-  def self.deck
-    action = CLI::ARGV1&.upcase&.to_sym
-
-    if CLI::FLAGS[:HELP].include?(CLI::ARGV1)
-      CLI::usage
-      exit(CLI::EXIT_CODES[:SUCCESS])
-    elsif CLI::ARGV1.nil?
-      # no args, open deck menu
-      Aro::Create.new(Aro::Db.get_name_from_namefile)
-      Aro::Deck.display_selection_menu
-    elsif action == CLI::CREATE_DECK_ACTIONS[:CREATE]
-      CLI::Aroface.exit_error_missing_args! if CLI::ARGV2.nil?
-      deck = Aro::Deck.make(CLI::ARGV2.to_s)
-      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)    
-      if Aro::Mancy.game.nil?
-        Aro::P.say(I18n.t("cli.errors.missing_deck"))
-        exit(CLI::EXIT_CODES[:GENERAL_ERROR])
-      end
-
-      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.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.to_s != 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.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
-
-  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
-
-      {
-        count_n: show_options_count,
-        order_o: show_options_order
-      }
-    end
-
-  end
-end

data/bin/cli.rb

@@ -1,39 +0,0 @@
-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/lib/aro/c.rb

@@ -1,32 +0,0 @@
-module Aro
-  DIRS = {
-    ARO: Proc.new{Aro::IS_TEST.call ? ".aro_test" : ".aro"},
-  }
-
-  AROYES = :aroyes
-
-  NUMERALS = {
-    O:    0,
-    I:    1,
-    II:   2,
-    III:  3,
-    IV:   4,
-    V:    5,
-    VI:   6,
-    VII:  7,
-    VIII: 8,
-    IX:   9,
-    X:    10,
-    XI:   11,
-    XII:  12,
-    XIII: 13,
-    XIV:  14,
-    XV:   15,
-    XVI:  16,
-    XVII: 17,
-    XVIII:18,
-    XIX:  19,
-    XX:   20,
-    XXI:  21,
-  }
-end

data/lib/aro/create.rb

@@ -1,29 +0,0 @@
-module Aro
-  class Create
-    attr_accessor :initialized
-
-    def initialize(name)
-      self.initialized = false
-
-      if !name.nil? && (
-        name.kind_of?(String) ||
-        name.kind_of?(Symbol)
-      )
-        # explicitly only allow String/Symbol types for name
-        name = name.to_s.strip
-
-        # 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 database
-        Aro::Db.new(name) 
-        self.initialized = true       
-      end
-    end
-
-  end
-end

data/lib/aro/db.rb

@@ -1,107 +0,0 @@
-require :active_record.to_s
-require :base64.to_s
-require :yaml.to_s
-require :fileutils.to_s
-
-module Aro
-  class Db
-    CONFIG_FILE = "database.yml"
-    SQL_FILE = "database.sql"
-    SCHEMA_FILE = "schema.rb"
-    MIGRATIONS_DIR = "db/migrate"
-
-    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::Mancy.is_aro_dir?
-        # pwd is in aro directory, use name file
-        name = get_name_from_namefile
-      elsif !name.nil? && !Aro::Mancy.is_aro_dir?
-        # first use, pwd is not in aro directory yet
-        echo_cmd = "echo #{name} >> #{name}/#{Aro::Mancy::NAME_FILE}"
-        Aro::P.say("#{echo_cmd} (result: #{system(echo_cmd)})")
-      end
-
-      if name.nil?
-        # if name is still nil, need to use create to generate aro directory
-        raise "invalid aro directory. use `aro create` to generate one"
-      end
-
-      setup_local_aro(name)
-    end
-
-    def connect(name)
-      ActiveRecord::Base.establish_connection(config(name))
-    end
-
-    def config(name = nil)
-      @config ||= YAML.load_file(db_config_filepath(name))
-    end
-
-    def self.base_aro_dir(name)
-      "#{Aro::Mancy.is_aro_dir? ? "." : name}/#{Aro::DIRS[:ARO].call}"
-    end
-
-    def db_config_filepath(name)
-      "#{Aro::Db.base_aro_dir(name)}/#{CONFIG_FILE}"
-    end
-
-    def db_filepath(name)
-      "#{Aro::Db.base_aro_dir(name)}/#{SQL_FILE}"
-    end
-
-    def self.get_name_from_namefile
-      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?(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 #{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::Db.base_aro_dir(name)}/#{SQL_FILE}",
-        username: name,
-        password: name
-      }.to_yaml
-      File.open(db_config_filepath(name), "w") do |file|
-        file.write(c)
-      end
-
-      connect(name)
-      setup(name)
-    end
-
-    def setup(name)
-      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 #{Aro::Db.base_aro_dir(name)}"
-        Aro::P.say(cp_cmd)
-        system(cp_cmd)
-      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)
-      require 'active_record/schema_dumper'
-      filename = "#{Aro::Db.base_aro_dir(name)}/#{SCHEMA_FILE}"
-      File.open(filename, "w+") do |f|
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, f)
-      end
-    end
-  end
-end

data/lib/aro/environment.rb

@@ -1,3 +0,0 @@
-module Aro
-  IS_TEST = Proc.new{ENV[:ARO_ENV.to_s] == :test.to_s}
-end

data/lib/aro/i18n.rb

@@ -1,12 +0,0 @@
-require :i18n.to_s
-
-module Aro
-  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_DIR}/*.yml"]
-  I18n.default_locale = :en
-end

data/lib/aro/prompt.rb

@@ -1,25 +0,0 @@
-require :"tty-prompt".to_s
-
-module Aro
-  class P
-    include Singleton
-
-    attr_accessor :prompt
-
-    def initialize
-      self.prompt = TTY::Prompt.new
-    end
-
-    def self.p
-      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
-  end
-end

data/lib/aro/version.rb

@@ -1,4 +0,0 @@
-module Aro
-  VERSION = :"0.1.6"
-  RELEASE_NOTES = :"fix issue with corrupt card data."
-end

data/lib/aro.rb

@@ -1,45 +0,0 @@
-# require aro directories
-[
-  :aro,
-  :models,
-].each{|dir|
-  Dir[File.join(
-    __dir__,
-    dir.to_s,
-    :"**/*.rb".to_s
-  )].each { |file| require file}
-}
-
-module Aro
-  class Mancy
-    include Singleton
-
-    attr_accessor :game
-
-    O = 0
-    S = 1
-    N = 4
-    OS = 2
-    PS1 = Aro::Mancy.name
-    NAME_FILE = :".name".to_s
-    I2097I = :i2097i
-
-    def initialize
-      Aro::Create.new(Aro::Db.get_name_from_namefile)
-      self.game = Aro::Deck.current_deck
-    end
-
-    def self.game
-      Mancy.instance.game
-    end
-
-    def self.is_aro_dir?
-      File.exist?(Aro::Mancy::NAME_FILE)
-    end
-  end
-end
-
-# TODO: this doesn't work
-# require :"active_support/time_with_zone".to_s
-# TODO: this doesn't work
-  # Time.zone = ActiveSupport::TimeZone[Time.now.gmtoff].tzinfo.name

data/lib/models/deck.rb

@@ -1,294 +0,0 @@
-require :base64.to_s
-require_relative :"./log".to_s
-
-class Aro::Deck < ActiveRecord::Base
-  has_many :logs
-
-  DECK_FILE = ".deck"
-  CARD_DELIM = ","
-  DEV_TAROT_FILE = "/dev/tarot"
-
-  # update this for # of cards you will draw
-  DRAW_COUNT = 7
-  
-  # do not modify
-  DISPLAY_WIDTH = Aro::Deck::DRAW_COUNT*Aro::Deck::DRAW_COUNT
-  HISTORY_SEPARATOR = "#{"-" * Aro::Deck::DISPLAY_WIDTH}"
-  
-  # change to update how timestamps appear
-  DATE_FORMAT = "%Y:%m:%d:%H:%M:%S"
-
-  before_create :populate_cards
-  after_commit :generate_log
-
-  def self.make(new_name)
-    Aro::Create.new(new_name)
-    new_deck = Aro::Deck.create(name: new_name)
-    if Aro::Deck.current_deck.nil?
-      File.open(Aro::Deck::DECK_FILE, "w") do |file|
-        file.write(new_deck.id)
-      end
-    end
-    new_deck
-  end
-
-  def self.fresh_cards
-    I18n.t("cards.index").map{|c| "+#{c}"}.join(Aro::Deck::CARD_DELIM)
-  end
-
-  def populate_cards
-    self.cards = Aro::Deck.fresh_cards
-  end
-
-  def generate_log
-    prev_cards = Base64::decode64(logs.last.card_data) if logs.any?
-    if prev_cards.present? && prev_cards != cards || prev_cards.nil?
-      logs.create(
-        card_data: Base64::encode64(cards),
-        drawn_data: Base64::encode64(drawn || "")
-      )
-    end
-  end
-
-  def self.display_selection_menu
-    unless Aro::Deck.any?
-      Aro::P.say(I18n.t("cli.messages.no_decks"))
-      exit(CLI::EXIT_CODES[:SUCCESS])
-    end
-
-    selection = Aro::P.p.select("choose a deck:") do |menu|
-      Aro::Deck.all.each{|d|
-        if d.id == Aro::Deck.current_deck&.id
-          menu.default d.id
-        end
-        menu.choice(d.name, d.id)
-      }
-    end
-    File.open(Aro::Deck::DECK_FILE, "w") do |file|
-      file.write(selection)
-    end
-  end
-
-  def self.current_deck
-    if File.exist?(DECK_FILE)
-      current_deck_id = File.read(DECK_FILE)
-      return Aro::Deck.find_by(id: current_deck_id)
-    end
-  end
-
-  def self.card_strip(card)
-    card.gsub(/[+-]/, "").strip
-  end
-
-  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"
-    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 += "#{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)
-      )
-      h_text += Aro::Deck::HISTORY_SEPARATOR + "\n"
-      
-      drawn_cards = Base64::decode64(l.drawn_data).split(Aro::Deck::CARD_DELIM)
-
-      if !drawn_cards.nil? && drawn_cards.any?
-        h_text += I18n.t("cli.messages.history_drawn").center(Aro::Deck::DISPLAY_WIDTH) + "\n"
-        h_text += Aro::Deck::HISTORY_SEPARATOR + "\n\n"
-        h_text += get_display_for_cards(
-          drawn_cards
-        )
-        h_text += "\n"
-        h_text += Aro::Deck::HISTORY_SEPARATOR + "\n"
-      end
-
-      3.times do
-        h_text += Aro::Deck::HISTORY_SEPARATOR + "\n"
-      end
-    }
-
-    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)
-    result = ""
-    input.each_with_index{|c, i|
-      if i == I18n.t("cards.index").count - 1
-        result += c.ljust(Aro::Deck::DISPLAY_WIDTH)
-      else
-        result += c.ljust(Aro::Deck::DRAW_COUNT) + ((i + 1) % Aro::Deck::DRAW_COUNT == 0 ? "\n" : "")
-      end
-    }
-    result += "\n"
-    result
-  end
-
-  def explore
-    # allows user to browse each card in the current deck.
-    answer = Aro::P.p.select(
-      I18n.t("cli.messages.choose_card"),
-      # formatted for tty-prompt gem
-      cards.split(Aro::Deck::CARD_DELIM).map{|c| [I18n.t("cards.#{Aro::Deck.card_strip(c)}.name"), c]}.to_h,
-      per_page: 7,
-      cycle: true,
-      default: 1
-    )
-
-    Aro::P.say(I18n.t("cards.#{Aro::Deck.card_strip(answer)}"))
-  end
-
-  def shuffle
-    # shuffles the current deck and generates a log record.
-    update(cards: cards.split(Aro::Deck::CARD_DELIM).shuffle.join(Aro::Deck::CARD_DELIM))
-  end
-
-  def reset
-    # completely reset the deck. replace all drawn and reset order.
-    # all orientations will be set to upright.
-    update(cards: Aro::Deck.fresh_cards, drawn: "")
-  end
-
-  def replace
-    # replaces all drawn cards FIFO and puts them on the bottom of
-    # the deck. this will preserve all card orientations.
-    cards_arr = cards.split(Aro::Deck::CARD_DELIM) || []
-    drawn_arr = drawn&.split(Aro::Deck::CARD_DELIM) || []
-    
-    # append each drawn card to cards
-    drawn_arr.each{|dc| cards_arr << dc }
-
-    # clear drawn
-    update(drawn: "", cards: cards_arr.join(Aro::Deck::CARD_DELIM))
-  end
-
-  # 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(Aro::Mancy::N)}
-    
-    # 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) || []
-
-    sleeps = 0
-    sleeps_max = z_max
-
-    # find a card that is not already drawn
-    while sleeps <= sleeps_max && dev_tarot.nil? do
-      # 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).split("")
-      else
-        # preferred randomness
-        read_value = Aro::Deck.read_dev_tarot&.strip&.split("")
-        if read_value.count >= Aro::Mancy::N - 1
-          dev_tarot = read_value
-        end
-      end
-      
-      unless dev_tarot.nil?
-        abs_dev_tarot = dev_tarot[Aro::Mancy::S] + Aro::NUMERALS.key(
-          dev_tarot.join("")[Aro::Mancy::OS..].to_i
-        ).to_s
-        if abs_cards_arr.include?(abs_dev_tarot)
-          # dev_tarot is valid
-          dev_tarot = dev_tarot[Aro::Mancy::O] + abs_dev_tarot
-        else
-          dev_tarot = nil
-        end
-      end
-
-      if dev_tarot.nil?
-        # dev_tarot is invalid
-        sleeps += 1
-        sleep(z.to_i)
-      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