data_matrix 0.1.1

data/ext/data_matrix/iec16022ecc200.h

@@ -0,0 +1,36 @@
+// IEC16022 bar code generation library
+// Adrian Kennard, Andrews & Arnold Ltd
+// with help from Cliff Hones on the RS coding
+//
+// Revision 1.3  2004/09/09 07:45:09  cvs
+// Added change history to source files
+// Added "info" type to IEC16022
+// Added exact size checking shortcodes on encoding generation for iec16022
+//
+
+// Main encoding function
+// Returns the grid (malloced) containing the matrix. L corner at 0,0.
+// Takes suggested size in *Wptr, *Hptr, or 0,0. Fills in actual size.
+// Takes barcodelen and barcode to be encoded
+// Note, if *encodingptr is null, then fills with auto picked (malloced) encoding
+// If lenp not null, then the length of encoded data before any final unlatch or pad is stored
+// If maxp not null, then the max storage of this size code is stored
+// If eccp not null, then the number of ecc bytes used in this size is stored
+// Returns 0 on error (writes to stderr with details).
+
+#ifndef IEC16022ECC200_H
+#define IEC16022ECC200_H 1
+
+#define IEC16022ECC200_MAXBARCODE 3116
+#define IEC16022ECC200_ERROR_STRING_TOO_SHORT -1
+#define IEC16022ECC200_ERROR_CANNOT_ENCODE_CHARACTER_X12 -2
+#define IEC16022ECC200_ERROR_UNEXPECTED_FAILURE -3
+#define IEC16022ECC200_ERROR_UNKNOWN_ENCODING -4
+#define IEC16022ECC200_ERROR_DID_NOT_FIT -5
+#define IEC16022ECC200_BARCODE_TOO_LONG -6
+
+unsigned char* iec16022ecc200(int *Wptr, int *Hptr, char **encodingptr, const int barcodelen, const unsigned char *barcode,
+                              int *lenp,int *maxp,int *eccp);
+void iec16022init(int *Wptr, int *Hptr, const char *barcode);
+
+#endif

data/ext/data_matrix/reedsol.c

@@ -0,0 +1,122 @@
+// reedsol.c
+//
+// This is a simple Reed-Solomon encoder
+// (C) Cliff Hones 2004
+//
+// It is not written with high efficiency in mind, so is probably
+// not suitable for real-time encoding.  The aim was to keep it
+// simple, general and clear.
+//
+// <Some notes on the theory and implementation need to be added here>
+
+// Usage:
+// First call rs_init_gf(poly) to set up the Galois Field parameters.
+// Then  call rs_init_code(size, index) to set the encoding size
+// Then  call rs_encode(datasize, data, out) to encode the data.
+//
+// These can be called repeatedly as required - but note that
+// rs_init_code must be called following any rs_init_gf call.
+//
+// If the parameters are fixed, some of the statics below can be
+// replaced with constants in the obvious way, and additionally
+// malloc/free can be avoided by using static arrays of a suitable
+// size.
+
+#include <stdlib.h>             // only needed for malloc/free
+
+static int gfpoly;
+static int symsize;             // in bits
+static int logmod;              // 2**symsize - 1
+static int rlen;
+
+static int *log = NULL, *alog = NULL, *rspoly = NULL;
+
+// rs_init_gf(poly) initialises the parameters for the Galois Field.
+// The symbol size is determined from the highest bit set in poly
+// This implementation will support sizes up to 30 bits (though that
+// will result in very large log/antilog tables) - bit sizes of
+// 8 or 4 are typical
+//
+// The poly is the bit pattern representing the GF characteristic
+// polynomial.  e.g. for ECC200 (8-bit symbols) the polynomial is
+// a**8 + a**5 + a**3 + a**2 + 1, which translates to 0x12d.
+
+void rs_init_gf (int poly) {
+  int m, b, p, v;
+  // Return storage from previous setup
+  if (log) {
+    free(log);
+    free(alog);
+    free(rspoly);
+    rspoly = NULL;
+  }
+  // Find the top bit, and hence the symbol size
+  for (b = 1, m = 0; b <= poly; b <<= 1)
+    m++;
+  b >>= 1;
+  m--;
+  gfpoly = poly;
+  symsize = m;
+  // Calculate the log/alog tables
+  logmod = (1 << m) - 1;
+  log = (int *) malloc (sizeof (int) * (logmod + 1));
+  alog = (int *) malloc (sizeof (int) * logmod);
+
+  for (p = 1, v = 0; v < logmod; v++) {
+    alog[v] = p;
+    log[p] = v;
+    p <<= 1;
+    if (p & b)
+      p ^= poly;
+  }
+}
+
+// rs_init_code(nsym, index) initialises the Reed-Solomon encoder
+// nsym is the number of symbols to be generated (to be appended
+// to the input data).  index is usually 1 - it is the index of
+// the constant in the first term (i) of the RS generator polynomial:
+// (x + 2**i)*(x + 2**(i+1))*...   [nsym terms]
+// For ECC200, index is 1.
+
+void rs_init_code (int nsym, int index) {
+  int i, k;
+  if (rspoly)
+    free(rspoly);
+  rspoly = (int *) malloc(sizeof(int) * (nsym + 1));
+  rlen = nsym;
+
+  rspoly[0] = 1;
+  for (i = 1; i <= nsym; i++) {
+    rspoly[i] = 1;
+    for (k = i - 1; k > 0; k--) {
+      if (rspoly[k])
+        rspoly[k] = alog[(log[rspoly[k]] + index) % logmod];
+      rspoly[k] ^= rspoly[k - 1];
+    }
+    rspoly[0] = alog[(log[rspoly[0]] + index) % logmod];
+    index++;
+  }
+}
+
+// Note that the following uses byte arrays, so is only suitable for
+// symbol sizes up to 8 bits.  Just change the data type of data and res
+// to unsigned int * for larger symbols.
+
+void rs_encode (int len, unsigned char *data, unsigned char *res) {
+  int i, k, m;
+  for (i = 0; i < rlen; i++)
+    res[i] = 0;
+  for (i = 0; i < len; i++) {
+    m = res[rlen - 1] ^ data[i];
+    for (k = rlen - 1; k > 0; k--) {
+      if (m && rspoly[k])
+        res[k] = res[k - 1] ^ alog[(log[m] + log[rspoly[k]]) % logmod];
+      else
+        res[k] = res[k - 1];
+    }
+    if (m && rspoly[0])
+      res[0] = alog[(log[m] + log[rspoly[0]]) % logmod];
+    else
+      res[0] = 0;
+  }
+}

