mtg_card_maker 0.1.0 → 0.2.0

data/lib/mtg_card_maker/layers/type_line_layer.rb

@@ -5,6 +5,7 @@ module MtgCardMaker
   # This is the small area in the center of the card below the artwork
   class TypeLineLayer < BaseLayer
     include LayerInitializer
+
     attr_reader :type_line, :color_scheme
 
     def initialize(dimensions:, type_line:, color: nil, color_scheme: DEFAULT_COLOR_SCHEME)
@@ -15,9 +16,6 @@ module MtgCardMaker
     end
 
     def render
-      # Ensure gradients are defined for this color scheme
-      SvgGradientService.define_all_gradients(svg, color_scheme)
-
       svg.g do
         render_type_background
         render_type_line
@@ -76,7 +74,7 @@ module MtgCardMaker
         y: layer_config.text_y_position(y, :type_area, height),
         font_size: layer_config.font_size(:type),
         available_width: layer_config.text_width(width, :type_area),
-        css_class: layer_config.css_class(:card_type)
+        css_class: layer_config.css_class(:type_line)
       )
       text_service.wrapped_text_lines.each do |line, attrs|
         svg.text line, attrs

data/lib/mtg_card_maker/logger.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module MtgCardMaker
+  # A logger wrapper around Ruby's standard Logger that adds emoji to output
+  # and provides separate streams for info (stdout) and warnings/errors (stderr).
+  #
+  # @example Basic usage
+  #   logger = MtgCardMaker::Logger.new
+  #   logger.info("Card generated successfully!")
+  #   logger.warn("Warning: temp file cleanup failed")
+  #   logger.error("Error: invalid configuration")
+  #
+  # @since 0.1.0
+  class Logger
+    # Initialize a new logger instance
+    #
+    # @param output_stream [IO] the output stream for info messages (default: $stdout)
+    # @param error_stream [IO] the error stream for warnings/errors (default: $stderr)
+    def initialize(output_stream: $stdout, error_stream: $stderr)
+      @info_logger = ::Logger.new(output_stream)
+      @error_logger = ::Logger.new(error_stream)
+
+      # Set simple formatters that just output the message
+      @info_logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
+      @error_logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
+    end
+
+    # Log an info message to stdout
+    #
+    # @param message [String] the message to log
+    # @return [void]
+    def info(message)
+      @info_logger.info(message)
+    end
+
+    # Log a warning message to stderr
+    #
+    # @param message [String] the warning message to log
+    # @return [void]
+    def warn(message)
+      @error_logger.warn("❌ #{message}")
+    end
+
+    # Log an error message to stderr
+    #
+    # @param message [String] the error message to log
+    # @return [void]
+    def error(message)
+      @error_logger.error("💥 Error: #{message}")
+    end
+
+    # Log a success message with sparkle emoji to stdout
+    #
+    # @param message [String] the success message to log
+    # @return [void]
+    def success(message)
+      info("✨ #{message} ✨")
+    end
+  end
+end

data/lib/mtg_card_maker/mana_cost.rb

@@ -5,7 +5,7 @@ require_relative 'icon_service'
 module MtgCardMaker
   # Mana cost class that generates SVG for the mana cost of a card.
   # This class parses mana cost strings (e.g., "2UR", "XG") and generates
-  # SVG circles with appropriate colors and icons for each mana symbol.
+  # SVG icons for each mana symbol.
   #
   # @example
   #   mana_cost = MtgCardMaker::ManaCost.new("2UR")
@@ -16,69 +16,46 @@ module MtgCardMaker
   #   svg = mana_cost.to_svg
   #
   # @since 0.1.0
-  # rubocop:disable Metrics/ClassLength
   class ManaCost
-    # Mapping of letters to colors
-    # @return [Hash] the color mapping for mana symbols
-    COLOR_MAP = {
-      'B' => :black, 'S' => :black,
-      'U' => :blue,  'I' => :blue,
-      'G' => :green, 'F' => :green,
-      'W' => :white, 'P' => :white,
-      'R' => :red,   'M' => :red,
-      'C' => :colorless
-    }.freeze
-
-    # @return [Array<Symbol>] the parsed mana elements
+    # @return [Array<String>] the parsed mana elements (symbol strings)
     attr_reader :elements
 
     # @return [Integer, nil] the integer value for generic mana
     attr_reader :int_val
 
