srl_ruby 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 808f335172ddb8259c8f7c7d5ed0207936c6f7ad
-  data.tar.gz: cd7bfcabd76599a570997cf9032d2522d346f038
+  metadata.gz: 192758cce667147a6b7369cf6d575aa7fb22b627
+  data.tar.gz: 3f851cdb8557bc8baba910ded6e4e0433851fa6a
 SHA512:
-  metadata.gz: 3db09d707e1496ed2711a903d5f655aca233fd695804a4ba6787fa8e067bb190efb9c770e9ee0e685ed6282f9956c8e23c30cedf4f3dca7a428c99e53e165c23
-  data.tar.gz: 02f3eb69d6cbc700e2d4f22ebe9d3e2c96892e150258aa9984af3102fde44a98cc2ebb4ab5025acdd6f961f1614cc75bf5e964d28e42263a6ca3b84b9df99b10
+  metadata.gz: d88c26d001764e3b224e9e6f2346791300624d348d825098bf1fedd658bcb3b66234c868144d83d6a8f6a02740dc36805cd765417af16f44ed6f4e6698ac647f
+  data.tar.gz: ced3406cfd86aed12bb5ca64ec7917cb9f3fdcbf20b29027c993b6e1402d793b2a5d5b9907c4de75cc293e04148f037208d232b7e7ed373b11d1d958a7e4f025

data/CHANGELOG.md

@@ -1,4 +1,10 @@
-## [0.3.1] - 2018-04-04
+## [0.3.2] - 2018-04-13
+### Added
+- `Cucumber` feature files are now part of the gem.
+- Added `floatingpoint.feature` as test and demo for validating flating point numbers
+
+
+## [0.3.1] - 2018-04-12
 ### Added
 - Added `Cucumber` feature files both for additional testing and demo purposes.  
     Almost all examples from SRL websites are "featured".

data/cucumber.yml

@@ -0,0 +1,4 @@
+default: --strict -v -b  --format progress features
+
+
+

data/features/basic/anchors.feature

@@ -0,0 +1,61 @@
+Feature: Defining anchors as patterns
+	As a shy Rubyist,
+  I want to use basic SRL anchors patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: defining a begin anchor as pattern
+  When I define the following SRL expression:
+  """
+  begin with uppercase letter,
+  digit
+  """
+  Then I expect the generated regular expression to be "^[A-Z]\d"
+  Then I expect matching for:
+  | "R2"   |
+  | "A10"  |
+
+  And I expect no match for:
+  | " R2 " |
+  | "r2  " |
+  | "%[_]" |
+  | "?;!"  |
+  | "SRL"  |
+  | "123"  |
+  
+
+Scenario: defining a begin anchor as pattern (alternative syntax)
+  When I define the following SRL expression:
+  """
+  starts with uppercase letter,
+  digit
+  """
+  Then I expect the generated regular expression to be "^[A-Z]\d"
+  Then I expect matching for:
+  | "R2"   |
+  | "A10"  |
+
+  And I expect no match for:
+  | " R2 " |
+  | "r2  " |
+
+
+Scenario: defining an end anchor as pattern
+  When I define the following SRL expression:
+  """
+  uppercase letter,
+  digit,
+  must end
+  """
+  Then I expect the generated regular expression to be "[A-Z]\d$"
+  Then I expect matching for:
+  | "r2-D2"   |
+  | "! B1"    |
+
+  And I expect no match for:
+  | " R2 " |
+  | "  r2" |
+  | "%[_]" |
+  | "?;!"  |
+  | "SRL"  |
+  | "123"  |

data/features/basic/characters.feature

