zscan 1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 998b97db8e9341f3920caa27bf11558954a777ba
-  data.tar.gz: 033986f8e4a4086985bca23c84f8acfabd2f5e29
+  metadata.gz: 71174140986194386fd74477637f21f95810d704
+  data.tar.gz: 72706410ead67f6cd9af96a7bf7024c72d7ef8c8
 SHA512:
-  metadata.gz: a8c23d9f29b57e113a55e46fb024bce0337aa8ee5b8317744ed9ce9c13ddf35e4b1b7af9bbf25d67c6b14e6c30bb7de00c214692cb5fea05c2e0f4fa6116478b
-  data.tar.gz: 06ccbc8c793f873a630c4774b746ad8ca1cfa4c2895414871c0b435812bd902e3f75618a6134551b5ab3f35b2838e12c9072e0bb15ff8f6010a7ba2ca4e8a83a
+  metadata.gz: 7c9b9a9516dfa9b5ced99820f66976868d2c0a521df1eb35a517d262d3519601bb28b2a5e95797de411398b22bea3d9aa504d4af96f1634c1f9353d873d134d0
+  data.tar.gz: d3c3bcc5255f1909acafdf4bb1977d0ac75d73a6e837af0382cc5dd57d4a1e98443898bd49252e9d2d0b9ee3c7bc3eb0561c423bea4a91feb44bccf6138ac86f

data/benchmark/one-or-more.rb

@@ -0,0 +1,19 @@
+require_relative "../lib/zscan"
+require "benchmark"
+
+z = ZScan.new 'a' * 100
+puts Benchmark.measure{
+  1000.times{
+    z.pos = 0
+    z.one_or_more{
+      z.scan 'a'
+    }
+  }
+}
+
+puts Benchmark.measure{
+  1000.times{
+    z.pos = 0
+    z.scan /a+/
+  }
+}

data/ext/bspec.c

