|
1
|
#!/usr/bin/env python
|
|
2
|
# Translates a data dictionary spreadsheet to Redmine formatting
|
|
3
|
|
|
4
|
import csv
|
|
5
|
import re
|
|
6
|
import sys
|
|
7
|
|
|
8
|
# Spreadsheet format
|
|
9
|
source_sep = ', '
|
|
10
|
|
|
11
|
##### URLs
|
|
12
|
|
|
13
|
url_comment_re = r'(?:\([^)]*\))'
|
|
14
|
|
|
15
|
def simplify_url(url): return re.sub(r'\(.*?\)', r'', url)
|
|
16
|
|
|
17
|
def url_comment_text(comment):
|
|
18
|
if not comment: return comment
|
|
19
|
|
|
20
|
match = re.match(r'^\(\d*:?(.*?)\)$', comment)
|
|
21
|
assert match
|
|
22
|
text, = match.groups()
|
|
23
|
return text
|
|
24
|
|
|
25
|
def url_term(url):
|
|
26
|
'''Prefixes any provider in the URL to the term name, to create a namespace.
|
|
27
|
Each hierarchical component of the provider is stored in a URL comment.
|
|
28
|
'''
|
|
29
|
match = re.match(r'^('+url_comment_re+r'*).*?([\w:-]+)$', url)
|
|
30
|
assert match
|
|
31
|
provider_str, term = match.groups()
|
|
32
|
provider = filter(bool, map(url_comment_text,
|
|
33
|
re.findall(url_comment_re, provider_str)))
|
|
34
|
|
|
35
|
return ':'.join(provider+[term])
|
|
36
|
|
|
37
|
##### Redmine
|
|
38
|
|
|
39
|
sp = ' ' # Unicode thin space
|
|
40
|
|
|
41
|
def redmine_esc(text): return '<notextile>'+text+'</notextile>'
|
|
42
|
|
|
43
|
def redmine_bold(text): return '*'+text+'*'
|
|
44
|
|
|
45
|
def redmine_pad(text): return sp+text+sp
|
|
46
|
|
|
47
|
def redmine_link(text, url):
|
|
48
|
if not url: return text
|
|
49
|
elif url.find('://') >= 0: return '"'+text+'":'+url # external link
|
|
50
|
else: return '[['+url+'|'+text+']]' # internal link
|
|
51
|
|
|
52
|
def source2redmine_link(url):
|
|
53
|
if url: return redmine_link(url_term(url), simplify_url(url))
|
|
54
|
else: return ''
|
|
55
|
|
|
56
|
def redmine_add_links(page_name, text):
|
|
57
|
# Link citations to entry in sources list
|
|
58
|
text = re.sub(r'(?<!\[)\[([^\[\]]*)\](?!\])',
|
|
59
|
redmine_bold(redmine_link(r'(\1)', page_name+r'#\1')), text)
|
|
60
|
return text
|
|
61
|
|
|
62
|
redmine_table_sep = '|'
|
|
63
|
redmine_table_sep_esc = redmine_esc(redmine_table_sep)
|
|
64
|
|
|
65
|
def redmine_table_esc(text):
|
|
66
|
text = text.replace(redmine_table_sep, redmine_table_sep_esc)
|
|
67
|
return text
|
|
68
|
|
|
69
|
class RedmineTableWriter:
|
|
70
|
'''Formats rows as a Redmine table'''
|
|
71
|
|
|
72
|
def __init__(self, stream):
|
|
73
|
self.stream = stream
|
|
74
|
|
|
75
|
def writerow(self, row):
|
|
76
|
row = map(redmine_table_esc, row)
|
|
77
|
self.stream.write(('|'.join(['']+row+['']))+'\n')
|
|
78
|
|
|
79
|
class RedmineDictWriter:
|
|
80
|
'''Formats rows as Redmine sections containing a table'''
|
|
81
|
|
|
82
|
def __init__(self, term_col, def_col, header, stream):
|
|
83
|
self.term_col = term_col
|
|
84
|
self.def_col = def_col
|
|
85
|
self.header = header
|
|
86
|
self.page_name = header[term_col]
|
|
87
|
self.stream = stream
|
|
88
|
|
|
89
|
def writerow(self, row):
|
|
90
|
row = map(lambda f: redmine_add_links(self.page_name, f), row)
|
|
91
|
|
|
92
|
term = row[self.term_col]
|
|
93
|
def_ = row[self.def_col]
|
|
94
|
self.stream.write('h2. '+term+'\n\n')
|
|
95
|
if def_: self.stream.write(def_+'\n\n')
|
|
96
|
|
|
97
|
table = RedmineTableWriter(self.stream)
|
|
98
|
for i, col_name in enumerate(self.header):
|
|
99
|
if not i in set([self.term_col, self.def_col]):
|
|
100
|
value = row[i]
|
|
101
|
if value: table.writerow([redmine_bold(col_name), value])
|
|
102
|
self.stream.write('\n')
|
|
103
|
|
|
104
|
|
|
105
|
def main():
|
|
106
|
try: _prog_name, term_col, def_col, sources_col = sys.argv
|
|
107
|
except ValueError: raise SystemExit('Usage: '+sys.argv[0]
|
|
108
|
+' <spreadsheet term_col# definition_col# sources_col# >redmine')
|
|
109
|
term_col, def_col, sources_col = map(int, [term_col, def_col, sources_col])
|
|
110
|
|
|
111
|
# Translate input
|
|
112
|
reader = csv.reader(sys.stdin)
|
|
113
|
header = reader.next()
|
|
114
|
page_name = header[term_col]
|
|
115
|
writer = RedmineDictWriter(term_col, def_col, header, sys.stdout)
|
|
116
|
for row in reader:
|
|
117
|
term = row[term_col]
|
|
118
|
sources = row[sources_col].split(source_sep)
|
|
119
|
|
|
120
|
row[term_col] = redmine_link(term, page_name+'#'+term)
|
|
121
|
row[sources_col] = source_sep.join(map(source2redmine_link, sources))
|
|
122
|
|
|
123
|
writer.writerow(row)
|
|
124
|
|
|
125
|
main()
|