data/ext/data_matrix/reedsol.h

@@ -0,0 +1,10 @@
+#ifndef REEDSOL_H
+#define REEDSOL_H 1
+/* don't compile in the main function from reedsol.c */
+#define LIB
+
+void rs_init_gf(int poly);
+void rs_init_code(int nsym, int index);
+void rs_encode(int len, unsigned char *data, unsigned char *res);
+
+#endif

data/lib/data_matrix.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require 'data_matrix/version'
+require 'data_matrix/data_matrix'
+require 'data_matrix/encoder'
+
+# DataMatrix main module
+module DataMatrix
+end

data/lib/data_matrix/encoder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# Encoder ext ruby method aliases
+module DataMatrix
+  # encoder class ruby extensions
+  class Encoder
+    alias to_str to_s
+    alias to_a data
+
+    def initialize(value)
+      raise ArgumentError, 'Value must be convertible to string' unless value.respond_to?(:to_s)
+      encode_string(value.to_s)
+    end
+
+    def length
+      height * width
+    end
+    alias size length
+  end
+end

data/lib/data_matrix/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module DataMatrix
+  VERSION = '0.1.1'
+end

data/lib/semacode.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+# This file is needed to replace original semacode gem
+require 'data_matrix'

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: data_matrix
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Mikhail Bortnyk
+- Guido Sohne
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+    This Ruby extension implements a DataMatrix encoder for Ruby. It is typically
+    used to create semacodes, which are barcodes, that contain URLs. This encoder
+    does not create image files or visual representations of the semacode. This is
+    because it can be used for more than creating images, such as rendering
+    semacodes to HTML, SVG, PDF or even stored in a database or file for later
+    use.
+email:
+- vessimir@gmail.com
+- guido@sohne.net
+executables: []
+extensions:
+- ext/data_matrix/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- data_matrix.gemspec
+- ext/data_matrix/data_matrix.c
+- ext/data_matrix/data_matrix.h
+- ext/data_matrix/extconf.rb
+- ext/data_matrix/iec16022ecc200.c
+- ext/data_matrix/iec16022ecc200.h
+- ext/data_matrix/reedsol.c
+- ext/data_matrix/reedsol.h
+- lib/data_matrix.rb
+- lib/data_matrix/encoder.rb
+- lib/data_matrix/version.rb
+- lib/semacode.rb
+homepage: https://github.com/vessi/data_matrix
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Create semacodes (2D barcodes) using Ruby.
+test_files: []