qrencoder 1.0.0 → 1.2.0

data/History.txt

@@ -1,3 +1,8 @@
+== 1.0.1 / 2008-03-11
+
+* 1 Minor enhancement
+  * Updated to using Hoe's new rakefile format
+
 == 1.0.0 / 2007-01-03
 
 * Initial release

data/{README.txt → README.rdoc}

@@ -30,31 +30,26 @@ All of these in a square that may range from 21 to 177 pixels a side (there are
 multiple levels of error correction are possible which might also influence the
 final size.
 
-== FEATURES/PROBLEMS:
-  
-* This gem requires you to build and install an external C library
-* The QREncode lib this GEM is built around is NOT thread-safe!
+== USAGE:
 
-== SYNOPSIS:
+Basic usage is as follows:
 
-There are 4 initialization methods for creating a QR code, two for strings, two
-for data. Both of these come in a simpler variant which take the string/data to
-be encoded. The second argument is a QR Code version (used to pick the size of
-the final QR Code); this version is adjusted upwards if the data is too large to
-fit within the specified version.
+  text = "Some string"
+  qrcode = QREncoder.encode(text) #=> #<QREncoder::QRCode:0x1003710d0>
+  puts "#{qrcode.version}"  #=> 7
+  puts "#{qrcode.width}"    #=> 34
+  qrcode.save_png("/tmp/foo.png")
 
-  img = QRCode.encode_string(text, 1)
-  puts "#{img.version}"  #=> 7
-  puts "#{img.width}"    #=> 34
-  img.save_png("/tmp/foo.png")
-
-You can retrieve the pixels of the output image directly or use the included
+You can retrieve the pixels of the QRCode object directly or use the included
 methods to save a PNG file directly.
 
+See the rdocs[http://rdoc.info/github/harrisj/qrencoder] for options you can
+pass to <tt>QREncoder#encode</tt>.
+
 == REQUIREMENTS:
 
 This gem requires you to build the C library lib <tt>libqrcode.a</tt> available
-from http://megaui.net/fukuchi/works/qrencode/index.en.html. 
+from http://megaui.net/fukuchi/works/qrencode/index.en.html.
 
 Normally, the build process also expects you to install <tt>libpng</tt>, but
 this is only used for the <tt>qrenc</tt> command-line utility and can be avoided
@@ -69,10 +64,37 @@ This gem also requires the following gems to be installed:
 * ruby-inline
 * png
 
-== INSTALL:
+== INSTALLATION:
 
 * First build the <tt>libqrencode</tt> library following the instructions above.
-* Then <tt>sudo gem install qrencoder --include-dependencies</tt>
+* Then <tt>[sudo] gem install qrencoder</tt>
+
+== DEVELOPMENT AND CONTRIBUTING:
+
+This project uses Bundler and its own gemspec for dependency management. To get
+started, just clone the repo and run:
+
+  gem install bundler
+  bundle install
+  rake
+
+The default Rake task will compile the C component and run the specs. If it
+fails to build, make sure that you have libqrencode installed properly.
+
+Please send pull requests. Topic branches are preferred. New features will not
+be accepted without corresponding tests.
+
+== FEATURES/PROBLEMS:
+
+* This gem requires you to build and install an external C library
+* The QREncode lib this GEM is built around is NOT thread-safe!
+
+== CONTRIBUTORS:
+
+* Jacob Harris (harrisj)
+* Joshua Davey (jgdavey)
+* Joseph Holsten
+* Wesley Moore (wezm)
 
 == QRCODE LICENSE:
 

data/ext/qrencoder_ext/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+dir_config("qrencode")
+
+if have_header("qrencode.h") && have_library("qrencode", "QRinput_new")
+  create_makefile("qrencoder_ext")
+end

data/ext/qrencoder_ext/qrencoder_ext.c

@@ -0,0 +1,273 @@
+#include "qrencode.h"
+#include "ruby.h"
+
+VALUE mQREncoder;
+VALUE cQRCode;
+
+static void qrcode_free(void *p) {
+  QRcode *qrcode = (QRcode *) p;
+  QRcode_free(qrcode);
+}
+
+/*
+ * call-seq:
+ *   width
+ *
+ * Width of the symbol in modules. This value usually corresponds to 1 module
+ * is 1 pixel, but you could conceivably scale it up if you wanted to.
+ */
+static VALUE _width(VALUE self) {
+  QRcode *qrcode;
+  Data_Get_Struct(self, QRcode, qrcode);
+  return INT2FIX(qrcode->width);
+}
+
+
+/*
+ * call-seq:
+ *   version
+ *
+ * Version of the symbol. A QR Code version indicates the size of the 2-D
+ * barcode in modules. See +qrencode_string+ for a more detailed description of
+ * the version. Note that the version returned might be larger than the version
+ * specified for an encode_string if the requested version is for a barcode too
+ * small to encode the data.
+ */
+static VALUE _version(VALUE self) {
+  QRcode *qrcode;
+  Data_Get_Struct(self, QRcode, qrcode);
+  return INT2FIX(qrcode->version);
+}
+
+/*
+ * call-seq:
+ *   data
+ *
+ * Returns the raw data of the QRcode within a single array of width*width
+ * elements. Each item is a byte of data of which only the least significant
+ * bit is the pixel. The full use of each bit from Least Significant to Most is
+ * as follows
+ *
+ * - 1=black / 0=white
+ * - data and ecc code area
+ * - format information
+ * - version information
+ * - timing pattern
+ * - alignment pattern
+ * - finder pattern and separator
+ * - non-data modules (format, timing, etc.)
+ *
+ * This structure allows the QRcode spec to store multiple types of information
+ * within the allocated output buffers, but you usually only care about the pixel
+ * color. For those cases, just use the +pixels+ or +points+ methods.
+ */
+static VALUE _data(VALUE self) {
+  QRcode *qrcode;
+  VALUE out;
+  unsigned char *p, b;
+  int i, max;
+
+  Data_Get_Struct(self, QRcode, qrcode);
+  p = qrcode->data;
+  max = qrcode->width * qrcode->width;
+  out = rb_ary_new2(max);
+
+  for (i=0; i < max; i++) {
+    b = *p;
+    rb_ary_push(out, INT2FIX(b));
+    p++;
+  }
+
+  return out;
+}
+
+/*
+ * call-seq:
+ *   pixels
+ *
+ * Returns the QRcode as an array of rows where each item in a row represents
+ * the value of the pixel (1 = black, 0 = white)
+ */
+static VALUE _pixels(VALUE self) {
+  QRcode *qrcode;
+  VALUE out, row;
+  unsigned char *p;
+  int x, y, bit;
+
+  Data_Get_Struct(self, QRcode, qrcode);
+  p = qrcode->data;
+  out = rb_ary_new2(qrcode->width);
+
+  for (y=0; y < qrcode->width; y++) {
+    row = rb_ary_new2(qrcode->width);
+
+    for (x=0; x < qrcode->width; x++) {
+      bit = *p & 1;
+      rb_ary_push(row, INT2FIX(bit));
+      p++;
+    }
+
+    rb_ary_push(out, row);
+  }
+
+  return out;
+}
+
+/*
+ * call-seq:
+ *   points
+ *
+ * Returns the black pixels of the encoded image as an array of coordinate pairs.
+ */
+static VALUE _points(VALUE self) {
+  QRcode *qrcode;
+  VALUE out, point;
+  unsigned char *p;
+  int x, y, bit;
+
+  Data_Get_Struct(self, QRcode, qrcode);
+  p = qrcode->data;
+  out = rb_ary_new2(qrcode->width);
+
+  for (y=0; y < qrcode->width; y++) {
+    for (x=0; x < qrcode->width; x++) {
+      bit = *p & 1;
+
+      if (bit) {
+        point = rb_ary_new2(2);
+        rb_ary_push(point, INT2FIX(x));
+        rb_ary_push(point, INT2FIX(y));
+        rb_ary_push(out, point);
+      }
+
+      p++;
+    }
+  }
+
+  return out;
+}
+
+/* Handles +clone+ and +dup+ */
+static VALUE qr_init_copy(VALUE copy, VALUE orig) {
+  QRcode *copy_qrcode;
+  QRcode *orig_qrcode;
+  if (copy == orig)
+    return copy;
+
+  Data_Get_Struct(orig, QRcode, orig_qrcode);
+  Data_Get_Struct(copy, QRcode, copy_qrcode);
+  MEMCPY(copy_qrcode, orig_qrcode, QRcode, 1);
+
+  /* Code will be freed by original object */
+  RDATA(copy)->dfree = NULL;
+
+  return copy;
+}
+
+/*
+ * call-seq:
+ *   new(string, version, eclevel, mode, case_sensitive)
+ *
+ * Encodes a QR code from a string.
+ *
+ * There are 5 required arguments:
+ *
+ * [string] the string to encode
+ * [version] the version of the QR Code
+ * [error correction level] an integer representing an error correction level
+ * [encoding mode] an integer representing the encoding mode
+ * [case sensitivity] 1 (case sensitive) or 0 (case insensitive)
+ *
+ * == Version
+ *
+ * What is the version? Each QRCode is made up of <b>modules</b> which are the
+ * basic display element of a QRCode and may be made up of 1 or more pixels
+ * (here, it's just 1 module is 1 pixel). Version 1 is a 21x21  module square,
+ * while the maximum version 40 is 177x177 modules.  The full module reference
+ * is here http://www.denso-wave.com/qrcode/vertable1-e.html
+ *
+ * Should you encode more text than can fit in a module, the encoder will scale
+ * up to the smallest version able to contain your data. Unless you want to
+ * specifically fix your barcode to a certain version, it's fine to just set
+ * the version argument to 1 and let the algorithm figure out the proper size.
+ *
+ * == Error correction
+ *
+ * The following four constants can be specified for error correction levels, each
+ * specified with the maximum approximate error rate they can compensate for, as
+ * well as the maximum capacity of an 8-bit data QR Code with the error encoding:
+ *
+ * - <tt>QR_ECLEVEL_L</tt> - 7%/2953 [default]
+ * - <tt>QR_ECLEVEL_M</tt> - 15%/2331
+ * - <tt>QR_ECLEVEL_Q</tt> - 25%/1663
+ * - <tt>QR_ECLEVEL_H</tt> - 30%/1273
+ *
+ * Higher error rates are suitable for applications where the QR Code is likely
+ * to be smudged or damaged, but as is apparent here, they can radically reduce
+ * the maximum data capacity of a QR Code.
+ *
+ * == Encoding mode
+ *
+ * There are 4 possible encodings for a QR Code which can modify the maximum
+ * data capacity. These are specified with four possible Constants, each
+ * listed here with the maximum capacity available for that encoding at the
+ * lowest  error correction rate.
+ *
+ * - <tt>QR_MODE_NUM</tt> - Numeric/7089
+ * - <tt>QR_MODE_AN</tt> - Alphanumeric/4296
+ * - <tt>QR_MODE_8</tt> - 8-bit ASCII/2953 [default]
+ * - <tt>QR_MODE_KANJI</tt>  - Kanji (JIS-1 & 2)/1817
+ *
+ * Note that the QR Code specification seemingly predates the rise and triumph
+ * of UTF-8, and the specification makes no requirement that writers and
+ * readers use ISO-8859-1 or UTF-8 or whatever to interpret the data in a
+ * barcode. If you encode in UTF-8, it might be read as ISO-8859-1 or not.
+ *
+ * == Case sensitivity
+ *
+ * Encoding can either be case sensitive (1) or not (0). Without case
+ * sensitivity turned on, many decoders will view all alphabetic characters as
+ * uppercase.
+ */
+static VALUE qr_initialize(VALUE self, VALUE _string, VALUE _version, VALUE _eclevel, VALUE _hint, VALUE _casesensitive) {
+  const char *string = StringValuePtr(_string);
+  int version = FIX2INT(_version);
+  int eclevel = FIX2INT(_eclevel);
+  int hint = FIX2INT(_hint);
+  int casesensitive = FIX2INT(_casesensitive);
+
+  QRcode *code = QRcode_encodeString(string, version, eclevel, hint, casesensitive);
+
+  if (DATA_PTR(self)) {
+    QRcode_free(DATA_PTR(self));
+    DATA_PTR(self) = NULL;
+  }
+
+  DATA_PTR(self) = code;
+  return self;
+}
+
+/* Allocate memory */
+static VALUE qr_alloc(VALUE klass) {
+  QRcode *code;
+  VALUE obj = Data_Make_Struct(klass, QRcode, NULL, qrcode_free, code);
+  return obj;
+}
+
+void Init_qrencoder_ext()
+{
+    mQREncoder = rb_define_module("QREncoder");
+    cQRCode = rb_define_class_under(mQREncoder, "QRCode", rb_cObject);
+
+    rb_define_method(cQRCode, "initialize_copy", qr_init_copy, 1);
+    rb_define_method(cQRCode, "initialize", qr_initialize, 5);
+    rb_define_alloc_func(cQRCode, qr_alloc);
+
+    rb_define_method(cQRCode, "width", _width, 0);
+    rb_define_method(cQRCode, "version", _version, 0);
+    rb_define_method(cQRCode, "data", _data, 0);
+    rb_define_method(cQRCode, "pixels", _pixels, 0);
+    rb_define_method(cQRCode, "points", _points, 0);
+
+    rb_define_alias(cQRCode, "height", "width");
+}

data/lib/qrencoder.rb

@@ -1,282 +1,68 @@
-require 'rubygems'
-require 'inline'
-require 'png'
+require 'qrencoder/version'
+require 'qrencoder/qrencoder_ext'
+require 'qrencoder/qrcode'
 
-class QRCode
-  GEM_VERSION = '1.0.0'
-  
-  # Encoding modes
+module QREncoder
+  # Numeric-only encoding mode
   QR_MODE_NUM = 0
-	QR_MODE_AN = 1			
-	QR_MODE_8 = 2			
-	QR_MODE_KANJI	= 3 
-	
-	# Error correction
-	QR_ECLEVEL_L = 0
-	QR_ECLEVEL_M = 1
-	QR_ECLEVEL_Q = 2
-	QR_ECLEVEL_H = 3
-	
-  ##
-  # Version of the symbol. A QR Code version indicates the size of the 2-D
-  # barcode in modules. See #qrencode_string for a more detailed description of 
-  # the version. Note that the version returned might be larger than the version
-  # specified for an encode_string if the requested version is for a barcode too
-  # small to encode the data.
-  def version; end;
-  
-  ##
-  # Width of the symbol in modules. This value usually corresponds to 1 module 
-  # is 1 pixel, but you could conceivably scale it up if you wanted to.
-  def width; end;
 
-  ##
-  # Returns the raw data of the QRcode within a single array of width*width
-  # elements. Each item is a byte of data of which only the least significant
-  # bit is the pixel. The full use of each bit from Least Significant to Most is
-  # as follows
-  #
-  # * 1=black/0=white
-  # * data and ecc code area
-  # * format information
-  # * version information
-  # * timing pattern
-  # * alignment pattern
-  # * finder pattern and separator
-  # * non-data modules (format, timing, etc.)
-  #
-  # This structure allows the QRcode spec to store multiple types of information
-  # within the allocated output buffers, but you usually only care about the pixel
-  # color. For those cases, just use the #pixels or #points methods.
-  def data; end;
-  
-  ##
-  # Returns the QRcode as an array of rows where each item in a row represents
-  # the value of the pixel (1=black, 0=white)
-  def pixels; end;
+  # Alphanumeric-only encoding mode
+  QR_MODE_AN = 1
 
-  ##
-  # Returns the black pixels of the encoded image as an array of coordinate pairs.
-  def points; end;
-    
-  ##
-  # Encodes a QR code from a string. This version of the method assumes the 
-  # input data is 8-bit ASCII and that you want the most basic error correction.
-  # For more detailed control over those parameters, use #encode_string_ex. This
-  # method takes 2 arguments: a string to encode and a QRCode <tt>version</tt>
-  # which essentially determines the size of the QRCode. 
-  #
-  # What is the version? Each QRCode is made up
-  # of <b>modules</b> which are the basic display element of a QRCode and may
-  # be made up of 1 or more pixels (here, it's just 1 module is 1 pixel).
-  # Version 1 is a 21x21 
-  # module square, while the maximum version 40 is 177x177 modules. The full
-  # module reference is here http://www.denso-wave.com/qrcode/vertable1-e.html
-  #
-  # Should you encode more text than can fit in a module, the encoder will scale
-  # up to the smallest version able to contain your data. Unless you want to 
-  # specifically fix your barcode to a certain version, it's fine to just set
-  # the version argument to 1 and let #encode_string figure out the proper size.  
-  def encode_string; end;
-  
-  ##
-  # This function is similar in purpose to #encode_string, but it allows you to
-  # explicitly specify the encoding and error correction level. There are 4 
-  # arguments to this function:
-  #
-  # * <tt>string</tt> the string to encode
-  # * <tt>version</tt> the version of the QR Code (see #encode_string for explanation)
-  # * <tt>error correction level</tt>
-  # * <tt>encoding mode</tt>
-  #
-  # The following four Constants can be specified for error correction levels, each
-  # specified with the maximum approximate error rate they can compensate for, as
-  # well as the maximum capacity of an 8-bit data QR Code with the error encoding:
-  # 
-  # * <tt>QR_ECLEVEL_L</tt> - 7%/2953 [default]
-	# * <tt>QR_ECLEVEL_M</tt> - 15%/2331
-	# * <tt>QR_ECLEVEL_Q</tt> - 25%/1663
-	# * <tt>QR_ECLEVEL_H</tt> - 30%/1273
-  #
-	# Higher error rates are suitable for applications where the QR Code is likely
-	# to be smudged or damaged, but as is apparent here, they can radically reduce 
-	# the maximum data capacity of a QR Code. 
-	#
-	# There are also 4 possible encodings for a QR Code which can modify the 
-	# maximum data capacity. These are specified with four possible Constants, each
-	# listed here with the maximum capacity available for that encoding at the lowest
-	# error correction rate.
-	#
-	# * <tt>QR_MODE_NUM</tt> - Numeric/7089
-	# * <tt>QR_MODE_AN</tt> - Alphanumeric/4296			
-	# * <tt>QR_MODE_8</tt> - 8-bit ASCII/2953 [default]			
-	# * <tt>QR_MODE_KANJI</tt>	- Kanji (JIS-1 & 2)/1817
-	#
-	# Note that the QR Code specification seemingly predates the rise and triumph
-	# of UTF-8, and the specification makes no requirement that writers and readers
-	# use ISO-8859-1 or UTF-8 or whatever to interpret the data in a barcode. If you
-	# encode in UTF-8, it might be read as ISO-8859-1 or not. 
-  def encode_string_ex; end;
-  
-  # now for the inlines
-  inline do |builder|
-    builder.add_link_flags "-lqrencode"
-    builder.include '"qrencode.h"'
+  # 8-bit ASCII encoding mode
+  QR_MODE_8 = 2
 
-    builder.prefix <<-"END"
-      static void qrcode_free(void *p) {
-        QRcode *qrcode = (QRcode *) p;
-        QRcode_free(qrcode);
-      }
-    END
-    
-    builder.c <<-"END"
-      int width() {
-        QRcode *qrcode;
-        Data_Get_Struct(self, QRcode, qrcode);
-        return qrcode->width;
-      }
-    END
-    
-    builder.c <<-"END"
-      int version() {
-        QRcode *qrcode;
-        Data_Get_Struct(self, QRcode, qrcode);
-        return qrcode->version;
-      }
-    END
-    
-    builder.c <<-"END"
-      VALUE data() {
-        QRcode *qrcode;
-        VALUE out;
-        unsigned char *p, b;
-        int i, max;
-        
-        Data_Get_Struct(self, QRcode, qrcode);
-        p = qrcode->data;
-        max = qrcode->width * qrcode->width;
-        out = rb_ary_new2(max);
-        
-        for (i=0; i < max; i++) {
-          b = *p;
-          rb_ary_push(out, INT2FIX(b));
-          p++;
-        }
-        
-        return out;
-      }
-    END
-    
-    builder.c <<-"END"
-      VALUE pixels() {
-        QRcode *qrcode;
-        VALUE out, row;
-        unsigned char *p;
-        int x, y, bit;
-                     
-        Data_Get_Struct(self, QRcode, qrcode);        
-      	p = qrcode->data;
-    		out = rb_ary_new2(qrcode->width);
-        
-    		for (y=0; y < qrcode->width; y++) {
-    			row = rb_ary_new2(qrcode->width);
+  # Kanji encoding mode
+  QR_MODE_KANJI = 3
 
-    			for (x=0; x < qrcode->width; x++) {
-    				bit = *p & 1;
-    				rb_ary_push(row, INT2FIX(bit));
-    				p++;
-    			}
+  # Low error correction
+  QR_ECLEVEL_L = 0
 
-    			rb_ary_push(out, row);
-    		}
-    		
-    		return out;
-  		}
-    END
-        
-    builder.c <<-"END"
-      VALUE points() {
-        QRcode *qrcode;
-        VALUE out, point;
-        unsigned char *p;
-        int x, y, bit;
+  # Medium error correction
+  QR_ECLEVEL_M = 1
 
-        Data_Get_Struct(self, QRcode, qrcode);        
-      	p = qrcode->data;
-    		out = rb_ary_new2(qrcode->width);
-        
-        for (y=0; y < qrcode->width; y++) {
-        	for (x=0; x < qrcode->width; x++) {
-        		bit = *p & 1;
+  # Medium-high error correction
+  QR_ECLEVEL_Q = 2
 
-        		if (bit) {
-        			point = rb_ary_new2(2);
-        			rb_ary_push(point, INT2FIX(x));
-        			rb_ary_push(point, INT2FIX(y));
-        			rb_ary_push(out, point);
-        		}
+  # High error correction
+  QR_ECLEVEL_H = 3
 
-        		p++;
-        	}	
-        }
-        
-        return out;     
-      }
-    END
-    
-    builder.c_singleton <<-"END"
-      VALUE encode_string_ex(const char *string, int version, int eclevel, int mode) {
-        QRcode *code;
-        VALUE klass;
-        
-        code = QRcode_encodeString(string, version, eclevel, mode);
-        klass = rb_const_get_at(rb_cObject, rb_intern("QRCode")); 
-        return Data_Wrap_Struct(klass, NULL, qrcode_free, code);
-      }      
-    END
+  # Encode a string, return a QRCode object
+  #
+  # This method takes 2 arguments: the string you wish to encode, and a hash of
+  # options. The options are as follows:
+  #
+  # [:version] An integer representing the minimum QRCode version (default: +1+)
+  # [:correction] The amount of error correction to apply. One of +:low+, +:medium+, +:high+. (default: +:low+)
+  # [:mode] The encoding mode to use. Must be one of +:numeric+, +:alphanumeric+, +:ascii+, +:kanji+. (default: +:ascii+)
+  # [:case_sensitive] Set to +false+ if case does not matter. (default: +true+)
+  #
+  # For more information about what each of these modes and correction levels
+  # mean, see QRCode.new
+  #
+  def self.encode(string, options={})
+    version = options[:version] || 1
+    correction = corrections[options[:correction] || :low]
+    mode = modes[options[:mode] || :ascii]
+    case_sensitive = options[:case_sensitive] == false ? 0 : 1
+    QRCode.new(string, version, correction, mode, case_sensitive)
+  end
 
-   builder.c_singleton <<-"END" 
-     VALUE encode_string(const char *string, int version) {
-       QRcode *code;
-       VALUE klass;
-       
-       code = QRcode_encodeString(string, version, QR_ECLEVEL_L, QR_MODE_8);
-       klass = rb_const_get_at(rb_cObject, rb_intern("QRCode")); 
-       return Data_Wrap_Struct(klass, NULL, qrcode_free, code);
-     }
-   END
-        
-#    builder.c <<-"END"
-#      VALUE encode_data_ex(const char *data, int len, int version, int eclevel, int mode) {
-#        QRcode *code;
-#        QRinput *input;
-#        
-#        input = QRinput_new();
-#        QRinput_append(input, mode, data, len);
-#        code = QRcode_encode(input, version, eclevel);
-#        Qrinput_free(input);
-#        return Data_Wrap_Struct(CLASS_OF(self), NULL, qrcode_free, code);        
-#      }
-#    END
-  end 
-  
-  ##
-  # Height of the symbol. Since QR Codes are square, this is the same as the 
-  # width but this alias is provided if you want to avoid confusion.
-  alias :height :width
-  
-  ##
-  # Save the QRcode to a PNG file. You can also specify a margin in pixels around
-  # the image, although the specification requests it should be at least 4 px.
-  def save_png(path, margin=4)
-    canvas = PNG::Canvas.new width + (2*margin), width+(2*margin)
+  def self.corrections
+    {
+      :low => QR_ECLEVEL_L,
+      :medium => QR_ECLEVEL_M,
+      :high => QR_ECLEVEL_H
+    }
+  end
 
-    points.each do |p|
-      canvas.point p[0]+margin, p[1]+margin, PNG::Color::Black
-    end
-    
-    png = PNG.new canvas
-    png.save path
+  def self.modes
+    {
+      :numeric => QR_MODE_NUM,
+      :alphanumeric => QR_MODE_AN,
+      :ascii => QR_MODE_8,
+      :kanji => QR_MODE_KANJI
+    }
   end
+
 end