qr_code_maker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 883092da5fc7735a8babef3fe6bb57b630147a3ed7c4ce7c21e3e095b829c9e8
+  data.tar.gz: 26869583a0e07a791bd552a2675000e5b33cf00c4217e08e82cca4208f7bc196
+SHA512:
+  metadata.gz: 44d9ea7bd6708381e7445a180956273309269b50d5b9ff54ce8c01736c8c48de030fb4ff6a3a154ad195f3c27d73ca8a488d0d6ccf58c861fe5e2a316b90d9da
+  data.tar.gz: 2b9e34abdbae056cf89512be3ebbb9216832db62af0a9d2f9b063bc019e63e864607cf02ea287c10ec968c08052cec14ce97b6eca3be1757d91dd08b80a53e53

data/README.md

@@ -0,0 +1,78 @@
+# qr_code_maker
+
+_A simple, zero-dependency, standard-library-only QR code generator for Ruby._
+
+`qr_code_maker` is written in pure Ruby, with no external gem dependencies. It supports the full QR Code specification (Versions 1-40, ECC levels L, M, Q, H) and generates vector SVG strings or terminal ASCII art.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'qr_code_maker'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install qr_code_maker
+```
+
+## Usage
+
+### High-Level API (Quickest)
+
+You can generate QR code SVG strings or ASCII prints directly from a URL or text string:
+
+```ruby
+require 'qr_code_maker'
+
+# Generate a raw SVG string
+svg = QrCodeMaker.generate_svg("https://github.com")
+
+# Generate an ASCII terminal representation
+ascii = QrCodeMaker.generate_ascii("https://github.com")
+puts ascii
+```
+
+### Object-Oriented API
+
+If you need more control, you can instantiate a `QRCode` object:
+
+```ruby
+require 'qr_code_maker'
+
+# Create the QR Code object with custom Error Correction Level (:l, :m, :q, or :h)
+qr = QrCodeMaker::QRCode.new("https://github.com", level: :m)
+
+# Access metadata
+puts qr.version            # The auto-chosen QR version (1-40)
+puts qr.module_count       # Dimension of the grid (width/height)
+puts qr.checked?(0, 0)     # Check if the module at (row, col) is dark (true) or light (false)
+
+# Render to SVG with options
+svg = qr.as_svg(
+  color: "black",          # Foreground color of the modules
+  bg_color: "white",       # Background color (set to nil or false for transparent)
+  module_size: 10,         # Size of each module in pixels
+  margin: 4                # Number of modules for quiet zone margin
+)
+```
+
+## Running Tests
+
+Run the automated test suite with:
+
+```bash
+ruby -Ilib -Itest test/test_qr_code_maker.rb
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/qr_code_maker/encoder.rb

