referencingLink() - Code Metrics - Inspection of "Refactoring referencing" - chdemko/pandoc-numbering - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d6b46b...4e469a )

by Christophe

created 2016-06-15 08:20 UTC

referencingLink() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
dl	0
loc	82
rs	7.3557
c	1
b	0
f	0

How to fix Long Method

#!/usr/bin/env python

"""
Pandoc filter to number all kinds of things.
"""

from pandocfilters import walk, stringify, Str, Space, Para, BulletList, Plain, Strong, Span, Link, Emph, RawInline, RawBlock, Header
from functools import reduce
import json
import io
import sys
import codecs
import re
import unicodedata
import subprocess

count = {}
information = {}
collections = {}
headers = [0, 0, 0, 0, 0, 0]
headerRegex = '(?P<header>(?P<hidden>(-\.)*)(\+\.)*)'

def toJSONFilters(actions):
    """Converts a list of actions into a filter that reads a JSON-formatted
    pandoc document from stdin, transforms it by walking the tree
    with the actions, and returns a new JSON-formatted pandoc document
    to stdout.  The argument is a list of functions action(key, value, format, meta),
    where key is the type of the pandoc object (e.g. 'Str', 'Para'),
    value is the contents of the object (e.g. a string for 'Str',
    a list of inline elements for 'Para'), format is the target
    output format (which will be taken for the first command line
    argument if present), and meta is the document's metadata.
    If the function returns None, the object to which it applies
    will remain unchanged.  If it returns an object, the object will
    be replaced.    If it returns a list, the list will be spliced in to
    the list to which the target object belongs.    (So, returning an
    empty list deletes the object.)
    """
    try:
        input_stream = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8')
    except AttributeError:
        # Python 2 does not have sys.stdin.buffer.
        # REF: http://stackoverflow.com/questions/2467928/python-unicodeencodeerror-when-reading-from-stdin
        input_stream = codecs.getreader("utf-8")(sys.stdin)

    doc = json.loads(input_stream.read())
    if len(sys.argv) > 1:
        format = sys.argv[1]
    else:
        format = ""
    altered = reduce(lambda x, action: walk(x, action, format, doc[0]['unMeta']), actions, doc)
    addListings(altered, format, altered[0]['unMeta'])
    json.dump(altered, sys.stdout)

def removeAccents(string):
    nfkd_form = unicodedata.normalize('NFKD', string)
    return u"".join([c for c in nfkd_form if not unicodedata.combining(c)])

def toIdentifier(string):
    # replace invalid characters by dash
    string = re.sub('[^0-9a-zA-Z_-]+', '-', removeAccents(string.lower()))

    # Remove leading digits
    string = re.sub('^[^a-zA-Z]+', '', string)

    return string

def toLatex(x):
    """Walks the tree x and returns concatenated string content,
    leaving out all formatting.
    """
    result = []

    def go(key, val, format, meta):
        if key in ['Str', 'MetaString']:
            result.append(val)
        elif key == 'Code':
            result.append(val[1])
        elif key == 'Math':
            # Modified from the stringify function in the pandocfilter package
            if format == 'latex':
                result.append('$' + val[1] + '$')
            else:
                result.append(val[1])
        elif key == 'LineBreak':
            result.append(" ")
        elif key == 'Space':
            result.append(" ")
        elif key == 'Note':
            # Do not stringify value from Note node
            del val[:]

    walk(x, go, 'latex', {})
    return ''.join(result)