@@ -0,0 +1,141 @@
+#include "zscan.h"
+
+static const rb_data_type_t* zscan_type;
+
+typedef struct {
+  long s_size;
+  long a_size;
+  long a_cap;
+  void** code;
+} BSpec;
+
+static void bspec_free(void* pp) {
+  BSpec* p = pp;
+  free(p->code);
+  free(p);
+}
+
+static size_t bspec_memsize(const void* pp) {
+  const BSpec* p = pp;
+  return p ? sizeof(*p) : 0;
+}
+
+static const rb_data_type_t bspec_type = {
+  "ZScan::BinarySpec",
+  {NULL, bspec_free, bspec_memsize}
+};
+
+static VALUE bspec_alloc(VALUE klass) {
+  BSpec* bs = (BSpec*)malloc(sizeof(BSpec));
+  bs->s_size = 0;
+  bs->a_cap = 4;
+  bs->a_size = 0;
+  bs->code = (void**)malloc(bs->a_cap * sizeof(void*));
+  return TypedData_Wrap_Struct(klass, &bspec_type, bs);
+}
+
+static VALUE bspec_append(VALUE self, VALUE v_code, VALUE v_s_size) {
+  BSpec* bs = rb_check_typeddata(self, &bspec_type);
+  if (bs->a_size == bs->a_cap) {
+    bs->a_cap *= 2;
+    bs->code = (void**)realloc(bs->code, bs->a_cap * sizeof(void*));
+  }
+  long s_size = NUM2LONG(v_s_size);
+  bs->code[bs->a_size++] = ((void**)RSTRING_PTR(v_code))[0];
+  bs->s_size += s_size;
+  return self;
+}
+
+static VALUE bspec_big_endian_p(VALUE self) {
+# ifdef DYNAMIC_ENDIAN
+  /* for universal binary of NEXTSTEP and MacOS X */
+  int init = 1;
+  char* p = (char*)&init;
+  return p[0] ? Qfalse : Qtrue;
+# elif defined(WORDS_BIGENDIAN)
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
+}
+
+#define GCC_VERSION_SINCE(major, minor, patchlevel) \
+  (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
+   ((__GNUC__ > (major)) ||  \
+    (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
+    (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
+
+#if GCC_VERSION_SINCE(4,3,0) || defined(__clang__)
+# define swap32(x) __builtin_bswap32(x)
+# define swap64(x) __builtin_bswap64(x)
+#endif
+
+#ifndef swap16
+# define swap16(x)  ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
+#endif
+
+#ifndef swap32
+# define swap32(x)  ((uint32_t)((((x)&0xFF)<<24) \
+    |(((x)>>24)&0xFF)      \
+    |(((x)&0x0000FF00)<<8) \
+    |(((x)&0x00FF0000)>>8)))
+#endif
+
+#ifndef swap64
+# define byte_in_64bit(n) ((uint64_t)0xff << (n))
+# define swap64(x)  ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
+    |(((x)>>56)&0xFF)              \
+    |(((x)&byte_in_64bit(8))<<40)  \
+    |(((x)&byte_in_64bit(48))>>40) \
+    |(((x)&byte_in_64bit(16))<<24) \
+    |(((x)&byte_in_64bit(40))>>24) \
+    |(((x)&byte_in_64bit(24))<<8)  \
+    |(((x)&byte_in_64bit(32))>>8)))
+#endif
+
+// NOTE can not use sizeof in preprocessor
+#define INT64toNUM(x) (sizeof(long) == 8 ? LONG2NUM(x) : LL2NUM(x))
+#define UINT64toNUM(x) (sizeof(long) == 8 ? ULONG2NUM(x) : ULL2NUM(x))
+
+#define CAST(var, ty) *((ty*)(&(var)))
+
+#include "bspec_exec.inc"
+
+static VALUE zscan_scan_binary(VALUE self, VALUE spec) {
+  ZScan* p = rb_check_typeddata(self, zscan_type);
+  if (!rb_enc_str_asciicompat_p(p->s)) {
+    rb_raise(rb_eRuntimeError, "encoding of source string should be ascii-compatible");
+    return Qnil;
+  }
+  BSpec* bs = rb_check_typeddata(spec, &bspec_type);
+  if (bs->a_size == 0) {
+    return rb_ary_new();
+  }
+  long s_size = bs->s_size;
+  if (p->bytepos + s_size > RSTRING_LEN(p->s)) {
+    return Qnil;
+  }
+  volatile VALUE a = rb_ary_new2(bs->a_size - 1);
+  bspec_exec(bs->code, RSTRING_PTR(p->s) + p->bytepos, a);
+  p->bytepos += s_size;
+  p->pos += s_size;
+  return a;
+}
+
+void Init_zscan_bspec(VALUE zscan, const rb_data_type_t* _zscan_type) {
+  zscan_type = _zscan_type;
+  rb_define_method(zscan, "scan_binary", zscan_scan_binary, 1);
+
+  VALUE bs = rb_define_class_under(zscan, "BinarySpec", rb_cObject);
+  rb_define_singleton_method(bs, "big_endian?", bspec_big_endian_p, 0);
+  rb_define_alloc_func(bs, bspec_alloc);
+  rb_define_method(bs, "append", bspec_append, 2);
+
+# include "bspec_opcode_names.inc"
+  void** opcodes = (void**)bspec_exec(NULL, NULL, Qnil);
+  for (long i = 0; i < bspec_opcode_size; i++) {
+    VALUE bytecode = rb_str_new((char*)&opcodes[i], sizeof(void*));
+    OBJ_FREEZE(bytecode);
+    rb_define_const(bs, bspec_opcode_names[i], bytecode);
+  }
+}

data/ext/extconf.rb

@@ -1,3 +1,8 @@
 require "mkmf"
 
 create_makefile 'zscan'
+
+headers = Dir.glob('*.h').join ' '
+File.open 'Makefile', 'a' do |f|
+  f.puts "\n$(OBJS): #{headers}"
+end

data/ext/zscan.c