+    # @return [LayerConfig] the layer configuration
+    attr_reader :layer_config
+
     # Initialize a new mana cost parser
     #
     # @param mana_string [String, nil] the mana cost string (e.g., "2UR", "XG")
     # @param icon_set [Symbol] the icon set to use (default: :default)
-    def initialize(mana_string = nil, icon_set = :default) # rubocop:disable Metrics/MethodLength
+    def initialize(mana_string = nil, icon_set = :default)
       @elements = []
-      @origins = [] # :numeric, :C, or color symbol
       @int_val = nil
-      @original_string = mana_string
       @icon_service = IconService.new(icon_set)
+      @layer_config = LayerConfig.default
 
       return if mana_string.nil? || mana_string.empty?
 
-      # Convert to uppercase for consistency
-      mana_string = mana_string.to_s.upcase
-
-      # Parse the mana string
-      parse_mana_string(mana_string)
-
-      # Limit to maximum circles
-      layer_config = LayerConfig.default
-      max_circles = layer_config.mana_cost_config[:max_circles]
-      @elements = @elements.first(max_circles)
-      @origins = @origins.first(max_circles)
+      parse_mana_string(mana_string.to_s.upcase)
+      limit_elements
     end
 
-    # Returns SVG string for the mana cost circles with drop shadow
+    # Returns SVG string for the mana cost icons with drop shadow
     #
     # @return [String] the SVG markup for the mana cost
     def to_svg
-      layer_config = LayerConfig.default
       circle_spacing = layer_config.mana_cost_config[:circle_spacing]
 
-      # Build mana cost circles SVG
-      mana_circles = @elements.each_with_index.map do |color, i|
-        x = i * circle_spacing
-        y = 0
-        mana_element_svg(x, y, color, @origins[i])
+      mana_icons = @elements.each_with_index.map do |symbol, i|
+        render_mana_icon(i * circle_spacing, 0, symbol)
       end.join
 
       <<~SVG.delete("\n")
         #{drop_shadow_filter}
         <g filter="url(#mana-cost-drop-shadow)">
-        #{mana_circles}
+        #{mana_icons}
         </g>
       SVG
     end
@@ -86,61 +63,74 @@ module MtgCardMaker
     private
 
     def parse_mana_string(mana_string)
-      return if mana_string.nil?
-
-      if numeric_cost?(mana_string) || mana_string.start_with?('X')
+      if mana_string.start_with?('X')
+        parse_x_cost(mana_string)
+      elsif mana_string.match?(/^\d+/)
         parse_numeric_cost(mana_string)
       else
         parse_colored_mana(mana_string)
       end
     end
 
-    def numeric_cost?(mana_string)
-      mana_string.match?(/^\d+/)
+    def parse_x_cost(mana_string)
+      @elements << '{X}'
+      remaining_string = mana_string[1..]
+
+      # Check if the remaining string starts with a number
+      if remaining_string.match?(/^\d+/)
+        parse_numeric_cost(remaining_string)
+      else
+        parse_colored_mana(remaining_string)
+      end
     end
 
     def parse_numeric_cost(mana_string)
-      mana_string = mana_string.gsub(/^X/, '10')
-
-      int_match = mana_string.match(/^(\d+)/)
-      @int_val = int_match[1].to_i
+      numeric_value = mana_string.match(/^(\d+)/)[1].to_i
 
-      # If it's a double-digit number, treat as X
-      @int_val = 10 if @int_val >= 10
-
-      @elements << :colorless
-      @origins << :numeric
+      if numeric_value >= 100
+        @int_val = nil
+        @elements << '{X}'
+      else
+        @int_val = numeric_value
+        @elements << "{#{numeric_value}}"
+      end
 
