prosody
6ac5ad578565
util/datamapper.lua

Find changesets by keywords by author, files, the commit message, revision number or hash, or revset expression.

Software / code / prosody

Annotate

util/datamapper.lua @ 13265:6ac5ad578565

mod_cron: Load last task run time inside task runner to fix async This ensures that all interactions with storage happen inside an async thread, allowing async waiting to be performed in storage drivers.
author Kim Alvefur <zash@zash.se>
date Sat, 14 Oct 2023 22:32:33 +0200
parent 12975:d10957394a3c
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
1 -- This file is generated from teal-src/util/datamapper.lua
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
2
12782
8815d3090928 util.mathcompat: Module to ease reuse of math.type()
Kim Alvefur <zash@zash.se>
parents: 12580
diff changeset
3 if not math.type then
12975
d10957394a3c util: Prefix module imports with prosody namespace
Kim Alvefur <zash@zash.se>
parents: 12782
diff changeset
4 require("prosody.util.mathcompat")
12782
8815d3090928 util.mathcompat: Module to ease reuse of math.type()
Kim Alvefur <zash@zash.se>
parents: 12580
diff changeset
5 end
8815d3090928 util.mathcompat: Module to ease reuse of math.type()
Kim Alvefur <zash@zash.se>
parents: 12580
diff changeset
6
12975
d10957394a3c util: Prefix module imports with prosody namespace
Kim Alvefur <zash@zash.se>
parents: 12782
diff changeset
7 local st = require("prosody.util.stanza");
d10957394a3c util: Prefix module imports with prosody namespace
Kim Alvefur <zash@zash.se>
parents: 12782
diff changeset
8 local pointer = require("prosody.util.jsonpointer");
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
9
11462
d1982b7eb00d util.datamapper: Fix arrays nesting one level too deep
Kim Alvefur <zash@zash.se>
parents: 11461
diff changeset
10 local schema_t = {}
d1982b7eb00d util.datamapper: Fix arrays nesting one level too deep
Kim Alvefur <zash@zash.se>
parents: 11461
diff changeset
11
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
12 local function toboolean(s)
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
13 if s == "true" or s == "1" then
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
14 return true
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
15 elseif s == "false" or s == "0" then
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
16 return false
11455
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
17 elseif s then
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
18 return true
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
19 end
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
20 end
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
21
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
22 local function totype(t, s)
11479
377a9eaf7bef util.datamapper: Fix error on attempt to coerce nil to something
Kim Alvefur <zash@zash.se>
parents: 11476
diff changeset
23 if not s then
377a9eaf7bef util.datamapper: Fix error on attempt to coerce nil to something
Kim Alvefur <zash@zash.se>
parents: 11476
diff changeset
24 return nil
377a9eaf7bef util.datamapper: Fix error on attempt to coerce nil to something
Kim Alvefur <zash@zash.se>
parents: 11476
diff changeset
25 end
11455
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
26 if t == "string" then
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
27 return s
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
28 elseif t == "boolean" then
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
29 return toboolean(s)
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
30 elseif t == "number" or t == "integer" then
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
31 return tonumber(s)
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
32 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
33 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
34
11454
1d9c1893cc5e util.datamapper: Use enum instead of mutually exclusive booleans
Kim Alvefur <zash@zash.se>
parents: 11453
diff changeset
35 local value_goes = {}
1d9c1893cc5e util.datamapper: Use enum instead of mutually exclusive booleans
Kim Alvefur <zash@zash.se>
parents: 11453
diff changeset
36
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
37 local function resolve_schema(schema, root)
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
38 if type(schema) == "table" then
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
39 if schema["$ref"] and schema["$ref"]:sub(1, 1) == "#" then
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
40 return pointer.resolve(root, schema["$ref"]:sub(2))
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
41 end
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
42 end
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
43 return schema
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
44 end
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
45
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
46 local function guess_schema_type(schema)
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
47 local schema_types = schema.type
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
48 if type(schema_types) == "string" then
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
49 return schema_types
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
50 elseif schema_types ~= nil then
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
51 error("schema has unsupported 'type' property")
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
52 elseif schema.properties then
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
53 return "object"
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
54 elseif schema.items then
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
55 return "array"
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
56 end
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
57 return "string"
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
58 end
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
59
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
60 local function unpack_propschema(propschema, propname, current_ns)
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
61
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
62 local proptype = "string"
11466
c098d07e6717 util.datamapper: Finally implement support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11465
diff changeset
63 local value_where = propname and "in_text_tag" or "in_text"
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
64 local name = propname
11476
83e127eb91f9 util.datamapper: Deal with locally built stanzas missing xmlns
Kim Alvefur <zash@zash.se>
parents: 11475
diff changeset
65 local namespace
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
66 local prefix
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
67 local single_attribute
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
68 local enums
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
69
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
70 if type(propschema) == "table" then
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
71 proptype = guess_schema_type(propschema);
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
72 elseif type(propschema) == "string" then
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
73 error("schema as string is not supported: " .. propschema .. " {" .. current_ns .. "}" .. propname)
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
74 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
75
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
76 if proptype == "object" or proptype == "array" then
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
77 value_where = "in_children"
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
78 end
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
79
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
80 if type(propschema) == "table" then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
81 local xml = propschema.xml
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
82 if xml then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
83 if xml.name then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
84 name = xml.name
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
85 end
11476
83e127eb91f9 util.datamapper: Deal with locally built stanzas missing xmlns
Kim Alvefur <zash@zash.se>
parents: 11475
diff changeset
86 if xml.namespace and xml.namespace ~= current_ns then
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
87 namespace = xml.namespace
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
88 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
89 if xml.prefix then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
90 prefix = xml.prefix
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
91 end
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
92 if proptype == "array" and xml.wrapped then
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
93 value_where = "in_wrapper"
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
94 elseif xml.attribute then
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
95 value_where = "in_attribute"
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
96 elseif xml.text then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
97 value_where = "in_text"
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
98 elseif xml.x_name_is_value then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
99 value_where = "in_tag_name"
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
100 elseif xml.x_single_attribute then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
101 single_attribute = xml.x_single_attribute
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
102 value_where = "in_single_attribute"
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
103 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
104 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
105 if propschema["const"] then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
106 enums = {propschema["const"]}
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
107 elseif propschema["enum"] then
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
108 enums = propschema["enum"]
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
109 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
110 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
111
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
112 return proptype, value_where, name, namespace, prefix, single_attribute, enums
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
113 end
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
114
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
115 local parse_object
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
116 local parse_array
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
117
11465
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
118 local function extract_value(s, value_where, proptype, name, namespace, prefix, single_attribute, enums)
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
119 if value_where == "in_tag_name" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
120 local c
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
121 if proptype == "boolean" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
122 c = s:get_child(name, namespace);
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
123 elseif enums and proptype == "string" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
124
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
125 for i = 1, #enums do
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
126 c = s:get_child(enums[i], namespace);
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
127 if c then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
128 break
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
129 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
130 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
131 else
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
132 c = s:get_child(nil, namespace);
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
133 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
134 if c then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
135 return c.name
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
136 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
137 elseif value_where == "in_attribute" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
138 local attr = name
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
139 if prefix then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
140 attr = prefix .. ":" .. name
11476
83e127eb91f9 util.datamapper: Deal with locally built stanzas missing xmlns
Kim Alvefur <zash@zash.se>
parents: 11475
diff changeset
141 elseif namespace and namespace ~= s.attr.xmlns then
11465
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
142 attr = namespace .. "\1" .. name
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
143 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
144 return s.attr[attr]
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
145
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
146 elseif value_where == "in_text" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
147 return s:get_text()
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
148
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
149 elseif value_where == "in_single_attribute" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
150 local c = s:get_child(name, namespace)
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
151 return c and c.attr[single_attribute]
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
152 elseif value_where == "in_text_tag" then
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
153 return s:get_child_text(name, namespace)
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
154 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
155 end
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
156
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
157 function parse_object(schema, s, root)
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
158 local out = {}
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
159 schema = resolve_schema(schema, root)
11461
766b0eddd12c util.datamapper: Deal with type name changes in util.jsonschema
Kim Alvefur <zash@zash.se>
parents: 11458
diff changeset
160 if type(schema) == "table" and schema.properties then
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
161 for prop, propschema in pairs(schema.properties) do
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
162 propschema = resolve_schema(propschema, root)
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
163
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
164 local proptype, value_where, name, namespace, prefix, single_attribute, enums = unpack_propschema(propschema, prop, s.attr.xmlns)
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
165
11465
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
166 if value_where == "in_children" and type(propschema) == "table" then
11455
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
167 if proptype == "object" then
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
168 local c = s:get_child(name, namespace)
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
169 if c then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
170 out[prop] = parse_object(propschema, c, root);
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
171 end
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
172 elseif proptype == "array" then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
173 local a = parse_array(propschema, s, root);
11481
b2f9782497dd util.datamapper: Don't include empty unwrapped arrays
Kim Alvefur <zash@zash.se>
parents: 11479
diff changeset
174 if a and a[1] ~= nil then
b2f9782497dd util.datamapper: Don't include empty unwrapped arrays
Kim Alvefur <zash@zash.se>
parents: 11479
diff changeset
175 out[prop] = a;
b2f9782497dd util.datamapper: Don't include empty unwrapped arrays
Kim Alvefur <zash@zash.se>
parents: 11479
diff changeset
176 end
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
177 else
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
178 error("unreachable")
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
179 end
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
180 elseif value_where == "in_wrapper" and type(propschema) == "table" and proptype == "array" then
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
181 local wrapper = s:get_child(name, namespace);
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
182 if wrapper then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
183 out[prop] = parse_array(propschema, wrapper, root);
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
184 end
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
185 else
11465
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
186 local value = extract_value(s, value_where, proptype, name, namespace, prefix, single_attribute, enums)
19a88b61ab4e util.datamapper: Factor out extraction of the XML part to use
Kim Alvefur <zash@zash.se>
parents: 11464
diff changeset
187
11455
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
188 out[prop] = totype(proptype, value)
a5050e21ab08 util.datamapper: Separate extraction of xml from coercion to target type
Kim Alvefur <zash@zash.se>
parents: 11454
diff changeset
189 end
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
190 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
191 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
192
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
193 return out
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
194 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
195
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
196 function parse_array(schema, s, root)
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
197 local itemschema = resolve_schema(schema.items, root);
11471
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
198 local proptype, value_where, child_name, namespace, prefix, single_attribute, enums = unpack_propschema(itemschema, nil, s.attr.xmlns)
11466
c098d07e6717 util.datamapper: Finally implement support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11465
diff changeset
199 local attr_name
c098d07e6717 util.datamapper: Finally implement support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11465
diff changeset
200 if value_where == "in_single_attribute" then
c098d07e6717 util.datamapper: Finally implement support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11465
diff changeset
201 value_where = "in_attribute";
c098d07e6717 util.datamapper: Finally implement support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11465
diff changeset
202 attr_name = single_attribute;
c098d07e6717 util.datamapper: Finally implement support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11465
diff changeset
203 end
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
204 local out = {}
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
205
11471
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
206 if proptype == "object" then
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
207 if type(itemschema) == "table" then
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
208 for c in s:childtags(child_name, namespace) do
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
209 table.insert(out, parse_object(itemschema, c, root));
11471
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
210 end
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
211 else
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
212 error("array items must be schema object")
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
213 end
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
214 elseif proptype == "array" then
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
215 if type(itemschema) == "table" then
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
216 for c in s:childtags(child_name, namespace) do
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
217 table.insert(out, parse_array(itemschema, c, root));
11471
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
218 end
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
219 end
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
220 else
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
221 for c in s:childtags(child_name, namespace) do
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
222 local value = extract_value(c, value_where, proptype, attr_name or child_name, namespace, prefix, single_attribute, enums)
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
223
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
224 table.insert(out, totype(proptype, value));
ab03de8e503e util.datamapper: Handle nested arrays or objects in arrays
Kim Alvefur <zash@zash.se>
parents: 11470
diff changeset
225 end
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
226 end
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
227 return out
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
228 end
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
229
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
230 local function parse(schema, s)
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
231 local s_type = guess_schema_type(schema)
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
232 if s_type == "object" then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
233 return parse_object(schema, s, schema)
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
234 elseif s_type == "array" then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
235 return parse_array(schema, s, schema)
11457
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
236 else
6a51749af7f4 util.datamapper: Add initial support for parsing arrays
Kim Alvefur <zash@zash.se>
parents: 11456
diff changeset
237 error("top-level scalars unsupported")
11435
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
238 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
239 end
a1fa6202fa13 util.datamapper: Library for extracting data from stanzas
Kim Alvefur <zash@zash.se>
parents:
diff changeset
240
11475
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
241 local function toxmlstring(proptype, v)
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
242 if proptype == "string" and type(v) == "string" then
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
243 return v
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
244 elseif proptype == "number" and type(v) == "number" then
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
245 return string.format("%g", v)
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
246 elseif proptype == "integer" and type(v) == "number" then
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
247 return string.format("%d", v)
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
248 elseif proptype == "boolean" then
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
249 return v and "1" or "0"
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
250 end
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
251 end
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
252
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
253 local unparse
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
254
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
255 local function unparse_property(out, v, proptype, propschema, value_where, name, namespace, current_ns, prefix,
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
256 single_attribute, root)
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
257
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
258 if value_where == "in_attribute" then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
259 local attr = name
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
260 if prefix then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
261 attr = prefix .. ":" .. name
11476
83e127eb91f9 util.datamapper: Deal with locally built stanzas missing xmlns
Kim Alvefur <zash@zash.se>
parents: 11475
diff changeset
262 elseif namespace and namespace ~= current_ns then
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
263 attr = namespace .. "\1" .. name
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
264 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
265
11475
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
266 out.attr[attr] = toxmlstring(proptype, v)
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
267 elseif value_where == "in_text" then
11475
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
268 out:text(toxmlstring(proptype, v))
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
269 elseif value_where == "in_single_attribute" then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
270 assert(single_attribute)
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
271 local propattr = {}
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
272
11476
83e127eb91f9 util.datamapper: Deal with locally built stanzas missing xmlns
Kim Alvefur <zash@zash.se>
parents: 11475
diff changeset
273 if namespace and namespace ~= current_ns then
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
274 propattr.xmlns = namespace
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
275 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
276
11475
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
277 propattr[single_attribute] = toxmlstring(proptype, v)
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
278 out:tag(name, propattr):up();
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
279
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
280 else
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
281 local propattr
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
282 if namespace ~= current_ns then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
283 propattr = {xmlns = namespace}
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
284 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
285 if value_where == "in_tag_name" then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
286 if proptype == "string" and type(v) == "string" then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
287 out:tag(v, propattr):up();
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
288 elseif proptype == "boolean" and v == true then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
289 out:tag(name, propattr):up();
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
290 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
291 elseif proptype == "object" and type(propschema) == "table" and type(v) == "table" then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
292 local c = unparse(propschema, v, name, namespace, nil, root);
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
293 if c then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
294 out:add_direct_child(c);
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
295 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
296 elseif proptype == "array" and type(propschema) == "table" and type(v) == "table" then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
297 if value_where == "in_wrapper" then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
298 local c = unparse(propschema, v, name, namespace, nil, root);
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
299 if c then
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
300 out:add_direct_child(c);
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
301 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
302 else
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
303 unparse(propschema, v, name, namespace, out, root);
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
304 end
11475
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
305 else
9bd36e871f05 util.datamapper: Factor out conversion from any value to XML string
Kim Alvefur <zash@zash.se>
parents: 11471
diff changeset
306 out:text_tag(name, toxmlstring(proptype, v), propattr)
11467
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
307 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
308 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
309 end
88792dd2bee9 util.datamapper: Factor out handling of object properties for array reuse
Kim Alvefur <zash@zash.se>
parents: 11466
diff changeset
310
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
311 function unparse(schema, t, current_name, current_ns, ctx, root)
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
312
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
313 if root == nil then
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
314 root = schema
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
315 end
11436
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
316
11458
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
317 if schema.xml then
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
318 if schema.xml.name then
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
319 current_name = schema.xml.name
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
320 end
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
321 if schema.xml.namespace then
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
322 current_ns = schema.xml.namespace
11436
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
323 end
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
324
11458
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
325 end
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
326
11462
d1982b7eb00d util.datamapper: Fix arrays nesting one level too deep
Kim Alvefur <zash@zash.se>
parents: 11461
diff changeset
327 local out = ctx or st.stanza(current_name, {xmlns = current_ns})
11458
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
328
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
329 local s_type = guess_schema_type(schema)
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
330 if s_type == "object" then
11436
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
331
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
332 for prop, propschema in pairs(schema.properties) do
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
333 propschema = resolve_schema(propschema, root)
11436
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
334 local v = t[prop]
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
335
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
336 if v ~= nil then
11456
4e376a43fe40 util.datamapper: Factor out common schema unpacking
Kim Alvefur <zash@zash.se>
parents: 11455
diff changeset
337 local proptype, value_where, name, namespace, prefix, single_attribute = unpack_propschema(propschema, prop, current_ns)
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
338 unparse_property(out, v, proptype, propschema, value_where, name, namespace, current_ns, prefix, single_attribute, root)
11436
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
339 end
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
340 end
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
341 return out
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
342
12580
a9dbf657c894 util.datamapper: Improve handling of schemas with non-obvious "type"
Kim Alvefur <zash@zash.se>
parents: 12133
diff changeset
343 elseif s_type == "array" then
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
344 local itemschema = resolve_schema(schema.items, root)
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
345 local proptype, value_where, name, namespace, prefix, single_attribute = unpack_propschema(itemschema, current_name, current_ns)
11468
348b191cd850 util.datamapper: Complete array building support
Kim Alvefur <zash@zash.se>
parents: 11467
diff changeset
346 for _, item in ipairs(t) do
12133
11060c8919b6 util.datamapper: Add support for $ref pointers
Kim Alvefur <zash@zash.se>
parents: 11481
diff changeset
347 unparse_property(out, item, proptype, itemschema, value_where, name, namespace, current_ns, prefix, single_attribute, root)
11458
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
348 end
0e00fa518688 util.datamapper: Limited support for unparsing simple arrays of strings
Kim Alvefur <zash@zash.se>
parents: 11457
diff changeset
349 return out
11436
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
350 end
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
351 end
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
352
5df9ffc25bb4 util.datamapper: Add 'unparse' for turning tables into XML
Kim Alvefur <zash@zash.se>
parents: 11435
diff changeset
353 return {parse = parse; unparse = unparse}