@@ -0,0 +1,44 @@
+Feature: Defining basic character patterns
+	As a shy Rubyist,
+  I want to use basic SRL character patterns
+	So that I can use them when crafting my regular expressions
+
+# Reminder: in SRL, a character is either:
+# a small letter [a-z]
+# a capital letter [A-Z]
+# a digit [0-9]
+# an underscore '_'
+Scenario: defining any character as pattern
+  When I define the following SRL expression:
+  """
+  any character,
+  any character
+  """
+  Then I expect the generated regular expression to be "\w\w"
+  Then I expect matching for:
+  | "srl"     |
+  | "SRL"     |
+  | "123"     |
+  | " (red} " |
+  | "r_!"     |
+  And I expect no match for:
+  | "B"   |
+  | "%[_]"|
+  | "?;!" |
+  
+  
+Scenario: defining any non-character as pattern
+  When I define the following SRL expression:
+  """
+  no character
+  """
+  Then I expect the generated regular expression to be "\W"
+  Then I expect matching for:
+  | "{}"      |
+  | " (red} " |
+  | "r_!"     |
+  And I expect no match for:
+  | "srl"     |
+  | "SRL"     |
+  | "123"     |  
+

data/features/basic/digits.feature

@@ -0,0 +1,94 @@
+Feature: Defining digit letter patterns
+	As a shy Rubyist,
+  I want to use basic SRL digit patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: defining any single digit as pattern
+  When I define the following SRL expression:
+  """
+  digit
+  """
+  Then I expect the generated regular expression to be "\d"
+  Then I expect matching for:
+  | "123"     |
+  | "THX1138" |
+  | " >red7: "|
+  And I expect no match for:
+  | "one" |
+  | "?;!" |
+
+
+Scenario: using alternative syntax for any single digit
+  When I define the following SRL expression:
+  """
+  number
+  """
+  Then I expect the generated regular expression to be "\d"
+  Then I expect matching for:
+  | "123"     |
+  | "THX1138" |
+  | " >red7: "|
+  And I expect no match for:
+  | "one" |
+  | "?;!" |
+
+
+  Scenario: defining a negated digit pattern
+  When I define the following SRL expression:
+  """
+  no digit
+  """
+  Then I expect the generated regular expression to be "\D"
+  Then I expect matching for:
+  | "a"   |
+  | "two" |
+  | "B1"  |
+  | "  1" |
+  And I expect no match for:
+  | "129" |
+
+
+Scenario: defining any single digit from a given range as pattern
+  When I define the following SRL expression:
+  """
+  digit from 3 to 8
+  """
+  Then I expect the generated regular expression to be "[3-8]"
+  Then I expect matching for:
+  | "4"   |
+  | "124" |
+  | "B52" |
+  And I expect no match for:
+  | "129" |
+  | "five"|
+
+
+Scenario: using alternative syntax for any single digit from a given range
+  When I define the following SRL expression:
+  """
+  number from 3 to 8
+  """
+  Then I expect the generated regular expression to be "[3-8]"
+  Then I expect matching for:
+  | "4"   |
+  | "124" |
+  | "B52" |
+  And I expect no match for:
+  | "129" |
+  | "five"|
+
+
+Scenario: defining any single digit from a given scrambled range
+  When I define the following SRL expression:
+  """
+  digit from 8 to 3
+  """
+  Then I expect the generated regular expression to be "[3-8]"
+  Then I expect matching for:
+  | "4"   |
+  | "124" |
+  | "B52" |
+  And I expect no match for:
+  | "129" |
+  | "five"|

data/features/basic/letters.feature

