def test_m_value_orthodox(self):
     self.assertEqual('88',
                      rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa 9-9 88 xx")[
                          't'])
     self.assertEqual('88',
                      rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa 9-9 88 xx")[2])
     self.assertEqual(None,
                      rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa 9-9 88 xx")[
                          'tttt'])

 def test_m_value(self):
     self.assertEqual('88',
                      ("Aa 9-9 88 xx" == rex('/([0-9-]+) (?P<t>[0-9-]+)/'))[
                          't'])
     self.assertEqual('88',
                      ("Aa 9-9 88 xx" == rex('/([0-9-]+) (?P<t>[0-9-]+)/'))[
                          2])
     self.assertEqual(None,
                      ("Aa 9-9 88 xx" == rex('/([0-9-]+) (?P<t>[0-9-]+)/'))[
                          'tttt'])

def arpa(fp, gram=None, header_start = None, header_end = None, section_start = None, section_end = None, file_end = None):
    section = None
    lm_info = {}
    max_gram = 0
    for l in fp:
        #print(l)
        if l.startswith("\\"):
            if l == "\\data\\\n":
                section = 0
                print("loading header", file=sys.stderr)
                if header_start and header_start() == False:
                    break
            elif l=="\\end\\\n":
                if file_end:
                    file_end(lm_info)
                break
            else:
                res = (l == rex("/^\\\\(\\d+)-grams/"))
                if res is not None:
                    section = int(res[1])
                    print("loading %d-grams" % section, file=sys.stderr)
                    if section_start and section_start(lm_info,section) == False:
                        break
            continue
        if l == "\n":
            if section == 0 and header_end and header_end(lm_info)== False:
                break
            elif section is not None and section > 0 and section_end and section_end(lm_info,section) == False:
                break
            section = None
            continue
        if section == 0:
            res = (l == rex("/^ngram (\d+)=(\d+)/"))
            lm_info[int(res[1])] = int(res[2])
            print("ngram %d=%d"%(int(res[1]), int(res[2])), file=sys.stderr)
            max_gram = max(max_gram, int(res[1]))
        else:
            larr = l.strip("\n").split("\t")
            bow = None
            if len(larr) == 3:
                bow = float(larr[-1])
            elif len(larr) < 2:
                continue
            if bow is None:
                bow = 0
            prob = float(larr[0])
            words = larr[1].split(" ")
            if gram and gram(lm_info, section, words, prob, bow) == False:
                break

def test_m_action_ex():
    r = rex('m!test!')
    assert r.action == 'm'
    assert r.pattern == 'test'
    assert r.flags == 0

 def test_m_action_ex(self):
     r = rex("m!test!")
     self.assertEqual(r.action, "m")
     self.assertEqual(r.pattern, "test")
     self.assertEqual(r.flags, 0)

 def test_cache_2(self):
     a = rex("s/cache/test/")
     b = rex("s/cache/test/")
     self.assertEqual(a is b, True)

 def test_not_cache(self):
     rex("s/cache/test1/", cache=False)
     self.assertNotIn("s/cache/test1/", rex_module.REX_CACHE)

 def test_m_value(self):
     self.assertEqual("88", ("Aa 9-9 88 xx" == rex("/([0-9-]+) (?P<t>[0-9-]+)/"))["t"])
     self.assertEqual("88", ("Aa 9-9 88 xx" == rex("/([0-9-]+) (?P<t>[0-9-]+)/"))[2])
     self.assertEqual(None, ("Aa 9-9 88 xx" == rex("/([0-9-]+) (?P<t>[0-9-]+)/"))["tttt"])

 def test_s_multi(self):
     self.assertEqual("This is a dog dog dog dog", "This is a cat cat cat cat" == rex("s/cat/dog/"))

def test_m_false():
    assert not ("Aa 9-9  xx" == rex('/([0-9-]+) (?P<t>[0-9-]+)/'))

 def test_m_true(self):
     self.assertTrue("Aa 9-9 88 xx" == rex("/([0-9-]+) (?P<t>[0-9-]+)/"))

def test_m_true_orthodox():
    assert rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa 9-9 88 xx")

def test_m_false_noncache():
    assert rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa 9-9 88 xx", cache=False)
    assert not rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa bb cc xx", cache=False)

def test_m_true():
    assert ("Aa 9-9 88 xx" == rex('/([0-9-]+) (?P<t>[0-9-]+)/'))

def test_s_action_flags():
    r = rex('/test/im')
    assert r.action == 'm'
    assert r.pattern == 'test'
    assert r.flags == re.I | re.M

def test_s_action():
    r = rex('s/test/ohh/')
    assert r.action == 's'
    assert r.pattern == 'test'
    assert r.replacement == 'ohh'
    assert r.flags == 0

 def test_s_action(self):
     r = rex("s/test/ohh/")
     self.assertEqual(r.action, "s")
     self.assertEqual(r.pattern, "test")
     self.assertEqual(r.replacement, "ohh")
     self.assertEqual(r.flags, 0)

def test_m_false_orthodox():
    assert not rex('/([0-9-]+) (?P<t>[0-9-]+)/', "Aa 9-9  xx")

 def test_s_action_flags(self):
     r = rex("/test/im")
     self.assertEqual(r.action, "m")
     self.assertEqual(r.pattern, "test")
     self.assertEqual(r.flags, re.I | re.M)

import importlib
import inspect
from textwrap import dedent, indent
from collections import namedtuple
from pathlib import Path

import jinja2
import sass
import click
import markdown
from rex import rex


CONTENT_MODULE_PATH = "tests.test_content"

OUTPUT_RE = rex(r"""s/^.*?assert .*? == ['"](.*)['"].*?# output$\n/\1/""")

Example = namedtuple("Example", ('name', 'title', 'details', 'setup', 'old', 'new', 'output'))


def compile_sass(source_path, target_path_pattern):
    # First generate the content from which we can generate the hashname
    output = sass.compile(
        filename=str(source_path),
        output_style='compressed')
    hash = hashlib.sha512(output.encode('utf-8')).hexdigest()[:8]
    target_path = str(target_path_pattern).format(hash)
    source_map_target_path = target_path + '.map'
    output = sass.compile(
        filename=str(source_path),
        output_style='compressed',