aro 0.1.6 → 0.1.7

data/sys/models/deck.rb

@@ -0,0 +1,212 @@
+require :base64.to_s
+require_relative :"../shr/t".to_s
+
+class Aro::Deck < ActiveRecord::Base
+  has_many :logs
+
+  DECK_FILE = :".deck"
+  CARD_DELIM = :","
+
+  before_create :populate_cards
+  after_commit :generate_log
+
+  def self.make(new_name)
+    Aro::Db.new
+    new_deck = Aro::Deck.create(name: new_name)
+    if Aro::Deck.current_deck.nil?
+      File.open(Aro::Deck::DECK_FILE.to_s, "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.to_s)
+  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.to_s, "w") do |file|
+      file.write(selection)
+    end
+  end
+
+  def self.current_deck
+    if File.exist?(DECK_FILE.to_s)
+      current_deck_id = File.read(DECK_FILE.to_s)
+      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::Mancy::S, order_o: Aro::Log::ORDERING[:DESC])
+    unless count_n.kind_of?(Numeric) && count_n.to_i > Aro::Mancy::O
+      if count_n&.to_s&.to_sym == Aro::Mancy::ALL
+        count_n = logs.count
+      else
+        count_n = Aro::Mancy::S
+      end
+    end
+    count_n = [[Aro::Mancy::S, count_n.to_i].max, logs.count].min
+    Aro::V.say("count_n: #{count_n}")
+    Aro::V.say("order_o: #{order_o}")
+    unless Aro::Log::ORDERING.values.include?(order_o)
+      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).first(count_n)
+
+    # todo: this is doing more work than it needs to. needs debugging.
+    # Aro::V.say("h_logs.count: #{h_logs.count}")
+
+    # for now tests just expect text output
+    return h_logs if CLI::Config.is_test?
+
+    Aro::P.say(I18n.t("cli.messages.showing", name: name, count: count_n, order: order_o))
+
+    h_text = Aro::Vi::Deck.generate({
+      deck: self,
+      h_logs: h_logs,
+      count_n: count_n,
+      order_o: order_o
+    })
+
+    if count_n == Aro::Mancy::S
+      Aro::Vi::Deck.draw(h_text)
+    else
+      Aro::P.less(h_text)
+    end
+  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.to_s).map{|c| [I18n.t("cards.#{Aro::Deck.card_strip(c)}.name"), c]}.to_h,
+      per_page: Aro::Mancy::NUMERALS[:VII],
+      cycle: true,
+      default: Aro::Mancy::S
+    )
+
+    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.to_s).shuffle.join(Aro::Deck::CARD_DELIM.to_s))
+  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.to_s) || []
+    drawn_arr = drawn&.split(Aro::Deck::CARD_DELIM.to_s) || []
+    
+    # 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.to_s))
+  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.to_s) || []
+    # 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.to_s) || []
+
+    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::T::DEV_TAROT_FILE.to_s)
+        dev_tarot = Aro::T.summon_ruby_facot(cards_arr).split("")
+      else
+        # preferred randomness
+        read_value = Aro::T.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::Mancy::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.to_s),
+      drawn: drawn_arr.join(Aro::Deck::CARD_DELIM.to_s)
+    )
+  end
+end

data/sys/models/log.rb

@@ -0,0 +1,10 @@
+require_relative :"./deck".to_s
+
+class Aro::Log < ActiveRecord::Base
+  ORDERING = {
+    ASC: :asc,
+    DESC: :desc
+  }
+
+  belongs_to :deck, :class_name => :"#{Aro::Deck.name}".to_s
+end

data/sys/reiquire.rb