@@ -0,0 +1,86 @@
+Feature: Defining basic letter patterns
+	As a shy Rubyist,
+  I want to use basic SRL letter patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: defining any small letter as pattern
+  When I define the following SRL expression:
+  """
+  letter, 
+  letter
+  """
+  Then I expect the generated regular expression to be "[a-z][a-z]"
+  Then I expect matching for:
+  | "srl"     |
+  | "99 km"   |
+  | " >red: " |
+  And I expect no match for:
+  | "123" |
+  | "ABC" |
+  | "f1"  |
+  | "?;!" |
+
+
+Scenario: defining one small letter from a given range as pattern
+  When I define the following SRL expression:
+  """
+  letter from a to f
+  """
+  Then I expect the generated regular expression to be "[a-f]"
+  Then I expect matching for:
+  | "b1"   |
+  | "red"  |
+  |" 12 cm"|
+  And I expect no match for:
+  | "123" |
+  | "z"   |
+  | "12g3"|
+
+
+Scenario: defining any capital letter as pattern
+  When I define the following SRL expression:
+  """
+  uppercase letter
+  """
+  Then I expect the generated regular expression to be "[A-Z]"
+  Then I expect matching for:
+  | "Ruby"    |
+  | "99 Km"   |
+  | " >OFF: " |
+  And I expect no match for:
+  | "123" |
+  | "abc" |
+  | "?;!" |
+
+  
+Scenario: defining one capital letter from a given range as pattern
+  When I define the following SRL expression:
+  """
+  uppercase letter from X to Z
+  """
+  Then I expect the generated regular expression to be "[X-Z]"
+  Then I expect matching for:
+  | "Yes"    |
+  | ">Zulu"  |
+  |" 123 wHY"|
+  And I expect no match for:
+  | "yES" |
+  | "123" |
+  | "12f3"|
+
+
+Scenario: defining one small letter from a scrambled range as pattern
+  When I define the following SRL expression:
+  """
+  letter from d to a
+  """
+  Then I expect the generated regular expression to be "[a-d]"
+  Then I expect matching for:
+  | "b1"   |
+  And I expect no match for:
+  | "123" |
+
+
+  
+ 

data/features/basic/literally.feature

@@ -0,0 +1,58 @@
+Feature: Defining literal strings as patterns
+	As a shy Rubyist,
+  I want to use basic SRL literal strings patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: defining a literal string as pattern
+  When I define the following SRL expression:
+  """
+  literally "aba"
+  """
+  Then I expect the generated regular expression to be "aba"
+  Then I expect matching for:
+  | "nabab  "  |
+  | "alibaba"  |
+  | "<abakka>" |
+
+  And I expect no match for:
+  | "a ba"|
+  | "%[_]"|
+  | "?;!" |
+  | "srl" |
+  | "SRL" |
+  | "123" |
+
+
+Scenario: defining a character from a set as pattern
+  When I define the following SRL expression:
+  """
+  one of "13579"
+  """
+  Then I expect the generated regular expression to be "[13579]"
+  Then I expect matching for:
+  | "NCC-1701-A"  |
+  | "even24685"   |
+
+  And I expect no match for:
+  | "a ba"|
+  | "%[_]"|
+  | "?;!" |
+  | "srl" |
+  | "SRL" |
+  | "246" |
+
+  
+Scenario: defining a character not from a  given set
+  When I define the following SRL expression:
+  """
+  none of "13579"
+  """
+  Then I expect the generated regular expression to be "[^13579]"
+  Then I expect matching for:
+  |  "42"   |
+  | "text"  |
+  | "%[_]?" |
+
+  And I expect no match for:
+  | "13" |

data/features/basic/quantifiers.feature

