cw_card_utils 0.1.6 → 0.1.8

data/lib/cw_card_utils/scryfall_cmc_data.rb

@@ -1,11 +1,85 @@
 # frozen_string_literal: true
 
 require "json"
+require "singleton"
 
 module CwCardUtils
+  # Abstract base class for card data sources
+  class CardDataSource
+    def find_card(name)
+      raise NotImplementedError, "Subclasses must implement find_card"
+    end
+
+    def cmc_for_card(name)
+      card = find_card(name)
+      card&.dig("cmc")
+    rescue StandardError
+      nil
+    end
+
+    def color_identity_for_card(name)
+      card = find_card(name)
+      card&.dig("color_identity") || []
+    rescue StandardError
+      []
+    end
+
+    def keywords_for_card(name)
+      card = find_card(name)
+      card&.dig("keywords") || []
+    rescue StandardError
+      []
+    end
+
+    def toughness_for_card(name)
+      card = find_card(name)
+      card&.dig("toughness")
+    rescue StandardError
+      nil
+    end
+
+    def power_for_card(name)
+      card = find_card(name)
+      card&.dig("power")
+    rescue StandardError
+      nil
+    end
+
+    def oracle_text_for_card(name)
+      card = find_card(name)
+      card&.dig("oracle_text")
+    rescue StandardError
+      nil
+    end
+
+    def type_for_card(name)
+      card = find_card(name)
+      type = card&.dig("type_line")
+      return nil if type&.include?("Land")
+      type
+    rescue StandardError
+      nil
+    end
+  end
+
+  # Example MongoDB data source implementation
+  # Users can implement their own data sources by inheriting from CardDataSource
+  class MongoCardDataSource < CardDataSource
+    def initialize(collection)
+      super()
+      @collection = collection
+    end
+
+    def find_card(name)
+      @collection.find_one({ "name" => name })
+    rescue StandardError
+      nil
+    end
+  end
+
   # Represents a card with Scryfall data
   class ScryfallCard
-    def initialize(name, data_source = ScryfallCmcData.new)
+    def initialize(name, data_source = ScryfallCmcData.instance)
       @name = name
       @data = data_source.find_card(@name) || {}
     end
@@ -40,74 +114,47 @@ module CwCardUtils
   end
 
   # Handles conversion mana cost (CMC) data for Magic: The Gathering cards
-  class ScryfallCmcData
+  # Uses Singleton pattern to avoid loading the large JSON file multiple times
+  class ScryfallCmcData < CardDataSource
+    include Singleton
+
     def initialize
-      @data = JSON.parse(File.read(File.expand_path("../../data/scryfall.cards.cmc.json", __dir__)))
+      super
+      @data = nil
+      @card_index = nil
       @found_cards = {}
     end
 
     def find_card(name)
-      @data.find { |card| card["name"] == name }
+      load_data_if_needed
+      @card_index[name] || @found_cards[name] ||= linear_search(name)
     rescue StandardError
       nil
     end
 
-    def cmc_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      @found_cards[name]["cmc"]
-    rescue StandardError
-      nil
-    end
-
-    def color_identity_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      @found_cards[name]["color_identity"]
-    rescue StandardError
-      nil
-    end
-
-    def keywords_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      @found_cards[name]["keywords"]
-    rescue StandardError
-      nil
+    def cmc_data
+      load_data_if_needed
+      @data
     end
 
-    def toughness_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      @found_cards[name]["toughness"]
-    rescue StandardError
-      nil
-    end
+    private
 
-    def power_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      @found_cards[name]["power"]
-    rescue StandardError
-      nil
-    end
+    def load_data_if_needed
+      return if @data
 
-    def oracle_text_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      @found_cards[name]["oracle_text"]
-    rescue StandardError
-      nil
+      @data = JSON.parse(File.read(File.expand_path("../../data/scryfall.cards.cmc.json", __dir__)))
+      build_card_index
     end
 
-    def type_for_card(name)
-      @found_cards[name] ||= find_card(name)
-      type = @found_cards[name]["type_line"]
-      if type.include?("Land")
-        type = nil
+    def build_card_index
+      @card_index = {}
+      @data.each do |card|
+        @card_index[card["name"]] = card
       end
-
-      type
-    rescue StandardError
-      nil
     end
 
-    def cmc_data
-      @data
+    def linear_search(name)
+      @data.find { |card| card["name"] == name }
     end
   end
 end

