Merge pull request #2 from sophilabs/adventures

Adventures

Author: pricco

learnregex/alternation/README.rst

@@ -0,0 +1,39 @@
+Alternation
+
+If you want to match different regular expressions on the same string, you
+can use the alternation operator (the pipe symbol |) to separate different
+expressions and instruct the engine to try to match either what's to the left
+of it or, if it fails, what's to the right of it.
+
+The alternation operator has the lowest precedence of all operators, meaning
+that the engine will try to match everything to its left as a whole and
+everything to its right (assuming the previous match failed) as a whole. If
+you want to limit the scope of the operator to use it inside a tiny part of a
+more complex expression you will need to learn how "groups" work. Luckily for
+you, that's the next adventure.
+
+For this adventure, write a python function that receives a string and
+returns `True` if it's either 'red', 'green' or 'blue'; and `False` otherwise.
+
+You can use this template to get started:
+
+.. sourcecode:: python
+
+    import re
+
+    def test(string):
+        # Your code goes here
+
+HINT
+----
+You can use multiple alternation operators, they resolve from left to
+right. That means that the expression 'aa|bb|cc' will try to match 'aa'
+first, if it fails it will follow with 'bb|cc' where it will again split
+the expressions between the alternation operator and start with 'bb', and
+so on...
+
+When you are done, you must run:
+
+.. sourcecode:: bash
+
+    $ {script} verify program.py

learnregex/alternation/SOLUTION.rst

@@ -0,0 +1,10 @@
+`program.py` content:
+
+.. sourcecode:: python
+
+    import re
+
+
+    def test(string):
+        return re.match(r'red$|green$|blue$', string)
+

learnregex/alternation/__init__.py

@@ -0,0 +1,27 @@
+import random
+
+from story.adventures import AdventureVerificationError, BaseAdventure
+
+from ..data import _
+from ..utils import load_solution_function
+
+
+class Adventure(BaseAdventure):
+
+    title = _('Alternation')
+    choices = ['red', 'green', 'blue']
+
+    def test(self, file):
+        function = load_solution_function(file)
+        correct_argument = random.choice(self.choices)
+        if not function(correct_argument):
+            raise AdventureVerificationError(
+                _("Your function didn't return True when executed with a "
+                  "correct argument '{}'.".format(correct_argument))
+            )
+        wrong_argument = (random.choice(self.choices)
+                          + random.choice(self.choices))
+        if function(wrong_argument):
+            raise AdventureVerificationError(
+                _("Your function returned True when executed with a wrong "
+                  "argument '{}'.".format(wrong_argument)))

learnregex/anchors/README.rst

@@ -0,0 +1,23 @@
+Anchors allow us to match specific positions inside a string instead of a
+character. They belong to a group called zero-length matches for this reason.
+
+With anchors we can match the start and end of a string using ^ and $
+respectively.
+
+For this adventure, write a python function that receives a string and
+returns `True` if it ends with a caret, and `False` otherwise.
+
+You can use this template to get started:
+
+.. sourcecode:: python
+
+    import re
+
+    def test(string):
+        # Your code goes here
+
+When you are done, you must run:
+
+.. sourcecode:: bash
+
+    $ {script} verify program.py

learnregex/anchors/SOLUTION.rst

@@ -0,0 +1,9 @@
+`program.py` content:
+
+.. sourcecode:: python
+
+    import re
+
+
+    def test(string):
+        return re.match(r'.*\^$', string)

learnregex/anchors/__init__.py

@@ -0,0 +1,26 @@
+import string
+
+from story.adventures import AdventureVerificationError, BaseAdventure
+
+from ..data import _
+from ..utils import get_random_string, load_solution_function
+
+
+class Adventure(BaseAdventure):
+
+    title = _('Anchors')
+    dictionary = string.ascii_lowercase + string.digits
+
+    def test(self, file):
+        function = load_solution_function(file)
+        correct_argument = get_random_string(self.dictionary, 4, 6) + '^'
+        if not function(correct_argument):
+            raise AdventureVerificationError(
+                _("Your function didn't return True when executed with a "
+                  "correct argument '{}'.".format(correct_argument))
+            )
+        wrong_argument = get_random_string(self.dictionary, 4, 6)
+        if function(wrong_argument):
+            raise AdventureVerificationError(
+                _("Your function returned True when executed with a wrong "
+                  "argument '{}'.".format(wrong_argument)))