@@ -0,0 +1,180 @@
+Feature: Defining quntifiers for patterns
+	As a shy Rubyist,
+  I want to use quantifiers for patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: Repeat a pattern an exact number of times
+  When I define the following SRL expression:
+  """
+  (uppercase letter,
+  digit) exactly 2 times
+  """
+  Then I expect the generated regular expression to be "(?:[A-Z]\d){2}"
+  Then I expect matching for:
+  | "R2D2" |
+
+  And I expect no match for:
+  | "r2D2"|
+  | "%[_]"|
+  | "?;!" |
+  | "SRL" |
+  | "123" |
+
+
+Scenario: Repeat a pattern a number from range
+  When I define the following SRL expression:
+  """
+  begin with
+  (uppercase letter,
+  digit) between 2 and 4 times
+  must end
+  """
+  Then I expect the generated regular expression to be "^(?:[A-Z]\d){2,4}$"
+  Then I expect matching for:
+  | "R2D2"     |
+  | "A1B2C3"   |
+  | "A1B2C3D4" |
+
+  And I expect no match for:
+  | "R2"          |
+  | "R2d2"        |
+  | "A1B2C3D4E5"  |
+  | "%[_]"        |
+  | "?;!"         |
+  | "SRL"         |
+  | "123"         |
+  
+  
+Scenario: Repeat a pattern a number from range (without 'times' keyword)
+  When I define the following SRL expression:
+  """
+  begin with
+  (uppercase letter,
+  digit) between 2 and 4
+  must end
+  """
+  Then I expect the generated regular expression to be "^(?:[A-Z]\d){2,4}$"
+  Then I expect matching for:
+  | "R2D2"     |
+  | "A1B2C3"   |
+  | "A1B2C3D4" |
+
+  And I expect no match for:
+  | "R2"          |
+  | "R2d2"        |
+  | "A1B2C3D4E5"  |
+  | "%[_]"        |
+  | "?;!"         |
+  | "SRL"         |
+  | "123"         |
+
+
+Scenario: Repeat a pattern zero or one times
+  When I define the following SRL expression:
+  """
+  begin with one of "+-" optional,
+  digit
+  """
+  Then I expect the generated regular expression to be "^[+\-]?\d"
+  Then I expect matching for:
+  | "42  "       |
+  | "+42 "       |
+  | "-42 "       |
+  | "99 bottles" |
+
+  And I expect no match for:
+  | "R2"         |
+  | "++42"       |
+
+
+Scenario: Repeat a pattern zero or more times
+  When I define the following SRL expression:
+  """
+  begin with one of "+-" optional,
+  digit never or more,
+  letter
+  """
+  Then I expect the generated regular expression to be "^[+\-]?\d*[a-z]"
+  Then I expect matching for:
+  | "42cm  "   |
+  | "+42cm "   |
+  | "-42cm "   |
+  | "50cents"  |
+  | "cents"    |
+  | "-cents"   |
+
+  And I expect no match for:
+  | "++42"     |
+  | "+42Km"    |
+
+
+Scenario: Repeat a pattern one or more times
+  When I define the following SRL expression:
+  """
+  begin with one of "+-" optional,
+  digit once or more,
+  letter
+  """
+  Then I expect the generated regular expression to be "^[+\-]?\d+[a-z]"
+  Then I expect matching for:
+  | "42cm  "   |
+  | "+42cm "   |
+  | "-42cm "   |
+  | "50cents"  |
+
+  And I expect no match for:
+  | "++42"     |
+  | "+42Km"    |
+  | "cents"    |
+  | "-cents"   |
+
+  
+Scenario: Repeat a pattern n times or more
+  When I define the following SRL expression:
+  """
+  begin with letter at least 2 times,
+  must end
+  """
+  Then I expect the generated regular expression to be "^[a-z]{2,}$"
+  Then I expect matching for:
+  | "ab"       |
+  | "abcdef"   |
+
+  And I expect no match for:
+  | "a"        |
+
+
+# This one won't very much in use
+Scenario: Repeat a pattern exactly once
+  When I define the following SRL expression:
+  """
+  begin with (uppercase letter, digit) once,
+  must end
+  """
+  Then I expect the generated regular expression to be "^(?:[A-Z]\d){1}$"
+  Then I expect matching for:
+  | "R2"       |
+
+  And I expect no match for:
+  | "r2"     |
+  | "R2D2"   |  
+
+
+Scenario: Repeat a pattern twice
+  When I define the following SRL expression:
+  """
+  begin with (uppercase letter, digit,
+  literally "-" optional) twice,
+  must end
+  """
+  Then I expect the generated regular expression to be "^(?:[A-Z]\d-?){2}$"
+  Then I expect matching for:
+  | "R2D2"     |
+  | "R2-D2"    |
+  | "R2-D2-"   |
+
+  And I expect no match for:
+  | "r2d2"     |
+  | "R2D2E3"   |
+  | "R2--D2"   |