data/lib/cw_card_utils/synergy_probability.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module CwCardUtils
+  # Calculates probability of drawing specific card combinations for synergy analysis
+  class SynergyProbability
+    def initialize(deck, deck_size: 60)
+      @deck = deck
+      @deck_size = deck_size
+    end
+
+    # Probability of drawing at least one of the target cards
+    def prob_single(target_names, draws)
+      total_copies = count_copies(target_names)
+      1 - hypergeometric(@deck_size - total_copies, draws).to_f / hypergeometric(@deck_size, draws)
+    end
+
+    # Probability of drawing ALL cards in the targets list (synergy pair/trio)
+    def prob_combo(target_names, draws)
+      case target_names.size
+      when 1
+        prob_single(target_names, draws)
+      when 2
+        prob_two_card_combo(target_names, draws)
+      when 3
+        prob_three_card_combo(target_names, draws)
+      else
+        # For >3 cards, fallback to approximation
+        approx_combo(target_names, draws)
+      end
+    end
+
+    private
+
+    # Exact for 2-card combos
+    def prob_two_card_combo(names, draws)
+      copies_a = count_copies([names[0]])
+      copies_b = count_copies([names[1]])
+
+      total = hypergeometric(@deck_size, draws).to_f
+
+      # Probability missing A
+      miss_a = hypergeometric(@deck_size - copies_a, draws) / total
+      # Probability missing B
+      miss_b = hypergeometric(@deck_size - copies_b, draws) / total
+      # Probability missing both
+      miss_both = hypergeometric(@deck_size - (copies_a + copies_b), draws) / total
+
+      # Inclusion–exclusion
+      [1 - (miss_a + miss_b - miss_both), 0].max
+    end
+
+    # Exact for 3-card combos
+    def prob_three_card_combo(names, draws)
+      copies_a = count_copies([names[0]])
+      copies_b = count_copies([names[1]])
+      copies_c = count_copies([names[2]])
+
+      total = hypergeometric(@deck_size, draws).to_f
+
+      miss_a = hypergeometric(@deck_size - copies_a, draws) / total
+      miss_b = hypergeometric(@deck_size - copies_b, draws) / total
+      miss_c = hypergeometric(@deck_size - copies_c, draws) / total
+
+      miss_ab = hypergeometric(@deck_size - (copies_a + copies_b), draws) / total
+      miss_ac = hypergeometric(@deck_size - (copies_a + copies_c), draws) / total
+      miss_bc = hypergeometric(@deck_size - (copies_b + copies_c), draws) / total
+
+      miss_abc = hypergeometric(@deck_size - (copies_a + copies_b + copies_c), draws) / total
+
+      # Inclusion–exclusion for 3 sets
+      [1 - (miss_a + miss_b + miss_c) +
+        (miss_ab + miss_ac + miss_bc) -
+        miss_abc, 0].max
+    end
+
+    # Approximation for >3 cards (same as old method)
+    def approx_combo(target_names, draws)
+      prob_missing = 0.0
+      target_names.each do |name|
+        copies = count_copies([name])
+        miss_prob = hypergeometric(@deck_size - copies, draws).to_f / hypergeometric(@deck_size, draws)
+        prob_missing += miss_prob
+      end
+      [1 - prob_missing, 0].max
+    end
+
+    # Utility: count how many copies of given cards are in the deck
+    def count_copies(names)
+      @deck.main.sum { |card| names.include?(card.name) ? card.count : 0 }
+    end
+
+    # Hypergeometric combination helper
+    def hypergeometric(n, k)
+      return 0 if k > n
+      factorial(n) / (factorial(k) * factorial(n - k))
+    end
+
+    def factorial(n)
+      return 1 if n.zero?
+      (1..n).reduce(1, :*)
+    end
+  end
+end

data/lib/cw_card_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CwCardUtils
-  VERSION = "0.1.6"
+  VERSION = "0.1.8"
 end

data/lib/cw_card_utils.rb

@@ -4,6 +4,7 @@ require_relative "cw_card_utils/version"
 require_relative "cw_card_utils/curve_calculator"
 require_relative "cw_card_utils/decklist_parser"
 require_relative "cw_card_utils/scryfall_cmc_data"
+require_relative "cw_card_utils/synergy_probability"
 require_relative "cw_card_utils/deck_comparator"
 
 module CwCardUtils

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cw_card_utils
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Ryan Stenhouse
@@ -40,7 +40,14 @@ files:
 - lib/cw_card_utils/curve_calculator.rb
 - lib/cw_card_utils/deck_comparator.rb
 - lib/cw_card_utils/decklist_parser.rb
+- lib/cw_card_utils/decklist_parser/archetype_detector.rb
+- lib/cw_card_utils/decklist_parser/card.rb
+- lib/cw_card_utils/decklist_parser/card_tagger.rb
+- lib/cw_card_utils/decklist_parser/color_identity_resolver.rb
+- lib/cw_card_utils/decklist_parser/deck.rb
+- lib/cw_card_utils/decklist_parser/parser.rb
 - lib/cw_card_utils/scryfall_cmc_data.rb
+- lib/cw_card_utils/synergy_probability.rb
 - lib/cw_card_utils/version.rb
 - sig/cw_card_utils.rbs
 homepage: https://cracklingwit.com