@@ -0,0 +1,1031 @@
+# frozen_string_literal: true
+
+module QrCodeMaker
+  QRMODE = {
+    mode_number: 1 << 0,      # 1
+    mode_alpha_numk: 1 << 1,  # 2
+    mode_8bit_byte: 1 << 2   # 4
+  }.freeze
+
+  QRMODE_NAME = {
+    number: :mode_number,
+    alphanumeric: :mode_alpha_numk,
+    byte_8bit: :mode_8bit_byte,
+    multi: :mode_multi
+  }.freeze
+
+  QRERRORCORRECTLEVEL = {
+    l: 1,
+    m: 0,
+    q: 3,
+    h: 2
+  }.freeze
+
+  QRMASKPATTERN = {
+    pattern000: 0,
+    pattern001: 1,
+    pattern010: 2,
+    pattern011: 3,
+    pattern100: 4,
+    pattern101: 5,
+    pattern110: 6,
+    pattern111: 7
+  }.freeze
+
+  QRMASKCOMPUTATIONS = [
+    proc { |i, j| (i + j) % 2 == 0 },
+    proc { |i, j| i % 2 == 0 },
+    proc { |i, j| j % 3 == 0 },
+    proc { |i, j| (i + j) % 3 == 0 },
+    proc { |i, j| ((i / 2).floor + (j / 3).floor) % 2 == 0 },
+    proc { |i, j| (i * j) % 2 + (i * j) % 3 == 0 },
+    proc { |i, j| ((i * j) % 2 + (i * j) % 3) % 2 == 0 },
+    proc { |i, j| ((i * j) % 3 + (i + j) % 2) % 2 == 0 }
+  ].freeze
+
+  QRPOSITIONPATTERNLENGTH = (7 + 1) * 2 + 1
+  QRFORMATINFOLENGTH = 15
+
+  QRMAXBITS = {
+    l: [152, 272, 440, 640, 864, 1088, 1248, 1552, 1856, 2192, 2592, 2960, 3424, 3688, 4184,
+      4712, 5176, 5768, 6360, 6888, 7456, 8048, 8752, 9392, 10_208, 10_960, 11_744, 12_248,
+      13_048, 13_880, 14_744, 15_640, 16_568, 17_528, 18_448, 19_472, 20_528, 21_616, 22_496, 23_648],
+    m: [128, 224, 352, 512, 688, 864, 992, 1232, 1456, 1728, 2032, 2320, 2672, 2920, 3320, 3624,
+      4056, 4504, 5016, 5352, 5712, 6256, 6880, 7312, 8000, 8496, 9024, 9544, 10_136, 10_984,
+      11_640, 12_328, 13_048, 13_800, 14_496, 15_312, 15_936, 16_816, 17_728, 18_672],
+    q: [104, 176, 272, 384, 496, 608, 704, 880, 1056, 1232, 1440, 1648, 1952, 2088, 2360, 2600, 2936,
+      3176, 3560, 3880, 4096, 4544, 4912, 5312, 5744, 6032, 6464, 6968, 7288, 7880, 8264, 8920, 9368,
+      9848, 10288, 10832, 11408, 12016, 12656, 13328],
+    h: [72, 128, 208, 288, 368, 480, 528, 688, 800, 976, 1120, 1264, 1440, 1576, 1784,
+      2024, 2264, 2504, 2728, 3080, 3248, 3536, 3712, 4112, 4304, 4768, 5024, 5288, 5608, 5960,
+      6344, 6760, 7208, 7688, 7888, 8432, 8768, 9136, 9776, 10_208]
+  }.freeze
+
+  class QRCodeArgumentError < ArgumentError; end
+  class QRCodeRunTimeError < RuntimeError; end
+
+  class QRMath
+    module_eval {
+      exp_table = Array.new(256)
+      log_table = Array.new(256)
+
+      8.times do |i|
+        exp_table[i] = 1 << i
+      end
+
+      (8...256).each do |i|
+        exp_table[i] = exp_table[i - 4] \
+          ^ exp_table[i - 5] \
+          ^ exp_table[i - 6] \
+          ^ exp_table[i - 8]
+      end
+
+      255.times do |i|
+        log_table[exp_table[i]] = i
+      end
+
+      const_set(:EXP_TABLE, exp_table).freeze
+      const_set(:LOG_TABLE, log_table).freeze
+    }
+
+    class << self
+      def glog(n)
+        raise QRCodeRunTimeError, "glog(#{n})" if n < 1
+        LOG_TABLE[n]
+      end
+
+      def gexp(n)
+        while n < 0
+          n += 255
+        end
+
+        while n >= 256
+          n -= 255
+        end
+
+        EXP_TABLE[n]
+      end
+    end
+  end
+
+  class QRPolynomial
+    def initialize(num, shift)
+      raise QRCodeRunTimeError, "#{num.size}/#{shift}" if num.empty?
+      offset = 0
+
+      while offset < num.size && num[offset] == 0
+        offset += 1
+      end
+
+      @num = Array.new(num.size - offset + shift)
+
+      (0...num.size - offset).each do |i|
+        @num[i] = num[i + offset]
+      end
+    end
+
+    def get(index)
+      @num[index]
+    end
+
+    def get_length
+      @num.size
+    end
+
+    def multiply(e)
+      num = Array.new(get_length + e.get_length - 1)
+
+      (0...get_length).each do |i|
+        (0...e.get_length).each do |j|
+          tmp = num[i + j].nil? ? 0 : num[i + j]
+          num[i + j] = tmp ^ QRMath.gexp(QRMath.glog(get(i)) + QRMath.glog(e.get(j)))
+        end
+      end
+
+      QRPolynomial.new(num, 0)
+    end
+
+    def mod(e)
+      if get_length - e.get_length < 0
+        return self
+      end
+
+      ratio = QRMath.glog(get(0)) - QRMath.glog(e.get(0))
+      num = Array.new(get_length)
+
+      (0...get_length).each do |i|
+        num[i] = get(i)
+      end
+
+      (0...e.get_length).each do |i|
+        tmp = num[i].nil? ? 0 : num[i]
+        num[i] = tmp ^ QRMath.gexp(QRMath.glog(e.get(i)) + ratio)
+      end
+
+      QRPolynomial.new(num, 0).mod(e)
+    end
+  end
+
+  class QRRSBlock
+    attr_reader :data_count, :total_count
+
+    def initialize(total_count, data_count)
+      @total_count = total_count
+      @data_count = data_count
+    end
+
+    RS_BLOCK_TABLE = [
+      [1, 26, 19], [1, 26, 16], [1, 26, 13], [1, 26, 9],
+      [1, 44, 34], [1, 44, 28], [1, 44, 22], [1, 44, 16],
+      [1, 70, 55], [1, 70, 44], [2, 35, 17], [2, 35, 13],
+      [1, 100, 80], [2, 50, 32], [2, 50, 24], [4, 25, 9],
+      [1, 134, 108], [2, 67, 43], [2, 33, 15, 2, 34, 16], [2, 33, 11, 2, 34, 12],
+      [2, 86, 68], [4, 43, 27], [4, 43, 19], [4, 43, 15],
+      [2, 98, 78], [4, 49, 31], [2, 32, 14, 4, 33, 15], [4, 39, 13, 1, 40, 14],
+      [2, 121, 97], [2, 60, 38, 2, 61, 39], [4, 40, 18, 2, 41, 19], [4, 40, 14, 2, 41, 15],
+      [2, 146, 116], [3, 58, 36, 2, 59, 37], [4, 36, 16, 4, 37, 17], [4, 36, 12, 4, 37, 13],
+      [2, 86, 68, 2, 87, 69], [4, 69, 43, 1, 70, 44], [6, 43, 19, 2, 44, 20], [6, 43, 15, 2, 44, 16],
+      [4, 101, 81], [1, 80, 50, 4, 81, 51], [4, 50, 22, 4, 51, 23], [3, 36, 12, 8, 37, 13],
+      [2, 116, 92, 2, 117, 93], [6, 58, 36, 2, 59, 37], [4, 46, 20, 6, 47, 21], [7, 42, 14, 4, 43, 15],
+      [4, 133, 107], [8, 59, 37, 1, 60, 38], [8, 44, 20, 4, 45, 21], [12, 33, 11, 4, 34, 12],
+      [3, 145, 115, 1, 146, 116], [4, 64, 40, 5, 65, 41], [11, 36, 16, 5, 37, 17], [11, 36, 12, 5, 37, 13],
+      [5, 109, 87, 1, 110, 88], [5, 65, 41, 5, 66, 42], [5, 54, 24, 7, 55, 25], [11, 36, 12, 7, 37, 13],
+      [5, 122, 98, 1, 123, 99], [7, 73, 45, 3, 74, 46], [15, 43, 19, 2, 44, 20], [3, 45, 15, 13, 46, 16],
+      [1, 135, 107, 5, 136, 108], [10, 74, 46, 1, 75, 47], [1, 50, 22, 15, 51, 23], [2, 42, 14, 17, 43, 15],
+      [5, 150, 120, 1, 151, 121], [9, 69, 43, 4, 70, 44], [17, 50, 22, 1, 51, 23], [2, 42, 14, 19, 43, 15],
+      [3, 141, 113, 4, 142, 114], [3, 70, 44, 11, 71, 45], [17, 47, 21, 4, 48, 22], [9, 39, 13, 16, 40, 14],
+      [3, 135, 107, 5, 136, 108], [3, 67, 41, 13, 68, 42], [15, 54, 24, 5, 55, 25], [15, 43, 15, 10, 44, 16],
+      [4, 144, 116, 4, 145, 117], [17, 68, 42], [17, 50, 22, 6, 51, 23], [19, 46, 16, 6, 47, 17],
+      [2, 139, 111, 7, 140, 112], [17, 74, 46], [7, 54, 24, 16, 55, 25], [34, 37, 13],
+      [4, 151, 121, 5, 152, 122], [4, 75, 47, 14, 76, 48], [11, 54, 24, 14, 55, 25], [16, 45, 15, 14, 46, 16],
+      [6, 147, 117, 4, 148, 118], [6, 73, 45, 14, 74, 46], [11, 54, 24, 16, 55, 25], [30, 46, 16, 2, 47, 17],
+      [8, 132, 106, 4, 133, 107], [8, 75, 47, 13, 76, 48], [7, 54, 24, 22, 55, 25], [22, 45, 15, 13, 46, 16],
+      [10, 142, 114, 2, 143, 115], [19, 74, 46, 4, 75, 47], [28, 50, 22, 6, 51, 23], [33, 46, 16, 4, 47, 17],
+      [8, 152, 122, 4, 153, 123], [22, 73, 45, 3, 74, 46], [8, 53, 23, 26, 54, 24], [12, 45, 15, 28, 46, 16],
+      [3, 147, 117, 10, 148, 118], [3, 73, 45, 23, 74, 46], [4, 54, 24, 31, 55, 25], [11, 45, 15, 31, 46, 16],
+      [7, 146, 116, 7, 147, 117], [21, 73, 45, 7, 74, 46], [1, 53, 23, 37, 54, 24], [19, 45, 15, 26, 46, 16],
+      [5, 145, 115, 10, 146, 116], [19, 75, 47, 10, 76, 48], [15, 54, 24, 25, 55, 25], [23, 45, 15, 25, 46, 16],
+      [13, 145, 115, 3, 146, 116], [2, 74, 46, 29, 75, 47], [42, 54, 24, 1, 55, 25], [23, 45, 15, 28, 46, 16],
+      [17, 145, 115], [10, 74, 46, 23, 75, 47], [10, 54, 24, 35, 55, 25], [19, 45, 15, 35, 46, 16],
+      [17, 145, 115, 1, 146, 116], [14, 74, 46, 21, 75, 47], [29, 54, 24, 19, 55, 25], [11, 45, 15, 46, 46, 16],
+      [13, 145, 115, 6, 146, 116], [14, 74, 46, 23, 75, 47], [44, 54, 24, 7, 55, 25], [59, 46, 16, 1, 47, 17],
+      [12, 151, 121, 7, 152, 122], [12, 75, 47, 26, 76, 48], [39, 54, 24, 14, 55, 25], [22, 45, 15, 41, 46, 16],
+      [6, 151, 121, 14, 152, 122], [6, 75, 47, 34, 76, 48], [46, 54, 24, 10, 55, 25], [2, 45, 15, 64, 46, 16],
+      [17, 152, 122, 4, 153, 123], [29, 74, 46, 14, 75, 47], [49, 54, 24, 10, 55, 25], [24, 45, 15, 46, 46, 16],
+      [4, 152, 122, 18, 153, 123], [13, 74, 46, 32, 75, 47], [48, 54, 24, 14, 55, 25], [42, 45, 15, 32, 46, 16],
+      [20, 147, 117, 4, 148, 118], [40, 75, 47, 7, 76, 48], [43, 54, 24, 22, 55, 25], [10, 45, 15, 67, 46, 16],
+      [19, 148, 118, 6, 149, 119], [18, 75, 47, 31, 76, 48], [34, 54, 24, 34, 55, 25], [20, 45, 15, 61, 46, 16]
+    ].freeze
+
+    def self.get_rs_blocks(version, error_correct_level)
+      rs_block = get_rs_block_table(version, error_correct_level)
+      raise QRCodeRunTimeError, "bad rsblock @ version: #{version}/error_correct_level:#{error_correct_level}" if rs_block.nil?
+
+      length = rs_block.size / 3
+      list = []
+
+      (0...length).each do |i|
+        count = rs_block[i * 3 + 0]
+        total_count = rs_block[i * 3 + 1]
+        data_count = rs_block[i * 3 + 2]
+
+        (0...count).each do
+          list << QRRSBlock.new(total_count, data_count)
+        end
+      end
+      list
+    end
+
+    def self.get_rs_block_table(version, error_correct_level)
+      case error_correct_level
+      when QRERRORCORRECTLEVEL[:l]
+        RS_BLOCK_TABLE[(version - 1) * 4 + 0]
+      when QRERRORCORRECTLEVEL[:m]
+        RS_BLOCK_TABLE[(version - 1) * 4 + 1]
+      when QRERRORCORRECTLEVEL[:q]
+        RS_BLOCK_TABLE[(version - 1) * 4 + 2]
+      when QRERRORCORRECTLEVEL[:h]
+        RS_BLOCK_TABLE[(version - 1) * 4 + 3]
+      end
+    end
+  end
+
+  class QRUtil
+    PATTERN_POSITION_TABLE = [
+      [],
+      [6, 18], [6, 22], [6, 26], [6, 30], [6, 34], [6, 22, 38], [6, 24, 42], [6, 26, 46], [6, 28, 50], [6, 30, 54],
+      [6, 32, 58], [6, 34, 62], [6, 26, 46, 66], [6, 26, 48, 70], [6, 26, 50, 74], [6, 30, 54, 78], [6, 30, 56, 82],
+      [6, 30, 58, 86], [6, 34, 62, 90], [6, 28, 50, 72, 94], [6, 26, 50, 74, 98], [6, 30, 54, 78, 102],
+      [6, 28, 54, 80, 106], [6, 32, 58, 84, 110], [6, 30, 58, 86, 114], [6, 34, 62, 90, 118],
+      [6, 26, 50, 74, 98, 122], [6, 30, 54, 78, 102, 126], [6, 26, 52, 78, 104, 130], [6, 30, 56, 82, 108, 134],
+      [6, 34, 60, 86, 112, 138], [6, 30, 58, 86, 114, 142], [6, 34, 62, 90, 118, 146], [6, 30, 54, 78, 102, 126, 150],
+      [6, 24, 50, 76, 102, 128, 154], [6, 28, 54, 80, 106, 132, 158], [6, 32, 58, 84, 110, 136, 162],
+      [6, 26, 54, 82, 110, 138, 166], [6, 30, 58, 86, 114, 142, 170]
+    ].freeze
+
+    G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0
+    G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0
+    G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1
+
+    DEMERIT_POINTS_1 = 3
+    DEMERIT_POINTS_2 = 3
+    DEMERIT_POINTS_3 = 40
+    DEMERIT_POINTS_4 = 10
+
+    BITS_FOR_MODE = {
+      QRMODE[:mode_number] => [10, 12, 14],
+      QRMODE[:mode_alpha_numk] => [9, 11, 13],
+      QRMODE[:mode_8bit_byte] => [8, 16, 16]
+    }.freeze
+
+    ARCH_BITS = ENV.fetch("RQRCODE_CORE_ARCH_BITS", nil)&.to_i || 1.size * 8
+
+    def self.max_size
+      PATTERN_POSITION_TABLE.count
+    end
+
+    def self.get_bch_format_info(data)
+      d = data << 10
+      while get_bch_digit(d) - get_bch_digit(G15) >= 0
+        d ^= (G15 << (get_bch_digit(d) - get_bch_digit(G15)))
+      end
+      ((data << 10) | d) ^ G15_MASK
+    end
+
+    def self.rszf(num, count)
+      (num >> count) & ((1 << (ARCH_BITS - count)) - 1)
+    end
+
+    def self.get_bch_version(data)
+      d = data << 12
+      while get_bch_digit(d) - get_bch_digit(G18) >= 0
+        d ^= (G18 << (get_bch_digit(d) - get_bch_digit(G18)))
+      end
+      (data << 12) | d
+    end
+
+    def self.get_bch_digit(data)
+      digit = 0
+      while data != 0
+        digit += 1
+        data = rszf(data, 1)
+      end
+      digit
+    end
+
+    def self.get_pattern_positions(version)
+      PATTERN_POSITION_TABLE[version - 1]
+    end
+
+    def self.get_mask(mask_pattern, i, j)
+      raise QRCodeRunTimeError, "bad mask_pattern: #{mask_pattern}" if mask_pattern > QRMASKCOMPUTATIONS.size
+      QRMASKCOMPUTATIONS[mask_pattern].call(i, j)
+    end
+
+    def self.get_error_correct_polynomial(error_correct_length)
+      a = QRPolynomial.new([1], 0)
+      (0...error_correct_length).each do |i|
+        a = a.multiply(QRPolynomial.new([1, QRMath.gexp(i)], 0))
+      end
+      a
+    end
+
+    def self.get_length_in_bits(mode, version)
+      raise QRCodeRunTimeError, "Unknown mode: #{mode}" unless QRMODE.value?(mode)
+      raise QRCodeRunTimeError, "Unknown version: #{version}" if version > 40
+
+      if version.between?(1, 9)
+        macro_version = 0
+      elsif version <= 26
+        macro_version = 1
+      elsif version <= 40
+        macro_version = 2
+      end
+
+      BITS_FOR_MODE[mode][macro_version]
+    end
+
+    def self.get_lost_points(modules)
+      demerit_points = 0
+      demerit_points += demerit_points_1_same_color(modules)
+      demerit_points += demerit_points_2_full_blocks(modules)
+      demerit_points += demerit_points_3_dangerous_patterns(modules)
+      demerit_points += demerit_points_4_dark_ratio(modules)
+      demerit_points
+    end
+
+    def self.demerit_points_1_same_color(modules)
+      demerit_points = 0
+      module_count = modules.size
+      max_index = module_count - 1
+
+      module_count.times do |row|
+        modules_row = modules[row]
+        module_count.times do |col|
+          same_count = 0
+          dark = modules_row[col]
+
+          if row > 0
+            row_above = modules[row - 1]
+            same_count += 1 if col > 0 && dark == row_above[col - 1]
+            same_count += 1 if dark == row_above[col]
+            same_count += 1 if col < max_index && dark == row_above[col + 1]
+          end
+
+          same_count += 1 if col > 0 && dark == modules_row[col - 1]
+          same_count += 1 if col < max_index && dark == modules_row[col + 1]
+
+          if row < max_index
+            row_below = modules[row + 1]
+            same_count += 1 if col > 0 && dark == row_below[col - 1]
+            same_count += 1 if dark == row_below[col]
+            same_count += 1 if col < max_index && dark == row_below[col + 1]
+          end
+
+          demerit_points += (DEMERIT_POINTS_1 + same_count - 5) if same_count > 5
+        end
+      end
+      demerit_points
+    end
+
+    def self.demerit_points_2_full_blocks(modules)
+      demerit_points = 0
+      module_count = modules.size
+      max_row = module_count - 1
+
+      max_row.times do |row|
+        row_curr = modules[row]
+        row_next = modules[row + 1]
+
+        max_row.times do |col|
+          val = row_curr[col]
+          if val == row_next[col] && val == row_curr[col + 1] && val == row_next[col + 1]
+            demerit_points += DEMERIT_POINTS_2
+          end
+        end
+      end
+      demerit_points
+    end
+
+    def self.demerit_points_3_dangerous_patterns(modules)
+      demerit_points = 0
+      module_count = modules.size
+      pattern_len = 7
+      max_start = module_count - pattern_len + 1
+
+      modules.each do |row|
+        max_start.times do |col|
+          if row[col] && !row[col + 1] && row[col + 2] &&
+              row[col + 3] && row[col + 4] && !row[col + 5] && row[col + 6]
+            demerit_points += DEMERIT_POINTS_3
+          end
+        end
+      end
+
+      module_count.times do |col|
+        max_start.times do |row|
+          if modules[row][col] && !modules[row + 1][col] && modules[row + 2][col] &&
+              modules[row + 3][col] && modules[row + 4][col] && !modules[row + 5][col] && modules[row + 6][col]
+            demerit_points += DEMERIT_POINTS_3
+          end
+        end
+      end
+      demerit_points
+    end
+
+    def self.demerit_points_4_dark_ratio(modules)
+      dark_count = modules.reduce(0) do |sum, col|
+        sum + col.count(true)
+      end
+      ratio = dark_count.to_f / (modules.size * modules.size)
+      ratio_delta = (100 * ratio - 50).abs / 5
+      ratio_delta * DEMERIT_POINTS_4
+    end
+  end
+
+  class QRBitBuffer
+    attr_reader :buffer
+
+    PAD0 = 0xEC
+    PAD1 = 0x11
+
+    def initialize(version)
+      @version = version
+      @buffer = []
+      @length = 0
+    end
+
+    def get(index)
+      buf_index = (index / 8).floor
+      (QRUtil.rszf(@buffer[buf_index], 7 - index % 8) & 1) == 1
+    end
+
+    def put(num, length)
+      (0...length).each do |i|
+        put_bit((QRUtil.rszf(num, length - i - 1) & 1) == 1)
+      end
+    end
+
+    def get_length_in_bits
+      @length
+    end
+
+    def put_bit(bit)
+      buf_index = (@length / 8).floor
+      if @buffer.size <= buf_index
+        @buffer << 0
+      end
+
+      if bit
+        @buffer[buf_index] |= QRUtil.rszf(0x80, @length % 8)
+      end
+
+      @length += 1
+    end
+
+    def byte_encoding_start(length)
+      put(QRMODE[:mode_8bit_byte], 4)
+      put(length, QRUtil.get_length_in_bits(QRMODE[:mode_8bit_byte], @version))
+    end
+
+    def alphanumeric_encoding_start(length)
+      put(QRMODE[:mode_alpha_numk], 4)
+      put(length, QRUtil.get_length_in_bits(QRMODE[:mode_alpha_numk], @version))
+    end
+
+    def numeric_encoding_start(length)
+      put(QRMODE[:mode_number], 4)
+      put(length, QRUtil.get_length_in_bits(QRMODE[:mode_number], @version))
+    end
+
+    def pad_until(prefered_size)
+      while get_length_in_bits % 8 != 0
+        put_bit(false)
+      end
+
+      while get_length_in_bits < prefered_size
+        put(PAD0, 8)
+        put(PAD1, 8) if get_length_in_bits < prefered_size
+      end
+    end
+
+    def end_of_message(max_data_bits)
+      put(0, 4) unless get_length_in_bits + 4 > max_data_bits
+    end
+  end
+
+  NUMERIC = %w[0 1 2 3 4 5 6 7 8 9].freeze
+
+  class QRNumeric
+    def initialize(data)
+      raise QRCodeArgumentError, "Not a numeric string `#{data}`" unless QRNumeric.valid_data?(data)
+      @data = data
+    end
+
+    def self.valid_data?(data)
+      (data.chars - NUMERIC).empty?
+    end
+
+    def write(buffer)
+      buffer.numeric_encoding_start(@data.size)
+      @data.size.times do |i|
+        if i % 3 == 0
+          chars = @data[i, 3]
+          bit_length = get_bit_length(chars.length)
+          buffer.put(chars.to_i, bit_length)
+        end
+      end
+    end
+
+    private
+
+    NUMBER_LENGTH = {
+      3 => 10,
+      2 => 7,
+      1 => 4
+    }.freeze
+
+    def get_bit_length(length)
+      NUMBER_LENGTH[length]
+    end
+  end
+
+  ALPHANUMERIC = [
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I",
+    "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", " ", "$",
+    "%", "*", "+", "-", ".", "/", ":"
+  ].freeze
+
+  class QRAlphanumeric
+    def initialize(data)
+      raise QRCodeArgumentError, "Not a alpha numeric uppercase string `#{data}`" unless QRAlphanumeric.valid_data?(data)
+      @data = data
+    end
+
+    def self.valid_data?(data)
+      (data.chars - ALPHANUMERIC).empty?
+    end
+
+    def write(buffer)
+      buffer.alphanumeric_encoding_start(@data.size)
+      @data.size.times do |i|
+        if i % 2 == 0
+          if i == (@data.size - 1)
+            value = ALPHANUMERIC.index(@data[i])
+            buffer.put(value, 6)
+          else
+            value = (ALPHANUMERIC.index(@data[i]) * 45) + ALPHANUMERIC.index(@data[i + 1])
+            buffer.put(value, 11)
+          end
+        end
+      end
+    end
+  end
+
+  class QR8bitByte
+    def initialize(data)
+      @data = data
+    end
+
+    def write(buffer)
+      buffer.byte_encoding_start(@data.bytesize)
+      @data.each_byte do |b|
+        buffer.put(b, 8)
+      end
+    end
+  end
+
+  class QRMulti
+    def initialize(data)
+      @data = data
+    end
+
+    def write(buffer)
+      @data.each { |seg| seg.writer.write(buffer) }
+    end
+  end
+
+  class QRSegment
+    attr_reader :data, :mode
+
+    def initialize(data:, mode: nil)
+      @data = data
+      @mode = QRMODE_NAME.dig(mode&.to_sym)
+
+      @mode ||= if QRNumeric.valid_data?(@data)
+        QRMODE_NAME[:number]
+      elsif QRAlphanumeric.valid_data?(@data)
+        QRMODE_NAME[:alphanumeric]
+      else
+        QRMODE_NAME[:byte_8bit]
+      end
+    end
+
+    def size(version)
+      4 + header_size(version) + content_size
+    end
+
+    def header_size(version)
+      QRUtil.get_length_in_bits(QRMODE[mode], version)
+    end
+
+    def content_size
+      chunk_size, bit_length, extra = case mode
+      when :mode_number
+        [3, QRNumeric.const_get(:NUMBER_LENGTH)[3], QRNumeric.const_get(:NUMBER_LENGTH)[data_length % 3] || 0]
+      when :mode_alpha_numk
+        [2, 11, 6]
+      when :mode_8bit_byte
+        [1, 8, 0]
+      end
+
+      (data_length / chunk_size) * bit_length + (((data_length % chunk_size) == 0) ? 0 : extra)
+    end
+
+    def writer
+      case mode
+      when :mode_number
+        QRNumeric.new(data)
+      when :mode_alpha_numk
+        QRAlphanumeric.new(data)
+      when :mode_multi
+        QRMulti.new(data)
+      else
+        QR8bitByte.new(data)
+      end
+    end
+
+    private
+
+    def data_length
+      data.bytesize
+    end
+  end
+
+  class QRCode
+    attr_reader :modules, :module_count, :version
+
+    def initialize(data, *args)
+      options = extract_options!(args)
+
+      level = (options[:level] || :h).to_sym
+      max_size = options[:max_size] || QRUtil.max_size
+
+      @data = case data
+      when String
+        QRSegment.new(data: data, mode: options[:mode])
+      when Array
+        raise QRCodeArgumentError, "Array must contain Hashes with :data and :mode keys" unless data.all? { |seg| seg.is_a?(Hash) && %i[data mode].all? { |s| seg.key? s } }
+        data.map { |seg| QRSegment.new(**seg) }
+      when QRSegment
+        data
+      else
+        raise QRCodeArgumentError, "data must be a String, QRSegment, or an Array"
+      end
+      @error_correct_level = QRERRORCORRECTLEVEL[level]
+
+      unless @error_correct_level
+        raise QRCodeArgumentError, "Unknown error correction level `#{level.inspect}`"
+      end
+
+      size = options[:size] || minimum_version(limit: max_size)
+
+      if size > max_size
+        raise QRCodeArgumentError, "Given size greater than maximum possible size of #{QRUtil.max_size}"
+      end
+
+      @version = size
+      @module_count = @version * 4 + QRPOSITIONPATTERNLENGTH
+      @modules = Array.new(@module_count)
+      @data_list = multi_segment? ? QRMulti.new(@data) : @data.writer
+      @data_cache = nil
+      make
+    end
+
+    def checked?(row, col)
+      if !row.between?(0, @module_count - 1) || !col.between?(0, @module_count - 1)
+        raise QRCodeRunTimeError, "Invalid row/column pair: #{row}, #{col}"
+      end
+      @modules[row][col]
+    end
+    alias_method :dark?, :checked?
+
+    def to_s(*args)
+      options = extract_options!(args)
+      dark = options[:dark] || "x"
+      light = options[:light] || " "
+      quiet_zone_size = options[:quiet_zone_size] || 0
+
+      rows = []
+      @modules.each do |row|
+        cols = light * quiet_zone_size
+        row.each do |col|
+          cols += (col ? dark : light)
+        end
+        rows << cols
+      end
+
+      quiet_zone_size.times do
+        rows.unshift(light * (rows.first.length / light.size))
+        rows << light * (rows.first.length / light.size)
+      end
+      rows.join("\n")
+    end
+
+    def inspect
+      "QRCodeMaker: @data='#{@data}', @error_correct_level=#{@error_correct_level}, @version=#{@version}, @module_count=#{@module_count}"
+    end
+
+    def error_correction_level
+      QRERRORCORRECTLEVEL.invert[@error_correct_level]
+    end
+
+    def multi_segment?
+      @data.is_a?(Array)
+    end
+
+    def mode
+      case @data_list
+      when QRNumeric
+        :mode_number
+      when QRAlphanumeric
+        :mode_alpha_numk
+      else
+        :mode_8bit_byte
+      end
+    end
+
+    protected
+
+    def make
+      prepare_common_patterns
+      make_impl(false, get_best_mask_pattern)
+    end
+
+    private
+
+    def prepare_common_patterns
+      @modules.map! { Array.new(@module_count) }
+
+      place_position_probe_pattern(0, 0)
+      place_position_probe_pattern(@module_count - 7, 0)
+      place_position_probe_pattern(0, @module_count - 7)
+      place_position_adjust_pattern
+      place_timing_pattern
+
+      @common_patterns = @modules.map(&:clone)
+    end
+
+    def make_impl(test, mask_pattern)
+      @modules = @common_patterns.map(&:clone)
+
+      place_format_info(test, mask_pattern)
+      place_version_info(test) if @version >= 7
+
+      if @data_cache.nil?
+        @data_cache = QRCode.create_data(
+          @version, @error_correct_level, @data_list
+        )
+      end
+
+      map_data(@data_cache, mask_pattern)
+    end
+
+    def place_position_probe_pattern(row, col)
+      (-1..7).each do |r|
+        next unless (row + r).between?(0, @module_count - 1)
+
+        (-1..7).each do |c|
+          next unless (col + c).between?(0, @module_count - 1)
+
+          is_vert_line = r.between?(0, 6) && (c == 0 || c == 6)
+          is_horiz_line = c.between?(0, 6) && (r == 0 || r == 6)
+          is_square = r.between?(2, 4) && c.between?(2, 4)
+
+          is_part_of_probe = is_vert_line || is_horiz_line || is_square
+          @modules[row + r][col + c] = is_part_of_probe
+        end
+      end
+    end
+
+    def get_best_mask_pattern
+      min_lost_point = 0
+      pattern = 0
+
+      8.times do |i|
+        make_impl(true, i)
+        lost_point = QRUtil.get_lost_points(modules)
+
+        if i == 0 || min_lost_point > lost_point
+          min_lost_point = lost_point
+          pattern = i
+        end
+      end
+      pattern
+    end
+
+    def place_timing_pattern
+      (8...@module_count - 8).each do |i|
+        @modules[i][6] = @modules[6][i] = i % 2 == 0
+      end
+    end
+
+    def place_position_adjust_pattern
+      positions = QRUtil.get_pattern_positions(@version)
+
+      positions.each do |row|
+        positions.each do |col|
+          next unless @modules[row][col].nil?
+
+          (-2..2).each do |r|
+            (-2..2).each do |c|
+              is_part_of_pattern = r.abs == 2 || c.abs == 2 || (r == 0 && c == 0)
+              @modules[row + r][col + c] = is_part_of_pattern
+            end
+          end
+        end
+      end
+    end
+
+    def place_version_info(test)
+      bits = QRUtil.get_bch_version(@version)
+
+      18.times do |i|
+        mod = !test && ((bits >> i) & 1) == 1
+        @modules[(i / 3).floor][ i % 3 + @module_count - 8 - 3 ] = mod
+        @modules[i % 3 + @module_count - 8 - 3][ (i / 3).floor ] = mod
+      end
+    end
+
+    def place_format_info(test, mask_pattern)
+      data = (@error_correct_level << 3 | mask_pattern)
+      bits = QRUtil.get_bch_format_info(data)
+
+      QRFORMATINFOLENGTH.times do |i|
+        mod = !test && ((bits >> i) & 1) == 1
+
+        # vertical
+        row = if i < 6
+          i
+        elsif i < 8
+          i + 1
+        else
+          @module_count - 15 + i
+        end
+        @modules[row][8] = mod
+
+        # horizontal
+        col = if i < 8
+          @module_count - i - 1
+        elsif i < 9
+          15 - i - 1 + 1
+        else
+          15 - i - 1
+        end
+        @modules[8][col] = mod
+      end
+
+      # fixed module
+      @modules[@module_count - 8][8] = !test
+    end
+
+    def map_data(data, mask_pattern)
+      inc = -1
+      row = @module_count - 1
+      bit_index = 7
+      byte_index = 0
+
+      (@module_count - 1).step(1, -2) do |col|
+        col -= 1 if col <= 6
+
+        loop do
+          2.times do |c|
+            if @modules[row][col - c].nil?
+              dark = false
+              if byte_index < data.size && !data[byte_index].nil?
+                dark = ((QRUtil.rszf(data[byte_index], bit_index) & 1) == 1)
+              end
+              mask = QRUtil.get_mask(mask_pattern, row, col - c)
+              dark = !dark if mask
+              @modules[row][ col - c ] = dark
+              bit_index -= 1
+
+              if bit_index == -1
+                byte_index += 1
+                bit_index = 7
+              end
+            end
+          end
+
+          row += inc
+
+          if row < 0 || @module_count <= row
+            row -= inc
+            inc = -inc
+            break
+          end
+        end
+      end
+    end
+
+    def minimum_version(limit: QRUtil.max_size, version: 1)
+      raise QRCodeRunTimeError, "Data length exceed maximum capacity of version #{limit}" if version > limit
+
+      max_size_bits = QRMAXBITS[error_correction_level][version - 1]
+      size_bits = multi_segment? ? @data.sum { |seg| seg.size(version) } : @data.size(version)
+
+      return version if size_bits < max_size_bits
+
+      minimum_version(limit: limit, version: version + 1)
+    end
+
+    def extract_options!(arr)
+      arr.last.is_a?(::Hash) ? arr.pop : {}
+    end
+
+    class << self
+      def count_max_data_bits(rs_blocks)
+        max_data_bytes = rs_blocks.reduce(0) do |sum, rs_block|
+          sum + rs_block.data_count
+        end
+        max_data_bytes * 8
+      end
+
+      def create_data(version, error_correct_level, data_list)
+        rs_blocks = QRRSBlock.get_rs_blocks(version, error_correct_level)
+        max_data_bits = count_max_data_bits(rs_blocks)
+        buffer = QRBitBuffer.new(version)
+
+        data_list.write(buffer)
+        buffer.end_of_message(max_data_bits)
+
+        if buffer.get_length_in_bits > max_data_bits
+          raise QRCodeRunTimeError, "code length overflow. (#{buffer.get_length_in_bits}>#{max_data_bits}). (Try a larger size!)"
+        end
+
+        buffer.pad_until(max_data_bits)
+        create_bytes(buffer, rs_blocks)
+      end
+
+      def create_bytes(buffer, rs_blocks)
+        offset = 0
+        max_dc_count = 0
+        max_ec_count = 0
+        dcdata = Array.new(rs_blocks.size)
+        ecdata = Array.new(rs_blocks.size)
+
+        rs_blocks.each_with_index do |rs_block, r|
+          dc_count = rs_block.data_count
+          ec_count = rs_block.total_count - dc_count
+          max_dc_count = [max_dc_count, dc_count].max
+          max_ec_count = [max_ec_count, ec_count].max
+
+          dcdata_block = Array.new(dc_count)
+          dcdata_block.size.times do |i|
+            dcdata_block[i] = 0xff & buffer.buffer[i + offset]
+          end
+          dcdata[r] = dcdata_block
+
+          offset += dc_count
+          rs_poly = QRUtil.get_error_correct_polynomial(ec_count)
+          raw_poly = QRPolynomial.new(dcdata[r], rs_poly.get_length - 1)
+          mod_poly = raw_poly.mod(rs_poly)
+
+          ecdata_block = Array.new(rs_poly.get_length - 1)
+          ecdata_block.size.times do |i|
+            mod_index = i + mod_poly.get_length - ecdata_block.size
+            ecdata_block[i] = (mod_index >= 0) ? mod_poly.get(mod_index) : 0
+          end
+          ecdata[r] = ecdata_block
+        end
+
+        total_code_count = rs_blocks.reduce(0) do |sum, rs_block|
+          sum + rs_block.total_count
+        end
+
+        data = Array.new(total_code_count)
+        index = 0
+
+        max_dc_count.times do |i|
+          rs_blocks.size.times do |r|
+            if i < dcdata[r].size
+              data[index] = dcdata[r][i]
+              index += 1
+            end
+          end
+        end
+
+        max_ec_count.times do |i|
+          rs_blocks.size.times do |r|
+            if i < ecdata[r].size
+              data[index] = ecdata[r][i]
+              index += 1
+            end
+          end
+        end
+
+        data
+      end
+    end
+  end
+end

