def whitelister_element_rules():
    return {
        # Commenting out disallowed tags so its easier to remember & revert
        'a': attribute_rule({'href': check_url}),
        'b': allow_without_attributes,
        # 'br': allow_without_attributes,
        # 'div': allow_without_attributes,
        'em': allow_without_attributes,
        'h1': allow_without_attributes,
        'h2': allow_without_attributes,
        'h3': allow_without_attributes,
        'h4': allow_without_attributes,
        'h5': allow_without_attributes,
        'h6': allow_without_attributes,
        'hr': allow_without_attributes,
        'i': allow_without_attributes,
        'img': attribute_rule({'src': check_url, 'width': True, 'height': True,
                               'alt': True}),
        'li': allow_without_attributes,
        'ol': allow_without_attributes,
        'p': allow_without_attributes,
        'strong': allow_without_attributes,
        'sub': allow_without_attributes,
        'sup': allow_without_attributes,
        'ul': allow_without_attributes,
    }

def whitelister_element_rules():
    return {
        'p': attribute_rule({'class': True}),
        'a': attribute_rule({'href': check_url, 'id': True, 'class': True}),
        'span': attribute_rule({'class': True}),
        'i': attribute_rule({'class': True}),
        'iframe': attribute_rule({'id': True, 'class': True, 'src': True, 'style': True, 'frameborder': True, 'allowfullscreen': True, 'width': True, 'height': True }),
    }

def whitelister_element_rules():
    return {
        'h2': attribute_rule({'style': True}),
        'h3': attribute_rule({'style': True}),
        'h4': attribute_rule({'style': True}),
        'h5': attribute_rule({'style': True}),
        'p': attribute_rule({'style': True}),
    }

def whitelister_element_rules():
    return {
        'iframe': attribute_rule(ALLTAGS),
        'object': attribute_rule(ALLTAGS),
        'script': attribute_rule(ALLTAGS),
        'style': attribute_rule(ALLTAGS),
        'embed': attribute_rule(ALLTAGS),
        'src': attribute_rule(ALLTAGS),
        'video': attribute_rule(ALLTAGS),
        'div': attribute_rule(ALLTAGS),
        'noscript': attribute_rule(ALLTAGS),
        'param': attribute_rule(ALLTAGS),
    }

def whitelister_element_rules():
    """
    Whitelist custom elements to the hallo.js editor
    """
    return {
        'blockquote': allow_without_attributes,
        'cite': allow_without_attributes,
        'a': attribute_rule({'href': check_url, 'class': True}),
        'h2': attribute_rule({'id': True}),
        'h3': attribute_rule({'id': True}),
        'h4': attribute_rule({'id': True}),
        'h5': attribute_rule({'id': True}),
    }

def allow_iframes():
    return {
        'iframe': attribute_rule(
            {
                'src': True,
                'width': True,
                'height': True,
                'frameborder': True,
                'marginheight': True,
                'marginwidth': True
            }),
        'tito-widget': attribute_rule({'event': True}),
        'tito-button': attribute_rule({'event': True}),
    }

def whitelister_element_rules():
    """
    Whitelist custom elements to the hallo.js editor
    """
    return {
        'a': attribute_rule({'href': check_url, 'class': True}),
    }

def whitelister_element_rules():
    allow_html_class = attribute_rule({'class': True})

    allowed_tags = ['aside', 'table', 'tr', 'th', 'td', 'tbody', 'thead',
                    'tfoot', 'col', 'colgroup']

    return {tag: allow_html_class for tag in allowed_tags}

 def test_rule_false_for_attr(self):
     """
     Test that attribute_rule() drops atrributes
     when the corresponding rule returns False
     """
     tag = self.soup.b
     fn = attribute_rule({'foo': False})
     fn(tag)
     self.assertEqual(str(tag), '<b>baz</b>')

 def test_rule_true_for_attr(self):
     """
     Test that attribute_rule() does not change atrributes
     when the corresponding rule returns True
     """
     tag = self.soup.b
     fn = attribute_rule({'foo': True})
     fn(tag)
     self.assertEqual(str(tag), '<b foo="bar">baz</b>')

 def test_no_rule_for_attr(self):
     """
     Test that attribute_rule() drops attributes for
     which no rule has been defined.
     """
     tag = self.soup.b
     fn = attribute_rule({'snowman': 'barbecue'})
     fn(tag)
     self.assertEqual(str(tag), '<b>baz</b>')

def whitelister_element_rules():
    return {
        'blockquote': allow_without_attributes,
        'code': allow_without_attributes,
        'table': allow_without_attributes,
        'tr': allow_without_attributes,
        'td': allow_without_attributes,
        'pre': attribute_rule({'class': True}),
    }

 def test_callable_returns_None(self):
     """
     Test that when the rule returns a callable,
     attribute_rule() replaces the attribute with
     the result of calling the callable on the attribute.
     """
     tag = self.soup.b
     fn = attribute_rule({'foo': lambda x: None})
     fn(tag)
     self.assertEqual(str(tag), '<b>baz</b>')

 def test_callable_called_on_attr(self):
     """
     Test that when the rule returns a callable,
     attribute_rule() replaces the attribute with
     the result of calling the callable on the attribute.
     """
     tag = self.soup.b
     fn = attribute_rule({'foo': len})
     fn(tag)
     self.assertEqual(str(tag), '<b foo="3">baz</b>')

def allow_iframes():
    return {
        'iframe': attribute_rule(
            {
                'src': True,
                'width': True,
                'height': True,
                'frameborder': True,
                'marginheight': True,
                'marginwidth': True
            })
    }

def whitelister_element_rules():
    allow_html_class = attribute_rule({
        'class': True,
        'itemprop': True,
        'itemscope': True,
        'itemtype': True,
    })

    allowed_tags = ['aside', 'h4', 'p', 'span',
                    'table', 'tr', 'th', 'td', 'tbody', 'thead', 'tfoot',
                    'col', 'colgroup']

    return {tag: allow_html_class for tag in allowed_tags}

def whitelist_blockquote():
    return {
        'style': blacklist_tag(),
        'font': unwrap_tag(),
        'span': unwrap_tag(),
        'blockquote': attribute_rule({'class': True}),
        'p': attribute_rule({'class': True}),
        'h2': attribute_rule({'class': True}),
        'h3': attribute_rule({'class': True}),
        'h4': attribute_rule({'class': True}),
        'h5': attribute_rule({'class': True}),
        'iframe': attribute_rule({
            'style': True, 'src': True,
            'width': True, 'height': True
        }),
        'img': attribute_rule({
            'srcset': True, 'class': True,
            'alt': True, 'sizes': True,
            'width': True, 'height': True,
            'src': True
        })
    }

def whitelister_element_rules():
    return {
        'span': attribute_rule({'style': True}),
        'font': attribute_rule({'size': True, 'face': True, 'color': True}),
        'p': attribute_rule({'align': True}),
    }

def whitelister_element_rules():
    return {"blockquote": allow_without_attributes, "a": attribute_rule({"href": check_url, "target": True})}

def whitelister_element_rules():
    return {
        'a': attribute_rule({'href': check_url, 'id': True}),
        'span': attribute_rule({'class': True}),
    }