aro 0.1.5 → 0.1.7

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/version.rb

@@ -1,4 +0,0 @@
-module Aro
-  VERSION = :"0.1.5"
-  RELEASE_NOTES = :"fix issue with config loading"
-end

data/lib/aro.rb

@@ -1,42 +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
-
-    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,287 +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(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) || []
-
-    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
-        dev_tarot = Aro::Deck.read_dev_tarot&.strip&.split("")
-      end
-      
-      unless dev_tarot.nil?
-        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
-        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

data/lib/models/log.rb

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