qrest 1.0.0

data/lib/qrest/segment.rb

@@ -0,0 +1,210 @@
+#
+#  qrest/segment.rb  --  Segments
+#
+
+require "qrest/base"
+
+
+module QRest
+
+  class Segment
+
+    def initialize data
+      @data = data
+    end
+
+    def write buffer, version
+      buffer.put 1<<self.class::ID, 4
+      buffer.put @data.bytesize, (get_length_in_bits version)
+    end
+
+    def size version
+      4 + (get_length_in_bits version) + (
+        chunk_size, bit_length, extra = cbe
+        num, rest = @data.bytesize.divmod chunk_size
+        r = num * bit_length
+        r += extra if rest.nonzero?
+        r
+      )
+    end
+
+    private
+
+    def get_length_in_bits version
+      macro_version =
+        case version
+        when 1.. 9 then 0
+        when  ..26 then 1
+        when  ..40 then 2
+        else            raise Error, "Unknown version: #{version}"
+        end
+      self.class::BITS_FOR_MODE[macro_version]
+    end
+
+
+    @sub = []
+
+    class <<self
+
+      def [] *args, **kwargs
+        new *args, **kwargs
+      end
+
+      def inherited cls
+        @sub.push cls
+      end
+
+      def create data, mode = nil
+        case data
+        when String then
+          if mode then
+            type = @sub.find { |t| mode.to_s == t::NAME }
+            type or raise ArgumentError, "Not a valid segment type: #{mode}"
+            type.new data
+          else
+            @sub.each do |t|
+              break t.new data
+            rescue ArgumentError, NotImplementedError
+            end
+          end
+        when Array then
+          Multi.new data
+        when Segment
+          data
+        else
+          raise ArgumentError, "Data must be a String, an Array, or a Segment"
+        end
+      end
+
+    end
+
+  end
+
+
+  class Multi
+
+    def initialize data
+      @segs = data.map! { |s|
+        args =
+          case s
+          when String then s
+          when Hash   then [ s[ :data], s[ :mode]]
+          end
+        Segment.create *args
+      }
+    end
+
+    def write buffer, version
+      @segs.each { |s| s.write buffer, version }
+    end
+
+    def size version
+      @segs.sum { |s| s.size version }
+    end
+
+  end
+
+
+  class Numeric < Segment
+
+    NAME          = "number"
+    ID            = 0
+    BITS_FOR_MODE = [10, 12, 14]
+
+    def initialize data
+      data =~ /[^0-9]/ and raise ArgumentError, "Not numeric: #{data}"
+      super
+    end
+
+    NUMBER_LENGTH = { 3 => 10, 2 => 7, 1 => 4 }
+
+    def write buffer, version
+      super
+      @data.scan /\d{1,3}/ do |chars|
+        buffer.put chars.to_i, NUMBER_LENGTH[ chars.length]
+      end
+    end
+
+    def cbe ; [3, NUMBER_LENGTH[3], NUMBER_LENGTH[ @data.size % 3]||0] ; end
+
+  end
+
+  class Alphanumeric < Segment
+
+    NAME          = "alphanumeric"
+    ID            = 1
+    BITS_FOR_MODE = [ 9, 11, 13]
+
+    ALPHANUMERIC, = [
+      *("0".."9"), *("A".."Z"), " ", "$", "%", "*", "+", "-", ".", "/", ":",
+    ].inject [{},0] do |(r,i),e| r[ e] = i ; [r,i+1] end
+
+    def initialize data
+      data.each_char { |c|
+        ALPHANUMERIC[ c] or raise ArgumentError, "Not alphanumeric uppercase: #{data}"
+      }
+      super
+    end
+
+    def write buffer, version
+      super
+      @data.scan /(.)(.)?/ do |c,d|
+        val = ALPHANUMERIC[ c]
+        len = 6
+        if d then
+          val = (val * ALPHANUMERIC.length) + ALPHANUMERIC[ d]
+          len += 5
+        end
+        buffer.put val, len
+      end
+    end
+
+    def cbe ; [2, 11, 6] ; end
+
+  end
+
+  class Kanji < Segment
+
+    NAME          = "kanji"
+    ID            = nil  # ???
+    BITS_FOR_MODE = [ 8, 10, 12]
+
+    def initialize data
+      super
+      not_implemented
+    end
+
+    def write buffer, version
+      super
+      not_implemented
+    end
+
+    def cbe ; not_implemented ; end
+
+    private
+
+    def not_implemented
+      raise NotImplementedError, "Not implemented yet. Please contribute."
+    end
+
+  end
+
+  class Bytes < Segment
+
+    NAME          = "8bit"
+    ID            = 2
+    BITS_FOR_MODE = [ 8, 16, 16]
+
+    def write buffer, version
+      super
+      @data.each_byte do |b|
+        buffer.put b, 8
+      end
+    end
+
+    def cbe ; [1, 8, 0] ; end
+
+  end
+
+end
+