learnregex/capturing/README.rst

@@ -0,0 +1,26 @@
+Groups provide an additional feature: they capture the string they end up
+matching and save it in a variable that we can use later, either in the same
+regular expression or after it finishes. In python we can use a captured
+group with a backslash and an index. For example: \1 will reference the first
+group of our regular expression, \2 will reference the second one and so on
+until \9, where we run out of numbers (they can only use one digit). If you
+need to capture more than 9 groups check out named groups.
+
+Say we want to test if a string ends with the same character it started. We
+could write something like this: '^(.).*\1$|^.$'. We capture the first
+character after the start of the string, match zero o more characters in
+between and reference the captured character before the string ends. We also
+alternate with another expression in case our string has only 1 character.
+
+For this adventure, write a python function that receives a string with only
+one pipe ('|') somewhere in between and returns `True` if everything to the
+left of the pipe equals what's to its right, and `False` otherwise.
+
+You can use this template to get started:
+
+.. sourcecode:: python
+
+    import re
+
+    def test(string):
+        # Your code goes here

learnregex/capturing/SOLUTION.rst

@@ -0,0 +1,10 @@
+`program.py` content:
+
+.. sourcecode:: python
+
+    import re
+
+
+    def test(string):
+        return re.match(r'(.*)\|\1$', string)
+

learnregex/capturing/__init__.py

@@ -0,0 +1,30 @@
+import string
+
+from story.adventures import AdventureVerificationError, BaseAdventure
+
+from ..data import _
+from ..utils import get_random_string, load_solution_function
+
+
+class Adventure(BaseAdventure):
+
+    title = _('Capturing')
+    dictionary = string.ascii_lowercase + string.digits
+
+    def test(self, file):
+        function = load_solution_function(file)
+        repeat = get_random_string(self.dictionary, 4, 6)
+        correct_argument = '{0}|{0}'.format(repeat)
+        if not function(correct_argument):
+            raise AdventureVerificationError(
+                _("Your function didn't return True when executed with a "
+                  "correct argument '{}'.".format(correct_argument))
+            )
+        wrong_argument = '{}|{}'.format(
+            get_random_string(self.dictionary, 5, 5),
+            get_random_string(self.dictionary, 5, 5)
+        )
+        if function(wrong_argument):
+            raise AdventureVerificationError(
+                _("Your function returned True when executed with a wrong "
+                  "argument '{}'.".format(wrong_argument)))

learnregex/character_classes/README.rst

