def markdown(s):
    s = s or ''
    return md(s, [
        'markdown.extensions.tables',
        'markdown.extensions.fenced_code',
        'markdown.extensions.codehilite',
    ])

def markdown(value, autoescape=True):
    """Converts markdown text into html"""
    #if autoescape:
    #    esc = conditional_escape
    #else:
    #    esc = lambda x: x
    return mark_safe(md(conditional_escape(value)))

def markdown(raw):
    html = md(raw, extensions=['gfm'])
    if not html.strip():
        return html
    kill_tags = ['body', 'head', 'style']
    cleaner   = Cleaner(kill_tags = kill_tags)
    html      = cleaner.clean_html(html)
    return html

def markdown(value):
    """
    Run text through markdown process

    >>> markdown('*test*')
    Markup(u'<p><em>test</em></p>')
    """
    return Markup(md(value))

def parse_speaker(speaker, content):
    speaker = speaker.lower().title()
    p, created = Post.objects.get_or_create(
            thread=t, author=characters[speaker],
            content_plain=content)
    if created:
        p.content_html = sp(md(text=content, extensions=["nl2br"]))
        p.creation_date = datetime.datetime.now()  # UTC?
        p.save()

def markdown(value, header_level=1):
    html = md(value,
              output_format='html5', safe_mode='escape',
              extensions=[
                  TocExtension(baselevel=header_level),
                  CodeHiliteExtension(),
                  FencedCodeExtension(),
                  TableExtension(),
              ])
    return mark_safe(html)

def markdown(s, markup_wrap=False):
    s = s or ''
    s = md(s, [
        'markdown.extensions.tables',
        'markdown.extensions.fenced_code',
        'markdown.extensions.codehilite',
    ])
    if markup_wrap:
        s = Markup(s)
    return s

    def markdown(text):
        jinja_env = jinja2.Environment()
        jinja_env.filters['media_url'] = media_url_func(site)
        jinja_env.filters['absolute_url'] = absolute_url_func(site)

        jinja_rendered = jinja_env.from_string(text).render()

        return md(
            jinja_rendered,
            tab_length=2,
            extensions=['markdown.extensions.fenced_code']
        )

def ajax_markdown_preview(request):
    d = {}
    if request.method == "POST":
        raw = request.POST.get('md','')
        raw.lstrip()
        html = md(raw, extensions=['gfm'])
        d['html'] = html
        d['code'] = 0
        d['msg']  = 'success'
        return HttpResponse(json.dumps(d),content_type="application/json")
    else:
        d['code'] = 1
        d['msg'] = 'invalid request method'
        return HttpResponse(json.dumps(d),content_type="application/json")

def render_card(card):
    title = escape(card.title)
    image = card.image.url if card.image else None
    content = mark_safe(md(conditional_escape(card.content)))
    button = card.button

    if content:
        image_height = 100
    else:
        image_height = 180

    return {'title': title,
            'image': image,
            'content': content,
            'button': button,
            'image_height': image_height,}

def mdtext(text):
    mdbody = re.sub(
        '\\[\\[(.*?)\\]\\]',
        lambda match: generate_article_link(match.group(1)),
        text
        )

    mdbody = md(
        mdbody,
        extensions=[
            'markdown.extensions.tables',
            'markdown.extensions.footnotes'
        ],
        output_format='html5'
        )

    return bleach.clean(
        mdbody,
        tags=ALLOWED_TAGS
        )

	def sanitise(self, text, markdown = True):
		if markdown:
			text = md(text)
		
		dom = PyQuery(text)
		
		for a in dom.find('a[href^="javascript:"]'):
			a = PyQuery(a)
			a.replaceWith(a.text())

		for obj in UNCLEAN_TAGS:
			dom.find(obj).remove()

		for attr in UNCLEAN_ATTRS:
			dom.find('[%s]' % attr).removeAttr(attr)
		
		text = dom.outerHtml()
		if markdown:
			dom = HTML2Text()
			text = dom.handle(text)

		return text

def api_index():
    return flask.make_response(md(open('README.md','r').read()))

def markdown(s):
    return md(s, ['markdown.extensions.tables'])

def markdown(post):
  page = linkname(post.category.name)
  prefix = 'https://s3.amazonaws.com/vineel.me/%s/' % post.id
  return Markup(md(post.body, ['awsimage(PREFIX=%s)' % prefix, 'syntax']))

	def parsed(self):
		return md(self.content)

def markdown(content):
	return a_blank(md(content))

def markdown(text):
    return mark_safe(md(text))

def markdown(value):
    """Renders the text as markdown"""
    return mark_safe(md(value))

def markdown(s):
    return md(s.decode('utf-8'),
              ['headerid(level=2)', 'def_list']).encode('utf-8')