data/features/basic/raw.feature

@@ -0,0 +1,22 @@
+Feature: Defining regular expression as pattern
+	As a shy Rubyist,
+  I want to embed regex expression in SRL
+	So that I can use them when crafting complex regular expressions
+
+
+Scenario: defining a literal string as pattern
+  When I define the following SRL expression:
+  """
+  letter,
+  raw "[^1-4]"
+  """
+  Then I expect the generated regular expression to be "[a-z][^1-4]"
+  Then I expect matching for:
+  | " b52  "  |
+  | "road66"  |
+  | "a     "  |
+
+  And I expect no match for:
+  | "%[_]"|
+  | "?;!" |
+  | "12b" |

data/features/basic/special_characters.feature

@@ -0,0 +1,90 @@
+Feature: Defining basic special character patterns
+	As a shy Rubyist,
+  I want to use basic SRL special character patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: defining any whitespace as pattern
+  When I define the following SRL expression:
+  """
+  whitespace,
+  whitespace
+  """
+  Then I expect the generated regular expression to be "\s\s"
+  Then I expect matching for:
+  | "two spaces>  " |
+  | "  <two spaces" |
+  | " two>  spaces" |
+
+  And I expect no match for:
+  | "B"   |
+  | "%[_]"|
+  | "?;!" |
+  | "srl" |
+  | "SRL" |
+  | "123" | 
+  
+  
+Scenario: defining any non-whitespace as pattern
+  When I define the following SRL expression:
+  """
+  no whitespace
+  """
+  Then I expect the generated regular expression to be "\S"
+  Then I expect matching for:
+  | "{}"      |
+  | " (red} " |
+  | "r_!"     |
+  And I expect no match for:
+  | "   "     |
+
+  
+Scenario: defining a backslash as pattern
+  When I define the following SRL expression:
+  """
+  backslash
+  """
+  Then I expect the generated regular expression to be "\\"
+  Then I expect matching for:
+  | "   \   " |
+  | "{}\    " |
+  And I expect no match for:
+  | "   " |
+  | "B"   |
+  | "%[_]"|
+  | "?;!" |
+  | "srl" |
+  | "SRL" |
+  | "123" | 
+  
+Scenario: defining a tab as pattern
+  When I define the following SRL expression:
+  """
+  tab
+  """
+  Then I expect the generated regular expression to be "\t"
+
+
+Scenario: defining a vertical tab as pattern
+  When I define the following SRL expression:
+  """
+  vertical tab
+  """
+  Then I expect the generated regular expression to be "\v"
+
+  
+Scenario: defining a newline as pattern
+  When I define the following SRL expression:
+  """
+  new line
+  """
+  Then I expect the generated regular expression to be "\n"
+
+
+  Scenario: defining a carriage return as pattern
+  When I define the following SRL expression:
+  """
+  carriage return
+  """
+  Then I expect the generated regular expression to be "\r"
+

data/features/email_validation.feature

@@ -0,0 +1,38 @@
+Feature: Defining an email validation pattern
+	As a shy Rubyist,
+  I want to use SRL to specify valid email address pattern
+	So that I can use its regex representation in my code
+
+
+Scenario: defining email validating expression
+  # The expression isn't 100 reliable but suffice in a vast majority of cases
+  When I define the following SRL expression:
+  """
+  begin with any of (digit, letter, one of "._%+-") once or more,
+  literally "@",
+  any of (digit, letter, one of ".-") once or more,
+  ( literally ".",
+    letter at least 2 times ) optional,
+  must end, 
+  case insensitive
+  """
+  Then I expect the generated regular expression to be "^(?:\d|[a-z]|[._%+\-])+@(?:\d|[a-z]|[.\-])+(?:\.[a-z]{2,})?$"
+  Then I expect matching for:
+  | s@example.com |
+  | simple@example.com    |
+  | john.doe@example.com  |
+  | disposable.style.email.with+symbol@example.com |
+  | other.email-with-dash@example.com  |
+  | fully-qualified-domain@example.com |
+  | user.name+tag+sorting@example.com  |
+  | example-indeed@strange-example.com |
+  | example@s.solutions |
+  | user@localserver    |
+
+  And I expect no match for:
+  | admin.example.com      |
+  | @office.info.com |
+  | method()*@example.com  |
+  | a@b@c@example.com      |
+  
+ 