def numbering(key, value, format, meta):
    global headerRegex
    if key == 'Header':
        [level, [id, classes, attributes], content] = value
        if 'unnumbered' not in classes:
            headers[level - 1] = headers[level - 1] + 1
            for index in range(level, 6):
                headers[index] = 0
    elif key == 'Para':
        if len(value) >= 3 and value[-2] == Space() and value[-1]['t'] == 'Str':
            last = value[-1]['c']

            match = re.match('^' + headerRegex + '#((?P<prefix>[a-zA-Z][\w.-]*):)?(?P<name>[a-zA-Z][\w:.-]*)?$', last)

            if match:
                # Is it a Para and the last element is an identifier beginning with '#'
                global count, information, collections

                # Detect the title
                title = []
                if value[-3]['t'] == 'Str' and value[-3]['c'][-1:] == ')':
                    for (i, item) in enumerate(value):
                        if item['t'] == 'Str' and item['c'][0] == '(':
                            title = value[i:-2]
                            title[0]['c'] = title[0]['c'][1:]
                            title[-1]['c'] = title[-1]['c'][:-1]
                            value = value[:i - 1] + value[-2:]
                            break

                # Compute the description
                description = value[:-2]

                # Compute the basicCategory and the category
                if match.group('prefix') == None:
                    basicCategory = toIdentifier(stringify(description))
                else:
                    basicCategory = match.group('prefix')

                # Compute the levelInf and levelSup values
                levelInf = len(match.group('hidden')) // 2
                levelSup = len(match.group('header')) // 2

                # Get the default inf and sup level
                if levelInf == 0 and levelSup == 0:
                    [levelInf, levelSup] = getDefaultLevels(basicCategory, meta)

                # Compute the section number
                sectionNumber = '.'.join(map(str, headers[:levelSup]))

                # Compute the leading (composed of the section numbering and a dot)
                if levelSup != 0:
                    leading = sectionNumber + '.'
                else:
                    leading = ''

                category = basicCategory + ':' + leading

                # Is it a new category?
                if category not in count:
                    count[category] = 0

                count[category] = count[category] + 1

                # Get the number
                number = str(count[category])

                # Determine the final tag
                if match.group('name') == None:
                    tag = category + number
                else:
                    tag = basicCategory + ':' + match.group('name')

                # Replace the '-.-.+.+...#' by the category count (omitting the hidden part)
                localNumber = '.'.join(map(str, headers[levelInf:levelSup] + [number]))

                # Compute the globalNumber
                if sectionNumber:
                    globalNumber = sectionNumber + '.' + number
                else:
                    globalNumber = number

                # Is the automatic formatting required for this category?
                if getFormat(basicCategory, meta):
                    # Prepare the final text
                    text = [Strong(description + [Space(), Str(localNumber)])]

                    # Add the title to the final text
                    if title:
                        text = text + [Space(), Emph([Str('(')] + title + [Str(')')])]

                    # Compute the link
                    link = description + [Space(), Str(localNumber)]

                    # Compute the toc
                    toc = [Str(globalNumber), Space()]
                    if title:
                        toc = toc + title
                    else:
                        toc = toc + description

                else:
                    # Prepare the final text
                    text = [
                        Span(['', ['description'], []], description),
                        Span(['', ['title'], []], title),
                        Span(['', ['local'], []], [Str(localNumber)]),
                        Span(['', ['global'], []], [Str(globalNumber)]),
                        Span(['', ['section'], []], [Str(sectionNumber)]),
                    ]

                    # Compute the link
                    link = [Span(['', ['pandoc-numbering-link'] + getClasses(basicCategory, meta), []], text)]

                    # Compute the toc
                    toc = [Span(['', ['pandoc-numbering-toc'] + getClasses(basicCategory, meta), []], text)]


                # Store the numbers and the label for automatic numbering (See referencing function)
                information[tag] = {
                    'section': sectionNumber,
                    'local': localNumber,
                    'global': globalNumber,
                    'count': number,
                    'description': description,
                    'title': title,
                    'link': link,
                    'toc': toc
                }

                # Prepare the contents
                contents = [Span([tag, ['pandoc-numbering-text'] + getClasses(basicCategory, meta), []], text)]

                # Compute collections
                if basicCategory not in collections:
                    collections[basicCategory] = []

                collections[basicCategory].append(tag)

                # Special case for LaTeX
                if format == 'latex' and getFormat(basicCategory, meta):
                    latexCategory = re.sub('[^a-z]+', '', basicCategory)
                    if title:
                      entry = title
                    else:
                      entry = description
                    latex = '\\phantomsection\\addcontentsline{' + latexCategory + '}{' + latexCategory + '}{\\protect\\numberline {' + \
                        leading + number + '}{\ignorespaces ' + toLatex(entry) + '}}'
                    contents.insert(0, RawInline('tex', latex))

                # Return the contents in a Para element
                return Para(contents)
            elif re.match('^' + headerRegex + '##(?P<prefix>[a-zA-Z][\w.-]*:)?(?P<name>[a-zA-Z][\w:.-]*)?$', last):
                # Special case where the last element is '...##...'
                value[-1]['c'] = value[-1]['c'].replace('##', '#', 1)
                return Para(value)

replace = None
search = None

def lowering(key, value, format, meta):
    if key == 'Str':
        return Str(value.lower())

def referencing(key, value, format, meta):
    if key == 'Link':
        return referencingLink(value, format, meta)
    elif key == 'Cite':
        return referencingCite(value, format, meta)

def referencingLink(value, format, meta):
    global information, replace, search
    if pandocVersion() < '1.16':
        # pandoc 1.15
        [text, [reference, title]] = value
    else:
        # pandoc > 1.15
        [attributes, text, [reference, title]] = value

    if re.match('^(#([a-zA-Z][\w:.-]*))$', reference):
        # Compute the name
        tag = reference[1:]

        if tag in information:
            if pandocVersion() < '1.16':
                # pandoc 1.15
                i = 0
            else:
                # pandoc > 1.15
                i = 1

            # Replace all '#t', '#T', '#d', '#D', '#s', '#g', '#c', '#n', '#' with the corresponding text in the title
            value[i + 1][1] = value[i + 1][1].replace('#t', stringify(information[tag]['title']).lower())
            value[i + 1][1] = value[i + 1][1].replace('#T', stringify(information[tag]['title']))
            value[i + 1][1] = value[i + 1][1].replace('#d', stringify(information[tag]['description']).lower())
            value[i + 1][1] = value[i + 1][1].replace('#D', stringify(information[tag]['description']))
            value[i + 1][1] = value[i + 1][1].replace('#s', information[tag]['section'])
            value[i + 1][1] = value[i + 1][1].replace('#g', information[tag]['global'])
            value[i + 1][1] = value[i + 1][1].replace('#c', information[tag]['count'])
            value[i + 1][1] = value[i + 1][1].replace('#n', information[tag]['local'])
            value[i + 1][1] = value[i + 1][1].replace('#', information[tag]['local'])

            if text == []:
                # The link text is empty, replace it with the default label
                value[i] = information[tag]['link']
            else:
                # The link text is not empty

                #replace all '#t' with the title in lower case
                replace = walk(information[tag]['title'], lowering, format, meta)
                search = '#t'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#T' with the title
                replace = information[tag]['title']
                search = '#T'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#d' with the description in lower case
                replace = walk(information[tag]['description'], lowering, format, meta)
                search = '#d'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#D' with the description
                replace = information[tag]['description']
                search = '#D'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#s' with the corresponding number
                replace = [Str(information[tag]['section'])]
                search = '#s'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#g' with the corresponding number
                replace = [Str(information[tag]['global'])]
                search = '#g'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#c' with the corresponding number
                replace = [Str(information[tag]['count'])]
                search = '#c'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#n' with the corresponding number
                replace = [Str(information[tag]['local'])]
                search = '#n'
                value[i] = walk(value[i], replacing, format, meta)

                #replace all '#' with the corresponding number
                replace = [Str(information[tag]['local'])]
                search = '#'
                value[i] = walk(value[i], replacing, format, meta)

