qrcode 0.0.1 → 0.1.1

data/lib/qrcode/encoder/error_correction_block.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2008-2021, by Duncan Robertson.
+# Copyright, 2011, by Gioele Barabucci.
+# Copyright, 2015, by Björn Blomqvist.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "constants"
+
+module QRCode
+	module Encoder
+		class ErrorCorrectionBlock
+			attr_reader :data_count, :total_count
+			
+			def initialize(total_count, data_count)
+				@total_count = total_count
+				@data_count = data_count
+			end
+			
+			# http://www.thonky.com/qr-code-tutorial/error-correction-table/
+			# Table of [block_count, total_codewords, data_codewords] for each version and error level
+			TABLE = [
+				# The order within each group is:
+				# L
+				# M
+				# Q
+				# H
+				
+				# 1
+				[1, 26, 19],
+				[1, 26, 16],
+				[1, 26, 13],
+				[1, 26, 9],
+				
+				# 2
+				[1, 44, 34],
+				[1, 44, 28],
+				[1, 44, 22],
+				[1, 44, 16],
+				
+				# 3
+				[1, 70, 55],
+				[1, 70, 44],
+				[2, 35, 17],
+				[2, 35, 13],
+				
+				# 4
+				[1, 100, 80],
+				[2, 50, 32],
+				[2, 50, 24],
+				[4, 25, 9],
+				
+				# 5
+				[1, 134, 108],
+				[2, 67, 43],
+				[2, 33, 15, 2, 34, 16],
+				[2, 33, 11, 2, 34, 12],
+				
+				# 6
+				[2, 86, 68],
+				[4, 43, 27],
+				[4, 43, 19],
+				[4, 43, 15],
+				
+				# 7
+				[2, 98, 78],
+				[4, 49, 31],
+				[2, 32, 14, 4, 33, 15],
+				[4, 39, 13, 1, 40, 14],
+				
+				# 8
+				[2, 121, 97],
+				[2, 60, 38, 2, 61, 39],
+				[4, 40, 18, 2, 41, 19],
+				[4, 40, 14, 2, 41, 15],
+				
+				# 9
+				[2, 146, 116],
+				[3, 58, 36, 2, 59, 37],
+				[4, 36, 16, 4, 37, 17],
+				[4, 36, 12, 4, 37, 13],
+				
+				# 10
+				[2, 86, 68, 2, 87, 69],
+				[4, 69, 43, 1, 70, 44],
+				[6, 43, 19, 2, 44, 20],
+				[6, 43, 15, 2, 44, 16],
+				
+				# 11
+				[4, 101, 81],
+				[1, 80, 50, 4, 81, 51],
+				[4, 50, 22, 4, 51, 23],
+				[3, 36, 12, 8, 37, 13],
+				
+				# 12
+				[2, 116, 92, 2, 117, 93],
+				[6, 58, 36, 2, 59, 37],
+				[4, 46, 20, 6, 47, 21],
+				[7, 42, 14, 4, 43, 15],
+				
+				# 13
+				[4, 133, 107],
+				[8, 59, 37, 1, 60, 38],
+				[8, 44, 20, 4, 45, 21],
+				[12, 33, 11, 4, 34, 12],
+				
+				# 14
+				[3, 145, 115, 1, 146, 116],
+				[4, 64, 40, 5, 65, 41],
+				[11, 36, 16, 5, 37, 17],
+				[11, 36, 12, 5, 37, 13],
+				
+				# 15
+				[5, 109, 87, 1, 110, 88],
+				[5, 65, 41, 5, 66, 42],
+				[5, 54, 24, 7, 55, 25],
+				[11, 36, 12, 7, 37, 13],
+				
+				# 16
+				[5, 122, 98, 1, 123, 99],
+				[7, 73, 45, 3, 74, 46],
+				[15, 43, 19, 2, 44, 20],
+				[3, 45, 15, 13, 46, 16],
+				
+				# 17
+				[1, 135, 107, 5, 136, 108],
+				[10, 74, 46, 1, 75, 47],
+				[1, 50, 22, 15, 51, 23],
+				[2, 42, 14, 17, 43, 15],
+				
+				# 18
+				[5, 150, 120, 1, 151, 121],
+				[9, 69, 43, 4, 70, 44],
+				[17, 50, 22, 1, 51, 23],
+				[2, 42, 14, 19, 43, 15],
+				
+				# 19
+				[3, 141, 113, 4, 142, 114],
+				[3, 70, 44, 11, 71, 45],
+				[17, 47, 21, 4, 48, 22],
+				[9, 39, 13, 16, 40, 14],
+				
+				# 20
+				[3, 135, 107, 5, 136, 108],
+				[3, 67, 41, 13, 68, 42],
+				[15, 54, 24, 5, 55, 25],
+				[15, 43, 15, 10, 44, 16],
+				
+				# 21
+				[4, 144, 116, 4, 145, 117],
+				[17, 68, 42],
+				[17, 50, 22, 6, 51, 23],
+				[19, 46, 16, 6, 47, 17],
+				
+				# 22
+				[2, 139, 111, 7, 140, 112],
+				[17, 74, 46],
+				[7, 54, 24, 16, 55, 25],
+				[34, 37, 13],
+				
+				# 23
+				[4, 151, 121, 5, 152, 122],
+				[4, 75, 47, 14, 76, 48],
+				[11, 54, 24, 14, 55, 25],
+				[16, 45, 15, 14, 46, 16],
+				
+				# 24
+				[6, 147, 117, 4, 148, 118],
+				[6, 73, 45, 14, 74, 46],
+				[11, 54, 24, 16, 55, 25],
+				[30, 46, 16, 2, 47, 17],
+				
+				# 25
+				[8, 132, 106, 4, 133, 107],
+				[8, 75, 47, 13, 76, 48],
+				[7, 54, 24, 22, 55, 25],
+				[22, 45, 15, 13, 46, 16],
+				
+				# 26
+				[10, 142, 114, 2, 143, 115],
+				[19, 74, 46, 4, 75, 47],
+				[28, 50, 22, 6, 51, 23],
+				[33, 46, 16, 4, 47, 17],
+				
+				# 27
+				[8, 152, 122, 4, 153, 123],
+				[22, 73, 45, 3, 74, 46],
+				[8, 53, 23, 26, 54, 24],
+				[12, 45, 15, 28, 46, 16],
+				
+				# 28
+				[3, 147, 117, 10, 148, 118],
+				[3, 73, 45, 23, 74, 46],
+				[4, 54, 24, 31, 55, 25],
+				[11, 45, 15, 31, 46, 16],
+				
+				# 29
+				[7, 146, 116, 7, 147, 117],
+				[21, 73, 45, 7, 74, 46],
+				[1, 53, 23, 37, 54, 24],
+				[19, 45, 15, 26, 46, 16],
+				
+				# 30
+				[5, 145, 115, 10, 146, 116],
+				[19, 75, 47, 10, 76, 48],
+				[15, 54, 24, 25, 55, 25],
+				[23, 45, 15, 25, 46, 16],
+				
+				# 31
+				[13, 145, 115, 3, 146, 116],
+				[2, 74, 46, 29, 75, 47],
+				[42, 54, 24, 1, 55, 25],
+				[23, 45, 15, 28, 46, 16],
+				
+				# 32
+				[17, 145, 115],
+				[10, 74, 46, 23, 75, 47],
+				[10, 54, 24, 35, 55, 25],
+				[19, 45, 15, 35, 46, 16],
+				
+				# 33
+				[17, 145, 115, 1, 146, 116],
+				[14, 74, 46, 21, 75, 47],
+				[29, 54, 24, 19, 55, 25],
+				[11, 45, 15, 46, 46, 16],
+				
+				# 34
+				[13, 145, 115, 6, 146, 116],
+				[14, 74, 46, 23, 75, 47],
+				[44, 54, 24, 7, 55, 25],
+				[59, 46, 16, 1, 47, 17],
+				
+				# 35
+				[12, 151, 121, 7, 152, 122],
+				[12, 75, 47, 26, 76, 48],
+				[39, 54, 24, 14, 55, 25],
+				[22, 45, 15, 41, 46, 16],
+				
+				# 36
+				[6, 151, 121, 14, 152, 122],
+				[6, 75, 47, 34, 76, 48],
+				[46, 54, 24, 10, 55, 25],
+				[2, 45, 15, 64, 46, 16],
+				
+				# 37
+				[17, 152, 122, 4, 153, 123],
+				[29, 74, 46, 14, 75, 47],
+				[49, 54, 24, 10, 55, 25],
+				[24, 45, 15, 46, 46, 16],
+				
+				# 38
+				[4, 152, 122, 18, 153, 123],
+				[13, 74, 46, 32, 75, 47],
+				[48, 54, 24, 14, 55, 25],
+				[42, 45, 15, 32, 46, 16],
+				
+				# 39
+				[20, 147, 117, 4, 148, 118],
+				[40, 75, 47, 7, 76, 48],
+				[43, 54, 24, 22, 55, 25],
+				[10, 45, 15, 67, 46, 16],
+				
+				# 40
+				[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
+			
+			# Create error correction blocks for given version and level
+			# @parameter version [Integer] QR code version (1-40)
+			# @parameter level [Integer] Error correction level
+			# @return [Array<ErrorCorrectionBlock>] Array of error correction blocks
+			def self.for(version, level)
+				entry = table_entry_for(version, level)
+				
+				if entry.nil?
+					raise RuntimeError, "Invalid error correction configuration: version=#{version}, level=#{level}"
+				end
+				
+				blocks = []
+				groups = entry.size / 3
+				
+				(0...groups).each do |i|
+					count = entry[i * 3 + 0]
+					total_count = entry[i * 3 + 1]
+					data_count = entry[i * 3 + 2]
+					
+					count.times do
+						blocks << ErrorCorrectionBlock.new(total_count, data_count)
+					end
+				end
+				
+				blocks
+			end
+			
+			# Get table entry for specific version and error correction level
+			# @parameter version [Integer] QR code version (1-40)  
+			# @parameter level [Integer] Error correction level
+			# @return [Array] Table entry [block_count, total_codewords, data_codewords, ...]
+			def self.table_entry_for(version, level)
+				return nil unless version.between?(1, 40)
+				
+				case level
+				when ERROR_CORRECTION_LEVEL[:l]
+					TABLE[(version - 1) * 4 + 0]
+				when ERROR_CORRECTION_LEVEL[:m]
+					TABLE[(version - 1) * 4 + 1]
+				when ERROR_CORRECTION_LEVEL[:q]
+					TABLE[(version - 1) * 4 + 2]
+				when ERROR_CORRECTION_LEVEL[:h]
+					TABLE[(version - 1) * 4 + 3]
+				end
+			end
+		end
+	end
+end

data/lib/qrcode/encoder/math.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2008-2025, by Duncan Robertson.
+# Copyright, 2025, by Samuel Williams.
+
+module QRCode
+	module Encoder
+		class Math
+			module_eval do
+				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
+			end
+			
+			class << self
+				def glog(n)
+					raise RuntimeError, "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
+	end
+end

data/lib/qrcode/encoder/polynomial.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2008-2021, by Duncan Robertson.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "math"
+
+module QRCode
+	module Encoder
+		class Polynomial
+			def initialize(num, shift)
+				raise RuntimeError, "#{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 ^ Encoder::Math.gexp(Encoder::Math.glog(get(i)) + Encoder::Math.glog(e.get(j)))
+					end
+				end
+				
+				Encoder::Polynomial.new(num, 0)
+			end
+			
+			def mod(e)
+				if get_length - e.get_length < 0
+					return self
+				end
+				
+				ratio = Encoder::Math.glog(get(0)) - Encoder::Math.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 ^ Encoder::Math.gexp(Encoder::Math.glog(e.get(i)) + ratio)
+				end
+				
+				Encoder::Polynomial.new(num, 0).mod(e)
+			end
+		end
+	end
+end

data/lib/qrcode/encoder/segment.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2021, by Sam Sayer.
+# Copyright, 2021-2025, by Duncan Robertson.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "constants"
+require_relative "util"
+
+module QRCode
+	module Encoder
+		# Base segment class - defaults to binary (8-bit byte) encoding
+		class Segment
+			attr_reader :data
+			
+			def initialize(data)
+				@data = data.to_s
+			end
+			
+			def mode
+				:mode_8bit_byte
+			end
+			
+			def bit_size(version)
+				4 + header_size(version) + content_size
+			end
+			
+			def header_size(version)
+				Encoder::Util.get_length_in_bits(MODE[mode], version)
+			end
+			
+			def content_size
+				@data.bytesize * 8
+			end
+			
+			def write(buffer)
+				buffer.byte_encoding_start(@data.bytesize)
+				
+				@data.each_byte do |b|
+					buffer.put(b, 8)
+				end
+			end
+			
+			# Factory method to build segments from various data types
+			# @parameter data [String, Array, Segment] The data to encode
+			# @parameter mode [Symbol] Encoding mode (:auto, :number, :alphanumeric, :byte_8bit)
+			# @return [Array<Segment>] Array of segments
+			def self.build(data, mode: :auto)
+				case data
+				when String
+					[create_segment_for_data(data, mode)]
+				when Array
+					data.map do |item|
+						case item
+						when Hash
+							create_segment_for_data(item[:data], item[:mode] || :auto)
+						when String
+							create_segment_for_data(item, mode)
+						when Segment
+							item
+						else
+							raise ArgumentError, "Array elements must be Strings, Hashes with :data key, or Segments"
+						end
+					end
+				when Segment
+					[data]
+				else
+					raise ArgumentError, "data must be a String, Segment, or Array"
+				end
+			end
+			
+			private_class_method def self.create_segment_for_data(data, mode)
+				case mode
+				when :auto
+					detect_optimal_segment_class(data).new(data)
+				when :number, :numeric
+					NumericSegment.new(data)
+				when :alphanumeric, :alpha_numk
+					AlphanumericSegment.new(data)
+				when :byte_8bit, :binary
+					Segment.new(data)
+				else
+					raise ArgumentError, "Unknown mode: #{mode}"
+				end
+			end
+			
+			private_class_method def self.detect_optimal_segment_class(data)
+				if NumericSegment.valid_data?(data)
+					NumericSegment
+				elsif AlphanumericSegment.valid_data?(data)
+					AlphanumericSegment
+				else
+					Segment
+				end
+			end
+		end
+		
+		# Numeric segment - optimized for numeric data (0-9)
+		class NumericSegment < Segment
+			def initialize(data)
+				data_str = data.to_s
+				unless self.class.valid_data?(data_str)
+					raise ArgumentError, "Not a numeric string `#{data_str}`"
+				end
+				super(data_str)
+			end
+			
+			def self.valid_data?(data)
+				data.to_s.match?(/\A\d+\z/)
+			end
+			
+			def mode
+				:mode_number
+			end
+			
+			def content_size
+				data_length = @data.length
+				case data_length % 3
+				when 0
+					(data_length / 3) * 10
+				when 1
+					((data_length / 3) * 10) + 4
+				when 2
+					((data_length / 3) * 10) + 7
+				end
+			end
+			
+			def write(buffer)
+				buffer.numeric_encoding_start(@data.size)
+				
+				@data.scan(/\d{1,3}/).each do |group|
+					case group.length
+					when 3
+						buffer.put(group.to_i, 10)
+					when 2
+						buffer.put(group.to_i, 7)
+					when 1
+						buffer.put(group.to_i, 4)
+					end
+				end
+			end
+		end
+		
+		# Alphanumeric segment - optimized for alphanumeric data
+		class AlphanumericSegment < Segment
+			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
+			
+			def initialize(data)
+				data_str = data.to_s
+				unless self.class.valid_data?(data_str)
+					raise ArgumentError, "Not an alphanumeric string `#{data_str}`"
+				end
+				super(data_str)
+			end
+			
+			def self.valid_data?(data)
+				(data.to_s.chars - ALPHANUMERIC).empty?
+			end
+			
+			def mode
+				:mode_alpha_numk
+			end
+			
+			def content_size
+				(@data.size / 2.0).ceil * 11
+			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
+	end
+end