mtg_card_maker 0.1.0

data/lib/mtg_card_maker/layer_config.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require_relative 'core_ext/deep_merge'
+
+module MtgCardMaker
+  # Configuration class for layer-specific styling and positioning that centralizes
+  # all hardcoded values used across different layers. This class provides a
+  # centralized configuration system for font sizes, positioning, frame styling,
+  # and other layer-specific settings.
+  #
+  # @example
+  #   config = MtgCardMaker::LayerConfig.new
+  #   config.font_size(:name) # => 32
+  #   config.corner_radius(:outer) # => { x: 25, y: 25 }
+  #
+  # @example Custom configuration
+  #   custom_config = {
+  #     font_sizes: { name: 36, type: 24 },
+  #     padding: { horizontal: 20 }
+  #   }
+  #   config = MtgCardMaker::LayerConfig.new(custom_config)
+  #
+  # @since 0.1.0
+  class LayerConfig
+    # Default configuration for all layers
+    # @return [Hash] the default configuration hash
+    DEFAULT_CONFIG = {
+      # Text rendering settings
+      font_sizes: {
+        name: 32,
+        type: 22,
+        description: 24,
+        flavor_text: 18,
+        power_area: 28,
+        copyright: 14
+      },
+
+      # Text rendering configuration
+      text_rendering: {
+        default_font_size: 16,
+        default_color: '#111',
+        default_line_height_multiplier: 1.2,
+        char_width_multiplier: 0.42,
+        css_classes: {
+          card_name: 'card-name',
+          card_type: 'card-type',
+          card_description: 'card-description',
+          flavor_text: 'card-flavor-text',
+          power_area: 'card-power-toughness',
+          copyright: 'card-copyright'
+        }
+      },
+
+      # Positioning and spacing
+      padding: {
+        horizontal: 15,
+        vertical: 30
+      },
+
+      # Layer-specific positioning offsets
+      positioning: {
+        name_area: {
+          y_offset: 10,
+          width_ratio: 0.75
+        },
+        type_area: {
+          y_offset: 8,
+          width_ratio: 0.75
+        },
+        description: {
+          y_offset: 30,
+          width_ratio: 1.0
+        },
+        flavor_text: {
+          y_offset: 45,
+          width_ratio: 1.0,
+          separator_offset: 70
+        },
+        power_area: {
+          y_offset: 9
+        }
+      },
+
+      # Frame styling
+      frames: {
+        stroke_width: 2,
+        corner_radius: {
+          name: { x: 10, y: 25 },
+          type: { x: 10, y: 25 },
+          power: { x: 10, y: 25 },
+          art: { x: 8, y: 8 },
+          inner: { x: 10, y: 10 },
+          outer: { x: 25, y: 25 }
+        }
+      },
+
+      # Mana cost settings
+      mana_cost: {
+        circle_radius: 15,
+        circle_spacing: 35,
+        icon_size: 24,
+        max_circles: 10,
+        margin: 10
+      },
+
+      # Copyright text settings
+      copyright: {
+        base_y: 830,
+        line_spacing: 18,
+        x_position: 90
+      },
+
+      # Type line icon settings
+      type_icon: {
+        x_offset: 13,
+        y_offset: 4,
+        scale: 0.23,
+        aspect_ratio: { x: 0.93839063, y: 1.0656543 }
+      },
+
+      # Frame settings
+      frame: {
+        bottom_margin: 120
+      },
+
+      # Drop shadow settings
+      drop_shadow: {
+        dx: -2,
+        dy: 2,
+        std_deviation: 1,
+        flood_opacity: 1.0
+      },
+
+      # Text positioning adjustments
+      text_positioning: {
+        mana_cost_text_y_offset: 7,
+        mana_cost_font_size: 24
+      },
+
+      # Icon opacity settings
+      icon_opacity: {
+        mana_cost: 0.7
+      }
+    }.freeze
+
+    # @return [Hash] the merged configuration hash
+    attr_reader :config
+
+    # Initialize a new layer configuration
+    #
+    # @param custom_config [Hash] custom configuration to merge with defaults
+    def initialize(custom_config = {})
+      # Extend the DEFAULT_CONFIG hash with deep merge functionality
+      default_config_with_merge = DEFAULT_CONFIG.dup.extend(DeepMerge)
+      @config = default_config_with_merge.deep_merge(custom_config)
+    end
+
+    # Font size getters
+    def font_size(layer_type)
+      config[:font_sizes][layer_type]
+    end
+
+    # Padding getters
+    def horizontal_padding
+      config[:padding][:horizontal]
+    end
+
+    def vertical_padding
+      config[:padding][:vertical]
+    end
+
+    # Positioning getters
+    def positioning(layer_type)
+      config[:positioning][layer_type] || {}
+    end
+
+    # Frame styling getters
+    def stroke_width
+      config[:frames][:stroke_width]
+    end
+
+    def corner_radius(layer_type)
+      config[:frames][:corner_radius][layer_type] || { x: 5, y: 5 }
+    end
+
+    # Mana cost getters
+    def mana_cost_config
+      config[:mana_cost]
+    end
+
+    # Copyright getters
+    def copyright_config
+      config[:copyright]
+    end
+
+    # Type icon getters
+    def type_icon_config
+      config[:type_icon]
+    end
+
+    # Text rendering getters
+    def text_rendering_config
+      config[:text_rendering]
+    end
+
+    def default_font_size
+      text_rendering_config[:default_font_size]
+    end
+
+    def default_text_color
+      text_rendering_config[:default_color]
+    end
+
+    def default_line_height_multiplier
+      text_rendering_config[:default_line_height_multiplier]
+    end
+
+    def char_width_multiplier
+      text_rendering_config[:char_width_multiplier]
+    end
+
+    def css_class(layer_type)
+      text_rendering_config[:css_classes][layer_type]
+    end
+
+    # Frame getters
+    def frame_config
+      config[:frame]
+    end
+
+    def frame_bottom_margin
+      frame_config[:bottom_margin]
+    end
+
+    # Drop shadow getters
+    def drop_shadow_config
+      config[:drop_shadow]
+    end
+
+    # Text positioning getters
+    def text_positioning_config
+      config[:text_positioning]
+    end
+
+    def mana_cost_text_y_offset
+      text_positioning_config[:mana_cost_text_y_offset]
+    end
+
+    def mana_cost_font_size
+      text_positioning_config[:mana_cost_font_size]
+    end
+
+    # Icon opacity getters
+    def icon_opacity_config
+      config[:icon_opacity]
+    end
+
+    def mana_cost_icon_opacity
+      icon_opacity_config[:mana_cost]
+    end
+
+    # Convenience methods for common calculations
+    def text_width(base_width, layer_type = nil)
+      if layer_type && positioning(layer_type)[:width_ratio]
+        (base_width * positioning(layer_type)[:width_ratio]) - (horizontal_padding * 2)
+      else
+        base_width - (horizontal_padding * 2)
+      end
+    end
+
+    def text_x_position(base_x)
+      base_x + horizontal_padding
+    end
+
+    def text_y_position(base_y, layer_type, height = nil)
+      offset = positioning(layer_type)[:y_offset] || 0
+      if height
+        base_y + (height / 2) + offset
+      else
+        base_y + offset
+      end
+    end
+
+    # Class method for easy access to default config
+    def self.default
+      new
+    end
+  end
+end