def referencingCite(value, format, meta):
    global information
    match = re.match('^(@(?P<tag>(?P<category>[a-zA-Z][\w.-]*):(([a-zA-Z][\w.-]*)|(\d*(\.\d*)*))))$', value[1][0]['c'])
    if match != None and getCiteShortCut(match.group('category'), meta):

        # Deal with @prefix:name shortcut
        tag = match.group('tag')
        if tag in information:
            if pandocVersion() < '1.16':
                # pandoc 1.15
                return Link([Str(information[tag]['local'])], ['#' + tag, ''])
            else:
                # pandoc > 1.15
                return Link(['', [], []], [Str(information[tag]['local'])], ['#' + tag, ''])

def replacing(key, value, format, meta):
    global replace, search
    if key == 'Str':
        prepare = value.split(search)
        if len(prepare) > 1:

            ret = []

            if prepare[0] != '':
                ret.append(Str(prepare[0]))

            for string in prepare[1:]:
                ret.extend(replace)
                if string != '':
                    ret.append(Str(string))

            return ret

def hasMeta(meta):
    return 'pandoc-numbering' in meta and meta['pandoc-numbering']['t'] == 'MetaList'

def isCorrect(definition):
    return definition['t'] == 'MetaMap' and\
        'category' in definition['c'] and\
        definition['c']['category']['t'] == 'MetaInlines' and\
        len(definition['c']['category']['c']) == 1 and\
        definition['c']['category']['c'][0]['t'] == 'Str'

def hasProperty(definition, name, type):
    return name in definition['c'] and definition['c'][name]['t'] == type

def getProperty(definition, name):
    return definition['c'][name]['c']

def getFirstValue(definition, name):
	return getProperty(definition, name)[0]['c']

def addListings(doc, format, meta):

    global collections, information

    if hasMeta(meta):

        listings = []

        # Loop on all listings definition
        for definition in meta['pandoc-numbering']['c']:
            if isCorrect(definition) and hasProperty(definition, 'listing', 'MetaInlines'):

                # Get the category name
                category = getFirstValue(definition, 'category')

                # Get the title
                title = getProperty(definition, 'listing')

                if format == 'latex':

                    # Special case for latex output

                    # Get the link color
                    if 'toccolor' in meta:
                        linkcolor = '\\hypersetup{linkcolor=' + stringify(meta['toccolor']['c']) + '}'
                    else:
                        linkcolor = '\\hypersetup{linkcolor=black}'

                    # Get the tab
                    if hasProperty(definition, 'tab', 'MetaString'):
                        try:
                            tab = float(getProperty(definition, 'tab'))
                        except ValueError:
                            tab = None
                    else:
                        tab = None

                    # Get the space
                    if hasProperty(definition, 'space', 'MetaString'):
                        try:
                            space = float(getProperty(definition, 'space'))
                        except ValueError:
                            space = None
                    else:
                        space = None

                    # Deal with default tab length
                    if tab == None:
                        tab = 1.5

                    # Deal with default space length
                    if space == None:
                        level = 0
                        if category in collections:
                            # Loop on the collection
                            for tag in collections[category]:
                                level = max(level, information[tag]['section'].count('.'))
                        space = level + 2.3

                    # Add a RawBlock
                    latexCategory = re.sub('[^a-z]+', '', category)
                    latex = [
                        linkcolor,
                        '\\makeatletter',
                        '\\newcommand*\\l@' + latexCategory + '{\\@dottedtocline{1}{' + str(tab) + 'em}{'+ str(space) +'em}}',
                        '\\@starttoc{' + latexCategory + '}',
                        '\\makeatother'
                    ]
                    elt = [RawBlock('tex', ''.join(latex))]
                else:
                    if category in collections:
                        # Prepare the list
                        elements = []

                        # Loop on the collection
                        for tag in collections[category]:

                            # Add an item to the list
                            text = information[tag]['toc']

                            if pandocVersion() < '1.16':
                                # pandoc 1.15
                                link = Link(text, ['#' + tag, ''])
                            else:
                                # pandoc 1.16
                                link = Link(['', [], []], text, ['#' + tag, ''])

                            elements.append([Plain([link])])

                        # Add a bullet list
                        elt = [BulletList(elements)]
                    else:

                        # Add nothing
                        elt = []

                # Add a new listing
                listings = listings + [Header(1, ['', ['unnumbered'], []], title)] + elt


        # Add listings to the document
        doc[1] = listings + doc[1]

