aboutsummaryrefslogtreecommitdiff
path: root/license.py
blob: e33f06e73a305418785e3e042bd3dfeb541d964c (plain) (blame)
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
class License(object):
    def __init__(self, name):
        self.name = name

    def __iter__(self):
        yield self

    def flatten(self):
        yield self.name

    def __str__(self, depth=0):
        return self.name

    def __repr__(self):
        return '<%s %s>' % (self.__class__.__name__, self.name)

class Licenses(object):
    def __init__(self, xs):
        self.xs = xs

    def __iter__(self):
        for x in self.xs:
            yield x

    def flatten(self):
        for x in self.xs:
            for y in x.flatten():
                yield y

    def __str__(self, depth=0):
        j = ' %s ' % (self._join,)
        ss = [x.__str__(depth=depth+1) for x in self.xs]
        s = j.join(ss)

        if depth > 0:
            s = '(%s)' % s

        return s

    def __repr__(self):
        return '<%s %r>' % (self.__class__.__name__, self.xs)

class AllLicenses(Licenses):
    _join = 'and'

class AnyLicense(Licenses):
    _join = 'or'

def parse_licenses(s):
    """
    >>> ls = parse_licenses("X")
    >>> ls
    <License X>
    >>> print ls
    X
    >>> list(ls)
    [<License X>]
    >>> list(ls.flatten())
    ['X']

    >>> ls = parse_licenses("X or Y or Z")
    >>> ls
    <AnyLicense [<License X>, <License Y>, <License Z>]>
    >>> print ls
    X or Y or Z
    >>> list(ls)
    [<License X>, <License Y>, <License Z>]
    >>> list(ls.flatten())
    ['X', 'Y', 'Z']

    >>> ls = parse_licenses("X and Y and Z")
    >>> ls
    <AllLicenses [<License X>, <License Y>, <License Z>]>
    >>> print ls
    X and Y and Z
    >>> list(ls)
    [<License X>, <License Y>, <License Z>]
    >>> list(ls.flatten())
    ['X', 'Y', 'Z']

    >>> print parse_licenses("X or Y and Z")
    X or (Y and Z)

    >>> print parse_licenses("X and Y or Z")
    (X and Y) or Z

    >>> print parse_licenses("X, and Y or Z")
    X and (Y or Z)
    """

    splits = (
        (', and ', AllLicenses),
        (' or ', AnyLicense),
        (' and ', AllLicenses))

    for (split_str, cls) in splits:
        if split_str in s:
            return cls([parse_licenses(sub) for sub in s.split(split_str)])

    return License(s)