data/lib/mtg_card_maker/layer_factory.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative 'layers/art_layer'
+require_relative 'layers/text_box_layer'
+require_relative 'layers/frame_layer'
+require_relative 'layers/name_layer'
+require_relative 'layers/border_layer'
+require_relative 'layers/power_layer'
+require_relative 'layers/type_line_layer'
+
+module MtgCardMaker
+  # Centralized factory for creating card layers that eliminates duplication
+  # between BaseCard and SpriteSheetService. This factory handles the creation
+  # of all layer types with proper configuration and dependencies.
+  #
+  # @example
+  #   layers = MtgCardMaker::LayerFactory.create_layers_for_card(card, mask_id, card_config)
+  #   layers.each { |layer| template.add_layer(layer) }
+  #
+  # @since 0.1.0
+  class LayerFactory
+    # Create all layers for a card using the factory pattern
+    #
+    # @param card [BaseCard] the card instance
+    # @param mask_id [String] the mask ID for art window
+    # @param card_config [Object] the card configuration object
+    # @return [Array<BaseLayer>] an array of all card layers
+    def self.create_layers_for_card(card, mask_id, card_config)
+      new(card, mask_id, card_config).create_layers
+    end
+
+    # Initialize a new layer factory
+    #
+    # @param card [BaseCard] the card instance
+    # @param mask_id [String] the mask ID for art window
+    # @param card_config [Object] the card configuration object
+    def initialize(card, mask_id, card_config)
+      @card = card
+      @mask_id = mask_id
+      @card_config = card_config
+      @color_scheme = card.color_scheme
+    end
+
+    # Create all layers for the card in the correct order
+    #
+    # @return [Array<BaseLayer>] an array of all card layers in rendering order
+    def create_layers
+      [
+        create_border_layer,
+        create_frame_layer,
+        create_name_layer,
+        create_art_layer,
+        create_type_line_layer,
+        create_text_box_layer,
+        create_power_layer
+      ]
+    end
+
+    private
+
+    def create_border_layer
+      border_color = @card.border_color || :white
+      BorderLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:border),
+        color: border_color,
+        mask_id: @mask_id
+      )
+    end
+
+    def create_frame_layer
+      FrameLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:frame),
+        color_scheme: @color_scheme,
+        mask_id: @mask_id
+      )
+    end
+
+    def create_name_layer
+      NameLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:name_area),
+        name: @card.name,
+        cost: @card.mana_cost,
+        color_scheme: @color_scheme
+      )
+    end
+
+    def create_art_layer
+      art = @card.art
+      ArtLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:art_layer),
+        color_scheme: @color_scheme,
+        art: art
+      )
+    end
+
+    def create_type_line_layer
+      TypeLineLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:type_area),
+        type_line: @card.type_line,
+        color_scheme: @color_scheme
+      )
+    end
+
+    def create_text_box_layer
+      TextBoxLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:text_box),
+        rules_text: @card.rules_text,
+        flavor_text: @card.flavor_text,
+        color_scheme: @color_scheme
+      )
+    end
+
+    def create_power_layer
+      PowerLayer.new(
+        dimensions: @card_config.dimensions_for_layer(:power_area),
+        power: @card.power,
+        toughness: @card.toughness,
+        color_scheme: @color_scheme
+      )
+    end
+  end
+end

