cw_card_utils 0.1.5 → 0.1.7

data/lib/cw_card_utils/decklist_parser.rb

@@ -1,592 +1,8 @@
 # frozen_string_literal: true
 
-module CwCardUtils
-  class CardTagger
-    def initialize(card, deck)
-      @card = card
-      @text = card.oracle_text.to_s.downcase
-      @type_line = card.type.to_s.downcase
-      @cmc = card.cmc || 0
-      @power = begin
-        card.power.to_i
-      rescue StandardError
-        0
-      end
-      @toughness = begin
-        card.toughness.to_i
-      rescue StandardError
-        0
-      end
-      @keywords = card.keywords.map(&:downcase)
-      @deck = deck
-      @tribe = deck.tribe&.to_s&.downcase
-    end
-
-    def tags
-      t = []
-
-      # === Threat ===
-      t << :threat if creature? && @power >= 3
-
-      # === Finisher ===
-      t << :finisher if likely_finisher?
-
-      # === Ramp ===
-      t << :ramp if @text.match?(/add .* mana|search.*basic|put.*land|mana pool/)
-
-      # === Draw ===
-      t << :draw if @text.match?(/draw.*card|investigate|learn/)
-
-      # === Tutor ===
-      t << :tutor if @text.match?(/search.*library/)
-
-      # === Interaction ===
-      t << :interaction if @text.match?(/destroy|exile|counter|fight|return.*to.*hand|sacrifice.*creature|discard/i)
-
-      # === Lock Pieces ===
-      t << :lock_piece if @text.match?(/players can't|creatures can't|skip.*step|can't untap|prevent all combat damage|each player.*sacrifice/i)
-
-      # === Tax Effects ===
-      t << :tax if @text.match?(/whenever an opponent|opponents? .* pay|opponents? .* can't|noncreature spells .* cost|can't cast more than/i)
-
-      # === Combo ===
-      t << :combo_piece if @text.match?(/infinite|copy.*spell|storm|you win the game/i)
-
-      # === ETB Effects ===
-      if @text.match?(/when.*enters.*the battlefield/)
-        t << :etb
-        t << :etb_buff if @text.match?(/creatures.*get.*\+/)
-        t << :etb_token if @text.match?(/create.*token/)
-        t << :etb_removal if @text.match?(/destroy|exile|tap|fight/)
-      end
-
-      # === Evasion / Scaling Threats ===
-      if @keywords.any? { |kw| %w[flying trample menace unblockable].include?(kw) } || @text.match?(/flying|trample|menace|unblockable/)
-        t << :evasive
-      end
-
-      if @text.match?(/gets \+x\/\+x|for each other|creatures you control|other .*#{@tribe}s? you control/i)
-        t << :scaling_threat
-        t << :synergistic_finisher if @cmc <= 4 && t.include?(:evasive)
-      end
-
-      # === Go-Wide Synergy ===
-      if @text.match?(/whenever.*creature.*enters|token.*you control/i)
-        t << :synergy
-      end
-
-      # === Choose-a-type tribal enablers ===
-      if @text.include?("choose a creature type")
-        t << :tribal_synergy
-        t << :tribal_creature
-        if @text.match?(/creatures.*chosen type.*get.*\+.*\+|whenever.*creature.*of the chosen type/i)
-          t << :threat unless t.include?(:threat)
-        end
-      end
-
-      if creature? && @power <= 2 && @tribe &&
-          (@text.include?("whenever") || @text.include?("enters") || @text.include?("lifelink") || @text.include?("vigilance") || @text.include?("+1/+1"))
-        t << :threat
-      end
-
-      # === Static tribal buffs ===
-      if @tribe
-        t << :tribal_creature if creature_subtypes.include?(@tribe)
-        t << :tribal_synergy if @text.include?("#{@tribe}s") || @text.include?("other #{@tribe}")
-
-        if @text.match?(/other .*#{@tribe}s? you control.*\+\d\/\+\d|creature you control of the chosen type.*\+\d\/\+\d/i)
-          t << :tribal_synergy
-          t << :threat unless t.include?(:threat)
-        end
-
-        # Threat based on synergy
-        if @tribe && @text.match?(/creatures.*you control.*#{@tribe}|gets \+1\/\+1 for each.*#{@tribe}/)
-          t << :scaling_threat
-          t << :threat unless t.include?(:threat)
-        end
-      end
-
-      if t.include?(:scaling_threat) && !t.include?(:threat) # rubocop:disable Style/InverseMethods
-        t << :threat
-      end
-
-      t.uniq.sort
-    end
-
-    private
-
-    def creature?
-      @type_line.include?("creature")
-    end
-
-    def planeswalker?
-      @type_line.include?("planeswalker")
-    end
-
-    def creature_subtypes
-      return [] unless creature?
-      raw = @type_line.split(/[—-]/).last.to_s.strip
-      raw.split.map(&:downcase)
-    end
-
-    def likely_finisher?
-      return true if @cmc >= 6 && @text.match?(/flying|trample|indestructible|each opponent|you win|extra turn|double/i)
-      return true if planeswalker? && @text.match?(/creatures.*get.*flying|you get an emblem|each opponent/i)
-      false
-    end
-  end
-
-  class ArchetypeDetector
-    attr_reader :deck, :format, :tribe, :colors, :tag_counts, :tag_ratios
-
-    def initialize(deck)
-      @deck = deck
-      @format = deck.format.to_s.downcase # :standard, :edh, etc.
-      @tribe = deck.tribe&.capitalize # e.g., "Cat"
-      @colors = resolve_color_identity(deck)
-      @tag_counts = Hash.new(0)
-      @tag_ratios = {}
-      count_tags
-      calculate_ratios
-    end
-
-    def detect
-      archetype = detect_archetype
-      color_label = resolve_color_label(colors)
-      tribe_label = tribe ? " #{tribe} Tribal" : ""
-      archetype_label = " #{archetype.to_s.capitalize}"
-
-
-      [color_label, tribe_label, archetype_label].join.strip.squeeze(" ")
-    end
-
-    private
-
-    # === TAG COUNTING ===
-
-    def count_tags
-      total_tags = 0
-
-      deck.each do |card|
-        next unless card.respond_to?(:tags)
-
-        card.tags.each do |tag|
-          @tag_counts[tag] += card.count
-          total_tags += card.count
-        end
-      end
-
-      @tag_counts[:_total] = total_tags
-    end
-
-    def calculate_ratios
-      total = @tag_counts[:_total].to_f
-      return if total.zero?
-
-      @tag_counts.each do |tag, count|
-        next if tag == :_total
-        @tag_ratios[tag] = count / total
-      end
-    end
-
-    # === CMC UTILITY ===
-
-    def average_cmc
-      @average_cmc ||= begin
-        cmcs = deck.main.map { |card| card.respond_to?(:cmc) ? card.cmc.to_f : nil }.compact
-        return 0 if cmcs.empty? # rubocop:disable Lint/NoReturnInBeginEndBlocks
-        cmcs.sum / cmcs.size
-      end
-    end
-
-    # === FORMAT-AWARE DETECTION ===
-    def detect_archetype
-      if format == "edh"
-        return :combo if tag_ratios[:combo_piece].to_f > 0.10 && tag_ratios[:draw].to_f > 0.08
-
-        control_indicators = tag_counts[:interaction].to_i +
-          tag_counts[:draw].to_i +
-          tag_counts[:tax].to_i +
-          tag_counts[:lock_piece].to_i
-
-        return :control if control_indicators >= 14 && tag_counts[:threat].to_i <= 6
-
-        return :ramp if tag_counts[:ramp] >= 10 && average_cmc >= 4.0
-        return :midrange if tag_counts[:threat] >= 15 && tag_counts[:interaction] >= 6
-
-        return :aggro if tag_ratios[:threat].to_f >= 0.2 ||
-          tag_counts[:synergistic_finisher].to_i >= 3 ||
-          (tag_counts[:scaling_threat].to_i >= 6 && average_cmc <= 3.5) ||
-          (tag_counts[:synergy].to_i >= 6 && average_cmc <= 3.0)
-      else
-        return :combo if tag_ratios[:combo_piece].to_f >= 0.12
-        return :control if tag_ratios[:interaction].to_f >= 0.25 &&
-          tag_ratios[:threat].to_f < 0.2 &&
-          (tag_ratios[:draw].to_f + tag_ratios[:tax].to_f + tag_ratios[:lock_piece].to_f) >= 0.15
-
-        return :aggro if tag_ratios[:threat].to_f >= 0.2 ||
-          tag_counts[:synergistic_finisher].to_i >= 3 ||
-          (tag_counts[:scaling_threat].to_i >= 6 && average_cmc <= 3.5) ||
-          (tag_counts[:synergy].to_i >= 6 && average_cmc <= 3.0)
-
-        return :ramp if tag_ratios[:ramp].to_f >= 0.12 && tag_counts[:finisher] >= 3 && average_cmc >= 4.0
-        return :tempo if tag_ratios[:interaction].to_f >= 0.2 && tag_ratios[:threat].to_f >= 0.2 && average_cmc <= 3.5
-        return :midrange if tag_ratios[:threat].to_f >= 0.2 && tag_ratios[:interaction].to_f >= 0.1
-      end
-
-      :unknown
-    end
-
-    # === COLOR IDENTITY ===
-
-    def resolve_color_identity(deck)
-      deck.main.flat_map { |c| c.respond_to?(:color_identity) ? c.color_identity : [] }.uniq.sort
-    end
-
-    def resolve_color_label(identity)
-      ColorIdentityResolver.resolve(identity)
-    end
-  end
-
-  class ColorIdentityResolver
-    COLOR_NAMES = {
-      %w[W] => "White",
-      %w[U] => "Blue",
-      %w[B] => "Black",
-      %w[R] => "Red",
-      %w[G] => "Green",
-
-      %w[U W] => "Azorius",
-      %w[B U] => "Dimir",
-      %w[B R] => "Rakdos",
-      %w[G R] => "Gruul",
-      %w[G W] => "Selesnya",
-      %w[B W] => "Orzhov",
-      %w[R U] => "Izzet",
-      %w[B G] => "Golgari",
-      %w[R W] => "Boros",
-      %w[G U] => "Simic",
-
-      %w[B U W] => "Esper",
-      %w[B R U] => "Grixis",
-      %w[B G R] => "Jund",
-      %w[G R W] => "Naya",
-      %w[G U W] => "Bant",
-      %w[B R W] => "Mardu",
-      %w[G R U] => "Temur",
-      %w[B G W] => "Abzan",
-      %w[R U W] => "Jeskai",
-      %w[B G U] => "Sultai",
-
-      %w[B R U W] => "Glint",
-      %w[B G R U] => "Dune",
-      %w[B G R W] => "Ink",
-      %w[G R U W] => "Witch",
-      %w[B G U W] => "Yore",
-
-      %w[B G R U W] => "Five-Color",
-      [] => "Colorless",
-    }.freeze
-
-    def self.resolve(identity)
-      key = identity.sort
-      COLOR_NAMES[key] || key.join("/")
-    end
-  end
-
-  # Parses a decklist and returns a Deck object.
-  class DecklistParser
-    attr_reader :deck
-
-    IGNORED_TRIBAL_TYPES = %w[
-      human wizard soldier scout shaman warrior cleric rogue advisor knight druid
-    ].freeze
-
-    def initialize(desklist, cmc_data_source = ScryfallCmcData.new)
-      @decklist = desklist.is_a?(IO) ? desklist.read : desklist
-      @deck = Deck.new(cmc_data_source)
-    end
-
-    def inspect
-      "<DecklistParser: #{@decklist.length}>"
-    end
-
-    # Parses the decklist and returns a Deck object.
-    def parse
-      return @deck if @deck.any?
-
-      sideboard = false
-
-      @decklist.each_line do |line|
-        line = line.strip
-        next if line.empty?
-
-        sideboard = true if line.downcase.start_with?("sideboard") && (sideboard == false)
-
-        if line.match?(/^(Deck|Sideboard|About|Commander|Creatures|Lands|Spells|Artifacts|Enchantments|Planeswalkers|Mainboard|Maybeboard|Companion)/i)
-          next
-        end
-        next if line.start_with?("#") # skip comment-style lines
-        next if line.start_with?("//") # skip comment-style lines
-        next if line.start_with?("Name") # skip deck name
-
-        # Match patterns like: "4 Lightning Bolt", "2 Sol Ring (CMM) 452", "1 Atraxa, Praetors' Voice"
-        next unless match = line.match(/^(\d+)\s+(.+?)(?:\s+\(.*?\)\s+\d+)?$/) # rubocop:disable Lint/AssignmentInCondition
-
-        count = match[1].to_i
-        name = match[2].strip
-        target = sideboard ? :sideboard : :mainboard
-        @deck.add({ count: count, name: name }, target)
-      end
-
-      @deck
-    end
-
-    # A Deck is a collection of cards.
-    class Deck
-      # A Card is a single card in a deck.
-      class Card
-        def initialize(name, count, cmc_data_source)
-          @name = name
-          @count = count
-          @tags = []
-          if cmc_data_source.is_a?(ScryfallCmcData)
-            @scryfall_card = ScryfallCard.new(name)
-          else
-            @cmc_data_source = cmc_data_source
-          end
-        end
-
-        attr_reader :name, :count
-        attr_accessor :tags
-
-        def cmc
-          @cmc ||= @scryfall_card&.cmc || @cmc_data_source&.cmc_for_card(@name)
-        end
-
-        def type
-          @type ||= @scryfall_card&.type || @cmc_data_source&.type_for_card(@name) || "Land"
-        end
-
-        def keywords
-          @keywords ||= @scryfall_card&.keywords || @cmc_data_source&.keywords_for_card(@name) || []
-        end
-
-        def oracle_text
-          @oracle_text ||= @scryfall_card&.oracle_text || @cmc_data_source&.oracle_text_for_card(@name)
-        end
-
-        def power
-          @power ||= @scryfall_card&.power || @cmc_data_source&.power_for_card(@name)
-        end
-
-        def toughness
-          @toughness ||= @scryfall_card&.toughness || @cmc_data_source&.toughness_for_card(@name)
-        end
-
-        def color_identity
-          @color_identity ||= @scryfall_card&.color_identity || @cmc_data_source&.color_identity_for_card(@name) || []
-        end
-
-        def inspect
-          "<Card: #{@name} (#{@count}) #{cmc}>"
-        end
-
-        def to_h
-          { name: @name, count: @count, cmc: cmc, type: type, keywords: keywords, power: power, toughness: toughness, oracle_text: oracle_text }
-        end
-
-        def to_json(*_args)
-          to_h.to_json
-        end
-      end
-
-      def initialize(cmc_data_source)
-        @main = []
-        @sideboard = []
-        @lands = []
-        @x_to_cast = []
-
-        @cmc_data_source = cmc_data_source
-      end
-
-      def to_h
-        {
-          mainboard: main.map(&:to_h),
-          sideboard: sideboard.map(&:to_h),
-          tribe: tribe,
-        }
-      end
-
-      def color_identity
-        @color_identity ||= main.map(&:color_identity).flatten.uniq
-      end
-
-      def color_identity_string
-        @color_identity_string ||= ColorIdentityResolver.resolve(color_identity)
-      end
-
-      def to_json(*_args)
-        to_h.to_json
-      end
-
-      def main
-        tag_cards(@main)
-      end
-
-      def sideboard
-        tag_cards(@sideboard)
-      end
-
-      def tag_cards(cards)
-        cards.map do |c|
-          c.tags = CardTagger.new(c, self).tags
-          c
-        end
-      end
-
-      def archetype
-        @archetype ||= ArchetypeDetector.new(self).detect
-      end
-
-      def inspect
-        "<Deck: main: #{mainboard_size} sideboard: #{sideboard_size} lands: #{lands_count} x_to_cast: #{x_to_cast_count} cards: #{cards_count}>"
-      end
-
-      def collapsed_curve
-        @collapsed_curve ||= CurveCalculator.new(self).collapsed_curve
-      end
-
-      def curve
-        @curve ||=CurveCalculator.new(self).curve
-      end
-
-      def normalized_curve
-        @normalized_curve ||=CurveCalculator.new(self).normalized_curve
-      end
-
-      def collapsed_normalized_curve
-        @collapsed_normalized_curve ||=CurveCalculator.new(self).collapsed_normalized_curve
-      end
-
-      def empty?
-        @main.empty? && @sideboard.empty?
-      end
-
-      def any?
-        !empty?
-      end
-
-      def each(&block)
-        @main.each do |c|
-          block.call(c)
-        end
-      end
-
-      def add(c, target = :mainboard)
-        reset_counters
-        card = Card.new(c[:name], c[:count], @cmc_data_source)
-        card.tags = CardTagger.new(card, self).tags
-
-        if target == :mainboard
-          @main << card
-        else
-          @sideboard << card
-        end
-
-        if card.type.include?("Land")
-          @lands << card
-        elsif card.cmc.nil?
-          @x_to_cast << card
-        end
-      end
-
-      def reset_counters
-        @mainboard_size = nil
-        @sideboard_size = nil
-        @lands_count = nil
-        @x_to_cast_count = nil
-        @cards_count = nil
-      end
-
-      def format
-        @format ||= detect_format_for_deck
-      end
-
-      def detect_format_for_deck
-        if mainboard_size >= 100
-          :commander
-        elsif mainboard_size >= 60
-          :standard
-        else
-          :modern
-        end
-      end
-
-      def mainboard_size
-        @mainboard_size ||= main.sum { |card| card.count }
-      end
-
-      def sideboard_size
-        @sideboard_size ||= sideboard.sum { |card| card.count }
-      end
-
-      def lands_count
-        @lands.sum { |card| card.count }
-      end
-
-      def x_to_cast_count
-        @x_to_cast.sum { |card| card.count }
-      end
-
-      def cards_count
-        mainboard_size + sideboard_size
-      end
-
-      def count_without_lands
-        cards_count - lands_count
-      end
-
-      def size
-        cards_count
-      end
-
-      def tribe
-        return @tribe if @tribe
-        @tribe = detect_tribe_for_deck
-      end
-
-      def detect_tribe_for_deck
-        subtype_counts = Hash.new(0)
-        total_creatures = 0
-
-        @main.each do |card|
-          next unless card.type&.include?("Creature")
-
-          total_creatures += 1
-          subtypes = card.type.split(/[—-]/).last.to_s.strip.split
-          subtypes.each do |type|
-            subtype_counts[type.downcase] += 1
-          end
-        end
-
-        return nil if total_creatures < 6 || subtype_counts.empty?
-
-        most_common = subtype_counts.max_by { |_, count| count }
-        return nil if most_common.nil?
-
-        dominant_type = most_common[0]
-        count = most_common[1]
-
-        # Suppress only if it's a boring type *and* barely dominant
-        if IGNORED_TRIBAL_TYPES.include?(dominant_type) && count.to_f / total_creatures < 0.7
-          return nil
-        end
-
-        return dominant_type.to_sym if count.to_f / total_creatures >= 0.4
-        nil
-      end
-
-    end
-  end
-end
+require_relative "decklist_parser/parser"
+require_relative "decklist_parser/deck"
+require_relative "decklist_parser/card"
+require_relative "decklist_parser/card_tagger"
+require_relative "decklist_parser/archetype_detector"
+require_relative "decklist_parser/color_identity_resolver"