cw_card_utils 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8d8eb329c364d67fedf00a49698b9f145f06b6e08f7effae3eb92fb5c22d244
-  data.tar.gz: 8cc571695d9d0b3b07c2da11abffe0a047d08591c8b490fbaffdf88a21226fe5
+  metadata.gz: 542ae86bcb4458bd4fd9a53552089133dad00a4f716e5cf5bc73de11a52da217
+  data.tar.gz: 835722e23e181a4f4eeb945a18ca5ebb523825d097c42aa8533ed86cb278a042
 SHA512:
-  metadata.gz: 38000b90cc9c72b84efdf4c8eb892d20748fe4050af8874c99847a9e4b572b4fcbe573cfba49a964fcda60b8d177bbf9195f3f9b89c9f92c4f08d716d18c41ca
-  data.tar.gz: 9f62737b9b7fde768f4f990b0367b94b6e86d8bcab4a4925e1c91a8c6abfaae71a2ac56bd8ecfe5ffb74ec956010ad3c6d8658e102c032eeb3514e8488e0e79f
+  metadata.gz: 9ff3819a39ee37ee199013b2cb32c5f08f16e139a2d9138ee39d833123f7b40de7fcd4ab20238cd49ef683faca8319166d96cb10df252e88edae953965ae66d4
+  data.tar.gz: e867a1dbe6cda9971d7d28e976c610a250d0799b730fe1f107330e2fe6f81cad29021716893bd1b51fa6b5f45b900392b39c04236785ba93a66c0821825e1b8c

data/lib/cw_card_utils/deck_comparator.rb

@@ -29,7 +29,7 @@ module CwCardUtils
     private
 
     def analyze_deck(deck)
-      detector = ArchetypeDetector.new(deck)
+      detector = CwCardUtils::DecklistParser::ArchetypeDetector.new(deck)
       archetype = detector.detect
 
       curve = deck.normalized_curve

data/lib/cw_card_utils/decklist_parser/archetype_detector.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    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
+  end
+end

data/lib/cw_card_utils/decklist_parser/card.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    # A Card is a single card in a deck.
+    class Card
+      def initialize(name, count, cmc_data_source = CwCardUtils::ScryfallCmcData.instance)
+        @name = name
+        @count = count
+        @tags = []
+        @cmc_data_source = cmc_data_source
+      end
+
+      attr_reader :name, :count, :cmc_data_source
+      attr_accessor :tags
+
+      def cmc
+        @cmc ||= @cmc_data_source&.cmc_for_card(@name)
+      end
+
+      def type
+        @type ||= @cmc_data_source&.type_for_card(@name) || "Land"
+      end
+
+      def keywords
+        @keywords ||= @cmc_data_source&.keywords_for_card(@name) || []
+      end
+
+      def oracle_text
+        @oracle_text ||= @cmc_data_source&.oracle_text_for_card(@name)
+      end
+
+      def power
+        @power ||= @cmc_data_source&.power_for_card(@name)
+      end
+
+      def toughness
+        @toughness ||= @cmc_data_source&.toughness_for_card(@name)
+      end
+
+      def color_identity
+        @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
+
+
+  end
+end

data/lib/cw_card_utils/decklist_parser/card_tagger.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+
+    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
+
+  end
+end

data/lib/cw_card_utils/decklist_parser/color_identity_resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    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
+  end
+end

data/lib/cw_card_utils/decklist_parser/deck.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    # A Deck is a collection of cards.
+    class Deck
+      IGNORED_TRIBAL_TYPES = %w[
+        human wizard soldier scout shaman warrior cleric rogue advisor knight druid
+      ].freeze
+
+      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 ||= CwCardUtils::DecklistParser::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 = CwCardUtils::DecklistParser::CardTagger.new(c, self).tags
+          c
+        end
+      end
+
+      def archetype
+        @archetype ||= CwCardUtils::DecklistParser::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 = CwCardUtils::DecklistParser::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
+          # Check if this looks like Commander (60+ cards, singleton except for basic lands)
+          if mainboard_size >= 60 && is_singleton_deck?
+            :commander
+          else
+            :standard
+          end
+        else
+          :modern
+        end
+      end
+
+      def is_singleton_deck?
+        # Count non-basic land cards and check for duplicates
+        non_basic_lands = @main.reject { |card| is_basic_land?(card) }
+
+        # Check if any non-basic land card appears more than once
+        card_counts = Hash.new(0)
+        non_basic_lands.each do |card|
+          card_counts[card.name] += card.count
+        end
+
+        # All non-basic land cards should appear only once
+        card_counts.values.all? { |count| count == 1 }
+      end
+
+      def is_basic_land?(card)
+        basic_land_names = %w[Plains Island Swamp Mountain Forest Wastes]
+        basic_land_names.include?(card.name)
+      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

data/lib/cw_card_utils/decklist_parser/parser.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  module DecklistParser
+    # Parses a decklist and returns a Deck object.
+    class Parser
+      attr_reader :deck
+
+      def initialize(decklist, cmc_data_source = CwCardUtils::ScryfallCmcData.instance)
+        @decklist = decklist.is_a?(IO) ? decklist.read : decklist
+        @deck = Deck.new(cmc_data_source)
+      end
+
+      def inspect
+        "<DecklistParser::Parser: #{@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
+
+    end
+  end
+end