test_numbering_sectioning() - Code Metrics - Inspection of "Version 2.0.0" - chdemko/pandoc-numbering - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 85d380...5cc46a )

by Christophe

created 2016-06-02 14:01 UTC

test_numbering_sectioning() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	2
dl	0
loc	36
rs	8.8571

# This Python file uses the following encoding: utf-8

from unittest import TestCase
from pandocfilters import Para, Str, Space, Span, Strong, RawInline, Emph, Header

import json

import pandoc_numbering

def init():

    pandoc_numbering.count = {}
    pandoc_numbering.information = {}
    pandoc_numbering.collections = {}
    pandoc_numbering.headers = [0, 0, 0, 0, 0, 0]
    if hasattr(pandoc_numbering.getCiteShortCut, 'value'):
        delattr(pandoc_numbering.getCiteShortCut, 'value')
    if hasattr(pandoc_numbering.getDefaultLevels, 'value'):
        delattr(pandoc_numbering.getDefaultLevels, 'value')
    if hasattr(pandoc_numbering.getClasses, 'value'):
        delattr(pandoc_numbering.getClasses, 'value')
    if hasattr(pandoc_numbering.getFormat, 'value'):
        delattr(pandoc_numbering.getFormat, 'value')

def test_numbering():
    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_prefix_single():
    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'#ex:')])
    dest = Para([
        Span(
            [u'ex:1', ['pandoc-numbering-text', 'ex'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_latex():
    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        RawInline(u'tex', u'\\phantomsection\\addcontentsline{exercise}{exercise}{\\protect\\numberline {1}{\\ignorespaces Exercise}}'),
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
       )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], 'latex', {}) == dest

    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'(The'), Space(), Str(u'title)'), Space(), Str(u'#')])
    dest = Para([
        RawInline(u'tex', u'\\phantomsection\\addcontentsline{exercise}{exercise}{\\protect\\numberline {1}{\\ignorespaces The title}}'),
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')]),
                Space(),
                Emph([Str(u'('), Str(u'The'), Space(), Str(u'title'), Str(u')')])
            ]
       )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], 'latex', {}) == dest

