File: scripts.py

package info (click to toggle)
npm2deb 0.2.8-5
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 252 kB
  • sloc: python: 1,694; makefile: 2
file content (324 lines) | stat: -rw-r--r-- 10,533 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
from argparse import ArgumentParser as _ArgumentParser
import os as _os
import sys as _sys

from npm2deb import Npm2Deb as _Npm2Deb
from npm2deb import utils as _utils
from npm2deb import templates as _templates
from npm2deb import helper as _helper
from npm2deb import Mapper as _Mapper
import npm2deb as _


def main(argv=None):
    # verify utf8 support
    _utils.verify_python3_env()
    if not argv:
        argv = _sys.argv
    parser = _ArgumentParser(prog='npm2deb')
    parser.add_argument('-D', '--debug', type=int, help='set debug level')
    parser.add_argument(
        '-v', '--version', action='version', version='%(prog)s ' + _.VERSION)

    subparsers = parser.add_subparsers(title='commands')

    parser_create = subparsers.add_parser(
        'create', help='create the debian files')
    parser_create.add_argument(
        '-n',
        '--noclean',
        action="store_true",
        default=False,
        help='do not remove files downloaded with npm')
    parser_create.add_argument(
        '--debhelper',
        default=_.DEBHELPER,
        help='specify debhelper version [default: %(default)s]')
    parser_create.add_argument(
        '--standards-version',
        default=_utils.get_latest_debian_standards_version(),
        help='set standards-version [default: %(default)s]')
    parser_create.add_argument(
        '--upstream-author',
        default=None,
        help='set upstream author if not automatically recognized')
    parser_create.add_argument(
        '--upstream-homepage',
        default=None,
        help='set upstream homepage if not automatically recognized')
    parser_create.add_argument(
        '--upstream-license',
        default=None,
        help='set upstream license if not automatically recognized')
    parser_create.add_argument(
        '--debian-license',
        default=None,
        help='license used for debian files [default: the same of upstream]')
    parser_create.add_argument(
        'node_module', help='node module available via npm')
    parser_create.set_defaults(func=create)

    parser_view = subparsers.add_parser(
        'view', help="a summary view of a node module")
    parser_view.add_argument(
        '-j',
        '--json',
        action="store_true",
        default=False,
        help='print verbose information in json format')
    parser_view.add_argument(
        'node_module', help='node module available via npm')
    parser_view.set_defaults(func=print_view)

    parser_depends = subparsers.add_parser(
        'depends', help='show module dependencies in npm and debian')
    parser_depends.add_argument(
        '-r',
        '--recursive',
        action="store_true",
        default=False,
        help='look for binary dependencies recursively')
    parser_depends.add_argument(
        '-f',
        '--force',
        action="store_true",
        default=False,
        help='force inspection for modules already in debian')
    parser_depends.add_argument(
        '-b',
        '--binary',
        action="store_true",
        default=False,
        help='show binary dependencies')
    parser_depends.add_argument(
        '-B',
        '--builddeb',
        action="store_true",
        default=False,
        help='show build dependencies')
    parser_depends.add_argument(
        'node_module', help='node module available via npm')
    parser_depends.set_defaults(func=show_dependencies)

    parser_rdepends = subparsers.add_parser(
        'rdepends', help='show the reverse dependencies for module')
    parser_rdepends.add_argument(
        'node_module', help='node module available via npm')
    parser_rdepends.set_defaults(func=show_reverse_dependencies)

    parser_search = subparsers.add_parser(
        'search', help="look for module in debian project")
    parser_search.add_argument(
        '-b',
        '--bug',
        action="store_true",
        default=False,
        help='search for existing bug in wnpp')
    parser_search.add_argument(
        '-d',
        '--debian',
        action="store_true",
        default=False,
        help='search for existing package in debian')
    parser_search.add_argument(
        '-r',
        '--repository',
        action="store_true",
        default=False,
        help='search for existing repository in alioth')
    parser_search.add_argument(
        'node_module', help='node module available via npm')
    parser_search.set_defaults(func=search_for_module)

    parser_itp = subparsers.add_parser('itp', help="print a itp bug template")
    parser_itp.add_argument(
        'node_module', help='node module available via npm')
    parser_itp.set_defaults(func=print_itp)

    parser_license = subparsers.add_parser(
        'license', help='print license template and exit')
    parser_license.add_argument(
        '-l',
        '--list',
        action="store_true",
        default=False,
        help='show the available licenses')
    parser_license.add_argument(
        'name', nargs='?', help='the license name to show')
    parser_license.set_defaults(func=print_license)

    if len(argv) == 1:
        parser.error("Please specify an option.")
    else:
        args = parser.parse_args(argv[1:])
        if args.debug:
            _utils.DEBUG_LEVEL = args.debug

        args.func(args)