-      # Remove the integer and parse remaining colored mana
-      remaining = mana_string[int_match[1].length..]
-      parse_colored_mana(remaining)
+      parse_colored_mana(mana_string[numeric_value.to_s.length..])
     end
 
     def parse_colored_mana(mana_string)
-      return if mana_string.nil? || mana_string.empty?
+      # Use regex to match symbols: single letters, 1-2 digits, or {anything between curly braces}
+      mana_string.scan(/([A-Z]|\d{1,2}|\{[^}]+\})/).flatten.each do |symbol|
+        # Add curly braces if not already present
+        formatted_symbol = symbol.start_with?('{') ? symbol : "{#{symbol}}"
 
-      mana_string.chars.each do |char|
-        process_colored_character(char)
+        # Allow any symbol - IconService will handle validation
+        @elements << formatted_symbol
       end
     end
 
-    def process_colored_character(char)
-      color = COLOR_MAP[char]
-      if colorless_symbol?(color, char)
-        @elements << :colorless
-        @origins << :C
-      elsif color
-        @elements << color
-        @origins << color
-      end
+    def limit_elements
+      max_circles = layer_config.mana_cost_config[:max_circles]
+      @elements = @elements.first(max_circles)
     end
 
-    def colorless_symbol?(color, char)
-      color == :colorless && char == 'C'
+    def render_mana_icon(x, y, symbol)
+      icon_size = if symbol.match?(%r{\{.*/.*\}}) # Hybrid or phyrexian symbols
+                    layer_config.mana_cost_config[:hybrid_icon_size]
+                  else
+                    layer_config.mana_cost_config[:icon_size]
+                  end
+
+      icon_svg = @icon_service.symbol_svg(symbol, size: icon_size)
+      return unless icon_svg
+
+      icon_x = x - (icon_size / 2)
+      icon_y = y - (icon_size / 2)
+
+      "<g transform='translate(#{icon_x}, #{icon_y})'>#{icon_svg}</g>"
     end
 
     def drop_shadow_filter
-      layer_config = LayerConfig.default
       drop_shadow = layer_config.drop_shadow_config
       <<~SVG.delete("\n")
         <defs>
@@ -152,69 +142,10 @@ module MtgCardMaker
         <feDropShadow dx="#{drop_shadow[:dx]}"
                       dy="#{drop_shadow[:dy]}"
                       stdDeviation="#{drop_shadow[:std_deviation]}"
-                      flood-color="black"
-                      flood-opacity="#{drop_shadow[:flood_opacity]}"/>
+                      flood-color="black"/>
         </filter>
         </defs>
       SVG
     end
-
-    def mana_element_svg(x, y, color, origin) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      layer_config = LayerConfig.default
-      circle_radius = layer_config.mana_cost_config[:circle_radius]
-      icon_size = layer_config.mana_cost_config[:icon_size]
-
-      fill = svg_color(color)
-      svg = "<circle cx='#{x}' cy='#{y}' r='#{circle_radius}' fill='#{fill}' />"
-
-      if color == :colorless && origin == :numeric
-        # Add text for numeric colorless mana circles
-        svg << colorless_text(x, y, origin)
-      else
-        # Add icon inside colored mana circles, smaller and with opacity
-        icon_svg = @icon_service.icon_svg(color, size: icon_size)
-        if icon_svg
-          icon_x = x - (icon_size / 2)
-          icon_y = y - (icon_size / 2)
-          layer_config = LayerConfig.default
-          opacity = layer_config.mana_cost_icon_opacity
-          svg << "<g transform='translate(#{icon_x}, #{icon_y})' opacity='#{opacity}'>#{icon_svg}</g>"
-        end
-      end
-
-      svg
-    end
-
-    def colorless_text(x, y, origin)
-      if origin == :numeric && @int_val
-        text = @int_val == 10 ? 'X' : @int_val.to_s
-        text_svg(x, y, text)
-      else
-        ''
-      end
-    end
-
-    def text_svg(x, y, text)
-      # Position text in the center of the circle with appropriate styling
-      layer_config = LayerConfig.default
-      font_size = layer_config.mana_cost_font_size
-      font_weight = text == 'X' ? 'normal' : 'semibold'
-      y_offset = layer_config.mana_cost_text_y_offset
-
-      "<text x='#{x}' y='#{y + y_offset}' fill='#000' text-anchor='middle' " \
-        "font-weight='#{font_weight}' font-size='#{font_size}' font-family='serif'>#{text}</text>"
-    end
-
-    def svg_color(color)
-      case color
-      when :white then '#FFF9C4'  # White primary color
-      when :blue then '#90CAF9'   # Blue primary color (from fixture)
-      when :black then '#BDBDBD'  # Black primary color (from fixture)
-      when :red then '#EF9A9A'    # Red primary color (from fixture)
-      when :green then '#A5D6A7'  # Green primary color (from fixture)
-      else '#DDD'
-      end
-    end
   end