data/features/floatingpoint.feature

@@ -0,0 +1,36 @@
+Feature: Defining a floating-point number pattern
+	As a Rubyist,
+  I want to use SRL to specify a pattern for floating points
+	So that I can use its regex representation in my code
+
+
+Scenario: defining a floating-point number expression
+  When I define the following SRL expression:
+  """
+  begin with one of "-+" optional, 
+  digit once or more,
+  literally "." optional, 
+  digit never or more,
+  (
+    one of "eE",
+    one of "-+" optional,
+     digit once or more
+  ) optional,
+  must end
+  """
+  Then I expect the generated regular expression to be "^[\-+]?\d+\.?\d*(?:[eE][\-+]?\d+)?$"
+  Then I expect matching for:
+  | 1        |
+  | +2       |
+  | -3       |
+  | +5.      |
+  | -6.      |
+  | 7.123    |
+  | 8.123E3  |
+  | 9.123e-4 |
+
+  And I expect no match for:
+  | text   |
+  | 1c     |
+  | 1,5    |
+  | 3E3+5  |

data/features/intermediate/any_of.feature

@@ -0,0 +1,35 @@
+Feature: Defining alternation as patterns
+	As a shy Rubyist,
+  I want to use alternation combine patterns
+	So that I can use them when crafting my regular expressions
+
+
+Background:
+  Given I define the following SRL expression:
+  """
+  capture (any of (literally "sample", (digit once or more)))
+  """
+
+
+Scenario: defining an alternation as pattern
+  Then I expect the generated regular expression to be "((?:sample|(?:\d+)))"
+  Then I expect matching for:
+  | "two samples  "  |
+  | "         1234"  |
+  | " sample 42"     |
+
+  And I expect no match for:
+  | "a ba"|
+  | "%[_]"|
+  | "?;!" |
+  | "srl" |
+  
+  
+Scenario: capturing an alternation 
+  When I use the text "sample 42"
+  Then I expect the first capture to be:
+  | 0 | sample  |
+  And I expect the second capture to be:
+  | 0 | 42  |
+  
+

data/features/intermediate/capture.feature

@@ -0,0 +1,64 @@
+Feature: Defining capture patterns
+	As a shy Rubyist,
+  I want to use intermediate SRL capture patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: using named captures
+  Given I define the following SRL expression:
+  """
+  capture (anything once or more) as "first", 
+  literally " - ", 
+  capture (literally "second part") as "second"
+  """
+  When I use the text "first part - second part"
+  Then I expect the first captures to be:
+  |first | first part  |
+  |second| second part |
+
+
+Scenario: using anonymous captures
+  Given I define the following SRL expression:
+  """
+  capture (anything once or more), 
+  literally " - ", 
+  capture (literally "second part")
+  """
+  When I use the text "first part - second part"
+  Then I expect the first captures to be:
+  | 0 | first part  |
+  | 1 | second part |
+
+  
+Scenario: using capture ... until
+  Given I define the following SRL expression:
+  """
+  begin with capture (
+    anything once or more
+  ) until literally "m"
+  """
+  When I use the text "this is an example"
+  Then I expect the first capture to be:
+  | 0 | this is an exa  |
+  
+  
+Scenario: using any of
+  Given I define the following SRL expression:
+  """
+  capture (any of (literally "sample", (digit once or more)))
+  """
+  When I use the text "sample && 1234"
+  Then I expect the first captures to be:
+  | 0 | sample  |
+  | 1 | 1234    |
+  
+  
+Scenario: using either of (synonym of any of)
+  Given I define the following SRL expression:
+  """
+  capture (either of (literally "sample", (digit once or more)))
+  """
+  When I use the text "sample && 1234"
+  Then I expect the first captures to be:
+  | 0 | sample  |
+  | 1 | 1234    |

