qr_forge 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 379423936d868bc8e4589d3483cc412c1bd6ec85bd6b9ae82e9ad58dfeb03903
+  data.tar.gz: 815cf224b5876c0222e8449b5edcbcc35d4f00c53d800f0a4cddb54d31f42735
+SHA512:
+  metadata.gz: 75c947677801f0d3d4469d3544206f9f3d0755ef90444b2eec312cf6373a0a2e10661d86a7f97d574ff69d05accb797299699d9bfd6f517b74130ecfe5393765
+  data.tar.gz: b31403d7730bb7f2bca48f237b8e99fd1a96414c470e24485164dd6046990e337a385bae68eb8832cff3cb2504b3fccdf0ffb5553b91a5d8bc70c7037e0bc10a

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,20 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Metrics/MethodLength:
+  Max: 50
+
+Naming/MethodParameterName:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Max: 10
+
+Metrics/BlockLength:
+  Max: 150

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-06-16
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Keegankb93
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# QrForge
+
+TODO: Delete this and the text below, and describe your gem
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/qr_forge`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+```
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/qr_forge.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/qr_forge/components/eye_inner/circle.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    module EyeInner
+      class Circle < ForgeComponent
+        # how many modules to inset on *each* side
+        INSET_MODULES = 2
+
+        # @see ForgeComponent#draw
+        def draw(y:, x:, quiet_zone:, area:, color: "black", **_)
+          # 1) full-finder radius in modules
+          full_radius = area / 2.0
+
+          # 2) subtract that many modules from *each* side
+          r = full_radius - INSET_MODULES
+
+          return if r <= 0 # no room to draw
+
+          # 3) center calculation
+          cx = x + quiet_zone + full_radius
+          cy = y + quiet_zone + full_radius
+
+          @xml_builder.circle(
+            cx:,
+            cy:,
+            r: r,
+            fill: color,
+            test_id: @test_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/components/eye_inner/square.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    module EyeInner
+      #
+      # Square component for the inner eye of a finder pattern
+      # This draws a 3x3 square in the center of the finder pattern.
+      class Square < ForgeComponent
+        # @see ForgeComponent#draw
+        def draw(y:, x:, quiet_zone:, area:, color: "black", **_)
+          position_offset = 2
+          area_offset = 4
+
+          x = x + position_offset + quiet_zone
+          y = y + position_offset + quiet_zone
+          area_with_offset = area - area_offset
+
+          @xml_builder.rect(
+            x:,
+            y:,
+            width: area_with_offset,
+            height: area_with_offset,
+            fill: color,
+            test_id: @test_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/components/eye_outer/circle.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    module EyeOuter
+      class Circle < ForgeComponent
+        DEFAULT_STROKE_WIDTH = 1.0
+
+        # @see ForgeComponent#draw
+        # Draws a circle that fills the full 'area' box, inset by half the stroke so it
+        # never overlaps the modules beneath.
+        def draw(y:, x:, quiet_zone:, area:, color: "black", **_)
+          stroke_width = DEFAULT_STROKE_WIDTH
+
+          # Radius = (full width of box – one stroke) / 2
+          r = (area - stroke_width) / 2.0
+
+          # Center of the N×N box (plus quiet_zone offset)
+          cx = x + quiet_zone + (area / 2.0)
+          cy = y + quiet_zone + (area / 2.0)
+
+          @xml_builder.circle(
+            cx: cx,
+            cy: cy,
+            r: r,
+            'stroke-width': stroke_width,
+            stroke: color,
+            fill: "transparent",
+            test_id: @test_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/components/eye_outer/square.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    module EyeOuter
+      class Square < ForgeComponent
+        # @see ForgeComponent#draw
+        def draw(y:, x:, quiet_zone:, area:, color: "black", **_)
+          x += quiet_zone
+          y += quiet_zone
+
+          # Draw the outer black square (7x7)
+          @xml_builder.rect(
+            x:,
+            y:,
+            width: area,
+            height: area,
+            fill: color
+          )
+
+          # Draw the inner (cutout) square (5x5) to create the finder pattern
+          inset = 1
+          inner = area - 2
+
+          @xml_builder.rect(
+            x: x + inset,
+            y: y + inset,
+            width: inner,
+            height: inner,
+            fill: color,
+            test_id: @test_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/components/forge_component.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    #
+    # Base class for all components in the QR code design.
+    class ForgeComponent
+      #
+      # @param xml_builder [Nokogiri::XML::Builder]
+      def initialize(xml_builder:, test_id: nil)
+        @xml_builder = xml_builder
+        @test_id = test_id
+      end
+
+      # TODO: For modules pass the next and prev module to change design based on if there is another module next or behind
+      #
+      # @param y [Integer] The row index
+      # @param x [Integer] The col index
+      # @param quiet_zone [Integer] The padding around the QR code
+      # @param area [Integer] width and height of the area to draw (width and height are equal)
+      def draw(y:, x:, quiet_zone:, area:, **_)
+        raise NotImplementedError, "FinderBorder::Base subclasses must implement `draw`"
+      end
+    end
+  end
+end

data/lib/qr_forge/components/module/circle.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    module Module
+      # Circle component for the individual module.
+      class Circle < ForgeComponent
+        # @see ForgeComponent#draw
+        def draw(y:, x:, quiet_zone:, color: "black", **_)
+          r = 0.5
+          cx = x + r + quiet_zone
+          cy = y + r + quiet_zone
+
+          @xml_builder.circle(
+            cx:,
+            cy:,
+            r:,
+            fill: color,
+            test_id: @test_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/components/module/square.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module QrForge
+  module Components
+    module Module
+      # Square component for the individual module.
+      class Square < ForgeComponent
+        # @see ForgeComponent#draw
+        def draw(y:, x:, quiet_zone:, color: "black", **_)
+          x += quiet_zone
+          y += quiet_zone
+          area = 1
+
+          @xml_builder.rect(
+            x:,
+            y:,
+            width: area,
+            height: area,
+            fill: color,
+            test_id: @test_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/exporter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "vips"
+
+module QrForge
+  #
+  # Handles exporting the generated QR code in various formats.
+  class Exporter
+    def initialize(config:)
+      @format = config.dig(:output, :format) || :svg
+    end
+
+    def export(svg)
+      case @format
+      when :svg
+        svg
+      when :png
+        as_png(svg)
+      else
+        raise "Unsupported export format: #{@format}"
+      end
+    end
+
+    private
+
+    #
+    # Exports the SVG to PNG format using Vips.
+    # @param svg [String] The SVG content to convert
+    # @return [StringIO] A StringIO object containing the PNG data
+    def as_png(svg)
+      image = Vips::Image.svgload_buffer(svg)
+      # TODO: Compression doesn't really seem to give much noticeable difference in quality or file size.
+      buffer = image.write_to_buffer(".png")
+
+      StringIO.new(buffer)
+    end
+  end
+end

data/lib/qr_forge/forge.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module QrForge
+  #
+  # Entry point for building QRCodes
+  class Forge
+    def initialize(text:, config:)
+      version = config.dig(:qr, :version)
+
+      @data = QrForge::QrData.new(text:, version:)
+      @renderer = QrForge::Renderer.new(qr_data: @data, config:)
+      @exporter = QrForge::Exporter.new(config:)
+    end
+
+    #
+    # Builds a QR code with the given parameters.
+    # @param text [String] The text/data to encode in the QR code
+    # @param size [Integer] The size of the QR code in modules [1-40]
+    # @return [String, StringIO] The SVG or PNG representation of the QR code
+    def self.build(text:, config: {})
+      new(text:, config:).build
+    end
+
+    def build
+      svg = @renderer.to_svg
+      @exporter.export(svg)
+    end
+  end
+end

data/lib/qr_forge/layout.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module QrForge
+  # Responsible only for computing all the exclusion & pattern zones
+  class Layout
+    FINDER_PATTERN_SIZE = 7
+    ALIGNMENT_PATTERN_SIZE = 5
+
+    def initialize(qr_data:, has_image: false)
+      @qr_data = qr_data
+      @module_count = qr_data.module_count
+      @version = qr_data.version
+      @modules = qr_data.modules
+      @has_image = has_image
+
+      # build_cache
+    end
+
+    #
+    # Checks if a given row and column are inside the image area.
+    # @param row [Integer] the row index
+    # @param col [Integer] the column index
+    # @return [Boolean] true if the row and column are inside the image area, false otherwise
+    def inside_image?(row, col)
+      inside_area?(row, col, image_area)
+    end
+
+    #
+    # Checks if a given row and column are inside the finder patterns.
+    # @param row [Integer] the row index
+    # @param col [Integer] the column index
+    # @return [Boolean] true if the row and column are inside any finder pattern, false otherwise
+    def inside_finder?(row, col)
+      inside_area?(row, col, finder_patterns[:areas])
+    end
+
+    #
+    # Checks if a given row and column are inside the alignment patterns.
+    # @param row [Integer] the row index
+    # @param col [Integer] the column index
+    # @return [Boolean] true if the row and column are inside any alignment pattern, false otherwise
+    def inside_alignment?(row, col)
+      inside_area?(row, col, alignment_patterns[:areas])
+    end
+
+    #
+    # Returns the image area as a Range of rows and columns.
+    # The image area is centered in the QR code and its size is based on the module count.
+    # @return [Range] the range of rows and columns that the image area covers
+    def image_area
+      @image_area ||= begin
+        raw  = (@module_count * 0.30).round
+        size = raw.even? ? raw + 1 : raw
+        start_idx = ((@module_count - size) / 2.0).floor
+        (start_idx...(start_idx + size))
+      end
+    end
+
+    #
+    # Returns the finder patterns' coordinates and areas.
+    # Coordinates are the top-left corners of the finder patterns.
+    # Areas are the ranges of rows and columns that the finder patterns cover.
+    # @return [Hash] with keys :coordinates and :areas
+    def finder_patterns
+      @finder_patterns ||= begin
+        offset = @module_count - FINDER_PATTERN_SIZE
+        coordinates = [[0, 0], [0, offset], [offset, 0]]
+        areas = []
+
+        coordinates.map do |row, col|
+          areas << [(row...(row + FINDER_PATTERN_SIZE)), (col...(col + FINDER_PATTERN_SIZE))]
+        end
+
+        { coordinates: coordinates, areas: areas }
+      end
+    end
+
+    # TODO: Remove some complexity out of this method
+    # Returns the alignment patterns' coordinates and areas.
+    # Coordinates are the top-left corners of the alignment patterns.
+    # Areas are the ranges of rows and columns that the alignment patterns cover.
+    # @return [Hash] with keys :coordinates and :areas
+    def alignment_patterns
+      @alignment_patterns ||= begin
+        # Offset from center to top-left corner of the alignment pattern
+        half_offset = (ALIGNMENT_PATTERN_SIZE - 1) / 2
+
+        # RQRCodeCore provides a helper method to get the alignment pattern centers
+        alignment_center_coordinates = RQRCodeCore::QRUtil.get_pattern_positions(@version)
+
+        # Filter out centers that are inside finder patterns or the image area
+        valid_alignment_coordinates = alignment_center_coordinates.product(alignment_center_coordinates).reject do |center_row, center_col|
+          inside_finder?(center_row, center_col) || (@has_image && inside_image?(center_row, center_col))
+        end
+
+        locations = { coordinates: [], areas: [] }
+
+        # Map valid alignment centers to their top-left corners and areas
+        valid_alignment_coordinates.map do |center_row, center_col|
+          top_left_row = center_row - half_offset
+          top_left_col = center_col - half_offset
+
+          locations[:coordinates] << [top_left_row, top_left_col]
+
+          row_range = top_left_row...(top_left_row + ALIGNMENT_PATTERN_SIZE)
+          col_range = top_left_col...(top_left_col + ALIGNMENT_PATTERN_SIZE)
+
+          locations[:areas] << [row_range, col_range]
+        end
+
+        locations
+      end
+    end
+
+    private
+
+    #
+    # Checks if a given row and column are inside a specified area.
+    # @return [Boolean] true if the row and column are inside the area, false otherwise
+    def inside_area?(row, col, area)
+      case area
+      when Range
+        area.cover?(row) && area.cover?(col)
+      when Array
+        Array(area).any? do |row_range, col_range|
+          row_range.cover?(row) && col_range.cover?(col)
+        end
+      else
+        raise ArgumentError, "Invalid area type: #{area.class}. Expected Range or Array of Ranges."
+      end
+    end
+
+    # Potentially implement caching for layouts. Benchmark saves 100-150ms on a version 40 QR code
+    # Most time spent is via RQRCodeCore.new and vips
+    # def build_cache
+    #   @cache = {
+    #   }
+    #
+    #   @cache[:logo] ||= compute_logo_coords
+    #   @cache[:finder] ||= compute_coords_for_areas(finder_patterns[:areas])
+    #   @cache[:alignment] ||= compute_coords_for_areas(alignment_patterns[:areas])
+    #
+    #   @cache
+    # end
+
+    # Turn a single Range (logo area) into a Set of [row,col] pairs
+    # def compute_logo_coords
+    #   coords = []
+    #
+    #   # Declare for readability
+    #   row_range = logo_area
+    #   col_range = logo_area
+    #
+    #   row_range.to_a.each do |r|
+    #     col_range.to_a.each do |c|
+    #       coords << [r, c]
+    #     end
+    #   end
+    #   coords.to_set
+    # end
+    #
+    # # Turn an Array of [row_range, col_range] into a Set of all covered coords
+    # def compute_coords_for_areas(areas)
+    #   coords = []
+    #   areas.each do |row_range, col_range|
+    #     row_range.to_a.each do |r|
+    #       col_range.to_a.each do |c|
+    #         coords << [r, c]
+    #       end
+    #     end
+    #   end
+    #   coords.to_set
+    # end
+  end
+end

data/lib/qr_forge/qr_data.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rqrcode_core/qrcode"
+
+module QrForge
+  #
+  # QrData is a wrapper around RQRCodeCore::QRCode that provides
+  # a simplified interface for accessing QR code data.
+  # We can also add additional data related to the QR code, but not always RQRCodeCore related
+  class QrData
+    attr_reader :modules, :version, :module_count, :quiet_zone
+
+    def initialize(text:, version: 10, level: :h)
+      qr = RQRCodeCore::QRCode.new(text, size: version, level: level)
+      @version = qr.version
+      @modules = qr.modules.map(&:dup)
+      @module_count = @modules.size
+    end
+  end
+end

data/lib/qr_forge/renderer.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "layout"
+
+module QrForge
+  #
+  # Renderer class is responsible for generating the SVG representation of a QR code.
+  #
+  # It takes QR data, design options, and renders the QR code with finder patterns, alignment patterns,
+  # and modules. It also handles the image if provided.
+  class Renderer
+    # Rendering of how row and column indices relate to the finder pattern:
+    #
+    #               col_index (x)
+    #              0 1 2 3 4 5 6
+    # row_index (y)
+    #   0          # # # # # # #
+    #   1          # . . . . . #
+    #   2          # . # # # . #
+    #   3          # . # X # . #   ← (3,3) is inside the finder
+    #   4          # . # # # . #
+    #   5          # . . . . . #
+    #   6          # # # # # # #
+    #
+    # Legend:
+    #   "#" = dark module (true)
+    #   "." = light module (false)
+    #   "X" = example point at (row_index=3, col_index=3)
+    #
+
+    DEFAULT_COLORS = {
+      module: "black",
+      outer_eye: "black",
+      inner_eye: "black"
+    }.freeze
+
+    DEFAULT_COMPONENTS = {
+      outer_eye: ::QrForge::Components::EyeOuter::Circle,
+      inner_eye: ::QrForge::Components::EyeInner::Circle,
+      module: ::QrForge::Components::Module::Circle
+    }.freeze
+
+    def initialize(qr_data:, config:)
+      @qr_data = qr_data
+      @components = DEFAULT_COMPONENTS.merge(config.fetch(:components, {}))
+      @quiet_zone = 4
+      @module_count = qr_data.module_count
+      @image = config.dig(:design, :image)
+      @width = config.dig(:design, :size)
+      @height = config.dig(:design, :size)
+      @colors = DEFAULT_COLORS.merge(config.dig(:design, :colors) || {})
+      @layout = QrForge::Layout.new(qr_data:, has_image: image_present?)
+    end
+
+    #
+    # Generates the SVG representation of the QR code.
+    def to_svg
+      Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+        xml.svg(
+          width: @width || canvas_size,
+          height: @height || canvas_size,
+          xmlns: "http://www.w3.org/2000/svg",
+          viewBox: "0 0 #{canvas_size} #{canvas_size}"
+        ) do
+          draw_background(xml)
+          draw_image(xml)
+          draw_finder_patterns(xml)
+          draw_alignment_patterns(xml)
+          draw_modules(xml)
+        end
+      end.to_xml
+    end
+
+    #
+    # Calculates the size of the canvas for the QR code.
+    # The canvas size is the module count plus the quiet zone on both sides.
+    #
+    # @return [Integer] the total size of the canvas in modules
+    #
+    # The quiet zone is a margin around the QR code to ensure readability.
+    def canvas_size
+      @canvas_size ||= @module_count + (@quiet_zone * 2)
+    end
+
+    private
+
+    #
+    # Checks if an image is present.
+    # @return [Boolean] true if an image is provided, false otherwise
+    def image_present?
+      !@image.nil? && !@image.empty?
+    end
+
+    #
+    # Draws the image in the center of the QR code if an image is provided and the QR code version is 2 or higher.
+    # The image is drawn in the area defined by the image_range, which is a Range of row indices.
+    def draw_image(xml)
+      return unless image_present? && @qr_data.version >= 2
+
+      image_range = @layout.image_area # a Range (row indices) for the image
+      size = image_range.size # width/height in modules
+
+      # Convert module coords → SVG coords (including quiet zone)
+      x = image_range.first + @quiet_zone
+      y = image_range.first + @quiet_zone
+
+      xml.image(
+        test_id: "image",
+        href: "data:image/png;base64,#{@image}",
+        x:,
+        y:,
+        width: size,
+        height: size,
+        preserveAspectRatio: "none"
+      )
+    end
+
+    #
+    # Draws the background rectangle for the QR code. Should always be white to ensure contrast.
+    # The rectangle is drawn with a size that includes the quiet zone around the QR code.
+    def draw_background(xml)
+      xml.rect(
+        test_id: "background",
+        x: -@quiet_zone,
+        y: -@quiet_zone,
+        width: canvas_size + @quiet_zone,
+        height: canvas_size + @quiet_zone,
+        fill: "white"
+      )
+    end
+
+    #
+    # Draws the finder patterns in the QR code.
+    # The finder patterns are the large squares in the corners of the QR code.
+    def draw_finder_patterns(xml)
+      @layout.finder_patterns[:coordinates].each.with_index do |(r, c), idx|
+        %i[outer_eye inner_eye].each do |layer|
+          @components[layer]
+            .new(xml_builder: xml, test_id: "finder_pattern_#{layer}_#{idx}")
+            .draw(y: r, x: c, quiet_zone: @quiet_zone, area: QrForge::Layout::FINDER_PATTERN_SIZE, color: @colors[layer])
+        end
+      end
+    end
+
+    #
+    # Draws the alignment patterns in the QR code.
+    # The alignment patterns are smaller squares that help with error correction.
+    def draw_alignment_patterns(xml)
+      size = QrForge::Layout::ALIGNMENT_PATTERN_SIZE
+
+      @layout.alignment_patterns[:coordinates].each.with_index do |(r, c), idx|
+        %i[outer_eye inner_eye].each do |layer|
+          @components[layer]
+            .new(xml_builder: xml, test_id: "alignment_pattern_#{layer}_#{idx}")
+            .draw(y: r, x: c, quiet_zone: @quiet_zone, area: size, color: @colors[layer])
+        end
+      end
+    end
+
+    # TODO: This can probably be optional as we can also just layer the image on top of the QR code.
+    # Removes modules in the image area if a image is present and the QR code version is 2 or higher.
+    #
+    # @return [void]
+    def remove_modules_for_image
+      return unless image_present? && @qr_data.version >= 2
+
+      image_area = @layout.image_area
+
+      image_area.each do |r|
+        image_area.each do |c|
+          @qr_data.modules[r][c] = false
+        end
+      end
+    end
+
+    #
+    # Draws the individual modules of the QR code.
+    def draw_modules(xml)
+      remove_modules_for_image
+
+      @qr_data.modules.each_with_index do |row, r|
+        row.each_with_index do |cell, c|
+          next if !cell ||
+                  @layout.inside_finder?(r, c) ||
+                  @layout.inside_alignment?(r, c)
+
+          @components[:module]
+            .new(xml_builder: xml, test_id: "module_#{r}_#{c}")
+            .draw(y: r, x: c, quiet_zone: @quiet_zone, area: 1, color: @colors[:module])
+        end
+      end
+    end
+  end
+end

data/lib/qr_forge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module QrForge
+  VERSION = "1.0.0"
+end

data/lib/qr_forge.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module QrForge;end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: qr_forge
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Keegankb93
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.18'
+- !ruby/object:Gem::Dependency
+  name: rqrcode_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.15'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.40'
+email:
+- keegankb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/qr_forge.rb
+- lib/qr_forge/components/eye_inner/circle.rb
+- lib/qr_forge/components/eye_inner/square.rb
+- lib/qr_forge/components/eye_outer/circle.rb
+- lib/qr_forge/components/eye_outer/square.rb
+- lib/qr_forge/components/forge_component.rb
+- lib/qr_forge/components/module/circle.rb
+- lib/qr_forge/components/module/square.rb
+- lib/qr_forge/exporter.rb
+- lib/qr_forge/forge.rb
+- lib/qr_forge/layout.rb
+- lib/qr_forge/qr_data.rb
+- lib/qr_forge/renderer.rb
+- lib/qr_forge/version.rb
+homepage: https://github.com/keegankb93/qr_forge
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/keegankb93/qr_forge
+  source_code_uri: https://github.com/keegankb93/qr_forge
+  changelog_uri: https://github.com/keegankb93/qr_forge/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: QRForge is a Ruby gem for rendering QR codes with different designs and formats.
+test_files: []