@@ -0,0 +1,25 @@
+Now that we now what special characters are and how to escape them, let's try
+their actual special meaning. We are going to start with character classes.
+
+A character class matches one out of a set of characters that we define. You
+define a character class by writing all the characters of your set between
+square brackets. For example, this matches either an "a" or a "b": [ba] (the
+order doesn't matter).
+
+For this adventure, write a python function that receives a string and
+returns `True` if the first character is a digit, and `False` otherwise.
+
+You can use this template to get started:
+
+.. sourcecode:: python
+
+    import re
+
+    def test(string):
+        # Your code goes here
+
+When you are done, you must run:
+
+.. sourcecode:: bash
+
+    $ {script} verify program.py

learnregex/character_classes/SOLUTION.rst

@@ -0,0 +1,10 @@
+`program.py` content:
+
+.. sourcecode:: python
+
+    import re
+
+
+    def test(string):
+        return re.match(r'[0123456789]', string)
+

learnregex/character_classes/__init__.py

@@ -0,0 +1,30 @@
+import random
+import string
+
+from story.adventures import AdventureVerificationError, BaseAdventure
+
+from ..data import _
+from ..utils import get_random_string, load_solution_function
+
+
+class Adventure(BaseAdventure):
+
+    title = _('Character classes')
+    dictionary = string.ascii_lowercase
+
+    def test(self, file):
+        function = load_solution_function(file)
+        correct_argument = '{}{}'.format(
+            random.randint(0, 9),
+            get_random_string(self.dictionary, 1, 5)
+        )
+        if not function(correct_argument):
+            raise AdventureVerificationError(
+                _("Your function didn't return True when executed with a "
+                  "correct argument '{}'.".format(correct_argument))
+            )
+        wrong_argument = get_random_string(self.dictionary, 1, 5)
+        if function(wrong_argument):
+            raise AdventureVerificationError(
+                _("Your function returned True when executed with a wrong "
+                  "argument '{}'.".format(wrong_argument)))

learnregex/greediness/README.rst

@@ -0,0 +1,36 @@
+When using quantifiers sometimes we'll run into an issue where they match
+more than we want. Suppose we want to match the first part (including the
+dot) of a domain. We write the expression '.*\.' thinking "this will return
+all the characters before the first dot along with it" and test it on
+"pyschool.github.io" expecting to get "pyschool." back, but it returns
+"pyschool.github.".
+
+What happened? Quantifiers are greedy by default, meaning they will match
+all the characters they can. In this case we have two dots in our string, so
+the quantifier gets to match all the characters up to the last dot without
+problem.
+
+We can make our quantifiers "lazy" by adding a question mark at their end
+(even the ? quantifier, which becomes ?? in its lazy form), meaning they will
+match the minimum amount of characters they can. If we add a question mark to
+our quantifier it becomes lazy and will now match all the characters up to
+the first dot and stop there, since the whole expression matches.
+
+For this adventure, write a python function that receives a string of comma
+separated values and returns all the characters from the start up to the
+first comma, including it.
+
+You can use this template to get started:
+
+.. sourcecode:: python
+
+    import re
+
+    def test(string):
+        # Your code goes here
+
+When you are done, you must run:
+
+.. sourcecode:: bash
+
+    $ {script} verify program.py

learnregex/greediness/SOLUTION.rst

@@ -0,0 +1,10 @@
+`program.py` content:
+
+.. sourcecode:: python
+
+    import re
+
+
+    def test(string):
+        return re.match(r'.*?,', string).group(0)
+

learnregex/greediness/__init__.py

@@ -0,0 +1,28 @@
+import string
+
+from story.adventures import AdventureVerificationError, BaseAdventure
+
+from ..data import _
+from ..utils import get_random_string, load_solution_function
+
+
+class Adventure(BaseAdventure):
+
+    title = _('Greediness')
+    dictionary = string.ascii_lowercase + string.digits
+
+    def test(self, file):
+        function = load_solution_function(file)
+        prefix = get_random_string(self.dictionary, 1, 5) + ','
+        correct_argument = '{}{},{}'.format(
+            prefix,
+            get_random_string(self.dictionary, 1, 5),
+            get_random_string(self.dictionary, 1, 5),
+        )
+        result = function(correct_argument)
+        if result != prefix:
+            raise AdventureVerificationError(
+                _("Your function didn't return the expected string '{}' when "
+                  "executed with '{}'. "
+                  "It returned '{}'.".format(prefix, correct_argument, result))
+            )

learnregex/groups/README.rst

@@ -0,0 +1,23 @@
+Groups have plenty of uses. They basically enclose a section of our
+expression so we can treat it as a token. This allows us to apply quantifiers
+to a whole expression instead of a single character or character class like
+we have been doing. It also allows us to use the alternation operator with a
+limited scope.
+
+Groups are defined with simple parenthesis. We can put everything inside them,
+even other groups.
+
+For this adventure, write a python function that receives a string and
+returns `True` if starts with one or more repetitions of the word 'hello' and
+ends with either 'python' or 'pyschool', and `False` otherwise. You don't
+need to check for spaces, the words just need to follow one immediately after
+another.
+
+You can use this template to get started:
+
+.. sourcecode:: python
+
+    import re
+
+    def test(string):
+        # Your code goes here

learnregex/groups/SOLUTION.rst

@@ -0,0 +1,10 @@
+`program.py` content:
+
+.. sourcecode:: python
+
+    import re
+
+
+    def test(string):
+        return re.match(r'(hello)+(python|pyschool)', string)
+