rqrcode_core 0.1.2 → 1.2.0

data/lib/rqrcode_core/qrcode/qr_math.rb

@@ -6,39 +6,38 @@ module RQRCodeCore
       exp_table = Array.new(256)
       log_table = Array.new(256)
 
-      ( 0...8 ).each do |i|
+      (0...8).each do |i|
         exp_table[i] = 1 << i
       end
 
-      ( 8...256 ).each do |i|
+      (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
 
-      ( 0...255 ).each do |i|
-        log_table[exp_table[i] ] = i
+      (0...255).each do |i|
+        log_table[exp_table[i]] = i
       end
 
-      EXP_TABLE = exp_table
-      LOG_TABLE = log_table
+      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 )
+        raise QRCodeRunTimeError, "glog(#{n})" if n < 1
         LOG_TABLE[n]
       end
 
-
       def gexp(n)
         while n < 0
-          n = n + 255
+          n += 255
         end
 
         while n >= 256
-          n = n - 255
+          n -= 255
         end
 
         EXP_TABLE[n]

data/lib/rqrcode_core/qrcode/qr_multi.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RQRCodeCore
+  class QRMulti
+    def initialize(data)
+      @data = data
+    end
+
+    def write(buffer)
+      @data.each { |seg| seg.writer.write(buffer) }
+    end
+  end
+end

data/lib/rqrcode_core/qrcode/qr_numeric.rb

@@ -1,38 +1,27 @@
 # frozen_string_literal: true
 
 module RQRCodeCore
-  NUMERIC = ['0','1','2','3','4','5','6','7','8','9'].freeze
+  NUMERIC = %w[0 1 2 3 4 5 6 7 8 9].freeze
 
   class QRNumeric
-    attr_reader :mode
-
-    def initialize( data )
-      @mode = QRMODE[:mode_number]
-
+    def initialize(data)
       raise QRCodeArgumentError, "Not a numeric string `#{data}`" unless QRNumeric.valid_data?(data)
 
-      @data = data;
+      @data = data
     end
 
-    def get_length
-      @data.size
-    end
-
-    def self.valid_data? data
-      data.each_char do |s|
-        return false if NUMERIC.index(s).nil?
-      end
-      true
+    def self.valid_data?(data)
+      (data.chars - NUMERIC).empty?
     end
 
-    def write( buffer)
-      buffer.numeric_encoding_start(get_length)
+    def write(buffer)
+      buffer.numeric_encoding_start(@data.size)
 
-      (@data.size).times do |i|
+      @data.size.times do |i|
         if i % 3 == 0
           chars = @data[i, 3]
           bit_length = get_bit_length(chars.length)
-          buffer.put( get_code(chars), bit_length )
+          buffer.put(get_code(chars), bit_length)
         end
       end
     end

data/lib/rqrcode_core/qrcode/qr_polynomial.rb

@@ -2,22 +2,22 @@
 
 module RQRCodeCore
   class QRPolynomial
-    def initialize( num, shift )
+    def initialize(num, shift)
       raise QRCodeRunTimeError, "#{num.size}/#{shift}" if num.empty?
       offset = 0
 
       while offset < num.size && num[offset] == 0
-        offset = offset + 1
+        offset += 1
       end
 
-      @num = Array.new( num.size - offset + shift )
+      @num = Array.new(num.size - offset + shift)
 
-      ( 0...num.size - offset ).each do |i|
+      (0...num.size - offset).each do |i|
         @num[i] = num[i + offset]
       end
     end
 
-    def get( index )
+    def get(index)
       @num[index]
     end
 
@@ -25,20 +25,20 @@ module RQRCodeCore
       @num.size
     end
 
-    def multiply( e )
-      num = Array.new( get_length + e.get_length - 1 )
+    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|
+      (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)))
+          num[i + j] = tmp ^ QRMath.gexp(QRMath.glog(get(i)) + QRMath.glog(e.get(j)))
         end
       end
 
-      return QRPolynomial.new( num, 0 )
+      QRPolynomial.new(num, 0)
     end
 
-    def mod( e )
+    def mod(e)
       if get_length - e.get_length < 0
         return self
       end
@@ -46,16 +46,16 @@ module RQRCodeCore
       ratio = QRMath.glog(get(0)) - QRMath.glog(e.get(0))
       num = Array.new(get_length)
 
-      ( 0...get_length ).each do |i|
+      (0...get_length).each do |i|
         num[i] = get(i)
       end
 