def getFormat(category, meta):
    if not hasattr(getFormat, 'value'):
        getFormat.value = {}
        if hasMeta(meta):
            # Loop on all listings definition
            for definition in meta['pandoc-numbering']['c']:
                if isCorrect(definition) and hasProperty(definition, 'format', 'MetaBool'):
                    getFormat.value[getFirstValue(definition, 'category')] = getProperty(definition, 'format')

    if not category in getFormat.value:
        getFormat.value[category] = True

    return getFormat.value[category]

def getCiteShortCut(category, meta):
    if not hasattr(getCiteShortCut, 'value'):
        getCiteShortCut.value = {}
        if hasMeta(meta):
            # Loop on all listings definition
            for definition in meta['pandoc-numbering']['c']:
                if isCorrect(definition) and hasProperty(definition, 'cite-shortcut', 'MetaBool'):
                    getCiteShortCut.value[getFirstValue(definition, 'category')] = getProperty(definition, 'cite-shortcut')

    if not category in getCiteShortCut.value:
        getCiteShortCut.value[category] = False

    return getCiteShortCut.value[category]

def getDefaultLevels(category, meta):
    if not hasattr(getDefaultLevels, 'value'):
        getDefaultLevels.value = {}
        if hasMeta(meta):
            # Loop on all listings definition
            for definition in meta['pandoc-numbering']['c']:
                if isCorrect(definition):
                    levelInf = 0
                    levelSup = 0
                    if hasProperty(definition, 'sectioning', 'MetaInlines') and\
                       len(getProperty(definition, 'sectioning')) == 1 and\
                       getProperty(definition, 'sectioning')[0]['t'] == 'Str':

                        global headerRegex

                        match = re.match('^' + headerRegex + '$', getFirstValue(definition, 'sectioning'))
                        if match:
                            # Compute the levelInf and levelSup values
                            levelInf = len(match.group('hidden')) // 2
                            levelSup = len(match.group('header')) // 2
                    else:
                        if hasProperty(definition, 'first', 'MetaString'):
                            try:
                                levelInf = max(min(int(getProperty(definition, 'first')) - 1, 6), 0)
                            except ValueError:
                                pass
                        if hasProperty(definition, 'last', 'MetaString'):
                            try:
                                levelSup = max(min(int(getProperty(definition, 'last')), 6), levelInf)
                            except ValueError:
                                pass
                    getDefaultLevels.value[getFirstValue(definition, 'category')] = [levelInf, levelSup]

    if not category in getDefaultLevels.value:
        getDefaultLevels.value[category] = [0, 0]


    return getDefaultLevels.value[category]

def getClasses(category, meta):
    if not hasattr(getClasses, 'value'):
        getClasses.value = {}
        if hasMeta(meta):
            # Loop on all listings definition
            for definition in meta['pandoc-numbering']['c']:
                if isCorrect(definition) and hasProperty(definition, 'classes', 'MetaList'):
                    classes = []
                    for elt in getProperty(definition, 'classes'):
                        classes.append(stringify(elt))
                    getClasses.value[getFirstValue(definition, 'category')] = classes

    if not category in getClasses.value:
        getClasses.value[category] = [category]

    return getClasses.value[category]

def pandocVersion():
    if not hasattr(pandocVersion, 'value'):
        p = subprocess.Popen(['pandoc', '-v'], stdout=subprocess.PIPE,stderr=subprocess.PIPE)
        out, err = p.communicate()
        pandocVersion.value = re.search(b'pandoc (?P<version>.*)', out).group('version').decode('utf-8')
    return pandocVersion.value

def main():
    toJSONFilters([numbering, referencing])

if __name__ == '__main__':
    main()