-  # rubocop:enable Metrics/ClassLength
 end

data/lib/mtg_card_maker/sprite_sheet_assets.rb

@@ -8,67 +8,21 @@ module MtgCardMaker
     end
 
     # Add all shared assets to the sprite sheet XML
-    def add_assets_to_sprite(xml)
-      add_sprite_styles(xml)
+    #
+    # @param xml [Nokogiri::XML::Builder] the XML builder for the sprite sheet
+    # @param embed_font [Boolean] whether to embed the font as base64 (default: true)
+    def add_assets_to_sprite(xml, embed_font: true)
+      add_sprite_styles(xml, embed_font: embed_font)
       add_sprite_masks(xml)
       add_sprite_gradients(xml)
     end
 
     private
 
-    def add_sprite_styles(xml)
+    def add_sprite_styles(xml, embed_font)
       xml.defs do
         xml.style(type: 'text/css') do
-          xml.cdata <<~CSS
-            @font-face {
-              font-family: 'Goudy Mediaeval DemiBold';
-              src: url('fonts/Goudy Mediaeval DemiBold.ttf') format('truetype');
-              font-weight: normal;
-              font-style: normal;
-            }
-
-            .card-name {
-              font-family: 'Goudy Mediaeval DemiBold', serif;
-              font-weight: normal;
-              font-style: normal;
-            }
-
-            .card-type {
-              font-family: 'Goudy Mediaeval DemiBold', serif;
-              font-weight: normal;
-              font-style: normal;
-            }
-
-            .card-description {
-              font-family: serif;
-              font-weight: normal;
-              font-style: normal;
-            }
-
-            .card-flavor-text {
-              font-family: serif;
-              font-weight: normal;
-              font-style: italic;
-            }
-
-            .card-power-toughness {
-              font-family: serif;
-              font-weight: bold;
-              font-style: normal;
-            }
-
-            .mana-cost-text {
-              font-family: serif;
-              font-weight: normal;
-              font-style: normal;
-            }
-
-            .mana-cost-text-large {
-              font-family: serif;
-              font-weight: semibold;
-              font-style: normal;
-            }
-          CSS
+          xml.cdata CssService.complete_styles(embed: embed_font)
         end
       end
     end
@@ -108,8 +62,8 @@ module MtgCardMaker
         SvgGradientService.define_frame_gradient(xml, color_scheme, scheme_name)
       when 'name'
         SvgGradientService.define_name_gradient(xml, color_scheme, scheme_name)
-      when 'description'
-        SvgGradientService.define_description_gradient(xml, color_scheme, scheme_name)
+      when 'text_box'
+        SvgGradientService.define_text_box_gradient(xml, color_scheme, scheme_name)
       end
     end
 
@@ -151,6 +105,7 @@ module MtgCardMaker
         ColorScheme.new(:red),
         ColorScheme.new(:green),
         ColorScheme.new(:gold),
+        ColorScheme.new(:silver),
         ColorScheme.new(:artifact)
       ]
     end

data/lib/mtg_card_maker/sprite_sheet_builder.rb

@@ -26,14 +26,20 @@ module MtgCardMaker
     end
 
     # Create the sprite sheet XML builder with assets and cards