data/features/intermediate/lookaround.feature

@@ -0,0 +1,51 @@
+Feature: Defining lookaround patterns
+	As a shy Rubyist,
+  I want to use intermediate SRL lookaround patterns
+	So that I can use them when crafting my regular expressions
+
+
+Scenario: using if not followed lookforward
+  Given I define the following SRL expression:
+  """
+  capture (digit) if followed by (anything once or more, digit)
+  """
+  When I use the text "This example contains 3 numbers. 2 should not match. Only 1 should."
+  Then I expect the first capture to be:
+  | 0 | 3  |
+  And I expect the second capture to be:
+  | 0 | 2  |  
+ 
+ 
+Scenario: using if not followed lookforward
+  Given I define the following SRL expression:
+  """
+  capture (digit) if not followed by (anything once or more, digit)
+  """
+  When I use the text "This example contains 3 numbers. 2 should not match. Only 1 should."
+  Then I expect the first capture to be:
+  | 0 | 1  |
+
+
+Scenario: using if already had
+  Given I define the following SRL expression:
+  """
+  capture (literally "bar") if already had literally "foo"
+  """
+  Then I expect no match for:
+  | "fobar"|
+  When I use the text "foobar"
+  Then I expect the first capture to be:
+  | 0 | bar  |
+
+  
+Scenario: using if already had
+  Given I define the following SRL expression:
+  """
+  capture (literally "bar") if not already had literally "foo"
+  """
+  Then I expect no match for:
+  | "foobar"|
+  When I use the text "fobar"
+  Then I expect the first capture to be:
+  | 0 | bar  |
+  

data/features/lib/step_definitions/srl_testing_steps.rb

@@ -0,0 +1,59 @@
+When("I define the following SRL expression:") do |srl_source|
+  @regex = SrlRuby::parse(srl_source)
+end
+
+When("I use the text {string}") do |test_string|
+  @subject = test_string
+end
+
+Then("I expect the generated regular expression to be {string}") do |regex_source|
+  expect(@regex.source).to eq(regex_source)
+end
+
+Then("I expect matching for:") do |table|
+  # table is a Cucumber::MultilineArgument::DataTable
+  values = table.raw.flatten.map { |raw_val| raw_val.gsub(/^"|"$/, '') }
+  values.each do |val|
+    expect(val).to match(@regex)
+  end
+end
+
+Then("I expect no match for:") do |table|
+  # table is a Cucumber::MultilineArgument::DataTable
+  values = table.raw.flatten.map { |raw_val| raw_val.gsub(/^"|"$/, '') }
+  values.each do |val|
+    expect(val).not_to match(@regex)
+  end
+end
+
+
+Then(/I expect the (first|second|third|fourth|fifth) captures? to be:/) do |rank_literal, table|
+  ordinal2indices = { 'first' => 0, 
+    'second' => 1, 
+    'third' => 2,
+    'fourth' => 3, 
+    'fifth' => 4
+  }
+  rank = ordinal2indices[rank_literal]
+  # table is a Cucumber::MultilineArgument::DataTable
+  expectations = table.rows_hash
+  
+  scan_results = @subject.scan(@regex)
+  actuals = scan_results[rank]
+  if actuals.nil?
+    puts "Big issue"
+    puts @regex.source
+  end
+
+  if @regex.names.empty?
+    capture_names = (0..actuals.size-1).to_a.map(&:to_s)
+  else
+    capture_names = @regex.names
+  end
+
+  capture_names.each_with_index do |var_name, index|
+    if expectations.include?(var_name)
+      expect(expectations[var_name]).to eq(actuals[index])
+    end
+  end
+end