data/lib/qrest/version.rb

@@ -0,0 +1,12 @@
+#
+#  qrest/version.rb  --  Version number
+#
+
+
+module QRest
+
+  NAME    = "qrest"
+  VERSION = "1.0.0"
+
+end
+

data/lib/qrest.rb

@@ -0,0 +1,67 @@
+#
+#  qrest.rb  --  QR code library
+#
+
+require "qrest/base"
+require "qrest/version"
+require "qrest/segment"
+require "qrest/rsblocks"
+require "qrest/modules"
+
+
+module QRest
+
+  class Code
+
+    class <<self
+      alias [] new
+    end
+
+    attr_reader :modules
+
+    def initialize input, *more, level: nil, max_version: nil, mode: nil, version: nil
+      input = [ input, *more] if not more.empty? or Hash === input
+      input = Segment.create input, mode
+      level ||= :h
+      error_correct_level = level.downcase.to_sym
+      Modules::ERRORCORRECTLEVEL[error_correct_level] or
+        raise ArgumentError, "Unknown error correction level: #{level}"
+      if version then
+        version <= Modules::MAX_VERSION or
+          raise ArgumentError, "Requested version exceeds maximum of #{Modules::MAX_VERSION}"
+      else
+        if max_version then
+          max_version <= Modules::MAX_VERSION or
+            raise ArgumentError, "Maximum posible version is #{Modules::MAX_VERSION}"
+        else
+          max_version = Modules::MAX_VERSION
+        end
+        mb = Modules::MAXBITS[error_correct_level]
+        version = 0
+        begin
+          version += 1
+          version <= max_version or
+            raise Error, "Data length exceeds maximum capacity of version #{max_version}"
+        end until (input.size version) <= mb[version - 1]
+      end
+
+      data = (RSBlocks.get version, error_correct_level).create_data input
+      @modules = Modules.create_best data, version, error_correct_level
+    end
+
+    def to_s dark: nil, light: nil, quiet_size: nil
+      @modules.to_s dark: dark, light: light, quiet_size: quiet_size
+    end
+
+    def method_missing sym, *args, **kwargs, &block
+      if @modules.respond_to? sym then
+        @modules.send sym, *args, **kwargs, &block
+      else
+        super
+      end
+    end
+
+  end
+
+end
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: qrest
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Bertram Scharpf
+bindir: bin
+cert_chain: []
+date: 2025-03-16 00:00:00.000000000 Z
+dependencies: []
+description: |
+  A Ruby library that generates QR Codes
+  as XPM, SVG or EPS graphics.
+email: "<software@bertram-scharpf.de>"
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/qrest.rb
+- lib/qrest/base.rb
+- lib/qrest/bch.rb
+- lib/qrest/bitbuffer.rb
+- lib/qrest/bitstream.rb
+- lib/qrest/demerits.rb
+- lib/qrest/foreign/supplement.rb
+- lib/qrest/formats/eps.rb
+- lib/qrest/formats/svg.rb
+- lib/qrest/formats/xpm.rb
+- lib/qrest/modules.rb
+- lib/qrest/polynomial.rb
+- lib/qrest/rsblocks.rb
+- lib/qrest/segment.rb
+- lib/qrest/version.rb
+homepage: https://github.com/BertramScharpf/ruby-qrest.git
+licenses:
+- BSD-2-Clause+
+metadata: {}
+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.4
+specification_version: 4
+summary: Generate QR Codes
+test_files: []