1		#!/usr/bin/env python
2
3		"""
4		Pandoc filter to number all kinds of things.
5		"""
6
7		from pandocfilters import walk, stringify, Str, Space, Para, BulletList, Plain, Strong, Span, Link, Emph, RawInline, RawBlock, Header
8		from functools import reduce
9		import json
10		import io
11		import sys
12		import codecs
13		import re
14		import unicodedata
15		import subprocess
16
17		count = {}
18		information = {}
19		collections = {}
20		headers = [0, 0, 0, 0, 0, 0]
21		headerRegex = '(?P<header>(?P<hidden>(-\.))(\+\.))'
22
23		def toJSONFilters(actions):
24		"""Converts a list of actions into a filter that reads a JSON-formatted
25		pandoc document from stdin, transforms it by walking the tree
26		with the actions, and returns a new JSON-formatted pandoc document
27		to stdout. The argument is a list of functions action(key, value, format, meta),
28		where key is the type of the pandoc object (e.g. 'Str', 'Para'),
29		value is the contents of the object (e.g. a string for 'Str',
30		a list of inline elements for 'Para'), format is the target
31		output format (which will be taken for the first command line
32		argument if present), and meta is the document's metadata.
33		If the function returns None, the object to which it applies
34		will remain unchanged. If it returns an object, the object will
35		be replaced. If it returns a list, the list will be spliced in to
36		the list to which the target object belongs. (So, returning an
37		empty list deletes the object.)
38		"""
39		try:
40		input_stream = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8')
41		except AttributeError:
42		# Python 2 does not have sys.stdin.buffer.
43		# REF: http://stackoverflow.com/questions/2467928/python-unicodeencodeerror-when-reading-from-stdin
44		input_stream = codecs.getreader("utf-8")(sys.stdin)
45
46		doc = json.loads(input_stream.read())
47		if len(sys.argv) > 1:
48		format = sys.argv[1]
49		else:
50		format = ""
51		altered = reduce(lambda x, action: walk(x, action, format, doc[0]['unMeta']), actions, doc)
52		addListings(altered, format, altered[0]['unMeta'])
53		json.dump(altered, sys.stdout)
54
55		def removeAccents(string):
56		nfkd_form = unicodedata.normalize('NFKD', string)
57		return u"".join([c for c in nfkd_form if not unicodedata.combining(c)])
58
59		def toIdentifier(string):
60		# replace invalid characters by dash
61		string = re.sub('[^0-9a-zA-Z_-]+', '-', removeAccents(string.lower()))
62
63		# Remove leading digits
64		string = re.sub('^[^a-zA-Z]+', '', string)
65
66		return string
67
68		def toLatex(x):
69		"""Walks the tree x and returns concatenated string content,
70		leaving out all formatting.
71		"""
72		result = []
73
74		def go(key, val, format, meta):
75		if key in ['Str', 'MetaString']:
76		result.append(val)
77		elif key == 'Code':
78		result.append(val[1])
79		elif key == 'Math':
80		# Modified from the stringify function in the pandocfilter package
81		if format == 'latex':
82		result.append('$' + val[1] + '$')
83		else:
84		result.append(val[1])
85		elif key == 'LineBreak':
86		result.append(" ")
87		elif key == 'Space':
88		result.append(" ")
89		elif key == 'Note':
90		# Do not stringify value from Note node
91		del val[:]
92
93		walk(x, go, 'latex', {})
94		return ''.join(result)
95
96		def numbering(key, value, format, meta):
97		global headerRegex
98		if key == 'Header':
99		[level, [id, classes, attributes], content] = value
100		if 'unnumbered' not in classes:
101		headers[level - 1] = headers[level - 1] + 1
102		for index in range(level, 6):
103		headers[index] = 0
104		elif key == 'Para':
105		if len(value) >= 3 and value[-2] == Space() and value[-1]['t'] == 'Str':
106		last = value[-1]['c']
107
108		match = re.match('^' + headerRegex + '#((?P<prefix>[a-zA-Z][\w.-]):)?(?P<name>[a-zA-Z][\w:.-])?$', last)
109
110		if match:
111		# Is it a Para and the last element is an identifier beginning with '#'
112		global count, information, collections
113
114		# Detect the title
115		title = []
116		if value[-3]['t'] == 'Str' and value[-3]['c'][-1:] == ')':
117		for (i, item) in enumerate(value):
118		if item['t'] == 'Str' and item['c'][0] == '(':
119		title = value[i:-2]
120		title[0]['c'] = title[0]['c'][1:]
121		title[-1]['c'] = title[-1]['c'][:-1]
122		value = value[:i - 1] + value[-2:]
123		break
124
125		# Compute the description
126		description = value[:-2]
127
128		# Compute the basicCategory and the category
129		if match.group('prefix') == None:
130		basicCategory = toIdentifier(stringify(description))
131		else:
132		basicCategory = match.group('prefix')
133
134		# Compute the levelInf and levelSup values
135		levelInf = len(match.group('hidden')) // 2
136		levelSup = len(match.group('header')) // 2
137
138		# Get the default inf and sup level
139		if levelInf == 0 and levelSup == 0:
140		[levelInf, levelSup] = getDefaultLevels(basicCategory, meta)
141
142		# Compute the section number
143		sectionNumber = '.'.join(map(str, headers[:levelSup]))
144
145		# Compute the leading (composed of the section numbering and a dot)
146		if levelSup != 0:
147		leading = sectionNumber + '.'
148		else:
149		leading = ''
150
151		category = basicCategory + ':' + leading
152
153		# Is it a new category?
154		if category not in count:
155		count[category] = 0
156
157		count[category] = count[category] + 1
158
159		# Get the number
160		number = str(count[category])
161
162		# Determine the final tag
163		if match.group('name') == None:
164		tag = category + number
165		else:
166		tag = basicCategory + ':' + match.group('name')
167
168		# Replace the '-.-.+.+...#' by the category count (omitting the hidden part)
169		localNumber = '.'.join(map(str, headers[levelInf:levelSup] + [number]))
170
171		# Compute the globalNumber
172		if sectionNumber:
173		globalNumber = sectionNumber + '.' + number
174		else:
175		globalNumber = number
176
177		# Is the automatic formatting required for this category?
178		if getFormat(basicCategory, meta):
179		# Prepare the final text
180		text = [Strong(description + [Space(), Str(localNumber)])]
181
182		# Add the title to the final text
183		if title:
184		text = text + [Space(), Emph([Str('(')] + title + [Str(')')])]
185
186		# Compute the link
187		link = description + [Space(), Str(localNumber)]
188
189		# Compute the toc
190		toc = [Str(globalNumber), Space()]
191		if title:
192		toc = toc + title
193		else:
194		toc = toc + description
195
196		else:
197		# Prepare the final text
198		text = [
199		Span(['', ['description'], []], description),
200		Span(['', ['title'], []], title),
201		Span(['', ['local'], []], [Str(localNumber)]),
202		Span(['', ['global'], []], [Str(globalNumber)]),
203		Span(['', ['section'], []], [Str(sectionNumber)]),
204		]
205
206		# Compute the link
207		link = [Span(['', ['pandoc-numbering-link'] + getClasses(basicCategory, meta), []], text)]
208
209		# Compute the toc
210		toc = [Span(['', ['pandoc-numbering-toc'] + getClasses(basicCategory, meta), []], text)]
211
212
213		# Store the numbers and the label for automatic numbering (See referencing function)
214		information[tag] = {
215		'section': sectionNumber,
216		'local': localNumber,
217		'global': globalNumber,
218		'count': number,
219		'description': description,
220		'title': title,
221		'link': link,
222		'toc': toc
223		}
224
225		# Prepare the contents
226		contents = [Span([tag, ['pandoc-numbering-text'] + getClasses(basicCategory, meta), []], text)]
227
228		# Compute collections
229		if basicCategory not in collections:
230		collections[basicCategory] = []
231
232		collections[basicCategory].append(tag)
233
234		# Special case for LaTeX
235		if format == 'latex' and getFormat(basicCategory, meta):
236		latexCategory = re.sub('[^a-z]+', '', basicCategory)
237		if title:
238		entry = title
239		else:
240		entry = description
241		latex = '\\phantomsection\\addcontentsline{' + latexCategory + '}{' + latexCategory + '}{\\protect\\numberline {' + \
242		leading + number + '}{\ignorespaces ' + toLatex(entry) + '}}'
243		contents.insert(0, RawInline('tex', latex))
244
245		# Return the contents in a Para element
246		return Para(contents)
247		elif re.match('^' + headerRegex + '##(?P<prefix>[a-zA-Z][\w.-]:)?(?P<name>[a-zA-Z][\w:.-])?$', last):
248		# Special case where the last element is '...##...'
249		value[-1]['c'] = value[-1]['c'].replace('##', '#', 1)
250		return Para(value)
251
252		replace = None
253		search = None
254
255		def lowering(key, value, format, meta):
256		if key == 'Str':
257		return Str(value.lower())
258
259		def referencing(key, value, format, meta):
260		if key == 'Link':
261		return referencingLink(value, format, meta)
262		elif key == 'Cite':
263		return referencingCite(value, format, meta)
264
265		def referencingLink(value, format, meta):
266		global information, replace, search
267		if pandocVersion() < '1.16':
268		# pandoc 1.15
269		[text, [reference, title]] = value
270		else:
271		# pandoc > 1.15
272		[attributes, text, [reference, title]] = value
273
274		if re.match('^(#([a-zA-Z][\w:.-]*))$', reference):
275		# Compute the name
276		tag = reference[1:]
277
278		if tag in information:
279		if pandocVersion() < '1.16':
280		# pandoc 1.15
281		i = 0
282		else:
283		# pandoc > 1.15
284		i = 1
285
286		# Replace all '#t', '#T', '#d', '#D', '#s', '#g', '#c', '#n', '#' with the corresponding text in the title
287		value[i + 1][1] = value[i + 1][1].replace('#t', stringify(information[tag]['title']).lower())
288		value[i + 1][1] = value[i + 1][1].replace('#T', stringify(information[tag]['title']))
289		value[i + 1][1] = value[i + 1][1].replace('#d', stringify(information[tag]['description']).lower())
290		value[i + 1][1] = value[i + 1][1].replace('#D', stringify(information[tag]['description']))
291		value[i + 1][1] = value[i + 1][1].replace('#s', information[tag]['section'])
292		value[i + 1][1] = value[i + 1][1].replace('#g', information[tag]['global'])
293		value[i + 1][1] = value[i + 1][1].replace('#c', information[tag]['count'])
294		value[i + 1][1] = value[i + 1][1].replace('#n', information[tag]['local'])
295		value[i + 1][1] = value[i + 1][1].replace('#', information[tag]['local'])
296
297		if text == []:
298		# The link text is empty, replace it with the default label
299		value[i] = information[tag]['link']
300		else:
301		# The link text is not empty
302
303		#replace all '#t' with the title in lower case
304		replace = walk(information[tag]['title'], lowering, format, meta)
305		search = '#t'
306		value[i] = walk(value[i], replacing, format, meta)
307
308		#replace all '#T' with the title
309		replace = information[tag]['title']
310		search = '#T'
311		value[i] = walk(value[i], replacing, format, meta)
312
313		#replace all '#d' with the description in lower case
314		replace = walk(information[tag]['description'], lowering, format, meta)
315		search = '#d'
316		value[i] = walk(value[i], replacing, format, meta)
317
318		#replace all '#D' with the description
319		replace = information[tag]['description']
320		search = '#D'
321		value[i] = walk(value[i], replacing, format, meta)
322
323		#replace all '#s' with the corresponding number
324		replace = [Str(information[tag]['section'])]
325		search = '#s'
326		value[i] = walk(value[i], replacing, format, meta)
327
328		#replace all '#g' with the corresponding number
329		replace = [Str(information[tag]['global'])]
330		search = '#g'
331		value[i] = walk(value[i], replacing, format, meta)
332
333		#replace all '#c' with the corresponding number
334		replace = [Str(information[tag]['count'])]
335		search = '#c'
336		value[i] = walk(value[i], replacing, format, meta)
337
338		#replace all '#n' with the corresponding number
339		replace = [Str(information[tag]['local'])]
340		search = '#n'
341		value[i] = walk(value[i], replacing, format, meta)
342
343		#replace all '#' with the corresponding number
344		replace = [Str(information[tag]['local'])]
345		search = '#'
346		value[i] = walk(value[i], replacing, format, meta)
347
348		def referencingCite(value, format, meta):
349		global information
350		match = re.match('^(@(?P<tag>(?P<category>[a-zA-Z][\w.-]):(([a-zA-Z][\w.-])\|(\d(\.\d)*))))$', value[1][0]['c'])
351		if match != None and getCiteShortCut(match.group('category'), meta):
352
353		# Deal with @prefix:name shortcut
354		tag = match.group('tag')
355		if tag in information:
356		if pandocVersion() < '1.16':
357		# pandoc 1.15
358		return Link([Str(information[tag]['local'])], ['#' + tag, ''])
359		else:
360		# pandoc > 1.15
361		return Link(['', [], []], [Str(information[tag]['local'])], ['#' + tag, ''])
362
363		def replacing(key, value, format, meta):
364		global replace, search
365		if key == 'Str':
366		prepare = value.split(search)
367		if len(prepare) > 1:
368
369		ret = []
370
371		if prepare[0] != '':
372		ret.append(Str(prepare[0]))
373
374		for string in prepare[1:]:
375		ret.extend(replace)
376		if string != '':
377		ret.append(Str(string))
378
379		return ret
380
381		def hasMeta(meta):
382		return 'pandoc-numbering' in meta and meta['pandoc-numbering']['t'] == 'MetaList'
383
384		def isCorrect(definition):
385		return definition['t'] == 'MetaMap' and\
386		'category' in definition['c'] and\
387		definition['c']['category']['t'] == 'MetaInlines' and\
388		len(definition['c']['category']['c']) == 1 and\
389		definition['c']['category']['c'][0]['t'] == 'Str'
390
391		def hasProperty(definition, name, type):
392		return name in definition['c'] and definition['c'][name]['t'] == type
393
394		def getProperty(definition, name):
395		return definition['c'][name]['c']
396
397		def getFirstValue(definition, name):
398		return getProperty(definition, name)[0]['c']
399
400		def addListings(doc, format, meta):
401
402		global collections, information
403
404		if hasMeta(meta):
405
406		listings = []
407
408		# Loop on all listings definition
409		for definition in meta['pandoc-numbering']['c']:
410		if isCorrect(definition) and hasProperty(definition, 'listing', 'MetaInlines'):
411
412		# Get the category name
413		category = getFirstValue(definition, 'category')
414
415		# Get the title
416		title = getProperty(definition, 'listing')
417
418		if format == 'latex':
419
420		# Special case for latex output
421
422		# Get the link color
423		if 'toccolor' in meta:
424		linkcolor = '\\hypersetup{linkcolor=' + stringify(meta['toccolor']['c']) + '}'
425		else:
426		linkcolor = '\\hypersetup{linkcolor=black}'
427
428		# Get the tab
429		if hasProperty(definition, 'tab', 'MetaString'):
430		try:
431		tab = float(getProperty(definition, 'tab'))
432		except ValueError:
433		tab = None
434		else:
435		tab = None
436
437		# Get the space
438		if hasProperty(definition, 'space', 'MetaString'):
439		try:
440		space = float(getProperty(definition, 'space'))
441		except ValueError:
442		space = None
443		else:
444		space = None
445
446		# Deal with default tab length
447		if tab == None:
448		tab = 1.5
449
450		# Deal with default space length
451		if space == None:
452		level = 0
453		if category in collections:
454		# Loop on the collection
455		for tag in collections[category]:
456		level = max(level, information[tag]['section'].count('.'))
457		space = level + 2.3
458
459		# Add a RawBlock
460		latexCategory = re.sub('[^a-z]+', '', category)
461		latex = [
462		linkcolor,
463		'\\makeatletter',
464		'\\newcommand*\\l@' + latexCategory + '{\\@dottedtocline{1}{' + str(tab) + 'em}{'+ str(space) +'em}}',
465		'\\@starttoc{' + latexCategory + '}',
466		'\\makeatother'
467		]
468		elt = [RawBlock('tex', ''.join(latex))]
469		else:
470		if category in collections:
471		# Prepare the list
472		elements = []
473
474		# Loop on the collection
475		for tag in collections[category]:
476
477		# Add an item to the list
478		text = information[tag]['toc']
479
480		if pandocVersion() < '1.16':
481		# pandoc 1.15
482		link = Link(text, ['#' + tag, ''])
483		else:
484		# pandoc 1.16
485		link = Link(['', [], []], text, ['#' + tag, ''])
486
487		elements.append([Plain([link])])
488
489		# Add a bullet list
490		elt = [BulletList(elements)]
491		else:
492
493		# Add nothing
494		elt = []
495
496		# Add a new listing
497		listings = listings + [Header(1, ['', ['unnumbered'], []], title)] + elt
498	View Code Duplication
		0 ignored issues – show Duplication introduced 2016-06-03 18:03 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
