`class Code`

== Creation

QRCode objects expect only one required constructor parameter and an optional hash of any other. Here's a few examples:

qr = QRCode::Encoder::Code.new('hello world') qr = QRCode::Encoder::Code.new('hello world', size: 1, level: :m, mode: :alphanumeric)

Nested

class

Definitions

`alias size module_count`

Alias for module_count - the width/height of the QR code square

`def self.build(data, level: :h, mode: :auto, size: nil, max_size: nil)`

Factory method to build QR code from data

Signature

parameter　data　String, Array: The data to encode
parameter　level　Symbol: Error correction level (:l, :m, :q, :h)
parameter　mode　Symbol: Encoding mode (:auto, :number, :alphanumeric, :byte_8bit)
parameter　size　Integer: QR code version (auto-detected if not specified)
parameter　max_size　Integer: Maximum allowed version

Implementation

def self.build(data, level: :h, mode: :auto, size: nil, max_size: nil)
	segments = Segment.build(data, mode: mode)
	new(segments, level: level, size: size, max_size: max_size)
end

`def initialize(segments, level: :h, size: nil, max_size: nil)`

Simple constructor that takes an array of segments

Signature

parameter　segments　Array<Segment>: Array of segments to encode
parameter　level　Symbol: Error correction level (:l, :m, :q, :h)
parameter　size　Integer: QR code version (auto-detected if not specified)
parameter　max_size　Integer: Maximum allowed version

Implementation

def initialize(segments, level: :h, size: nil, max_size: nil)
	@segments = Array(segments)
	@error_correction_level = ERROR_CORRECTION_LEVEL[level]
	
	unless @error_correction_level
		raise ArgumentError, "Unknown error correction level `#{level.inspect}`"
	end
	
	max_size ||= Encoder::Util.max_size
	calculated_size = size || minimum_version(limit: max_size)
	
	if calculated_size > max_size
		raise ArgumentError, "Given size greater than maximum possible size of #{max_size}"
	end
	
	@version = calculated_size
	@module_count = @version * 4 + POSITION_PATTERN_LENGTH
	@modules = Array.new(@module_count)
	@data_cache = nil
	make
end

`def checked?(row, col)`

checked? is called with a +col+ and +row+ parameter. This will return true or false based on whether that coordinate exists in the matrix returned. It would normally be called while iterating through modules. A simple example would be:

instance.checked?( 10, 10 ) => true

Implementation

def checked?(row, col)
	if !row.between?(0, @module_count - 1) || !col.between?(0, @module_count - 1)
		raise RuntimeError, "Invalid row/column pair: #{row}, #{col}"
	end
	@modules[row][col]
end

`def to_s(*args)`

This is a public method that returns the QR Code you have generated as a string. It will not be able to be read in this format by a QR Code reader, but will give you an idea if the final outout. It takes two optional args +:dark+ and +:light+ which are there for you to choose how the output looks. Here's an example of it's use:

instance.to_s => xxxxxxx x x x x x xx xxxxxxx x x xxx xxxxxx xxx x x x xxx x xxxxx x xx x xxx x

instance.to_s( dark: 'E', light: 'Q' ) => EEEEEEEQEQQEQEQQQEQEQQEEQQEEEEEEE EQQQQQEQQEEEQQEEEEEEQEEEQQEQQQQQE EQEEEQEQQEEEEEQEQQQQQQQEEQEQEEEQE

Implementation

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`

Public overide as default inspect is very verbose

QRCode::Encoder::Code.new('my string to generate', size: 4, level: :h) => QRCodeCore: @data='my string to generate', @error_correction_level=2, @version=4, @module_count=33

Implementation

def inspect
	"QRCodeCore: @segments=#{@segments.size} segments, @error_correction_level=#{@error_correction_level}, @version=#{@version}, @module_count=#{@module_count}"
end

`def error_correction_level`

Return a symbol for current error connection level

Implementation

def error_correction_level
	ERROR_CORRECTION_LEVEL.invert[@error_correction_level]
end

`def multi_segment?`

Return true if this QR Code includes multiple encoded segments

Implementation

def multi_segment?
	@segments.size > 1
end

`def mode`

Return the primary mode used (first segment's mode)

Implementation

def mode
	@segments.first&.mode || :mode_8bit_byte
end