-    def create_sprite_builder(width, height, card_files, assets)
+    #
+    # @param width [Integer] the width of the sprite sheet
+    # @param height [Integer] the height of the sprite sheet
+    # @param card_files [Array<Tempfile>] the individual card files
+    # @param assets [SpriteSheetAssets] the assets instance
+    # @param embed_font [Boolean] whether to embed the font as base64 (default: true)
+    def create_sprite_builder(width, height, card_files, assets, embed_font: true)
       Nokogiri::XML::Builder.new do |xml|
         xml.svg(xmlns: 'http://www.w3.org/2000/svg',
                 viewBox: "0 0 #{width} #{height}",
                 width: width,
                 height: height) do
-          assets.add_assets_to_sprite(xml)
-          add_cards_to_sprite(xml, card_files)
+          assets.add_assets_to_sprite(xml, embed_font: embed_font)
+          add_cards_to_sprite(xml, card_files, embed_font)
         end
       end
     end
@@ -45,13 +51,13 @@ module MtgCardMaker
 
     private
 
-    def add_cards_to_sprite(xml, card_files)
+    def add_cards_to_sprite(xml, card_files, embed_font)
       card_files.each_with_index do |file, index|
-        add_card_to_sprite(xml, file, index)
+        add_card_to_sprite(xml, file, index, embed_font)
       end
     end
 
-    def add_card_to_sprite(xml, card_file, index)
+    def add_card_to_sprite(xml, card_file, index, embed_font)
       position = calculate_card_position(index)
       doc = load_card_document(card_file)
       svg_element = doc.at_css('svg')
@@ -59,7 +65,12 @@ module MtgCardMaker
       return unless svg_element
 
       xml.g(transform: "translate(#{position[:x]}, #{position[:y]})") do
-        add_card_children(xml, svg_element)
+        # Add the card with its own viewBox for proper scaling
+        xml.svg(viewBox: "0 0 #{CARD_WIDTH} #{CARD_HEIGHT}",
+                width: CARD_WIDTH,
+                height: CARD_HEIGHT) do
+          add_card_children(xml, svg_element, embed_font)
+        end
       end
     end
 
@@ -77,8 +88,9 @@ module MtgCardMaker
       Nokogiri::XML(File.read(card_file.path))
     end
 
-    def add_card_children(xml, svg_element)
+    def add_card_children(xml, svg_element, _embed_font)
       excluded_elements = ['defs', 'style']
+
       svg_element.children.each do |child|
         next if excluded_elements.include?(child.name)
         next if child.name&.start_with?('linearGradient', 'radialGradient', 'pattern')

data/lib/mtg_card_maker/sprite_sheet_service.rb

@@ -42,11 +42,14 @@ module MtgCardMaker
       return false if card_configs.empty?
 
       begin
+        # Check if any card has embed_font: true
+        embed_font = should_embed_font?(card_configs)
+
         # Generate individual cards first
-        card_files = generate_individual_cards(card_configs)
+        card_files = generate_individual_cards(card_configs, embed_font)
 
         # Stitch them together into a sprite sheet
-        stitch_cards_into_sprite(card_files, output_file)
+        stitch_cards_into_sprite(card_files, output_file, embed_font)
       ensure
         # Clean up temporary files
         cleanup_temp_files(card_files)
@@ -63,11 +66,19 @@ module MtgCardMaker
 
     private
 
-    def generate_individual_cards(card_configs)
+    def logger
+      @logger ||= MtgCardMaker::Logger.new
+    end
+
+    def should_embed_font?(card_configs)
+      card_configs.values.any? { |config| config['embed_font'] == true }
+    end
+
+    def generate_individual_cards(card_configs, embed_font)
       card_files = []
 
       card_configs.values.each_with_index do |config, index|
-        card = card_from_config(config)
+        card = card_from_config(config, embed_font)
         temp_file = save_card_to_temp_file(card, index)
         card_files << temp_file
       rescue StandardError => e
@@ -82,7 +93,8 @@ module MtgCardMaker
       raise "❌ Error generating card #{index}: #{error.message}"
     end
 
