RubyGems - gherkin - Versions diffs - 2.11.2 → 2.11.3 - Mend

gherkin 2.11.2 → 2.11.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

data/.travis.yml +1 -0
data/History.md +9 -0
data/README.md +2 -1
data/ext/gherkin_lexer_ar/gherkin_lexer_ar.c +8 -8
data/ext/gherkin_lexer_bg/gherkin_lexer_bg.c +8 -8
data/ext/gherkin_lexer_bm/gherkin_lexer_bm.c +8 -8
data/ext/gherkin_lexer_ca/gherkin_lexer_ca.c +8 -8
data/ext/gherkin_lexer_cs/gherkin_lexer_cs.c +8 -8
data/ext/gherkin_lexer_cy_gb/gherkin_lexer_cy_gb.c +8 -8
data/ext/gherkin_lexer_da/gherkin_lexer_da.c +8 -8
data/ext/gherkin_lexer_de/gherkin_lexer_de.c +8 -8
data/ext/gherkin_lexer_en/gherkin_lexer_en.c +8 -8
data/ext/gherkin_lexer_en_au/gherkin_lexer_en_au.c +915 -373
data/ext/gherkin_lexer_en_lol/gherkin_lexer_en_lol.c +8 -8
data/ext/gherkin_lexer_en_pirate/gherkin_lexer_en_pirate.c +8 -8
data/ext/gherkin_lexer_en_scouse/gherkin_lexer_en_scouse.c +8 -8
data/ext/gherkin_lexer_en_tx/gherkin_lexer_en_tx.c +8 -8
data/ext/gherkin_lexer_eo/gherkin_lexer_eo.c +8 -8
data/ext/gherkin_lexer_es/gherkin_lexer_es.c +8 -8
data/ext/gherkin_lexer_et/gherkin_lexer_et.c +8 -8
data/ext/gherkin_lexer_fi/gherkin_lexer_fi.c +8 -8
data/ext/gherkin_lexer_fr/gherkin_lexer_fr.c +8 -8
data/ext/gherkin_lexer_he/gherkin_lexer_he.c +8 -8
data/ext/gherkin_lexer_hr/gherkin_lexer_hr.c +8 -8
data/ext/gherkin_lexer_hu/gherkin_lexer_hu.c +8 -8
data/ext/gherkin_lexer_id/gherkin_lexer_id.c +8 -8
data/ext/gherkin_lexer_is/gherkin_lexer_is.c +8 -8
data/ext/gherkin_lexer_it/gherkin_lexer_it.c +8 -8
data/ext/gherkin_lexer_ja/gherkin_lexer_ja.c +8 -8
data/ext/gherkin_lexer_ko/gherkin_lexer_ko.c +8 -8
data/ext/gherkin_lexer_lt/gherkin_lexer_lt.c +8 -8
data/ext/gherkin_lexer_lu/gherkin_lexer_lu.c +8 -8
data/ext/gherkin_lexer_lv/gherkin_lexer_lv.c +8 -8
data/ext/gherkin_lexer_nl/gherkin_lexer_nl.c +8 -8
data/ext/gherkin_lexer_no/gherkin_lexer_no.c +8 -8
data/ext/gherkin_lexer_pl/gherkin_lexer_pl.c +8 -8
data/ext/gherkin_lexer_pt/gherkin_lexer_pt.c +8 -8
data/ext/gherkin_lexer_ro/gherkin_lexer_ro.c +8 -8
data/ext/gherkin_lexer_ru/gherkin_lexer_ru.c +8 -8
data/ext/gherkin_lexer_sk/gherkin_lexer_sk.c +8 -8
data/ext/gherkin_lexer_sr_cyrl/gherkin_lexer_sr_cyrl.c +8 -8
data/ext/gherkin_lexer_sr_latn/gherkin_lexer_sr_latn.c +8 -8
data/ext/gherkin_lexer_sv/gherkin_lexer_sv.c +8 -8
data/ext/gherkin_lexer_tr/gherkin_lexer_tr.c +8 -8
data/ext/gherkin_lexer_uk/gherkin_lexer_uk.c +8 -8
data/ext/gherkin_lexer_uz/gherkin_lexer_uz.c +8 -8
data/ext/gherkin_lexer_vi/gherkin_lexer_vi.c +8 -8
data/ext/gherkin_lexer_zh_cn/gherkin_lexer_zh_cn.c +8 -8
data/ext/gherkin_lexer_zh_tw/gherkin_lexer_zh_tw.c +8 -8
data/gherkin.gemspec +4 -4
data/lib/gherkin/i18n.json +10 -10
data/lib/gherkin/i18n.rb +1 -1
data/ragel/lexer.c.rl.erb +5 -5
data/tasks/apidoc.rake +32 -0
data/tasks/ikvm.rake +1 -1
data/tasks/ragel_task.rb +1 -0
data/tasks/release.rake +1 -19
metadata +10 -10
data/tasks/yard.rake +0 -7

data/ext/gherkin_lexer_fi/gherkin_lexer_fi.c CHANGED

@@ -653,7 +653,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));
@@ -1084,14 +1084,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] == '%') {
@@ -1105,7 +1105,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);
@@ -1147,14 +1147,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] == '%') {
@@ -1168,7 +1168,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);
@@ -1189,7 +1189,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_fr/gherkin_lexer_fr.c CHANGED

@@ -931,7 +931,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));
@@ -1362,14 +1362,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] == '%') {
@@ -1383,7 +1383,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);
@@ -1425,14 +1425,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] == '%') {
@@ -1446,7 +1446,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);
@@ -1467,7 +1467,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_he/gherkin_lexer_he.c CHANGED

@@ -812,7 +812,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));
@@ -1243,14 +1243,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] == '%') {
@@ -1264,7 +1264,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);
@@ -1306,14 +1306,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] == '%') {
@@ -1327,7 +1327,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);
@@ -1348,7 +1348,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_hr/gherkin_lexer_hr.c CHANGED

@@ -761,7 +761,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));
@@ -1192,14 +1192,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] == '%') {
@@ -1213,7 +1213,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);
@@ -1255,14 +1255,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] == '%') {
@@ -1276,7 +1276,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);
@@ -1297,7 +1297,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_hu/gherkin_lexer_hu.c CHANGED

@@ -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_id/gherkin_lexer_id.c CHANGED

@@ -646,7 +646,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));
@@ -1077,14 +1077,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] == '%') {
@@ -1098,7 +1098,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);
@@ -1140,14 +1140,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] == '%') {
@@ -1161,7 +1161,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);
@@ -1182,7 +1182,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_is/gherkin_lexer_is.c CHANGED

@@ -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) {