data/lib/mtg_card_maker/layer_initializer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MtgCardMaker
+  # Mixin to provide common layer initialization patterns
+  module LayerInitializer
+    private
+
+    def initialize_layer_color(color, color_scheme, default_method)
+      color || color_scheme.send(default_method)
+    end
+  end
+end

data/lib/mtg_card_maker/layers/art_layer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'addressable/uri'
+require_relative '../../mtg_card_maker'
+
+module MtgCardMaker
+  # ArtLayer is a specialized layer for card artwork.
+  # It provides a placeholder for the art area,
+  # the art itself is not a feature of this gem.
+  class ArtLayer < BaseLayer
+    attr_reader :color_scheme, :art
+
+    def initialize(dimensions:, color_scheme: DEFAULT_COLOR_SCHEME, art: nil)
+      super(dimensions: dimensions, color: '#000')
+      @color_scheme = color_scheme
+      @art = parse_image_url(art)
+    end
+
+    # Render the art area with an ornate frame and optional image
+    def render
+      layer_config = LayerConfig.default
+      stroke_width = layer_config.stroke_width
+      outer_corners = layer_config.corner_radius(:art)
+      inner_corners = { x: 5, y: 5 } # Inner frame uses smaller radius
+
+      svg.g do
+        # Ornate art frame
+        svg.rect x: x - 3, y: y - 3,
+                 width: width + 6, height: height + 6,
+                 fill: 'none',
+                 stroke: color_scheme.primary_color,
+                 stroke_width: stroke_width,
+                 rx: outer_corners[:x], ry: outer_corners[:y]
+
+        # Frame border for the transparent window
+        svg.rect x: x, y: y, width: width, height: height, fill: 'none',
+                 stroke: ColorPalette::FRAME_STROKE_COLOR, stroke_width: stroke_width,
+                 rx: inner_corners[:x], ry: inner_corners[:y]
+
+        # Render image if provided
+        render_image if art
+      end
+    end
+
+    private
+
+    def parse_image_url(url)
+      return nil if url.nil? || url.empty?
+
+      begin
+        Addressable::URI.parse(url).to_s
+      rescue Addressable::URI::InvalidURIError => e
+        raise ArgumentError, "Invalid image URL: '#{url}'. Error: #{e.message}"
+      end
+    end
+
+    def render_image
+      svg.image href: art,
+                x: x, y: y, width: width, height: height,
+                preserveAspectRatio: 'xMidYMid slice'
+    end
+  end
+end