-      ( 0...e.get_length ).each do |i|
+      (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
 
-      return QRPolynomial.new( num, 0 ).mod(e)
+      QRPolynomial.new(num, 0).mod(e)
     end
   end
 end

data/lib/rqrcode_core/qrcode/qr_rs_block.rb

@@ -4,13 +4,13 @@ module RQRCodeCore
   class QRRSBlock
     attr_reader :data_count, :total_count
 
-    def initialize( total_count, data_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/
-    RQRCodeCore::QRRSBlock::RS_BLOCK_TABLE = [
+    RS_BLOCK_TABLE = [
       # L
       # M
       # Q
@@ -256,9 +256,9 @@ module RQRCodeCore
       [34, 54, 24, 34, 55, 25],
       [20, 45, 15, 61, 46, 16]
 
-    ]
+    ].freeze
 
-    def QRRSBlock.get_rs_blocks(version, error_correct_level)
+    def self.get_rs_blocks(version, error_correct_level)
       rs_block = QRRSBlock.get_rs_block_table(version, error_correct_level)
 
       if rs_block.nil?
@@ -269,20 +269,20 @@ module RQRCodeCore
       length = rs_block.size / 3
       list = []
 
-      ( 0...length ).each do |i|
+      (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 |j|
-          list << QRRSBlock.new( total_count, data_count )
+        (0...count).each do |j|
+          list << QRRSBlock.new(total_count, data_count)
         end
       end
 
       list
     end
 
-    def QRRSBlock.get_rs_block_table(version, error_correct_level)
+    def self.get_rs_block_table(version, error_correct_level)
       case error_correct_level
       when QRERRORCORRECTLEVEL[:l]
         QRRSBlock::RS_BLOCK_TABLE[(version - 1) * 4 + 0]
@@ -292,8 +292,6 @@ module RQRCodeCore
         QRRSBlock::RS_BLOCK_TABLE[(version - 1) * 4 + 2]
       when QRERRORCORRECTLEVEL[:h]
         QRRSBlock::RS_BLOCK_TABLE[(version - 1) * 4 + 3]
-      else
-        nil
       end
     end
   end

data/lib/rqrcode_core/qrcode/qr_segment.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RQRCodeCore
+  class QRSegment
+    attr_reader :data, :mode
+
+    def initialize(data:, mode: nil)
+      @data = data
+      @mode = QRMODE_NAME.dig(mode&.to_sym)
+
+      # If mode is not explicitely found choose mode according to data type
+      @mode ||= if RQRCodeCore::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::NUMBER_LENGTH[3], QRNumeric::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
+end

data/lib/rqrcode_core/qrcode/qr_util.rb

@@ -43,7 +43,7 @@ module RQRCodeCore
       [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
@@ -58,70 +58,70 @@ module RQRCodeCore
       QRMODE[:mode_number] => [10, 12, 14],
       QRMODE[:mode_alpha_numk] => [9, 11, 13],
       QRMODE[:mode_8bit_byte] => [8, 16, 16],
-      QRMODE[:mode_kanji] => [8, 10, 12],
-    }
+      QRMODE[:mode_kanji] => [8, 10, 12]
+    }.freeze
 
-    def QRUtil.max_size
+    def self.max_size
       PATTERN_POSITION_TABLE.count
     end
 
-    def QRUtil.get_bch_format_info( data )
+    def self.get_bch_format_info(data)
       d = data << 10
       while QRUtil.get_bch_digit(d) - QRUtil.get_bch_digit(G15) >= 0
         d ^= (G15 << (QRUtil.get_bch_digit(d) - QRUtil.get_bch_digit(G15)))
       end
-      (( data << 10 ) | d) ^ G15_MASK
+      ((data << 10) | d) ^ G15_MASK
     end
 
-    def QRUtil.rszf( num, count )
+    def self.rszf(num, count)
       # zero fill right shift
-      (num >> count) & ((2 ** ((num.size * 8) - count))-1)
+      (num >> count) & ((2**((num.size * 8) - count)) - 1)
     end
 
-    def QRUtil.get_bch_version(data)
+    def self.get_bch_version(data)
       d = data << 12
       while QRUtil.get_bch_digit(d) - QRUtil.get_bch_digit(G18) >= 0
         d ^= (G18 << (QRUtil.get_bch_digit(d) - QRUtil.get_bch_digit(G18)))
       end
-      ( data << 12 ) | d
+      (data << 12) | d
     end
 
-    def QRUtil.get_bch_digit( data )
+    def self.get_bch_digit(data)
       digit = 0
 
       while data != 0
-        digit = digit + 1
-        data = QRUtil.rszf( data, 1 )
+        digit += 1
+        data = QRUtil.rszf(data, 1)
       end
 
       digit
     end
 
-    def QRUtil.get_pattern_positions(version)
+    def self.get_pattern_positions(version)
       PATTERN_POSITION_TABLE[version - 1]
     end
 
-    def QRUtil.get_mask( mask_pattern, i, j )
+    def self.get_mask(mask_pattern, i, j)
       if mask_pattern > QRMASKCOMPUTATIONS.size
         raise QRCodeRunTimeError, "bad mask_pattern: #{mask_pattern}"
       end
 
-      return QRMASKCOMPUTATIONS[mask_pattern].call(i, j)
+      QRMASKCOMPUTATIONS[mask_pattern].call(i, j)
     end
 
-    def QRUtil.get_error_correct_polynomial( error_correct_length )
-      a = QRPolynomial.new( [1], 0 )
+    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 ) )
+      (0...error_correct_length).each do |i|
+        a = a.multiply(QRPolynomial.new([1, QRMath.gexp(i)], 0))
       end
 
       a
     end
 