def test_numbering_double():

    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:2', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'2')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_title():
    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'(The'), Space(), Str(u'title)'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')]),
                Space(),
                Emph([Str(u'('), Str(u'The'), Space(), Str(u'title'), Str(u')')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_level():
    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
    dest = Para([
        Span(
            [u'exercise:0.0.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'0.0.1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
    dest = Para([
        Span(
            [u'exercise:1.1.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1.1.1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
    dest = Para([
        Span(
            [u'exercise:1.1.2', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1.1.2')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
    dest = Para([
        Span(
            [u'exercise:1.2.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1.2.1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_unnumbered():

    init()

    src = Header(1, [u'unnumbered-chapter', [u'unnumbered'], []], [Str(u'Unnumbered'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Para([Str(u'Exercise'), Space(), Str(u'+.#')])
    dest = Para([
        Span(
            [u'exercise:0.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'0.1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_hidden():
    init()

    src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Para([Str(u'Exercise'), Space(), Str(u'-.#exercise:one')])
    dest = Para([
        Span(
            [u'exercise:one', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Para([Str(u'Exercise'), Space(), Str(u'-.#')])
    dest = Para([
        Span(
            [u'exercise:1.2', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'2')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    src = Para([Str(u'Exercise'), Space(), Str(u'-.#')])
    dest = Para([
        Span(
            [u'exercise:2.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Para([Str(u'Exercise'), Space(), Str(u'+.#')])
    dest = Para([
        Span(
            [u'exercise:2.2', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'2.2')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest

def test_numbering_sharp_sharp():
    init()

    src = Para([Str(u'Exercise'), Space(), Str(u'##')])
    dest = Para([Str(u'Exercise'), Space(), Str(u'#')])
    pandoc_numbering.numbering(src['t'], src['c'], '', {})

    assert src == dest

def test_numbering_sectioning_string():

    init()

    meta = {
        'pandoc-numbering': {
            't': 'MetaList',
            'c': [
                {
                    't': 'MetaMap',
                    'c': {
                        'category': {
                            't': 'MetaInlines',
                            'c': [Str('exercise')]
                        },
                        'sectioning': {
                            't': 'MetaInlines',
                            'c': [Str('-.+.')]
                        }
                    }
                }
            ]
        }
    }

    src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:2.2.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'2.1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest

def test_numbering_sectioning_map():

    init()

    meta = {
        'pandoc-numbering': {
            't': 'MetaList',
            'c': [
                {
                    't': 'MetaMap',
                    'c': {
                        'category': {
                            't': 'MetaInlines',
                            'c': [Str('exercise')]
                        },
                        'first': {
                            'c': 2,
                            't': 'MetaString'
                        },
                        'last': {
                            'c': 2,
                            't': 'MetaString'
                        }
                    }
                }
            ]
        }
    }

    src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:2.2.1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'2.1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest

def test_numbering_sectioning_map_error():

    init()

    meta = {
        'pandoc-numbering': {
            't': 'MetaList',
            'c': [
                {
                    't': 'MetaMap',
                    'c': {
                        'category': {
                            't': 'MetaInlines',
                            'c': [Str('exercise')]
                        },
                        'first': {
                            'c': 'a',
                            't': 'MetaString'
                        },
                        'last': {
                            'c': 'b',
                            't': 'MetaString'
                        }
                    }
                }
            ]
        }
    }

    src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
    pandoc_numbering.numbering(src['t'], src['c'], '', meta)

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest

def test_classes():
    init()

    meta = {
        'pandoc-numbering': {
            't': 'MetaList',
            'c': [
                {
                    't': 'MetaMap',
                    'c': {
                        'category': {
                            't': 'MetaInlines',
                            'c': [Str('exercise')]
                        },
                        'classes': {
                            't': 'MetaList',
                            'c': [{'t': 'MetaInlines', 'c': [{'t': 'Str', 'c': 'my-class'}]}]
                        }
                    }
                }
            ]
        }
    }

    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'my-class'], []],
            [
                Strong([Str(u'Exercise'), Space(), Str(u'1')])
            ]
        )
    ])

    assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest

def test_format():
    init()

    meta = {
        'pandoc-numbering': {
            't': 'MetaMap',
            'c': {
                'format': {
                    't': 'MetaMap',
                    'c': {
                        'exercise': {
                            'c': False,
                            't': 'MetaBool'
                        }
                    }
                }
            }
        }
    }
    src = Para([Str(u'Exercise'), Space(), Str(u'#')])
    dest = json.loads(json.dumps(Para([
        Span(
            [u'exercise:1', ['pandoc-numbering-text', 'exercice'], []],
            [
                Span(['', ['description'], []], [Str(u'Exercise')]),
                Span(['', ['number'], []], [Str(u'1')]),
                Span(['', ['title'], []], [])
            ]
        )
    ])))

    json.loads(json.dumps(pandoc_numbering.numbering(src['t'], src['c'], '', meta))) == dest



1		# This Python file uses the following encoding: utf-8
2
3		from unittest import TestCase
4		from pandocfilters import Para, Str, Space, Span, Strong, RawInline, Emph, Header
5
6		import json
7
8		import pandoc_numbering
9
10	View Code Duplication	def init():
		0 ignored issues – show Duplication introduced 2016-06-02 14:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
11		pandoc_numbering.count = {}
12		pandoc_numbering.information = {}
13		pandoc_numbering.collections = {}
14		pandoc_numbering.headers = [0, 0, 0, 0, 0, 0]
15		if hasattr(pandoc_numbering.getCiteShortCut, 'value'):
16		delattr(pandoc_numbering.getCiteShortCut, 'value')
17		if hasattr(pandoc_numbering.getDefaultLevels, 'value'):
18		delattr(pandoc_numbering.getDefaultLevels, 'value')
19		if hasattr(pandoc_numbering.getClasses, 'value'):
20		delattr(pandoc_numbering.getClasses, 'value')
21		if hasattr(pandoc_numbering.getFormat, 'value'):
22		delattr(pandoc_numbering.getFormat, 'value')
23
24		def test_numbering():
25		init()
26
27		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
28		dest = Para([
29		Span(
30		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
31		[
32		Strong([Str(u'Exercise'), Space(), Str(u'1')])
33		]
34		)
35		])
36
37		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
38
39		def test_numbering_prefix_single():
40		init()
41
42		src = Para([Str(u'Exercise'), Space(), Str(u'#ex:')])
43		dest = Para([
44		Span(
45		[u'ex:1', ['pandoc-numbering-text', 'ex'], []],
46		[
47		Strong([Str(u'Exercise'), Space(), Str(u'1')])
48		]
49		)
50		])
51
52		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
53
54		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
55		dest = Para([
56		Span(
57		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
58		[
59		Strong([Str(u'Exercise'), Space(), Str(u'1')])
60		]
61		)
62		])
63
64		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
65
66		def test_numbering_latex():
67		init()
68
69		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
70		dest = Para([
71		RawInline(u'tex', u'\\phantomsection\\addcontentsline{exercise}{exercise}{\\protect\\numberline {1}{\\ignorespaces Exercise}}'),
72		Span(
73		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
74		[
75		Strong([Str(u'Exercise'), Space(), Str(u'1')])
76		]
77		)
78		])
79
80		assert pandoc_numbering.numbering(src['t'], src['c'], 'latex', {}) == dest
81
82		init()
83
84		src = Para([Str(u'Exercise'), Space(), Str(u'(The'), Space(), Str(u'title)'), Space(), Str(u'#')])
85		dest = Para([
86		RawInline(u'tex', u'\\phantomsection\\addcontentsline{exercise}{exercise}{\\protect\\numberline {1}{\\ignorespaces The title}}'),
87		Span(
88		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
89		[
90		Strong([Str(u'Exercise'), Space(), Str(u'1')]),
91		Space(),
92		Emph([Str(u'('), Str(u'The'), Space(), Str(u'title'), Str(u')')])
93		]
94		)
95		])
96
97		assert pandoc_numbering.numbering(src['t'], src['c'], 'latex', {}) == dest
98
99	View Code Duplication	def test_numbering_double():
		0 ignored issues – show Duplication introduced 2016-06-02 14:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
100		init()
101
102		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
103		pandoc_numbering.numbering(src['t'], src['c'], '', {})
104
105		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
106		dest = Para([
107		Span(
108		[u'exercise:2', ['pandoc-numbering-text', 'exercise'], []],
109		[
110		Strong([Str(u'Exercise'), Space(), Str(u'2')])
111		]
112		)
113		])
114
115		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
116
117		def test_numbering_title():
118		init()
119
120		src = Para([Str(u'Exercise'), Space(), Str(u'(The'), Space(), Str(u'title)'), Space(), Str(u'#')])
121		dest = Para([
122		Span(
123		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
124		[
125		Strong([Str(u'Exercise'), Space(), Str(u'1')]),
126		Space(),
127		Emph([Str(u'('), Str(u'The'), Space(), Str(u'title'), Str(u')')])
128		]
129		)
130		])
131
132		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
133
134		def test_numbering_level():
135		init()
136
137		src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
138		dest = Para([
139		Span(
140		[u'exercise:0.0.1', ['pandoc-numbering-text', 'exercise'], []],
141		[
142		Strong([Str(u'Exercise'), Space(), Str(u'0.0.1')])
143		]
144		)
145		])
146
147		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
148
149		src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
150		pandoc_numbering.numbering(src['t'], src['c'], '', {})
151
152		src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
153		pandoc_numbering.numbering(src['t'], src['c'], '', {})
154
155		src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
156		dest = Para([
157		Span(
158		[u'exercise:1.1.1', ['pandoc-numbering-text', 'exercise'], []],
159		[
160		Strong([Str(u'Exercise'), Space(), Str(u'1.1.1')])
161		]
162		)
163		])
164
165		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
166
167		src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
168		dest = Para([
169		Span(
170		[u'exercise:1.1.2', ['pandoc-numbering-text', 'exercise'], []],
171		[
172		Strong([Str(u'Exercise'), Space(), Str(u'1.1.2')])
173		]
174		)
175		])
176
177		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
178
179		src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
180		pandoc_numbering.numbering(src['t'], src['c'], '', {})
181
182		src = Para([Str(u'Exercise'), Space(), Str(u'+.+.#')])
183		dest = Para([
184		Span(
185		[u'exercise:1.2.1', ['pandoc-numbering-text', 'exercise'], []],
186		[
187		Strong([Str(u'Exercise'), Space(), Str(u'1.2.1')])
188		]
189		)
190		])
191
192		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
193
194	View Code Duplication	def test_numbering_unnumbered():
		0 ignored issues – show Duplication introduced 2016-06-02 14:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
195		init()
196
197		src = Header(1, [u'unnumbered-chapter', [u'unnumbered'], []], [Str(u'Unnumbered'), Space(), Str('chapter')])
198		pandoc_numbering.numbering(src['t'], src['c'], '', {})
199
200		src = Para([Str(u'Exercise'), Space(), Str(u'+.#')])
201		dest = Para([
202		Span(
203		[u'exercise:0.1', ['pandoc-numbering-text', 'exercise'], []],
204		[
205		Strong([Str(u'Exercise'), Space(), Str(u'0.1')])
206		]
207		)
208		])
209
210		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
211
212		def test_numbering_hidden():
213		init()
214
215		src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
216		pandoc_numbering.numbering(src['t'], src['c'], '', {})
217
218		src = Para([Str(u'Exercise'), Space(), Str(u'-.#exercise:one')])
219		dest = Para([
220		Span(
221		[u'exercise:one', ['pandoc-numbering-text', 'exercise'], []],
222		[
223		Strong([Str(u'Exercise'), Space(), Str(u'1')])
224		]
225		)
226		])
227
228		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
229
230		src = Para([Str(u'Exercise'), Space(), Str(u'-.#')])
231		dest = Para([
232		Span(
233		[u'exercise:1.2', ['pandoc-numbering-text', 'exercise'], []],
234		[
235		Strong([Str(u'Exercise'), Space(), Str(u'2')])
236		]
237		)
238		])
239
240		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
241
242		src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
243		pandoc_numbering.numbering(src['t'], src['c'], '', {})
244
245		src = Para([Str(u'Exercise'), Space(), Str(u'-.#')])
246		dest = Para([
247		Span(
248		[u'exercise:2.1', ['pandoc-numbering-text', 'exercise'], []],
249		[
250		Strong([Str(u'Exercise'), Space(), Str(u'1')])
251		]
252		)
253		])
254
255		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
256
257		src = Para([Str(u'Exercise'), Space(), Str(u'+.#')])
258		dest = Para([
259		Span(
260		[u'exercise:2.2', ['pandoc-numbering-text', 'exercise'], []],
261		[
262		Strong([Str(u'Exercise'), Space(), Str(u'2.2')])
263		]
264		)
265		])
266
267		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
268
269		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
270		dest = Para([
271		Span(
272		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
273		[
274		Strong([Str(u'Exercise'), Space(), Str(u'1')])
275		]
276		)
277		])
278
279		assert pandoc_numbering.numbering(src['t'], src['c'], '', {}) == dest
280
281		def test_numbering_sharp_sharp():
282		init()
283
284		src = Para([Str(u'Exercise'), Space(), Str(u'##')])
285		dest = Para([Str(u'Exercise'), Space(), Str(u'#')])
286		pandoc_numbering.numbering(src['t'], src['c'], '', {})
287
288		assert src == dest
289
290	View Code Duplication	def test_numbering_sectioning_string():
		0 ignored issues – show Duplication introduced 2016-06-02 14:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
291		init()
292
293		meta = {
294		'pandoc-numbering': {
295		't': 'MetaList',
296		'c': [
297		{
298		't': 'MetaMap',
299		'c': {
300		'category': {
301		't': 'MetaInlines',
302		'c': [Str('exercise')]
303		},
304		'sectioning': {
305		't': 'MetaInlines',
306		'c': [Str('-.+.')]
307		}
308		}
309		}
310		]
311		}
312		}
313
314		src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
315		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
316
317		src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
318		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
319
320		src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
321		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
322
323		src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
324		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
325
326		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
327		dest = Para([
328		Span(
329		[u'exercise:2.2.1', ['pandoc-numbering-text', 'exercise'], []],
330		[
331		Strong([Str(u'Exercise'), Space(), Str(u'2.1')])
332		]
333		)
334		])
335
336		assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest
337
338	View Code Duplication	def test_numbering_sectioning_map():
		0 ignored issues – show Duplication introduced 2016-06-02 14:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
339		init()
340
341		meta = {
342		'pandoc-numbering': {
343		't': 'MetaList',
344		'c': [
345		{
346		't': 'MetaMap',
347		'c': {
348		'category': {
349		't': 'MetaInlines',
350		'c': [Str('exercise')]
351		},
352		'first': {
353		'c': 2,
354		't': 'MetaString'
355		},
356		'last': {
357		'c': 2,
358		't': 'MetaString'
359		}
360		}
361		}
362		]
363		}
364		}
365
366		src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
367		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
368
369		src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
370		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
371
372		src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
373		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
374
375		src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
376		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
377
378		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
379		dest = Para([
380		Span(
381		[u'exercise:2.2.1', ['pandoc-numbering-text', 'exercise'], []],
382		[
383		Strong([Str(u'Exercise'), Space(), Str(u'2.1')])
384		]
385		)
386		])
387
388		assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest
389
390	View Code Duplication	def test_numbering_sectioning_map_error():
		0 ignored issues – show Duplication introduced 2016-06-02 14:02 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
391		init()
392
393		meta = {
394		'pandoc-numbering': {
395		't': 'MetaList',
396		'c': [
397		{
398		't': 'MetaMap',
399		'c': {
400		'category': {
401		't': 'MetaInlines',
402		'c': [Str('exercise')]
403		},
404		'first': {
405		'c': 'a',
406		't': 'MetaString'
407		},
408		'last': {
409		'c': 'b',
410		't': 'MetaString'
411		}
412		}
413		}
414		]
415		}
416		}
417
418		src = Header(1, [u'first-chapter', [], []], [Str(u'First'), Space(), Str('chapter')])
419		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
420
421		src = Header(1, [u'second-chapter', [], []], [Str(u'Second'), Space(), Str('chapter')])
422		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
423
424		src = Header(2, [u'first-section', [], []], [Str(u'First'), Space(), Str('section')])
425		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
426
427		src = Header(2, [u'second-section', [], []], [Str(u'Second'), Space(), Str('section')])
428		pandoc_numbering.numbering(src['t'], src['c'], '', meta)
429
430		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
431		dest = Para([
432		Span(
433		[u'exercise:1', ['pandoc-numbering-text', 'exercise'], []],
434		[
435		Strong([Str(u'Exercise'), Space(), Str(u'1')])
436		]
437		)
438		])
439
440		assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest
441
442		def test_classes():
443		init()
444
445		meta = {
446		'pandoc-numbering': {
447		't': 'MetaList',
448		'c': [
449		{
450		't': 'MetaMap',
451		'c': {
452		'category': {
453		't': 'MetaInlines',
454		'c': [Str('exercise')]
455		},
456		'classes': {
457		't': 'MetaList',
458		'c': [{'t': 'MetaInlines', 'c': [{'t': 'Str', 'c': 'my-class'}]}]
459		}
460		}
461		}
462		]
463		}
464		}
465
466		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
467		dest = Para([
468		Span(
469		[u'exercise:1', ['pandoc-numbering-text', 'my-class'], []],
470		[
471		Strong([Str(u'Exercise'), Space(), Str(u'1')])
472		]
473		)
474		])
475
476		assert pandoc_numbering.numbering(src['t'], src['c'], '', meta) == dest
477
478		def test_format():
479		init()
480
481		meta = {
482		'pandoc-numbering': {
483		't': 'MetaMap',
484		'c': {
485		'format': {
486		't': 'MetaMap',
487		'c': {
488		'exercise': {
489		'c': False,
490		't': 'MetaBool'
491		}
492		}
493		}
494		}
495		}
496		}
497		src = Para([Str(u'Exercise'), Space(), Str(u'#')])
498		dest = json.loads(json.dumps(Para([
499		Span(
500		[u'exercise:1', ['pandoc-numbering-text', 'exercice'], []],
501		[
502		Span(['', ['description'], []], [Str(u'Exercise')]),
503		Span(['', ['number'], []], [Str(u'1')]),
504		Span(['', ['title'], []], [])
505		]
506		)
507		])))
508
509		json.loads(json.dumps(pandoc_numbering.numbering(src['t'], src['c'], '', meta))) == dest
510
511

chdemko / pandoc-numbering

Push — master ( 85d380...5cc46a )

test_numbering_sectioning() B

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like