499		# Add listings to the document
500		doc[1] = listings + doc[1]
501
502		def getFormat(category, meta):
503		if not hasattr(getFormat, 'value'):
504		getFormat.value = {}
505		if hasMeta(meta):
506		# Loop on all listings definition
507		for definition in meta['pandoc-numbering']['c']:
508		if isCorrect(definition) and hasProperty(definition, 'format', 'MetaBool'):
509		getFormat.value[getFirstValue(definition, 'category')] = getProperty(definition, 'format')
510
511		if not category in getFormat.value:
512		getFormat.value[category] = True
513
514		return getFormat.value[category]
515
516		def getCiteShortCut(category, meta):
517		if not hasattr(getCiteShortCut, 'value'):
518		getCiteShortCut.value = {}
519		if hasMeta(meta):
520		# Loop on all listings definition
521		for definition in meta['pandoc-numbering']['c']:
522		if isCorrect(definition) and hasProperty(definition, 'cite-shortcut', 'MetaBool'):
523		getCiteShortCut.value[getFirstValue(definition, 'category')] = getProperty(definition, 'cite-shortcut')
524
525		if not category in getCiteShortCut.value:
526		getCiteShortCut.value[category] = False
527
528		return getCiteShortCut.value[category]
529
530		def getDefaultLevels(category, meta):
531		if not hasattr(getDefaultLevels, 'value'):
532		getDefaultLevels.value = {}
533		if hasMeta(meta):
534		# Loop on all listings definition
535		for definition in meta['pandoc-numbering']['c']:
536		if isCorrect(definition):
537		levelInf = 0
538		levelSup = 0
539		if hasProperty(definition, 'sectioning', 'MetaInlines') and\
540		len(getProperty(definition, 'sectioning')) == 1 and\
541		getProperty(definition, 'sectioning')[0]['t'] == 'Str':
542
543		global headerRegex
544
545		match = re.match('^' + headerRegex + '$', getFirstValue(definition, 'sectioning'))
546		if match:
547		# Compute the levelInf and levelSup values
548		levelInf = len(match.group('hidden')) // 2
549		levelSup = len(match.group('header')) // 2
550		else:
551		if hasProperty(definition, 'first', 'MetaString'):
552		try:
553		levelInf = max(min(int(getProperty(definition, 'first')) - 1, 6), 0)
554		except ValueError:
555		pass
556		if hasProperty(definition, 'last', 'MetaString'):
557		try:
558		levelSup = max(min(int(getProperty(definition, 'last')), 6), levelInf)
559		except ValueError:
560		pass
561		getDefaultLevels.value[getFirstValue(definition, 'category')] = [levelInf, levelSup]
562
563		if not category in getDefaultLevels.value:
564	View Code Duplication	getDefaultLevels.value[category] = [0, 0]
		0 ignored issues – show Duplication introduced 2016-06-03 18:03 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
