aboutsummaryrefslogtreecommitdiff
path: root/licentia/source/program/licentia/license/grant.lux
blob: 9be9208f1ee6350160adcad8afe724105864339b (plain)
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
(.using
 [library
  [lux "*"
   [data
    ["[0]" text
     ["%" format {"+" format}]]]]]
 [//
  [time {"+" Days}]
  ["_" term]
  ["[0]" definition]
  [//
   ["$" document]]])

(def: grant_header
  (format "Subject to the terms and conditions of " _.license
          ", each " _.contributor
          " hereby grants to " _.recipient))

(def: .public grant_characteristics
  (List Text)
  (list "perpetual"
        "world-wide"
        "non-exclusive"
        "no-charge"
        "royalty-free"
        "irrevocable"))

(def: .public copyright_grant_rights
  (List Text)
  (list "use"
        "reproduce"
        "display"
        "perform"
        "modify"
        (format "create an " _.extension " of")
        "sublicense"
        "distribute"))

(def: .public copyright
  ($.sentence (format grant_header " a " ($.and ..grant_characteristics)
                      " copyright license to " ($.or ..copyright_grant_rights)
                      " " _.licensed_work
                      " and such an " _.extension
                      " in a " _.source_code_form
                      " or an " _.object_form)))

(def: .public (patent retaliation?)
  (-> Bit Text)
  (let [grant (format grant_header " a " ($.and ..grant_characteristics)
                      " patent license to " ($.or definition.patent_rights) " "
                      _.licensed_work
                      ", where such license applies only to any " _.patent_claim
                      " that is necessarily infringed by their " ($.plural _.contribution)
                      " alone or by combination of their " ($.plural _.contribution)
                      " with " _.licensed_work)
        retaliation_clause (format "If " _.recipient " institutes patent litigation against any " _.legal_entity
                                   " (including a cross-claim or counterclaim in a lawsuit) alleging that "
                                   _.licensed_work " or a " _.contribution
                                   " incorporated within " _.licensed_work " constitutes direct or contributory patent infringement"
                                   ", then any patent licenses granted to " _.recipient
                                   " under " _.license
                                   " for " _.licensed_work
                                   " shall terminate as of the date such litigation is filed")]
    ($.paragraph (partial_list grant
                               (if retaliation?
                                 (list retaliation_clause)
                                 (list))))))

(def: .public date
  ($.sentence (format "The licenses granted in " _.license
                      " with respect to any " _.contribution
                      " become effective for each " _.contribution
                      " on the date the " _.contributor
                      " first distributes such " _.contribution)))

(def: restoration_scope "an ongoing basis")

(def: .public (grant_restoration_clause termination_period)
  (-> Days Text)
  (let [restoration_condition (format _.recipient " becomes compliant")
        restored_grants (format "the rights granted under " _.license
                                " from a particular " _.contributor)
        invalidation_condition (format "such " _.contributor
                                       " explicitly and finally terminates the grants to " _.recipient)
        complaint_period_condition (format "such " _.contributor
                                           " fails to notify " _.recipient
                                           " of the non-compliance by some reasonable means prior to " (%.nat termination_period)
                                           " " ($.plural "day") " after " _.recipient
                                           " has come back into compliance")]
    (format "However, if " restoration_condition ", then " restored_grants " are reinstated provisionally"
            ", unless and until " invalidation_condition
            ", and on " ..restoration_scope ", if " complaint_period_condition)))

(def: .public (grace_period_clause grace_period)
  (-> Days Text)
  (let [the_grants (format "grants to " _.recipient " from a particular " _.contributor)
        automatic_restoration_conditions (let [notification (format "such " _.contributor
                                                                    " notifies " _.recipient
                                                                    " of the non-compliance by some reasonable means")
                                               first_offense (format "this is the first time " _.recipient
                                                                     " has received notice of non-compliance with " _.license
                                                                     " from such " _.contributor)
                                               prompt_compliance (format _.recipient
                                                                         " becomes compliant prior to " (%.nat grace_period)
                                                                         " " ($.plural "day") " after reception of the notice")]
                                           ($.and (list notification
                                                        first_offense
                                                        prompt_compliance)))]
    (format "Moreover, " the_grants
            " are reinstated on " ..restoration_scope
            " if " automatic_restoration_conditions)))

(def: .public (termination termination_period grace_period)
  (-> Days Days Text)
  (let [on_violation_of_terms (let [what (format "The rights granted under " _.license)
                                    when (format _.recipient " fails to comply with any of its terms")]
                                (format what " will terminate automatically if " when))]
    ($.paragraph (list on_violation_of_terms
                       (..grant_restoration_clause termination_period)
                       (..grace_period_clause grace_period)))))

(def: .public no_retroactive_termination
  (let [situation "In the event of termination"
        coverage "all end user license agreements"
        exclusions "(excluding licenses to distributors and resellers)"
        source (format "that have been validly granted by " _.recipient " or any distributor")
        scope "hereunder prior to termination"
        effect "shall survive termination"]
    ($.paragraph (list (format situation ", " coverage " " exclusions " " source " " scope " " effect)))))