@@ -1,24 +1,6 @@
-#include <ruby/ruby.h>
-#include <ruby/re.h>
-#include <ruby/encoding.h>
-#include <ctype.h>
-
+#include "zscan.h"
 // todo infect check
 
-typedef struct {
-  long pos;
-  long bytepos;
-} Pos;
-
-typedef struct {
-  long pos;
-  long bytepos;
-  VALUE s;
-  long stack_i;
-  long stack_cap;
-  Pos* stack;
-} ZScan;
-
 static void zscan_mark(void* pp) {
   ZScan* p = pp;
   rb_gc_mark(p->s);
@@ -282,6 +264,16 @@ static VALUE zscan_try(VALUE self) {
   return r;
 }
 
+// optimized version without pushing and block
+static VALUE zscan__try(VALUE self, VALUE r) {
+  if (RTEST(r)) {
+    zscan_drop(self);
+  } else {
+    zscan_pop(self);
+  }
+  return r;
+}
+
 static VALUE zscan_zero_or_one(int argc, VALUE* argv, VALUE self) {
   REQUIRE_BLOCK;
   volatile VALUE a = Qnil;
@@ -380,76 +372,7 @@ VALUE zscan_scan_float(VALUE self) {
   }
 }
 
-static VALUE bspec_big_endian_p(VALUE self) {
-# ifdef DYNAMIC_ENDIAN
-  /* for universal binary of NEXTSTEP and MacOS X */
-  int init = 1;
-  char* p = (char*)&init;
-  return p[0] ? Qfalse : Qtrue;
-# elif defined(WORDS_BIGENDIAN)
-  return Qtrue;
-#else
-  return Qfalse;
-#endif
-}
-
-#define GCC_VERSION_SINCE(major, minor, patchlevel) \
-  (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
-   ((__GNUC__ > (major)) ||  \
-    (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
-    (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
-
-#if GCC_VERSION_SINCE(4,3,0) || defined(__clang__)
-# define swap32(x) __builtin_bswap32(x)
-# define swap64(x) __builtin_bswap64(x)
-#endif
-
-#ifndef swap16
-# define swap16(x)	((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
-#endif
-
-#ifndef swap32
-# define swap32(x)	((uint32_t)((((x)&0xFF)<<24)	\
-		|(((x)>>24)&0xFF)	\
-		|(((x)&0x0000FF00)<<8)	\
-		|(((x)&0x00FF0000)>>8)	))
-#endif
-
-#ifndef swap64
-# ifdef HAVE_INT64_T
-#  define byte_in_64bit(n) ((uint64_t)0xff << (n))
-#  define swap64(x)       ((uint64_t)((((x)&byte_in_64bit(0))<<56) 	\
-	   |(((x)>>56)&0xFF)	                \
-	   |(((x)&byte_in_64bit(8))<<40)	\
-	   |(((x)&byte_in_64bit(48))>>40)	\
-	   |(((x)&byte_in_64bit(16))<<24)	\
-	   |(((x)&byte_in_64bit(40))>>24)	\
-	   |(((x)&byte_in_64bit(24))<<8)	\
-	   |(((x)&byte_in_64bit(32))>>8)))
-# endif
-#endif
-
-// NOTE can not use sizeof in preprocessor
-#define INT64toNUM(x) (sizeof(long) == 8 ? LONG2NUM(x) : LL2NUM(x))
-#define UINT64toNUM(x) (sizeof(long) == 8 ? ULONG2NUM(x) : ULL2NUM(x))
-
-#define CAST(var, ty) *((ty*)(&(var)))
-
-#include "bspec_exec.inc"
-
-static VALUE zscan_scan_binary(VALUE self, VALUE spec) {
-  P;
-  long s_size = NUM2LONG(rb_iv_get(spec, "@s_size"));
-  if (p->bytepos + s_size > RSTRING_LEN(p->s)) {
-    return Qnil;
-  }
-  VALUE code = rb_iv_get(spec, "@code");
-  long a_size = RSTRING_LEN(code) / sizeof(void*);
-  volatile VALUE a = rb_ary_new2(a_size);
-  bspec_exec((void**)RSTRING_PTR(code), RSTRING_PTR(p->s) + p->bytepos, a);
-  zscan_bytepos_eq(self, LONG2NUM(p->bytepos + s_size));
-  return a;
-}
+extern void Init_zscan_bspec(VALUE, const rb_data_type_t*);
 
 void Init_zscan() {
   VALUE zscan = rb_define_class("ZScan", rb_cObject);
@@ -471,21 +394,11 @@ void Init_zscan() {
   rb_define_method(zscan, "clear_pos_stack", zscan_clear_pos_stack, 0);
 
   rb_define_method(zscan, "try", zscan_try, 0);
+  rb_define_method(zscan, "_try", zscan__try, 1);
   rb_define_method(zscan, "zero_or_one", zscan_zero_or_one, -1);
   rb_define_method(zscan, "zero_or_more", zscan_zero_or_more, -1);
   rb_define_method(zscan, "one_or_more", zscan_one_or_more, -1);
 
   rb_define_method(zscan, "scan_float", zscan_scan_float, 0);
-  rb_define_method(zscan, "scan_binary", zscan_scan_binary, 1);
-
-  VALUE bs = rb_define_class_under(zscan, "BinarySpec", rb_cObject);
-  rb_define_singleton_method(bs, "big_endian?", bspec_big_endian_p, 0);
-
-# include "bspec_opcode_names.inc"
-  void** opcodes = (void**)bspec_exec(NULL, NULL, Qnil);
-  for (long i = 0; i < bspec_opcode_size; i++) {
-    VALUE bytecode = rb_str_new((char*)&opcodes[i], sizeof(void*));
-    OBJ_FREEZE(bytecode);
-    rb_define_const(bs, bspec_opcode_names[i], bytecode);
-  }
+  Init_zscan_bspec(zscan, &zscan_type);
 }

data/ext/zscan.h

@@ -0,0 +1,19 @@
+#pragma once
+#include <ruby/ruby.h>
+#include <ruby/re.h>
+#include <ruby/encoding.h>
+#include <ctype.h>
+
+typedef struct {
+  long pos;
+  long bytepos;
+} Pos;
+
+typedef struct {
+  long pos;
+  long bytepos;
+  VALUE s;
+  long stack_i;
+  long stack_cap;
+  Pos* stack;
+} ZScan;

data/lib/zscan.rb

@@ -3,7 +3,7 @@ require_relative "zscan/instructions"
 require "date"
 
 class ZScan
-  VERSION = '1.1'
+  VERSION = '1.2'
 
   def initialize s, dup=false
     if s.encoding.ascii_compatible?
@@ -139,18 +139,16 @@ class ZScan
   end
 
   def self.binary_spec &p
-    bs = BinarySpec.new
+    bs = BinarySpec.send :new
     bs.instance_eval &p
-    bs.instance_variable_get(:@code) << BinarySpec::RET
+    bs.send :append, BinarySpec::RET, 0
     bs
   end
 
   class BinarySpec
-    BLANK = ''.force_encoding 'binary'
-
-    def initialize
-      @code = BLANK.dup
-      @s_size = 0
+    private :append
+    class << self
+      private :new
     end
   end
 

data/lib/zscan/instructions.rb

@@ -3,127 +3,109 @@ class ZScan::BinarySpec
   def int8 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT8
-      @s_size += 1
+      append INT8, 1
     end
   end
   def int16 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT16
-      @s_size += 2
+      append INT16, 2
     end
   end
   def int16_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT16_SWAP
-      @s_size += 2
+      append INT16_SWAP, 2
     end
   end
   def int32 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT32
-      @s_size += 4
+      append INT32, 4
     end
   end
   def int32_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT32_SWAP
-      @s_size += 4
+      append INT32_SWAP, 4
     end
   end
   def int64 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT64
-      @s_size += 8
+      append INT64, 8
     end
   end
   def int64_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << INT64_SWAP
-      @s_size += 8
+      append INT64_SWAP, 8
     end
   end
   def uint8 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT8
-      @s_size += 1
+      append UINT8, 1
     end
   end
   def uint16 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT16
-      @s_size += 2
+      append UINT16, 2
     end
   end
   def uint16_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT16_SWAP
-      @s_size += 2
+      append UINT16_SWAP, 2
     end
   end
   def uint32 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT32
-      @s_size += 4
+      append UINT32, 4
     end
   end
   def uint32_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT32_SWAP
-      @s_size += 4
+      append UINT32_SWAP, 4
     end
   end
   def uint64 n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT64
-      @s_size += 8
+      append UINT64, 8
     end
   end
   def uint64_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << UINT64_SWAP
-      @s_size += 8
+      append UINT64_SWAP, 8
     end
   end
   def single n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << SINGLE
-      @s_size += 4
+      append SINGLE, 4
     end
   end
   def single_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << SINGLE_SWAP
-      @s_size += 4
+      append SINGLE_SWAP, 4
     end
   end
   def double n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << DOUBLE
-      @s_size += 8
+      append DOUBLE, 8
     end
   end
   def double_swap n=1
     raise ArgumentError, "repeat count should be >= 1, but got #{n}" if n < 1
     n.times do
-      @code << DOUBLE_SWAP
-      @s_size += 8
+      append DOUBLE_SWAP, 8
     end
   end
   if ZScan::BinarySpec.big_endian?

data/rakefile

@@ -143,8 +143,7 @@ file 'lib/zscan/instructions.rb' => __FILE__ do
   def #{ins.downcase} n=1
     raise ArgumentError, "repeat count should be >= 1, but got \#{n}" if n < 1
     n.times do
-      @code << #{ins}
-      @s_size += #{bspec_incr ins}
+      append #{ins}, #{bspec_incr ins}
     end
   end
       RUBY

data/readme.md

@@ -23,7 +23,7 @@ z.scan /\w+/   #=> 'world'
 z.eos?         #=> true
 ```
 
-## Motivation - `StringScanner`
+## Motivation: string scanner
 
 Ruby's stdlib `StringScanner` treats the scanning position as beginning of string:
 
@@ -47,7 +47,7 @@ z.scan /^/     #=> nil
 
 See also https://bugs.ruby-lang.org/issues/7092
 
-## Other motivations - `scanf` / `strptime` / `unpack`
+## Other motivations
 
 - For scan and convert, ruby's stdlib `Scanf` is slow (creates regexp array everytime called) and not possible to corporate with scanner.
 - For date parsing, `strptime` doesn't tell the parsed length.
@@ -77,15 +77,6 @@ For convienience
 - `#size`
 - `#bytesize`
 
-## Parsing combinators
-
-Combinators that manage scanner pos and stack state for you. In the combinators, if the returned value of the given block is `nil` or `false`, stops iteration. Can be nested, useful for building parsers.
-
-- `#try &block` returns `block`'s return.
-- `#zero_or_one result=[], &block` try to execute 0 or 1 time, returns `result`.
-- `#zero_or_more result=[], &block` try to execute 0 or more times, also stops iteration if scanner no advance, returns `result`.
-- `#one_or_more result=[], &block` try to execute 1 or more times, also stops iteration if scanner no advance, returns `nil` or `result`.
-
 ## Pos management
 
 - `#pos`
@@ -97,15 +88,7 @@ Combinators that manage scanner pos and stack state for you. In the combinators,
 - `#reset` go to beginning.
 - `#terminate` go to end of string.
 
-## (Low level) Efficient pos stack manipulation
-
-- `#push` push current pos into the stack.
-- `#pop` set current pos to top of the stack, and pop it.
-- `#drop` drop top of pos stack without changing current pos.
-- `#restore` set current pos to top of the stack.
-- `#clear_pos_stack` clear pos stack.
-
-## `ZScan::BinarySpec`
+## Binary parsing
 
 Specify a sequence of binary data. Designed for binary protocol parsing. Example:
 
@@ -150,9 +133,25 @@ Endians:
 
 Repeat count must be integer `>= 1`, default is `1`.
 
-It is implemented as a direct-threaded bytecode interpreter. Performance vs `String#unpack`:
+It is implemented as a direct-threaded bytecode interpreter. A bit faster than `String#unpack`.
 
-todo
+## Parsing combinators
+
+Combinators that manage scanner pos and stack state for you. In the combinators, if the returned value of the given block is `nil` or `false`, stops iteration and restores scanner location. Can be nested, useful for building parsers.
+
+- `#try &block` returns `block`'s return.
+- `#zero_or_one acc=[], &block` try to execute 0 or 1 time, returns `acc`.
+- `#zero_or_more acc=[], &block` try to execute 0 or more times, also stops iteration if scanner no advance, returns `acc`.
+- `#one_or_more acc=[], &block` try to execute 1 or more times, also stops iteration if scanner no advance, returns `nil` or `acc`.
+
+## (Low level) Efficient pos stack manipulation
+
+- `#push` push current pos into the stack.
+- `#pop` set current pos to top of the stack, and pop it.
+- `#drop` drop top of pos stack without changing current pos.
+- `#restore` set current pos to top of the stack.
+- `#clear_pos_stack` clear pos stack.
+- `z.push._try expr` equivalent to `z.try{ expr }`, but faster because no block is required
 
 ## License
 

data/spec/binary_scan_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require_relative "spec_helper"
 
 describe 'ZScan binary scanning methods' do
@@ -11,7 +12,7 @@ describe 'ZScan binary scanning methods' do
     assert_equal nil, (z.unpack 'I')
     assert_equal 2, z.pos
   end
-  
+
   it "#scan_binary" do
     s = ZScan.binary_spec do
       int8        # once
@@ -19,6 +20,7 @@ describe 'ZScan binary scanning methods' do
       double_be 1 # big endian, once
       single 1
     end
+
     a = [-1, 2, 3, 4.0, 3.0]
     z = ZScan.new(a.pack('cI<2Gf') + 'rest')
     b = z.scan_binary s

data/zscan.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "zscan"
-  s.version = "1.1" # version mapped from zscan.rb, don't change here
+  s.version = "1.2" # version mapped from zscan.rb, don't change here
   s.author = "Zete Lui"
   s.homepage = "https://github.com/luikore/zscan"
   s.platform = Gem::Platform::RUBY
@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">=1.9.2"
   s.licenses = ['BSD']
 
-  s.files = Dir.glob('{rakefile,zscan.gemspec,readme.md,**/*.{rb,c,inc}}')
+  s.files = Dir.glob('{rakefile,zscan.gemspec,readme.md,**/*.{rb,h,c,inc}}')
   s.require_paths = ["lib"]
   s.extensions = ["ext/extconf.rb"]
   s.rubygems_version = '1.8.24'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zscan
 version: !ruby/object:Gem::Version
-  version: '1.1'
+  version: '1.2'
 platform: ruby
 authors:
 - Zete Lui
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-14 00:00:00.000000000 Z
+date: 2013-05-17 00:00:00.000000000 Z
 dependencies: []
 description: improved string scanner, respects anchors and lookbehinds, supports codepoint
   positioning
@@ -21,6 +21,7 @@ files:
 - rakefile
 - zscan.gemspec
 - readme.md
+- benchmark/one-or-more.rb
 - benchmark/vs-strscan.rb
 - benchmark/vs-unpack.rb
 - ext/extconf.rb
@@ -31,6 +32,8 @@ files:
 - spec/spec_helper.rb
 - spec/typed_scan_spec.rb
 - spec/zscan_spec.rb
+- ext/zscan.h
+- ext/bspec.c
 - ext/zscan.c
 - ext/bspec_exec.inc
 - ext/bspec_opcode_names.inc
@@ -59,3 +62,4 @@ signing_key:
 specification_version: 4
 summary: improved string scanner
 test_files: []
+has_rdoc: false