565
566		return getDefaultLevels.value[category]
567
568		def getClasses(category, meta):
569		if not hasattr(getClasses, 'value'):
570		getClasses.value = {}
571		if hasMeta(meta):
572		# Loop on all listings definition
573		for definition in meta['pandoc-numbering']['c']:
574		if isCorrect(definition) and hasProperty(definition, 'classes', 'MetaList'):
575		classes = []
576		for elt in getProperty(definition, 'classes'):
577		classes.append(stringify(elt))
578		getClasses.value[getFirstValue(definition, 'category')] = classes
579
580		if not category in getClasses.value:
581		getClasses.value[category] = [category]
582
583		return getClasses.value[category]
584
585		def pandocVersion():
586		if not hasattr(pandocVersion, 'value'):
587		p = subprocess.Popen(['pandoc', '-v'], stdout=subprocess.PIPE,stderr=subprocess.PIPE)
588		out, err = p.communicate()
589		pandocVersion.value = re.search(b'pandoc (?P<version>.*)', out).group('version').decode('utf-8')
590		return pandocVersion.value
591
592		def main():
593		toJSONFilters([numbering, referencing])
594
595		if __name__ == '__main__':
596		main()
597

chdemko / pandoc-numbering

Push — master ( d6b46b...4e469a )

referencingLink() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like