data/lib/mtg_card_maker/layers/border_layer.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative '../metallic_renderer'
+
+module MtgCardMaker
+  # BorderLayer is a specialized layer for the border of the card.
+  # It renders the outermost border of the card and supports four color options:
+  # white, black, silver (colorless), and gold. The layer includes QR codes
+  # and copyright text at the bottom.
+  #
+  # @example
+  #   layer = MtgCardMaker::BorderLayer.new(
+  #     dimensions: { x: 0, y: 0, width: 630, height: 880 },
+  #     color: :gold,
+  #     mask_id: 'artWindowMask'
+  #   )
+  #   layer.render
+  #
+  # @since 0.1.0
+  class BorderLayer < BaseLayer
+    include MetallicRenderer
+    include LayerInitializer
+
+    # @return [ColorScheme] the color scheme for this layer
+    attr_reader :color_scheme
+
+    # @return [String] the mask ID for the art window
+    attr_reader :mask_id
+
+    # Supported colors for the border
+    # @return [Hash] the supported color mappings
+    SUPPORTED_COLORS = {
+      white: '#EEE',
+      black: '#000',
+      silver: :colorless,
+      gold: :gold
+    }.freeze
+
+    # Initialize a new border layer
+    #
+    # @param dimensions [Hash] the layer dimensions
+    # @option dimensions [Integer] :x the x-coordinate
+    # @option dimensions [Integer] :y the y-coordinate
+    # @option dimensions [Integer] :width the width
+    # @option dimensions [Integer] :height the height
+    # @param color [Symbol] the frame color (default: :white)
+    # @param mask_id [String] the mask ID for art window (default: 'artWindowMask')
+    # @raise [ArgumentError] if the color is not supported
+    def initialize(dimensions:, color: :white, mask_id: 'artWindowMask')
+      @color = color.to_sym
+      validate_color!
+
+      @mask_id = mask_id
+      @icon_service = IconService.new
+      @color_scheme = ColorScheme.new(color_key_for(@color))
+      super(dimensions: dimensions, color: @color)
+    end
+
+    # Render the border layer with QR code and copyright text
+    #
+    # @return [void]
+    def render
+      layer_config = LayerConfig.default
+      corners = layer_config.corner_radius(:outer)
+      color_key = color_key_for(@color)
+
+      render_frame_by_color(color_key, corners)
+      render_qr_code
+      render_copyright_texts(layer_config)
+    end
+
+    private
+
+    def render_frame_by_color(color, corners)
+      case color
+      when :white
+        render_white_frame(corners)
+      when :black
+        render_black_frame(corners)
+      when :colorless, :gold
+        render_metallic_frame(corners)
+      else
+        raise ArgumentError, "Unsupported border color: #{color.inspect}. Supported: white, black, silver, gold."
+      end
+    end
+
+    def render_white_frame(corners)
+      svg.rect x: x, y: y, width: width, height: height,
+               fill: SUPPORTED_COLORS[:white], rx: corners[:x], ry: corners[:y],
+               mask: "url(##{@mask_id})"
+    end
+
+    def render_black_frame(corners)
+      svg.rect x: x, y: y, width: width, height: height,
+               fill: SUPPORTED_COLORS[:black], rx: corners[:x], ry: corners[:y],
+               mask: "url(##{@mask_id})"
+    end
+
+    def render_metallic_frame(corners)
+      svg.rect x: x, y: y,
+               width: width, height: height,
+               rx: corners[:x], ry: corners[:y],
+               fill: '#EEE',
+               mask: "url(##{@mask_id})"
+      SvgGradientService.define_all_gradients(svg, color_scheme)
+      render_metallic_elements(
+        mask: @mask_id,
+        corners: corners,
+        geometry: { x: x, y: y, width: width, height: height, padding: 0 },
+        bottom_margin: 0,
+        opacity: { texture: 0.15, shadow: 0.18 }
+      )
+    end
+
+    def validate_color!
+      return if SUPPORTED_COLORS.key?(@color)
+
+      raise ArgumentError, "Unsupported border color: #{@color.inspect}. Supported: white, black, silver, gold."
+    end
+
+    def color_key_for(color)
+      return :colorless if color == :silver
+      return :gold if color == :gold
+
+      color
+    end
+
+    def fill_color
+      @color == :black ? '#FFF' : '#111'
+    end
+
+    def render_qr_code
+      qr_svg_content = @icon_service.qr_code_svg
+      raise 'QR code SVG content is nil' unless qr_svg_content
+
+      # Extract the path data from the SVG content
+      path_match = qr_svg_content.match(/<path[^>]*d="([^"]*)"[^>]*>/)
+      raise 'No path element found in QR code SVG' unless path_match
+
+      svg.path fill: fill_color, transform: 'translate(40,820) scale(1.1)',
+               d: path_match[1]
+    end
+
+    def render_copyright_texts(layer_config)
+      copyright_texts = [
+        '© 2025 Joe Sharp. Some rights reserved.',
+        'Portions of the materials used are property of Wizards of the Coast.',
+        '© Wizards of the Coast LLC'
+      ]
+
+      copyright_config = layer_config.copyright_config
+
+      copyright_texts.each_with_index do |text, index|
+        copyright_attrs = {
+          x: copyright_config[:x_position],
+          y: copyright_config[:base_y] + (index * copyright_config[:line_spacing]),
+          fill: fill_color,
+          font_size: layer_config.font_size(:copyright),
+          text_anchor: 'start',
+          class: 'card-copyright'
+        }
+        svg.text text, copyright_attrs
+      end
+    end
+  end
+end