data/features/lib/support/env..rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require 'cucumber'
+require 'srl_ruby'

data/features/password_validation.feature

@@ -0,0 +1,28 @@
+Feature: Defining a password validation pattern
+	As a shy Rubyist,
+  I want to use SRL to specify password pattern
+	So that I can use its regex representation in my code
+
+
+Scenario: defining a password validation expression
+  When I define the following SRL expression:
+  """
+  if followed by (anything never or more, letter),
+  if followed by (anything never or more, uppercase letter),
+  if followed by (anything never or more, digit),
+  if followed by (anything never or more, one of "!@#$%^&*[]\"';:_-<>., =+/\\"),
+  anything at least 8 times
+  """
+  Then I expect matching for:
+  | Sup3r $ecure! |
+  | P@sSword1     |
+  | Pass-w0rd     |
+
+  And I expect no match for:
+  | Password       |
+  | P@sS1          |
+  | justalongpassword  |
+  | m1ss1ng upper  |
+  | missing Number |
+  | M1SS1NG LOWER  |
+  | m1ss1ngSpec1al |

data/features/url_capturing.feature

@@ -0,0 +1,31 @@
+Feature: Defining an email validation pattern
+	As a shy Rubyist,
+  I want to use SRL to specify valid email address pattern
+	So that I can use its regex representation in my code
+
+Background:
+  Given I define the following SRL expression:
+  """
+  begin with capture (letter once or more) as "protocol",
+  literally "://",
+  capture (
+      letter once or more,
+      any of (letter, literally ".") once or more,
+      letter at least 2 times
+  ) as "domain",
+  (literally ":", capture (digit once or more) as "port") optional,
+  capture (literally "/", anything never or more) as "path" until (any of (literally "?", must end)),
+  literally "?" optional,
+  capture (anything never or more) as "parameters" optional,
+  must end,
+  case insensitive
+  """  
+  
+Scenario: defining url capturing expression
+  When I use the text "https://example.domain.com:1234/a/path?query=param"
+  Then I expect the first capture to be:
+  | protocol   | https      |
+  | domain     | example.domain.com  |
+  | port       | 1234        |
+  | path       | /a/path     |
+  | parameters | query=param |

data/lib/srl_ruby/version.rb

@@ -1,3 +1,3 @@
 module SrlRuby
-  VERSION = '0.3.1'.freeze
+  VERSION = '0.3.2'.freeze
 end

data/srl_ruby.gemspec

@@ -10,6 +10,7 @@ module PkgExtending
       '.rspec',
       '.yardopts',
       'appveyor.yml',
+      'cucumber.yml',
       'Gemfile',
       'Rakefile',
       'CHANGELOG.md',
@@ -19,6 +20,9 @@ module PkgExtending
       'lib/*.*',
       'lib/**/*.rb',
       'spec/**/*.rb',
+      'features/*.*',
+      'features/**/*.*',
+      'features/**/**/*.features',
       'srl_test/**/*.*'
     ]
     aPackage.files = file_list

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: srl_ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-12 00:00:00.000000000 Z
+date: 2018-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -99,6 +99,24 @@ files:
 - Rakefile
 - appveyor.yml
 - bin/srl_ruby
+- cucumber.yml
+- features/basic/anchors.feature
+- features/basic/characters.feature
+- features/basic/digits.feature
+- features/basic/letters.feature
+- features/basic/literally.feature
+- features/basic/quantifiers.feature
+- features/basic/raw.feature
+- features/basic/special_characters.feature
+- features/email_validation.feature
+- features/floatingpoint.feature
+- features/intermediate/any_of.feature
+- features/intermediate/capture.feature
+- features/intermediate/lookaround.feature
+- features/lib/step_definitions/srl_testing_steps.rb
+- features/lib/support/env..rb
+- features/password_validation.feature
+- features/url_capturing.feature
 - lib/regex/abstract_method.rb
 - lib/regex/alternation.rb
 - lib/regex/anchor.rb