-    def QRUtil.get_length_in_bits(mode, version)
+    def self.get_length_in_bits(mode, version)
       if !QRMODE.value?(mode)
-          raise QRCodeRunTimeError, "Unknown mode: #{mode}"
+        raise QRCodeRunTimeError, "Unknown mode: #{mode}"
       end
 
       if version > 40
@@ -139,10 +139,10 @@ module RQRCodeCore
         macro_version = 2
       end
 
-      return BITS_FOR_MODE[mode][macro_version]
+      BITS_FOR_MODE[mode][macro_version]
     end
 
-    def QRUtil.get_lost_points(modules)
+    def self.get_lost_points(modules)
       demerit_points = 0
 
       demerit_points += QRUtil.demerit_points_1_same_color(modules)
@@ -150,10 +150,10 @@ module RQRCodeCore
       demerit_points += QRUtil.demerit_points_3_dangerous_patterns(modules)
       demerit_points += QRUtil.demerit_points_4_dark_ratio(modules)
 
-      return demerit_points
+      demerit_points
     end
 
-    def QRUtil.demerit_points_1_same_color(modules)
+    def self.demerit_points_1_same_color(modules)
       demerit_points = 0
       module_count = modules.size
 
@@ -163,10 +163,10 @@ module RQRCodeCore
           same_count = 0
           dark = modules[row][col]
 
-          ( -1..1 ).each do |r|
+          (-1..1).each do |r|
             next if row + r < 0 || module_count <= row + r
 
-            ( -1..1 ).each do |c|
+            (-1..1).each do |c|
               next if col + c < 0 || module_count <= col + c
               next if r == 0 && c == 0
               if dark == modules[row + r][col + c]
@@ -181,10 +181,10 @@ module RQRCodeCore
         end
       end
 
-      return demerit_points
+      demerit_points
     end
 
-    def QRUtil.demerit_points_2_full_blocks(modules)
+    def self.demerit_points_2_full_blocks(modules)
       demerit_points = 0
       module_count = modules.size
 
@@ -196,16 +196,16 @@ module RQRCodeCore
           count += 1 if modules[row + 1][col]
           count += 1 if modules[row][col + 1]
           count += 1 if modules[row + 1][col + 1]
-          if (count == 0 || count == 4)
+          if count == 0 || count == 4
             demerit_points += DEMERIT_POINTS_2
           end
         end
       end
 
-      return demerit_points
+      demerit_points
     end
 
-    def QRUtil.demerit_points_3_dangerous_patterns(modules)
+    def self.demerit_points_3_dangerous_patterns(modules)
       demerit_points = 0
       module_count = modules.size
 
@@ -213,12 +213,12 @@ module RQRCodeCore
       modules.each do |row|
         (module_count - 6).times do |col_idx|
           if row[col_idx] &&
-            !row[col_idx + 1] &&
-            row[col_idx + 2] &&
-            row[col_idx + 3] &&
-            row[col_idx + 4] &&
-            !row[col_idx + 5] &&
-            row[col_idx + 6]
+              !row[col_idx + 1] &&
+              row[col_idx + 2] &&
+              row[col_idx + 3] &&
+              row[col_idx + 4] &&
+              !row[col_idx + 5] &&
+              row[col_idx + 6]
             demerit_points += DEMERIT_POINTS_3
           end
         end
@@ -227,21 +227,21 @@ module RQRCodeCore
       (0...module_count).each do |col|
         (0...(module_count - 6)).each 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]
+              !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
 
-      return demerit_points
+      demerit_points
     end
 
-    def QRUtil.demerit_points_4_dark_ratio(modules)
+    def self.demerit_points_4_dark_ratio(modules)
       # level 4
       dark_count = modules.reduce(0) do |sum, col|
         sum + col.count(true)
@@ -250,8 +250,7 @@ module RQRCodeCore
       ratio = dark_count / (modules.size * modules.size)
       ratio_delta = (100 * ratio - 50).abs / 5
 
-      demerit_points = ratio_delta * DEMERIT_POINTS_4
-      return demerit_points
+      ratio_delta * DEMERIT_POINTS_4
     end
   end
 end