@@ -0,0 +1,45 @@
+=begin
+  
+  reiquire.rb
+
+  ruby require helpers.
+
+  by i2097i
+
+=end
+
+# dependencies
+require :active_record.to_s
+require :"active_record/schema_dumper".to_s
+require :base64.to_s
+require :fileutils.to_s
+require :i18n.to_s
+require :"tty-prompt".to_s
+require :yaml.to_s
+
+module Reiquire
+  def self.aro
+    locale_path = Gem.loaded_specs[:aro.to_s]&.full_gem_path
+    # if CLI::Config.is_test?
+      # locale_path = Dir.pwd
+    # end
+
+    I18n.load_path += Dir["#{locale_path}/locale/*.yml"]
+    I18n.available_locales = [:en]
+    I18n.default_locale = :en    
+
+    # require all aro folders
+    Reiquire::requires [:aro, :cli, :dom, :models, :shr, :views]
+
+    # require cli module
+    require_relative :"./cli".to_s
+  end
+
+  def self.requires(dirs)
+    dirs.each{|d|
+      Dir[
+        File.join(__dir__, d.to_s, :"**/*.rb".to_s)
+      ].each { |f| require f}
+    }
+  end
+end

data/{lib/aro → sys/shr}/prompt.rb

@@ -1,7 +1,15 @@
-require :"tty-prompt".to_s
+=begin
+  
+  prompt.rb
+
+  base logger for aro.
+
+  by i2097i
+
+=end
 
 module Aro
-  class P
+  class Prompt
     include Singleton
 
     attr_accessor :prompt
@@ -15,7 +23,7 @@ module Aro
     end
 
     def self.say(message)
-      Aro::P::p.say(">[#{Aro::Mancy::PS1}::#{Time.now.to_i}]>: #{message}")
+      raise :override_me.to_s
     end
 
     def self.less(display_text = "")

data/sys/shr/t.rb