def search_for_module(args):
    _helper.DO_PRINT = True
    # enable all by default
    if not (args.bug or args.debian or args.repository):
        args.bug = True
        args.debian = True
        args.repository = True
    node_module = get_npm2deb_instance(args).name
    if args.debian:
        print("\nLooking for similar package:")
        mapper = _Mapper.get_instance()
        pkg_info = mapper.get_debian_package(node_module)
        print("  %s (%s)" % (pkg_info['repr'], pkg_info['suite']))
    if args.repository:
        print("")
        _helper.search_for_repository(node_module)
    if args.bug:
        print("")
        _helper.search_for_bug(node_module)
    print("")

    _show_mapper_warnings()


def print_view(args):
    npm2deb_instance = get_npm2deb_instance(args)
    if args.json:
        from json import dumps
        # print a clean version of json module
        json = npm2deb_instance.json
        for key in [
                'time', 'versions', 'dist-tags', 'component', 'users', 'time',
                'maintainers', 'readmeFilename', 'contributors', 'keywords'
        ]:
            if key in json:
                del json[key]
        print(dumps(json, indent=4, sort_keys=True))

    else:
        formatted = "{0:40}{1}"
        for key in ['name', 'version', 'description', 'homepage', 'license']:
            attr_key = key
            if key == 'license' or key == 'version':
                attr_key = 'upstream_%s' % key
            print(
                formatted.format("%s:" % key.capitalize(),
                                 getattr(npm2deb_instance, attr_key, None)))

        mapper = _Mapper.get_instance()
        pkg_info = mapper.get_debian_package(npm2deb_instance.name)
        print(
            formatted.format(
                "Debian:", "%s (%s)" % (pkg_info['repr'], pkg_info['suite'])))

        if mapper.has_warnings():
            print("")
            _show_mapper_warnings()


def print_itp(args):
    print(get_npm2deb_instance(args).get_ITP())


def print_license(args, prefix=""):
    if args.list:
        licenses = sorted(_templates.LICENSES.keys())
        print("%s Available licenses are: %s." % (prefix,
                                                  ', '.join(licenses).lower()))
    else:
        if args.name is None:
            print("You have to specify a license name")
            args.list = True
            print_license(args)
        else:
            template_license = _utils.get_license(args.name)
            if not template_license.startswith('FIX_ME'):
                print(template_license)
            else:
                print("Wrong license name.")
                args.list = True
                print_license(args)


def show_dependencies(args):
    _helper.DO_PRINT = True
    # enable all by default
    if not args.binary and not args.builddeb:
        args.binary = True
        args.builddeb = True

    npm2deb_instance = get_npm2deb_instance(args)
    module_name = npm2deb_instance.name
    json = npm2deb_instance.json

    if args.binary:
        if 'dependencies' in json and json['dependencies']:
            print("Dependencies:")
            _helper.print_formatted_dependency("NPM", "Debian")
            module_ver = npm2deb_instance.upstream_version
            module_deb = _Mapper.get_instance()\
                .get_debian_package(module_name)["repr"]
            _helper.print_formatted_dependency(
                "%s (%s)" % (module_name, module_ver), module_deb)
            _helper.search_for_dependencies(npm2deb_instance, args.recursive,
                                            args.force)
            print("")
        else:
            print("Module %s has no dependencies." % module_name)

    if args.builddeb:
        if 'devDependencies' in json and json['devDependencies']:
            print("Build dependencies:")
            _helper.print_formatted_dependency("NPM", "Debian")
            _helper.search_for_builddep(npm2deb_instance)
            print("")
        else:
            print("Module %s has no build dependencies." % module_name)

    _show_mapper_warnings()


def show_reverse_dependencies(args):
    _helper.DO_PRINT = True
    node_module = get_npm2deb_instance(args).name
    _helper.search_for_reverse_dependencies(node_module)


def create(args):
    npm2deb = get_npm2deb_instance(args)
    try:
        saved_path = _os.getcwd()
        _utils.create_dir(npm2deb.name)
        _utils.change_dir(npm2deb.name)
        npm2deb.start()
        _utils.change_dir(npm2deb.debian_name)
        npm2deb.initiate_build(saved_path)

    except OSError as os_error:
        print(str(os_error))
        exit(1)

    _show_mapper_warnings()


def get_npm2deb_instance(args):
    if not args.node_module or len(args.node_module) is 0:
        print('please specify a node_module.')
        exit(1)
    try:
        return _Npm2Deb(args=vars(args))
    except ValueError as value_error:
        print(value_error)
        exit(1)


def _show_mapper_warnings():
    mapper = _Mapper.get_instance()
    if mapper.has_warnings():
        print("Warnings occurred:")
        mapper.show_warnings()
        print("")


if __name__ == '__main__':
    main()