data/lib/qr_code_maker/renderer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module QrCodeMaker
+  class QRCode
+    def as_svg(options = {})
+      color = options[:color] || "black"
+      bg_color = options[:bg_color]
+      bg_color = "white" if bg_color.nil?
+      
+      module_size = options[:module_size] || 10
+      margin = options[:margin] || 4
+
+      view_box_size = @module_count + 2 * margin
+      total_size = view_box_size * module_size
+
+      path_data = +""
+      @modules.each_with_index do |row, r|
+        row.each_with_index do |col, c|
+          if col
+            path_data << "M#{c + margin},#{r + margin}h1v1h-1z"
+          end
+        end
+      end
+
+      svg = []
+      svg << %(<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{view_box_size} #{view_box_size}" width="#{total_size}" height="#{total_size}">)
+      if bg_color && bg_color != "transparent" && bg_color != false
+        svg << %(  <rect width="100%" height="100%" fill="#{bg_color}"/>)
+      end
+      svg << %(  <path d="#{path_data}" fill="#{color}" shape-rendering="crispEdges"/>)
+      svg << %(</svg>)
+      svg.join("\n")
+    end
+
+    def as_ascii(options = {})
+      dark = options[:dark] || "██"
+      light = options[:light] || "  "
+      margin = options[:margin] || 2
+
+      rows = []
+      margin.times { rows << (light * (@module_count + 2 * margin)) }
+
+      @modules.each do |row|
+        row_str = light * margin
+        row.each do |col|
+          row_str << (col ? dark : light)
+        end
+        row_str << (light * margin)
+        rows << row_str
+      end
+
+      margin.times { rows << (light * (@module_count + 2 * margin)) }
+      rows.join("\n")
+    end
+  end
+end

data/lib/qr_code_maker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "qr_code_maker/encoder"
+require_relative "qr_code_maker/renderer"
+
+module QrCodeMaker
+  # High-level helper to generate SVG in a single call
+  def self.generate_svg(data, options = {})
+    QRCode.new(data, options).as_svg(options)
+  end
+
+  # High-level helper to generate ASCII in a single call
+  def self.generate_ascii(data, options = {})
+    QRCode.new(data, options).as_ascii(options)
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: qr_code_maker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- swlkr
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Generate QR codes in SVG and ASCII format with a super simple API, relying
+  only on standard Ruby.
+email:
+- from@swlkr.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/qr_code_maker.rb
+- lib/qr_code_maker/encoder.rb
+- lib/qr_code_maker/renderer.rb
+homepage: https://github.com/swlkr/qr_code_generator
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: A zero-dependency standard-library-only QR code maker.
+test_files: []