anil.recoil.org
OCaml implementation of the Mozilla Public Suffix service
cmd
+336
-119
+5
bin/dune
+5
bin/dune
+6
bin/main.ml
+6
bin/main.ml
···
1
+
(*---------------------------------------------------------------------------
2
+
Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.
3
+
SPDX-License-Identifier: ISC
4
+
---------------------------------------------------------------------------*)
5
+
6
+
let () = exit (Cmdliner.Cmd.eval Publicsuffix_cmd.default_cmd)
+11
dune-project
+11
dune-project
···
22
22
(domain-name (>= 0.4.0))
23
23
(punycode (>= 0.1.0))
24
24
(alcotest :with-test)))
25
+
26
+
(package
27
+
(name publicsuffix-cmd)
28
+
(synopsis "Command-line interface library for publicsuffix")
29
+
(description
30
+
"Provides Cmdliner terms for building command-line tools that query the Public Suffix List. Can be used to build custom CLIs that need PSL functionality.")
31
+
(depends
32
+
(ocaml (>= 4.14.0))
33
+
(dune (>= 3.0))
34
+
publicsuffix
35
+
(cmdliner (>= 1.3.0))))
+4
lib/cmd/dune
+4
lib/cmd/dune
+123
lib/cmd/publicsuffix_cmd.ml
+123
lib/cmd/publicsuffix_cmd.ml
···
1
+
(*---------------------------------------------------------------------------
2
+
Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.
3
+
SPDX-License-Identifier: ISC
4
+
---------------------------------------------------------------------------*)
5
+
6
+
open Cmdliner
7
+
8
+
let psl = lazy (Publicsuffix.create ())
9
+
10
+
let print_error e =
11
+
Printf.printf "ERROR: %s\n" (Publicsuffix.error_to_string e)
12
+
13
+
let print_result = function
14
+
| Ok s -> print_endline s
15
+
| Error e -> print_error e
16
+
17
+
let print_bool_result = function
18
+
| Ok b -> print_endline (string_of_bool b)
19
+
| Error e -> print_error e
20
+
21
+
let print_result_with_section = function
22
+
| Ok (s, sec) ->
23
+
let sec_str = match sec with
24
+
| Publicsuffix.ICANN -> "ICANN"
25
+
| Publicsuffix.Private -> "PRIVATE"
26
+
in
27
+
Printf.printf "%s (%s)\n" s sec_str
28
+
| Error e -> print_error e
29
+
30
+
(* Common arguments *)
31
+
32
+
let domain_arg =
33
+
let doc = "The domain name to query." in
34
+
Arg.(required & pos 0 (some string) None & info [] ~docv:"DOMAIN" ~doc)
35
+
36
+
(* Commands *)
37
+
38
+
let registrable_cmd =
39
+
let doc = "Get the registrable domain for a given domain" in
40
+
let info = Cmd.info "registrable" ~doc in
41
+
let term =
42
+
Term.(const (fun domain ->
43
+
print_result (Publicsuffix.registrable_domain (Lazy.force psl) domain))
44
+
$ domain_arg)
45
+
in
46
+
Cmd.v info term
47
+
48
+
let suffix_cmd =
49
+
let doc = "Get the public suffix for a given domain" in
50
+
let info = Cmd.info "suffix" ~doc in
51
+
let term =
52
+
Term.(const (fun domain ->
53
+
print_result (Publicsuffix.public_suffix (Lazy.force psl) domain))
54
+
$ domain_arg)
55
+
in
56
+
Cmd.v info term
57
+
58
+
let is_suffix_cmd =
59
+
let doc = "Check if a domain is a public suffix" in
60
+
let info = Cmd.info "is_suffix" ~doc in
61
+
let term =
62
+
Term.(const (fun domain ->
63
+
print_bool_result (Publicsuffix.is_public_suffix (Lazy.force psl) domain))
64
+
$ domain_arg)
65
+
in
66
+
Cmd.v info term
67
+
68
+
let is_registrable_cmd =
69
+
let doc = "Check if a domain is a registrable domain" in
70
+
let info = Cmd.info "is_registrable" ~doc in
71
+
let term =
72
+
Term.(const (fun domain ->
73
+
print_bool_result (Publicsuffix.is_registrable_domain (Lazy.force psl) domain))
74
+
$ domain_arg)
75
+
in
76
+
Cmd.v info term
77
+
78
+
let registrable_section_cmd =
79
+
let doc = "Get the registrable domain with section information" in
80
+
let info = Cmd.info "registrable_section" ~doc in
81
+
let term =
82
+
Term.(const (fun domain ->
83
+
print_result_with_section (Publicsuffix.registrable_domain_with_section (Lazy.force psl) domain))
84
+
$ domain_arg)
85
+
in
86
+
Cmd.v info term
87
+
88
+
let suffix_section_cmd =
89
+
let doc = "Get the public suffix with section information" in
90
+
let info = Cmd.info "suffix_section" ~doc in
91
+
let term =
92
+
Term.(const (fun domain ->
93
+
print_result_with_section (Publicsuffix.public_suffix_with_section (Lazy.force psl) domain))
94
+
$ domain_arg)
95
+
in
96
+
Cmd.v info term
97
+
98
+
let stats_cmd =
99
+
let doc = "Print statistics about the Public Suffix List" in
100
+
let info = Cmd.info "stats" ~doc in
101
+
let term =
102
+
Term.(const (fun () ->
103
+
let psl = Lazy.force psl in
104
+
Printf.printf "Total rules: %d\n" (Publicsuffix.rule_count psl);
105
+
Printf.printf "ICANN rules: %d\n" (Publicsuffix.icann_rule_count psl);
106
+
Printf.printf "Private rules: %d\n" (Publicsuffix.private_rule_count psl))
107
+
$ const ())
108
+
in
109
+
Cmd.v info term
110
+
111
+
let default_cmd =
112
+
let doc = "Query the Public Suffix List" in
113
+
let sdocs = Manpage.s_common_options in
114
+
let info = Cmd.info "publicsuffix" ~version:"%%VERSION%%" ~doc ~sdocs in
115
+
Cmd.group info [
116
+
registrable_cmd;
117
+
suffix_cmd;
118
+
is_suffix_cmd;
119
+
is_registrable_cmd;
120
+
registrable_section_cmd;
121
+
suffix_section_cmd;
122
+
stats_cmd;
123
+
]
+35
lib/cmd/publicsuffix_cmd.mli
+35
lib/cmd/publicsuffix_cmd.mli
···
1
+
(*---------------------------------------------------------------------------
2
+
Copyright (c) 2025 Anil Madhavapeddy <anil@recoil.org>. All rights reserved.
3
+
SPDX-License-Identifier: ISC
4
+
---------------------------------------------------------------------------*)
5
+
6
+
(** Command-line interface terms for the publicsuffix library.
7
+
8
+
This module provides Cmdliner terms that can be used to build
9
+
command-line tools that work with the Public Suffix List. *)
10
+
11
+
(** {1 Command terms} *)
12
+
13
+
val registrable_cmd : unit Cmdliner.Cmd.t
14
+
(** Command to get the registrable domain for a given domain. *)
15
+
16
+
val suffix_cmd : unit Cmdliner.Cmd.t
17
+
(** Command to get the public suffix for a given domain. *)
18
+
19
+
val is_suffix_cmd : unit Cmdliner.Cmd.t
20
+
(** Command to check if a domain is a public suffix. *)
21
+
22
+
val is_registrable_cmd : unit Cmdliner.Cmd.t
23
+
(** Command to check if a domain is a registrable domain. *)
24
+
25
+
val registrable_section_cmd : unit Cmdliner.Cmd.t
26
+
(** Command to get the registrable domain with section information. *)
27
+
28
+
val suffix_section_cmd : unit Cmdliner.Cmd.t
29
+
(** Command to get the public suffix with section information. *)
30
+
31
+
val stats_cmd : unit Cmdliner.Cmd.t
32
+
(** Command to print statistics about the Public Suffix List. *)
33
+
34
+
val default_cmd : unit Cmdliner.Cmd.t
35
+
(** The default command that groups all subcommands. *)
+32
publicsuffix-cmd.opam
+32
publicsuffix-cmd.opam
···
1
+
# This file is generated by dune, edit dune-project instead
2
+
opam-version: "2.0"
3
+
synopsis: "Command-line interface library for publicsuffix"
4
+
description:
5
+
"Provides Cmdliner terms for building command-line tools that query the Public Suffix List. Can be used to build custom CLIs that need PSL functionality."
6
+
maintainer: ["Anil Madhavapeddy <anil@recoil.org>"]
7
+
authors: ["Anil Madhavapeddy"]
8
+
license: "ISC"
9
+
homepage: "https://tangled.org/@anil.recoil.org/ocaml-publicsuffix"
10
+
bug-reports: "https://tangled.org/@anil.recoil.org/ocaml-publicsuffix/issues"
11
+
depends: [
12
+
"ocaml" {>= "4.14.0"}
13
+
"dune" {>= "3.18" & >= "3.0"}
14
+
"publicsuffix"
15
+
"cmdliner" {>= "1.3.0"}
16
+
"odoc" {with-doc}
17
+
]
18
+
build: [
19
+
["dune" "subst"] {dev}
20
+
[
21
+
"dune"
22
+
"build"
23
+
"-p"
24
+
name
25
+
"-j"
26
+
jobs
27
+
"@install"
28
+
"@runtest" {with-test}
29
+
"@doc" {with-doc}
30
+
]
31
+
]
32
+
x-maintenance-intent: ["(latest)"]
+2
-1
test/dune
+2
-1
test/dune
+118
-118
test/publicsuffix.t
+118
-118
test/publicsuffix.t
···
11
11
Basic Statistics
12
12
----------------
13
13
14
-
$ psl_test stats
14
+
$ publicsuffix stats
15
15
Total rules: 10064
16
16
ICANN rules: 6930
17
17
Private rules: 3134
···
19
19
Null Input (Empty Domain)
20
20
-------------------------
21
21
22
-
$ psl_test registrable ""
22
+
$ publicsuffix registrable ""
23
23
ERROR: Empty domain
24
24
25
25
Mixed Case Tests
26
26
----------------
27
27
28
-
$ psl_test registrable "COM"
28
+
$ publicsuffix registrable "COM"
29
29
ERROR: Domain is itself a public suffix
30
30
31
-
$ psl_test registrable "example.COM"
31
+
$ publicsuffix registrable "example.COM"
32
32
example.com
33
33
34
-
$ psl_test registrable "WwW.example.COM"
34
+
$ publicsuffix registrable "WwW.example.COM"
35
35
example.com
36
36
37
37
Leading Dot Tests
38
38
-----------------
39
39
40
-
$ psl_test registrable ".com"
40
+
$ publicsuffix registrable ".com"
41
41
ERROR: Domain has a leading dot
42
42
43
-
$ psl_test registrable ".example"
43
+
$ publicsuffix registrable ".example"
44
44
ERROR: Domain has a leading dot
45
45
46
-
$ psl_test registrable ".example.com"
46
+
$ publicsuffix registrable ".example.com"
47
47
ERROR: Domain has a leading dot
48
48
49
-
$ psl_test registrable ".example.example"
49
+
$ publicsuffix registrable ".example.example"
50
50
ERROR: Domain has a leading dot
51
51
52
52
Unlisted TLD (Implicit * Rule)
···
55
55
Per the algorithm, if no rules match, the implicit * rule applies.
56
56
For an unlisted TLD like "example", the TLD itself is the suffix.
57
57
58
-
$ psl_test registrable "example"
58
+
$ publicsuffix registrable "example"
59
59
ERROR: Domain is itself a public suffix
60
60
61
-
$ psl_test registrable "example.example"
61
+
$ publicsuffix registrable "example.example"
62
62
example.example
63
63
64
-
$ psl_test registrable "b.example.example"
64
+
$ publicsuffix registrable "b.example.example"
65
65
example.example
66
66
67
-
$ psl_test registrable "a.b.example.example"
67
+
$ publicsuffix registrable "a.b.example.example"
68
68
example.example
69
69
70
70
TLD Listed With No Subdomains (.biz)
71
71
------------------------------------
72
72
73
-
$ psl_test registrable "biz"
73
+
$ publicsuffix registrable "biz"
74
74
ERROR: Domain is itself a public suffix
75
75
76
-
$ psl_test registrable "domain.biz"
76
+
$ publicsuffix registrable "domain.biz"
77
77
domain.biz
78
78
79
-
$ psl_test registrable "b.domain.biz"
79
+
$ publicsuffix registrable "b.domain.biz"
80
80
domain.biz
81
81
82
-
$ psl_test registrable "a.b.domain.biz"
82
+
$ publicsuffix registrable "a.b.domain.biz"
83
83
domain.biz
84
84
85
85
TLD Listed With Subdomains (.com)
86
86
---------------------------------
87
87
88
-
$ psl_test registrable "com"
88
+
$ publicsuffix registrable "com"
89
89
ERROR: Domain is itself a public suffix
90
90
91
-
$ psl_test registrable "example.com"
91
+
$ publicsuffix registrable "example.com"
92
92
example.com
93
93
94
-
$ psl_test registrable "b.example.com"
94
+
$ publicsuffix registrable "b.example.com"
95
95
example.com
96
96
97
-
$ psl_test registrable "a.b.example.com"
97
+
$ publicsuffix registrable "a.b.example.com"
98
98
example.com
99
99
100
100
Second-Level Domain (.uk.com)
101
101
-----------------------------
102
102
103
-
$ psl_test registrable "uk.com"
103
+
$ publicsuffix registrable "uk.com"
104
104
ERROR: Domain is itself a public suffix
105
105
106
-
$ psl_test registrable "example.uk.com"
106
+
$ publicsuffix registrable "example.uk.com"
107
107
example.uk.com
108
108
109
-
$ psl_test registrable "b.example.uk.com"
109
+
$ publicsuffix registrable "b.example.uk.com"
110
110
example.uk.com
111
111
112
-
$ psl_test registrable "a.b.example.uk.com"
112
+
$ publicsuffix registrable "a.b.example.uk.com"
113
113
example.uk.com
114
114
115
115
TLD with Single Character (.ac)
116
116
-------------------------------
117
117
118
-
$ psl_test registrable "test.ac"
118
+
$ publicsuffix registrable "test.ac"
119
119
test.ac
120
120
121
121
Wildcard TLD (.mm has *.mm rule, so c.mm is a suffix)
122
122
-----------------------------------------------------
123
123
124
-
$ psl_test registrable "mm"
124
+
$ publicsuffix registrable "mm"
125
125
ERROR: Domain is itself a public suffix
126
126
127
-
$ psl_test registrable "c.mm"
127
+
$ publicsuffix registrable "c.mm"
128
128
ERROR: Domain is itself a public suffix
129
129
130
-
$ psl_test registrable "b.c.mm"
130
+
$ publicsuffix registrable "b.c.mm"
131
131
b.c.mm
132
132
133
-
$ psl_test registrable "a.b.c.mm"
133
+
$ publicsuffix registrable "a.b.c.mm"
134
134
b.c.mm
135
135
136
136
Japan Tests (.jp)
···
138
138
139
139
More complex TLD with multiple levels:
140
140
141
-
$ psl_test registrable "jp"
141
+
$ publicsuffix registrable "jp"
142
142
ERROR: Domain is itself a public suffix
143
143
144
-
$ psl_test registrable "test.jp"
144
+
$ publicsuffix registrable "test.jp"
145
145
test.jp
146
146
147
-
$ psl_test registrable "www.test.jp"
147
+
$ publicsuffix registrable "www.test.jp"
148
148
test.jp
149
149
150
150
Second-level suffix under .jp:
151
151
152
-
$ psl_test registrable "ac.jp"
152
+
$ publicsuffix registrable "ac.jp"
153
153
ERROR: Domain is itself a public suffix
154
154
155
-
$ psl_test registrable "test.ac.jp"
155
+
$ publicsuffix registrable "test.ac.jp"
156
156
test.ac.jp
157
157
158
-
$ psl_test registrable "www.test.ac.jp"
158
+
$ publicsuffix registrable "www.test.ac.jp"
159
159
test.ac.jp
160
160
161
161
Kyoto has a rule, so kyoto.jp is a suffix:
162
162
163
-
$ psl_test registrable "kyoto.jp"
163
+
$ publicsuffix registrable "kyoto.jp"
164
164
ERROR: Domain is itself a public suffix
165
165
166
-
$ psl_test registrable "test.kyoto.jp"
166
+
$ publicsuffix registrable "test.kyoto.jp"
167
167
test.kyoto.jp
168
168
169
169
ide.kyoto.jp has *.ide.kyoto.jp rule (wildcard):
170
170
171
-
$ psl_test registrable "ide.kyoto.jp"
171
+
$ publicsuffix registrable "ide.kyoto.jp"
172
172
ERROR: Domain is itself a public suffix
173
173
174
-
$ psl_test registrable "b.ide.kyoto.jp"
174
+
$ publicsuffix registrable "b.ide.kyoto.jp"
175
175
b.ide.kyoto.jp
176
176
177
-
$ psl_test registrable "a.b.ide.kyoto.jp"
177
+
$ publicsuffix registrable "a.b.ide.kyoto.jp"
178
178
b.ide.kyoto.jp
179
179
180
180
Kobe has *.kobe.jp wildcard but !city.kobe.jp exception:
181
181
182
-
$ psl_test registrable "c.kobe.jp"
182
+
$ publicsuffix registrable "c.kobe.jp"
183
183
ERROR: Domain is itself a public suffix
184
184
185
-
$ psl_test registrable "b.c.kobe.jp"
185
+
$ publicsuffix registrable "b.c.kobe.jp"
186
186
b.c.kobe.jp
187
187
188
-
$ psl_test registrable "a.b.c.kobe.jp"
188
+
$ publicsuffix registrable "a.b.c.kobe.jp"
189
189
b.c.kobe.jp
190
190
191
191
Exception rule: city.kobe.jp is registrable despite *.kobe.jp:
192
192
193
-
$ psl_test registrable "city.kobe.jp"
193
+
$ publicsuffix registrable "city.kobe.jp"
194
194
city.kobe.jp
195
195
196
-
$ psl_test registrable "www.city.kobe.jp"
196
+
$ publicsuffix registrable "www.city.kobe.jp"
197
197
city.kobe.jp
198
198
199
199
Cook Islands Tests (.ck with !www.ck exception)
···
201
201
202
202
.ck has *.ck wildcard rule and !www.ck exception:
203
203
204
-
$ psl_test registrable "ck"
204
+
$ publicsuffix registrable "ck"
205
205
ERROR: Domain is itself a public suffix
206
206
207
-
$ psl_test registrable "test.ck"
207
+
$ publicsuffix registrable "test.ck"
208
208
ERROR: Domain is itself a public suffix
209
209
210
-
$ psl_test registrable "b.test.ck"
210
+
$ publicsuffix registrable "b.test.ck"
211
211
b.test.ck
212
212
213
-
$ psl_test registrable "a.b.test.ck"
213
+
$ publicsuffix registrable "a.b.test.ck"
214
214
b.test.ck
215
215
216
216
Exception: www.ck is registrable:
217
217
218
-
$ psl_test registrable "www.ck"
218
+
$ publicsuffix registrable "www.ck"
219
219
www.ck
220
220
221
-
$ psl_test registrable "www.www.ck"
221
+
$ publicsuffix registrable "www.www.ck"
222
222
www.ck
223
223
224
224
United States Tests (.us)
225
225
-------------------------
226
226
227
-
$ psl_test registrable "us"
227
+
$ publicsuffix registrable "us"
228
228
ERROR: Domain is itself a public suffix
229
229
230
-
$ psl_test registrable "test.us"
230
+
$ publicsuffix registrable "test.us"
231
231
test.us
232
232
233
-
$ psl_test registrable "www.test.us"
233
+
$ publicsuffix registrable "www.test.us"
234
234
test.us
235
235
236
236
State subdivision (.ak.us):
237
237
238
-
$ psl_test registrable "ak.us"
238
+
$ publicsuffix registrable "ak.us"
239
239
ERROR: Domain is itself a public suffix
240
240
241
-
$ psl_test registrable "test.ak.us"
241
+
$ publicsuffix registrable "test.ak.us"
242
242
test.ak.us
243
243
244
-
$ psl_test registrable "www.test.ak.us"
244
+
$ publicsuffix registrable "www.test.ak.us"
245
245
test.ak.us
246
246
247
247
Deep subdivision (.k12.ak.us):
248
248
249
-
$ psl_test registrable "k12.ak.us"
249
+
$ publicsuffix registrable "k12.ak.us"
250
250
ERROR: Domain is itself a public suffix
251
251
252
-
$ psl_test registrable "test.k12.ak.us"
252
+
$ publicsuffix registrable "test.k12.ak.us"
253
253
test.k12.ak.us
254
254
255
-
$ psl_test registrable "www.test.k12.ak.us"
255
+
$ publicsuffix registrable "www.test.k12.ak.us"
256
256
test.k12.ak.us
257
257
258
258
Internationalized Domain Names (IDN) - Chinese
···
262
262
食狮 = "food lion" in Chinese
263
263
公司 = "company" in Chinese
264
264
265
-
$ psl_test registrable "食狮.com.cn"
265
+
$ publicsuffix registrable "食狮.com.cn"
266
266
xn--85x722f.com.cn
267
267
268
-
$ psl_test registrable "食狮.公司.cn"
268
+
$ publicsuffix registrable "食狮.公司.cn"
269
269
xn--85x722f.xn--55qx5d.cn
270
270
271
-
$ psl_test registrable "www.食狮.公司.cn"
271
+
$ publicsuffix registrable "www.食狮.公司.cn"
272
272
xn--85x722f.xn--55qx5d.cn
273
273
274
-
$ psl_test registrable "shishi.公司.cn"
274
+
$ publicsuffix registrable "shishi.公司.cn"
275
275
shishi.xn--55qx5d.cn
276
276
277
-
$ psl_test registrable "公司.cn"
277
+
$ publicsuffix registrable "公司.cn"
278
278
ERROR: Domain is itself a public suffix
279
279
280
280
IDN TLD (中国 = China):
281
281
282
-
$ psl_test registrable "食狮.中国"
282
+
$ publicsuffix registrable "食狮.中国"
283
283
xn--85x722f.xn--fiqs8s
284
284
285
-
$ psl_test registrable "www.食狮.中国"
285
+
$ publicsuffix registrable "www.食狮.中国"
286
286
xn--85x722f.xn--fiqs8s
287
287
288
-
$ psl_test registrable "shishi.中国"
288
+
$ publicsuffix registrable "shishi.中国"
289
289
shishi.xn--fiqs8s
290
290
291
-
$ psl_test registrable "中国"
291
+
$ publicsuffix registrable "中国"
292
292
ERROR: Domain is itself a public suffix
293
293
294
294
Punycode Input (Same as Above in ASCII)
295
295
---------------------------------------
296
296
297
-
$ psl_test registrable "xn--85x722f.com.cn"
297
+
$ publicsuffix registrable "xn--85x722f.com.cn"
298
298
xn--85x722f.com.cn
299
299
300
-
$ psl_test registrable "xn--85x722f.xn--55qx5d.cn"
300
+
$ publicsuffix registrable "xn--85x722f.xn--55qx5d.cn"
301
301
xn--85x722f.xn--55qx5d.cn
302
302
303
-
$ psl_test registrable "www.xn--85x722f.xn--55qx5d.cn"
303
+
$ publicsuffix registrable "www.xn--85x722f.xn--55qx5d.cn"
304
304
xn--85x722f.xn--55qx5d.cn
305
305
306
-
$ psl_test registrable "shishi.xn--55qx5d.cn"
306
+
$ publicsuffix registrable "shishi.xn--55qx5d.cn"
307
307
shishi.xn--55qx5d.cn
308
308
309
-
$ psl_test registrable "xn--55qx5d.cn"
309
+
$ publicsuffix registrable "xn--55qx5d.cn"
310
310
ERROR: Domain is itself a public suffix
311
311
312
-
$ psl_test registrable "xn--85x722f.xn--fiqs8s"
312
+
$ publicsuffix registrable "xn--85x722f.xn--fiqs8s"
313
313
xn--85x722f.xn--fiqs8s
314
314
315
-
$ psl_test registrable "www.xn--85x722f.xn--fiqs8s"
315
+
$ publicsuffix registrable "www.xn--85x722f.xn--fiqs8s"
316
316
xn--85x722f.xn--fiqs8s
317
317
318
-
$ psl_test registrable "shishi.xn--fiqs8s"
318
+
$ publicsuffix registrable "shishi.xn--fiqs8s"
319
319
shishi.xn--fiqs8s
320
320
321
-
$ psl_test registrable "xn--fiqs8s"
321
+
$ publicsuffix registrable "xn--fiqs8s"
322
322
ERROR: Domain is itself a public suffix
323
323
324
324
Public Suffix Tests
···
326
326
327
327
Test the public_suffix function directly:
328
328
329
-
$ psl_test suffix "www.example.com"
329
+
$ publicsuffix suffix "www.example.com"
330
330
com
331
331
332
-
$ psl_test suffix "www.example.co.uk"
332
+
$ publicsuffix suffix "www.example.co.uk"
333
333
co.uk
334
334
335
-
$ psl_test suffix "example.com"
335
+
$ publicsuffix suffix "example.com"
336
336
com
337
337
338
-
$ psl_test suffix "com"
338
+
$ publicsuffix suffix "com"
339
339
com
340
340
341
-
$ psl_test suffix "b.ide.kyoto.jp"
341
+
$ publicsuffix suffix "b.ide.kyoto.jp"
342
342
ide.kyoto.jp
343
343
344
-
$ psl_test suffix "city.kobe.jp"
344
+
$ publicsuffix suffix "city.kobe.jp"
345
345
kobe.jp
346
346
347
-
$ psl_test suffix "www.ck"
347
+
$ publicsuffix suffix "www.ck"
348
348
ck
349
349
350
350
is_public_suffix Tests
351
351
----------------------
352
352
353
-
$ psl_test is_suffix "com"
353
+
$ publicsuffix is_suffix "com"
354
354
true
355
355
356
-
$ psl_test is_suffix "example.com"
356
+
$ publicsuffix is_suffix "example.com"
357
357
false
358
358
359
-
$ psl_test is_suffix "co.uk"
359
+
$ publicsuffix is_suffix "co.uk"
360
360
true
361
361
362
-
$ psl_test is_suffix "example.co.uk"
362
+
$ publicsuffix is_suffix "example.co.uk"
363
363
false
364
364
365
-
$ psl_test is_suffix "test.ck"
365
+
$ publicsuffix is_suffix "test.ck"
366
366
true
367
367
368
-
$ psl_test is_suffix "www.ck"
368
+
$ publicsuffix is_suffix "www.ck"
369
369
false
370
370
371
-
$ psl_test is_suffix "city.kobe.jp"
371
+
$ publicsuffix is_suffix "city.kobe.jp"
372
372
false
373
373
374
-
$ psl_test is_suffix "ide.kyoto.jp"
374
+
$ publicsuffix is_suffix "ide.kyoto.jp"
375
375
true
376
376
377
377
is_registrable_domain Tests
378
378
---------------------------
379
379
380
-
$ psl_test is_registrable "example.com"
380
+
$ publicsuffix is_registrable "example.com"
381
381
true
382
382
383
-
$ psl_test is_registrable "www.example.com"
383
+
$ publicsuffix is_registrable "www.example.com"
384
384
false
385
385
386
-
$ psl_test is_registrable "com"
386
+
$ publicsuffix is_registrable "com"
387
387
false
388
388
389
-
$ psl_test is_registrable "city.kobe.jp"
389
+
$ publicsuffix is_registrable "city.kobe.jp"
390
390
true
391
391
392
-
$ psl_test is_registrable "www.city.kobe.jp"
392
+
$ publicsuffix is_registrable "www.city.kobe.jp"
393
393
false
394
394
395
395
Section Information Tests
···
397
397
398
398
Test that ICANN vs Private section is correctly reported:
399
399
400
-
$ psl_test suffix_section "example.com"
400
+
$ publicsuffix suffix_section "example.com"
401
401
com (ICANN)
402
402
403
-
$ psl_test suffix_section "example.co.uk"
403
+
$ publicsuffix suffix_section "example.co.uk"
404
404
co.uk (ICANN)
405
405
406
406
Blogspot.com is in the PRIVATE section:
407
407
408
-
$ psl_test suffix_section "example.blogspot.com"
408
+
$ publicsuffix suffix_section "example.blogspot.com"
409
409
blogspot.com (PRIVATE)
410
410
411
-
$ psl_test registrable_section "www.example.blogspot.com"
411
+
$ publicsuffix registrable_section "www.example.blogspot.com"
412
412
example.blogspot.com (PRIVATE)
413
413
414
414
GitHub.io is in the PRIVATE section:
415
415
416
-
$ psl_test suffix_section "example.github.io"
416
+
$ publicsuffix suffix_section "example.github.io"
417
417
github.io (PRIVATE)
418
418
419
-
$ psl_test registrable_section "myproject.github.io"
419
+
$ publicsuffix registrable_section "myproject.github.io"
420
420
myproject.github.io (PRIVATE)
421
421
422
422
Trailing Dot Tests (FQDN)
···
424
424
425
425
Per the wiki, trailing dots should be preserved:
426
426
427
-
$ psl_test suffix "example.com."
427
+
$ publicsuffix suffix "example.com."
428
428
com.
429
429
430
-
$ psl_test suffix "example.com"
430
+
$ publicsuffix suffix "example.com"
431
431
com
432
432
433
-
$ psl_test registrable "www.example.com."
433
+
$ publicsuffix registrable "www.example.com."
434
434
example.com.
435
435
436
-
$ psl_test registrable "www.example.com"
436
+
$ publicsuffix registrable "www.example.com"
437
437
example.com
438
438
439
439
Edge Cases from Wiki Examples
···
443
443
444
444
Rule 1 (com): Cookies MAY be set for foo.com
445
445
446
-
$ psl_test registrable "foo.com"
446
+
$ publicsuffix registrable "foo.com"
447
447
foo.com
448
448
449
449
Rule 2 (*.foo.com): This isn't in the real PSL, but we test similar patterns
450
450
with *.ck:
451
451
452
-
$ psl_test is_suffix "bar.ck"
452
+
$ publicsuffix is_suffix "bar.ck"
453
453
true
454
454
455
455
Rule 3 (*.jp): bar.jp is a suffix
456
456
457
-
$ psl_test is_suffix "bar.jp"
457
+
$ publicsuffix is_suffix "bar.jp"
458
458
false
459
459
460
460
Rule 4: Note that *.hokkaido.jp is not in the actual PSL - only specific
461
461
city subdomains are listed. So bar.hokkaido.jp follows hokkaido.jp rule.
462
462
463
-
$ psl_test is_suffix "bar.hokkaido.jp"
463
+
$ publicsuffix is_suffix "bar.hokkaido.jp"
464
464
false
465
465
466
-
$ psl_test registrable "foo.bar.hokkaido.jp"
466
+
$ publicsuffix registrable "foo.bar.hokkaido.jp"
467
467
bar.hokkaido.jp
468
468
469
-
$ psl_test is_suffix "abashiri.hokkaido.jp"
469
+
$ publicsuffix is_suffix "abashiri.hokkaido.jp"
470
470
true
471
471
472
-
$ psl_test registrable "foo.abashiri.hokkaido.jp"
472
+
$ publicsuffix registrable "foo.abashiri.hokkaido.jp"
473
473
foo.abashiri.hokkaido.jp
474
474
475
475
Rule 6 (!pref.hokkaido.jp): pref.hokkaido.jp is registrable (exception)
476
476
477
-
$ psl_test registrable "pref.hokkaido.jp"
477
+
$ publicsuffix registrable "pref.hokkaido.jp"
478
478
pref.hokkaido.jp
479
479
480
-
$ psl_test is_suffix "pref.hokkaido.jp"
480
+
$ publicsuffix is_suffix "pref.hokkaido.jp"
481
481
false