FilesExpand file tree

 master

/

type_check.lua

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

233 lines (222 loc) · 6.73 KB

 master

/

type_check.lua

Copy path

Top

File metadata and controls

• Code
• Blame

233 lines (222 loc) · 6.73 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

--- Type-checking functions.

-- Functions and definitions for doing a basic lint check on files

-- loaded by LuaRocks.

module("luarocks.type_check", package.seeall)

rockspec_format = "1.0"

rockspec_types = {

rockspec_format = "string",

MUST_package = "string",

MUST_version = "string",

description = {

summary = "string",

detailed = "string",

homepage = "string",

license = "string",

maintainer = "string"

},

dependencies = {

platforms = {},

ANY = "string"

},

supported_platforms = {

ANY = "string"

},

external_dependencies = {

platforms = {},

ANY = {

program = "string",

header = "string",

library = "string"

}

},

MUST_source = {

platforms = {},

MUST_url = "string",

md5 = "string",

file = "string",

dir = "string",

tag = "string",

branch = "string",

module = "string",

cvs_tag = "string",

cvs_module = "string"

},

build = {

platforms = {},

type = "string",

install = {

lua = {

MORE = true

},

lib = {

MORE = true

},

conf = {

MORE = true

},

bin = {

MORE = true

}

},

copy_directories = {

ANY = "string"

},

MORE = true

},

hooks = {

platforms = {},

post_install = "string"

}

}

rockspec_types.build.platforms.ANY = rockspec_types.build

rockspec_types.dependencies.platforms.ANY = rockspec_types.dependencies

rockspec_types.external_dependencies.platforms.ANY = rockspec_types.external_dependencies

rockspec_types.MUST_source.platforms.ANY = rockspec_types.MUST_source

rockspec_types.hooks.platforms.ANY = rockspec_types.hooks

manifest_types = {

MUST_repository = {

-- packages

ANY = {

-- versions

ANY = {

-- items

ANY = {

MUST_arch = "string",

modules = { ANY = "string" },

commands = { ANY = "string" },

dependencies = { ANY = "string" },

-- TODO: to be extended with more metadata.

}

}

}

},

MUST_modules = {

-- modules

ANY = {

-- providers

ANY = "string"

}

},

MUST_commands = {

-- modules

ANY = {

-- commands

ANY = "string"

}

},

dependencies = {

-- each module

ANY = {

-- each version

ANY = {

-- each dependency

ANY = {

name = "string",

constraints = {

ANY = {

no_upgrade = "boolean",

op = "string",

version = {

string = "string",

ANY = 0,

}

}

}

}

}

}

}

}

local type_check_table

--- Type check an object.

-- The object is compared against an archetypical value

-- matching the expected type -- the actual values don't matter,

-- only their types. Tables are type checked recursively.

-- @param name any: The object name (for error messages).

-- @param item any: The object being checked.

-- @param expected any: The reference object. In case of a table,

-- its is structured as a type reference table.

-- @return boolean or (nil, string): true if type checking

-- succeeded, or nil and an error message if it failed.

-- @see type_check_table

local function type_check_item(name, item, expected, context)

name = tostring(name)

local item_type = type(item)

local expected_type = type(expected)

if expected_type == "number" then

if not tonumber(item) then

return nil, "Type mismatch on field "..context..name..": expected a number"

end

elseif expected_type == "table" then

if item_type ~= expected_type then

return nil, "Type mismatch on field "..context..name..": expected a table"

else

return type_check_table(item, expected, context..name..".")

end

elseif item_type ~= expected_type then

return nil, "Type mismatch on field "..context..name..": expected a "..expected_type

end

return true

end

--- Type check the contents of a table.

-- The table's contents are compared against a reference table,

-- which contains the recognized fields, with archetypical values

-- matching the expected types -- the actual values of items in the

-- reference table don't matter, only their types (ie, for field x

-- in tbl that is correctly typed, type(tbl.x) == type(types.x)).

-- If the reference table contains a field called MORE, then

-- unknown fields in the checked table are accepted.

-- If it contains a field called ANY, then its type will be

-- used to check any unknown fields. If a field is prefixed

-- with MUST_, it is mandatory; its absence from the table is

-- a type error.

-- Tables are type checked recursively.

-- @param tbl table: The table to be type checked.

-- @param types table: The reference table, containing

-- values for recognized fields in the checked table.

-- @return boolean or (nil, string): true if type checking

-- succeeded, or nil and an error message if it failed.

type_check_table = function(tbl, types, context)

assert(type(tbl) == "table")

assert(type(types) == "table")

for k, v in pairs(tbl) do

local t = types[k] or (type(k) == "string" and types["MUST_"..k]) or types.ANY

if t then

local ok, err = type_check_item(k, v, t, context)

if not ok then return nil, err end

elseif types.MORE then

-- Accept unknown field

else

return nil, "Unknown field "..k

end

end

for k, v in pairs(types) do

local mandatory_key = k:match("^MUST_(.+)")

if mandatory_key then

if not tbl[mandatory_key] then

return nil, "Mandatory field "..context..mandatory_key.." is missing."

end

end

end

return true

end

--- Type check a rockspec table.

-- Verify the correctness of elements from a

-- rockspec table, reporting on unknown fields and type

-- mismatches.

-- @return boolean or (nil, string): true if type checking

-- succeeded, or nil and an error message if it failed.

function type_check_rockspec(rockspec)

assert(type(rockspec) == "table")

return type_check_table(rockspec, rockspec_types, "")

end

--- Type check a manifest table.

-- Verify the correctness of elements from a

-- manifest table, reporting on unknown fields and type

-- mismatches.

-- @return boolean or (nil, string): true if type checking

-- succeeded, or nil and an error message if it failed.

function type_check_manifest(manifest)

assert(type(manifest) == "table")

return type_check_table(manifest, manifest_types, "")

end