data/lib/mtg_card_maker/layers/frame_layer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../metallic_renderer'
+
+module MtgCardMaker
+  # FrameLayer is a specialized layer for the colored frame of the card
+  # You choose the color, making it possible to make a blue card
+  # that costs mountains, for example.
+  class FrameLayer < BaseLayer
+    include MetallicRenderer
+    include LayerInitializer
+    attr_reader :color_scheme, :mask_id, :layer_config
+
+    def initialize(dimensions:, color: nil, color_scheme: DEFAULT_COLOR_SCHEME, mask_id: 'artWindowMask')
+      frame_color = initialize_layer_color(color, color_scheme, :primary_color)
+      super(dimensions: dimensions, color: frame_color)
+      @color_scheme = color_scheme
+      @mask_id = mask_id
+      @layer_config = LayerConfig.default
+    end
+
+    # Render the frame with a gradient background
+    def render
+      SvgGradientService.define_all_gradients(svg, color_scheme)
+      if metallic_properties?
+        render_metallic_frame
+      else
+        render_standard_frame
+      end
+    end
+
+    private
+
+    def render_metallic_frame
+      render_standard_frame
+      render_metallic_elements(
+        mask: @mask_id,
+        bottom_margin: layer_config.frame_bottom_margin,
+        opacity: { texture: 0.3, shadow: 0.4 }
+      )
+    end
+
+    def metallic_properties?
+      color_scheme.scheme_name == :gold
+    end
+
+    def render_standard_frame # rubocop:disable Metrics/AbcSize
+      stroke_width = layer_config.stroke_width
+      corners = layer_config.corner_radius(:inner)
+      padding = layer_config.horizontal_padding
+      bottom_margin = layer_config.frame_bottom_margin # Space for type line and power/toughness
+
+      # Inner decorative frame with mask for transparent window
+      svg.rect x: x + padding, y: y + padding,
+               width: width - (padding * 2), height: height - bottom_margin,
+               fill: "url(##{SvgGradientService.frame_gradient_id(color_scheme)})",
+               stroke: color_scheme.primary_color,
+               stroke_width: stroke_width,
+               rx: corners[:x], ry: corners[:y], mask: "url(##{@mask_id})"
+    end
+  end
+end