@@ -0,0 +1,60 @@
+=begin
+  
+  t.rb
+
+  tarot.
+
+  by i2097i
+
+=end
+
+module Aro
+  module T
+    DEV_TAROT_FILE = :"/dev/tarot"
+
+    RUBY_FACOT = :"Ruby::Facot".to_s
+
+    def self.is_dev_tarot?
+      CLI::Config.ivar(:DIMENSION)&.to_sym == CLI::Config::DMS[:DEV_TAROT]
+    end
+
+    # read dev_tarot
+    def self.read_dev_tarot
+      dt = nil
+      return dt unless File.exist?(Aro::T::DEV_TAROT_FILE.to_s)
+
+      File.open(Aro::T::DEV_TAROT_FILE.to_s, "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 self.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::Mancy::NUMERALS[symm].to_s
+
+      # return ruby_facot_str
+      ruby_facot_str
+    end
+  end
+end

data/sys/shr/version.rb

@@ -0,0 +1,18 @@
+=begin
+  
+  version.rb
+
+  aro version.
+
+  by i2097i
+
+=end
+
+module Aro
+  VERSION = :"0.1.7"
+  RELEASE_NOTES = :"this version".to_s + [
+    "adds views",
+    "adds ivars and ovars",
+    "adds verbose logging",
+  ].join(",")
+end

data/sys/views/base.rb

@@ -0,0 +1,29 @@
+=begin
+  
+  views/base.rb
+
+  the base view (abstract).
+
+  by i2097i
+
+=end
+
+require :aro.to_s
+
+module Aro
+  module Vi
+    class Base
+      def self.generate(model)
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+
+      def self.draw(model)
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+
+      def self.debug_log(model)
+        Aro::V.say(model)
+      end
+    end
+  end
+end

data/sys/views/dom.rb

@@ -0,0 +1,27 @@
+=begin
+  
+  views/dom.rb
+
+  the dom view.
+
+  by i2097i
+
+=end
+
+require_relative :"./base".to_s
+
+module Aro
+  module Vi
+    class Dom < Aro::Vi::Base
+      def self.generate(model)
+        # todo: implement this
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+
+      def self.draw(model)
+        # todo: implement this
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+    end
+  end
+end

data/sys/views/games/deck.rb

@@ -0,0 +1,97 @@
+=begin
+  
+  views/games/deck.rb
+
+  the deck game view.
+
+  by i2097i
+
+=end
+
+require_relative :"../base".to_s
+require_relative :"../../models/deck".to_s
+
+module Aro
+  module Vi
+    class Deck < Aro::Vi::Base
+
+      PARAMS = [
+        :deck,
+        :h_logs,
+        :count_n,
+        :order_o,
+      ]
+
+      def self.generate(model)
+        self.debug_log(model)
+        mk = model.keys
+        dp = Aro::Vi::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]
+        divider = dc[:DIVIDER] * width
+        result = "\n"
+        result += divider + "\n\n"
+        result += "#{deck.name.upcase.center(width)}\n\n"
+        h_logs.each_with_index{|l, i|
+          result += divider + "\n"
+          result += l.created_at.strftime(CLI::Config::DATE_FORMAT).center(width) + "\n"
+          result += "#{order_o.to_sym == Aro::Log::ORDERING[:DESC] ? deck.logs.count - i : 1 + i} of #{deck.logs.count}".rjust(width) + "\n"
+          result += divider + "\n\n"
+          result += self.get_display_for_cards(
+            Base64::decode64(l.card_data).split(Aro::Deck::CARD_DELIM.to_s)
+          )
+          result += divider + "\n"
+          
+          drawn_cards = Base64::decode64(l.drawn_data).split(Aro::Deck::CARD_DELIM.to_s)
+
+          if !drawn_cards.nil? && drawn_cards.any?
+            result += I18n.t("cli.messages.history_drawn").center(width) + "\n"
+            result += divider + "\n\n"
+            result += self.get_display_for_cards(
+              drawn_cards
+            )
+            result += "\n"
+            result += divider + "\n"
+          end
+
+          Aro::Mancy::OS.times do
+            result += divider + "\n"
+          end
+        }
+
+        result
+      end
+
+      def self.get_display_for_cards(input = [])
+        columns = CLI::Config.display_config[:COLUMNS].to_i
+        result = ""
+        input.each_with_index{|c, i|
+          
+          s = (i + Aro::Mancy::S) % [Aro::Mancy::S, columns].max
+          o = Aro::Mancy::O == s
+          if i == I18n.t("cards.index").count - Aro::Mancy::S
+            result += c.ljust(columns)
+          else
+            result += c.ljust(columns) + (o ? "\n" : "")
+          end
+        }
+        result += "\n"
+        result
+      end
+
+      def self.draw(model)
+        return false unless model.kind_of?(String)
+
+        Aro::P.say(model)
+      end
+    end
+  end
+end

data/sys/views/games/menu.rb

@@ -0,0 +1,27 @@
+=begin
+  
+  views/games/menu.rb
+
+  the game menu view.
+
+  by i2097i
+
+=end
+
+require_relative :"../base".to_s
+
+module Aro
+  module Vi
+    class Menu < Aro::Vi::Base
+      def self.generate(model)
+        # todo: implement this
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+
+      def self.draw(model)
+        # todo: implement this
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+    end
+  end
+end

data/sys/views/setup/setup.rb

@@ -0,0 +1,27 @@
+=begin
+  
+  views/setup/setup.rb
+
+  the setup view.
+
+  by i2097i
+
+=end
+
+require_relative :"../base".to_s
+
+module Aro
+  module Vi
+    class Setup < Aro::Vi::Base
+      def self.generate(model)
+        # todo: implement this
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+
+      def self.draw(model)
+        # todo: implement this
+        CLI::Nterface.exit_error_invalid_usage!
+      end
+    end
+  end
+end

data/tasks/make.rake

@@ -1,4 +1,4 @@
-desc "rspec && rake install"
+desc "rake install && rspec"
 task :make do
-  exec "rspec && rake install"
+  exec "rake install && rspec"
 end