-    def card_from_config(config)
+    def card_from_config(config, _embed_font)
+      # Never embed font in individual cards when creating sprite sheets
       BaseCard.new(
         name: config['name'],
         mana_cost: config['mana_cost'],
@@ -93,7 +105,8 @@ module MtgCardMaker
         toughness: config['toughness'],
         color: config['color'],
         border_color: config['border_color'],
-        art: config['art']
+        art: config['art'],
+        embed_font: false
       )
     end
 
@@ -103,9 +116,9 @@ module MtgCardMaker
       temp_file
     end
 
-    def stitch_cards_into_sprite(card_files, output_file)
+    def stitch_cards_into_sprite(card_files, output_file, embed_font)
       width, height = sprite_dimensions(card_files.length)
-      builder = @builder.create_sprite_builder(width, height, card_files, @assets)
+      builder = @builder.create_sprite_builder(width, height, card_files, @assets, embed_font: embed_font)
       @builder.write_sprite_file(output_file, builder)
       true
     rescue StandardError => e
@@ -119,7 +132,7 @@ module MtgCardMaker
         file.close
         file.unlink
       rescue StandardError => e
-        warn "Warning: Could not clean up temp file #{file.path}: #{e.message}"
+        logger.warn("Could not clean up temp file #{file.path}: #{e.message}")
       end
     end
   end

data/lib/mtg_card_maker/svg_gradient_service.rb

@@ -3,7 +3,7 @@
 module MtgCardMaker
   # Simplified gradient definitions for SVG cards
   # Removes complex abstraction in favor of direct gradient creation
-  class SvgGradientService # rubocop:disable Metrics/ClassLength
+  class SvgGradientService
     class << self
       # Defines all gradients needed for a color scheme
       def define_all_gradients(svg, color_scheme = DEFAULT_COLOR_SCHEME)
@@ -28,9 +28,9 @@ module MtgCardMaker
         "#{color_scheme.scheme_name}_name_gradient"
       end
 
-      # Get gradient ID for description gradient
-      def description_gradient_id(color_scheme)
-        "#{color_scheme.scheme_name}_description_gradient"
+      # Get gradient ID for text box gradient
+      def text_box_gradient_id(color_scheme)
+        "#{color_scheme.scheme_name}_text_box_gradient"
       end
 
       # Get gradient ID for metallic highlight gradient
@@ -50,7 +50,7 @@ module MtgCardMaker
 
       # Check if color scheme has metallic properties
       def metallic_properties?(color_scheme)
-        [:gold, :colorless].include?(color_scheme.scheme_name)
+        %i[gold colorless silver].include?(color_scheme.scheme_name)
       end
 
       def define_standard_gradients(svg, color_scheme)
@@ -59,7 +59,7 @@ module MtgCardMaker
         define_card_gradient(svg, color_scheme, scheme_name)
         define_frame_gradient(svg, color_scheme, scheme_name)
         define_name_gradient(svg, color_scheme, scheme_name)
-        define_description_gradient(svg, color_scheme, scheme_name)
+        define_text_box_gradient(svg, color_scheme, scheme_name)
       end
 
       def define_card_gradient(svg, color_scheme, scheme_name)
@@ -86,11 +86,11 @@ module MtgCardMaker
         end
       end
 
-      def define_description_gradient(svg, color_scheme, scheme_name)
-        svg.linearGradient id: "#{scheme_name}_description_gradient", x1: '0%', y1: '0%', x2: '100%', y2: '100%' do
-          svg.stop offset: '0%', 'stop-color': color_scheme.description_gradient_start
-          svg.stop offset: '50%', 'stop-color': color_scheme.description_gradient_middle
-          svg.stop offset: '100%', 'stop-color': color_scheme.description_gradient_end
+      def define_text_box_gradient(svg, color_scheme, scheme_name)
+        svg.linearGradient id: "#{scheme_name}_text_box_gradient", x1: '0%', y1: '0%', x2: '100%', y2: '100%' do
+          svg.stop offset: '0%', 'stop-color': color_scheme.text_box_gradient_start
+          svg.stop offset: '50%', 'stop-color': color_scheme.text_box_gradient_middle
+          svg.stop offset: '100%', 'stop-color': color_scheme.text_box_gradient_end
         end
       end