gherkin 2.11.2 → 2.11.3

data/.travis.yml

@@ -1,3 +1,4 @@
+before_install: gem install bundler -v 1.2.1
 rvm: 
   - 1.9.3
   - 1.9.2

data/History.md

@@ -1,3 +1,12 @@
+## [2.11.3](https://github.com/cucumber/gherkin/compare/v2.11.2...v2.11.3)
+
+* [.NET] Upgraded IKVM from 0.46.0.1 to 7.1.4532.2 - quite a version bump! (Aslak Hellesøy)
+* [JavaScript] Added a README to prevent npm warnings. (Aslak Hellesøy)
+* [Ruby] Don't use C++ style comments. ([#191](https://github.com/cucumber/gherkin/pull/191) Sam Goldman)
+* [Core] Fix for Australian language support ([#196](https://github.com/cucumber/gherkin/pull/196) hogfish)
+* [Ruby] Add encoding option to IO.read ([#190](https://github.com/cucumber/gherkin/pull/190), [#192](https://github.com/cucumber/gherkin/issues/192) [#194](https://github.com/cucumber/gherkin/pull/194) HUANG Wei, Levin Alexander)
+* [JavaScript] Can't run on IE because of `const` keyword ([#186](https://github.com/cucumber/gherkin/issues/186) Aslak Hellesøy)
+
 ## [2.11.2](https://github.com/cucumber/gherkin/compare/v2.11.1...v2.11.2)
 
 * [Java] Depend on an external gherkin-jvm-deps jar with repackaged dependencies (Aslak Hellesøy, Rex Hoffman)

data/README.md

@@ -54,7 +54,7 @@ The jar file is in the central Maven repo.
     <dependency>
         <groupId>info.cukes</groupId>
         <artifactId>gherkin</artifactId>
-        <version>2.11.2</version>
+        <version>2.11.3</version>
     </dependency>
 
 You can get it manually from [Maven Central](http://search.maven.org/#browse%7C-2073395818)
@@ -251,6 +251,7 @@ Now we can release:
   * gherkin.gemspec
   * java/pom.xml
   * js/package.json
+  * History.md
 * Run `bundle update`, so Gemfile.lock gets updated with the changes.
 * Commit changes, otherwise you will get an error at the end when a tag is made.
 * Run `bundle exec rake gems:prepare && ./build_native_gems.sh && bundle exec rake release:ALL`

data/ext/gherkin_lexer_ar/gherkin_lexer_ar.c

@@ -870,7 +870,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1301,14 +1301,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1322,7 +1322,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1364,14 +1364,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1385,7 +1385,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1406,7 +1406,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {

data/ext/gherkin_lexer_bg/gherkin_lexer_bg.c

@@ -1093,7 +1093,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1524,14 +1524,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1545,7 +1545,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1587,14 +1587,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1608,7 +1608,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1629,7 +1629,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {

data/ext/gherkin_lexer_bm/gherkin_lexer_bm.c

@@ -814,7 +814,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1245,14 +1245,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1266,7 +1266,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1308,14 +1308,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1329,7 +1329,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1350,7 +1350,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {

data/ext/gherkin_lexer_ca/gherkin_lexer_ca.c

@@ -1019,7 +1019,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1450,14 +1450,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1471,7 +1471,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1513,14 +1513,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1534,7 +1534,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1555,7 +1555,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {

data/ext/gherkin_lexer_cs/gherkin_lexer_cs.c

@@ -865,7 +865,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1296,14 +1296,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1317,7 +1317,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1359,14 +1359,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1380,7 +1380,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1401,7 +1401,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {

data/ext/gherkin_lexer_cy_gb/gherkin_lexer_cy_gb.c

@@ -720,7 +720,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1151,14 +1151,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1172,7 +1172,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1214,14 +1214,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1235,7 +1235,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1256,7 +1256,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {

data/ext/gherkin_lexer_da/gherkin_lexer_da.c

@@ -736,7 +736,7 @@ static VALUE
 unindent(VALUE con, int start_col)
 {
   VALUE re;
-  // Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters
+  /* Gherkin will crash gracefully if the string representation of start_col pushes the pattern past 32 characters */
   char pat[32]; 
   snprintf(pat, 32, "^[\t ]{0,%d}", start_col); 
   re = rb_reg_regcomp(rb_str_new2(pat));
@@ -1167,14 +1167,14 @@ _match:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1188,7 +1188,7 @@ _match:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1230,14 +1230,14 @@ _again:
         buff = data;
       }
 
-      // Allocate as a ruby string so that it gets cleaned up by GC
+      /* Allocate as a ruby string so that it gets cleaned up by GC */
       newstr_val = rb_str_new(buff, len);
       newstr = RSTRING_PTR(newstr_val);
 
 
       for (count = 0; count < len; count++) {
         if(buff[count] == 10) {
-          newstr[newstr_count] = '\0'; // terminate new string at first newline found
+          newstr[newstr_count] = '\0'; /* terminate new string at first newline found */
           break;
         } else {
           if (buff[count] == '%') {
@@ -1251,7 +1251,7 @@ _again:
       }
 
       line = lexer->line_number;
-      lexer_init(lexer); // Re-initialize so we can scan again with the same lexer
+      lexer_init(lexer); /* Re-initialize so we can scan again with the same lexer */
       raise_lexer_error(newstr, line);
     } else {
       rb_funcall(listener, rb_intern("eof"), 0);
@@ -1272,7 +1272,7 @@ _again:
     assert(lexer->content_start <= len && "content starts after data end");
     assert(lexer->mark < len && "mark is after data end");
     
-    // Reset lexer by re-initializing the whole thing
+    /* Reset lexer by re-initializing the whole thing */
     lexer_init(lexer);
 
     if (cs == lexer_error) {