Grcov report - core.rs

1

/*

2

 * Hurl (https://hurl.dev)

3

 * Copyright (C) 2026 Orange

4

5

 * Licensed under the Apache License, Version 2.0 (the "License");

6

 * you may not use this file except in compliance with the License.

7

 * You may obtain a copy of the License at

8

9

 *          http://www.apache.org/licenses/LICENSE-2.0

10

11

 * Unless required by applicable law or agreed to in writing, software

12

 * distributed under the License is distributed on an "AS IS" BASIS,

13

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

14

 * See the License for the specific language governing permissions and

15

 * limitations under the License.

16

17

*/

18

use std::fmt;

19

20

use crate::types::{SourceString, ToSource};

21

22

use super::option::EntryOption;

23

use super::primitive::{

24

    Bytes, KeyValue, LineTerminator, Placeholder, SourceInfo, Template, Whitespace, I64,

25

};

26

use super::section::{Assert, Capture, Cookie, MultipartParam, RegexValue, Section, SectionValue};

27

28

/// Represents Hurl AST root node.

29

#[derive(Clone, Debug, PartialEq, Eq)]

30

pub struct HurlFile {

31

    pub entries: Vec<Entry>,

32

    pub line_terminators: Vec<LineTerminator>,

33

34

35

/// Represents an entry; a request AST specification to be run and an optional response AST

36

/// specification to be checked.

37

#[derive(Clone, Debug, PartialEq, Eq)]

38

pub struct Entry {

39

    pub request: Request,

40

    pub response: Option<Response>,

41

42

43

impl Entry {

44

    /// Returns the source information for this entry.

45

15345

    pub fn source_info(&self) -> SourceInfo {

46

15345

        self.request.space0.source_info

47

48

49

    /// Returns true if the request or the response uses multilines string attributes

50

12395

    pub fn use_multiline_string_body_with_attributes(&self) -> bool {

51

        if let Some(Body {

52

225

            value: Bytes::MultilineString(multiline),

53

..

54

700

        }) = &self.request.body

55

56

225

            if multiline.has_attributes() {

57

15

                return true;

58

59

60

12380

        if let Some(response) = &self.response {

61

            if let Some(Body {

62

175

                value: Bytes::MultilineString(multiline),

63

..

64

2030

            }) = &response.body

65

66

175

                if multiline.has_attributes() {

67

10

                    return true;

68

69

70

71

12370

        false

72

73

74

75

#[derive(Clone, Debug, PartialEq, Eq)]

76

pub struct Request {

77

    pub line_terminators: Vec<LineTerminator>,

78

    pub space0: Whitespace,

79

    pub method: Method,

80

    pub space1: Whitespace,

81

    pub url: Template,

82

    pub line_terminator0: LineTerminator,

83

    pub headers: Vec<KeyValue>,

84

    pub sections: Vec<Section>,

85

    pub body: Option<Body>,

86

    pub source_info: SourceInfo,

87

88

89

impl Request {

90

    /// Returns the query strings params for this request.

91

///

92

    /// See <https://developer.mozilla.org/en-US/docs/Web/API/URL/searchParams>.

93

12710

    pub fn querystring_params(&self) -> &[KeyValue] {

94

14865

        for section in &self.sections {

95

2430

            if let SectionValue::QueryParams(params, _) = &section.value {

96

275

                return params;

97

98

99

12435

&[]

100

101

102

    /// Returns the form params for this request.

103

///

104

    /// See <https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST#url-encoded_form_submission>.

105

12670

    pub fn form_params(&self) -> &[KeyValue] {

106

14990

        for section in &self.sections {

107

2430

            if let SectionValue::FormParams(params, _) = &section.value {

108

110

                return params;

109

110

111

12560

&[]

112

113

114

    /// Returns the multipart form data for this request.

115

///

116

    /// See <https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST#multipart_form_submission>.

117

12590

    pub fn multipart_form_data(&self) -> &[MultipartParam] {

118

14925

        for section in &self.sections {

119

2450

            if let SectionValue::MultipartFormData(params, _) = &section.value {

120

115

                return params;

121

122

123

12475

&[]

124

125

126

    /// Returns the list of cookies on this request.

127

///

128

    /// See <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cookie>.

129

12670

    pub fn cookies(&self) -> &[Cookie] {

130

14930

        for section in &self.sections {

131

2485

            if let SectionValue::Cookies(cookies) = &section.value {

132

225

                return cookies;

133

134

135

12445

&[]

136

137

138

    /// Returns the basic authentication on this request.

139

///

140

    /// See <https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication>.

141

12375

    pub fn basic_auth(&self) -> Option<&KeyValue> {

142

14695

        for section in &self.sections {

143

2370

            if let SectionValue::BasicAuth(kv) = &section.value {

144

50

                return kv.as_ref();

145

146

147

12325

        None

148

149

150

    /// Returns the options specific for this request.

151

26675

    pub fn options(&self) -> &[EntryOption] {

152

27620

        for section in &self.sections {

153

6050

            if let SectionValue::Options(options) = &section.value {

154

5105

                return options;

155

156

157

21570

&[]

158

159

160

161

#[derive(Clone, Debug, PartialEq, Eq)]

162

pub struct Response {

163

    pub line_terminators: Vec<LineTerminator>,

164

    pub version: Version,

165

    pub space0: Whitespace,

166

    pub status: Status,

167

    pub space1: Whitespace,

168

    pub line_terminator0: LineTerminator,

169

    pub headers: Vec<KeyValue>,

170

    pub sections: Vec<Section>,

171

    pub body: Option<Body>,

172

    pub source_info: SourceInfo,

173

174

175

impl Response {

176

    /// Returns the captures list of this spec response.

177

24445

    pub fn captures(&self) -> &[Capture] {

178

24445

        for section in self.sections.iter() {

179

15705

            if let SectionValue::Captures(captures) = &section.value {

180

945

                return captures;

181

182

183

23500

&[]

184

185

186

    /// Returns the asserts list of this spec response.

187

35380

    pub fn asserts(&self) -> &[Assert] {

188

35380

        for section in self.sections.iter() {

189

23810

            if let SectionValue::Asserts(asserts) = &section.value {

190

22580

                return asserts;

191

192

193

12800

&[]

194

195

196

197

#[derive(Clone, Debug, PartialEq, Eq)]

198

pub struct Method(String);

199

200

impl Method {

201

    /// Creates a new AST element method/

202

15530

    pub fn new(method: &str) -> Method {

203

15530

        Method(method.to_string())

204

205

206

207

impl fmt::Display for Method {

208

14400

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

209

14400

        write!(f, "{}", self.0)

210

211

212

213

impl ToSource for Method {

214

920

    fn to_source(&self) -> SourceString {

215

920

        self.0.to_source()

216

217

218

219

#[derive(Clone, Debug, PartialEq, Eq)]

220

pub struct Version {

221

    pub value: VersionValue,

222

    pub source_info: SourceInfo,

223

224

225

#[derive(Copy, Clone, Debug, PartialEq, Eq)]

226

pub enum VersionValue {

227

    Version1,

228

    Version11,

229

    Version2,

230

    Version3,

231

    VersionAny,

232

233

234

impl fmt::Display for VersionValue {

235

13720

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

236

13720

        let s = match self {

237

45

            VersionValue::Version1 => "HTTP/1.0",

238

55

            VersionValue::Version11 => "HTTP/1.1",

239

60

            VersionValue::Version2 => "HTTP/2",

240

25

            VersionValue::Version3 => "HTTP/3",

241

13535

            VersionValue::VersionAny => "HTTP",

242

};

243

13720

        write!(f, "{s}")

244

245

246

247

impl ToSource for VersionValue {

248

190

    fn to_source(&self) -> SourceString {

249

190

        self.to_string().to_source()

250

251

252

253

#[derive(Clone, Debug, PartialEq, Eq)]

254

pub struct Status {

255

    pub value: StatusValue,

256

    pub source_info: SourceInfo,

257

258

259

#[derive(Clone, Debug, PartialEq, Eq)]

260

pub enum StatusValue {

261

    Any,

262

    Specific(u64),

263

264

265

impl fmt::Display for StatusValue {

266

1810

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

267

1810

        match self {

268

40

            StatusValue::Any => write!(f, "*"),

269

1770

            StatusValue::Specific(v) => write!(f, "{v}"),

270

271

272

273

274

impl ToSource for StatusValue {

275

190

    fn to_source(&self) -> SourceString {

276

190

        self.to_string().to_source()

277

278

279

280

#[derive(Clone, Debug, PartialEq, Eq)]

281

pub struct Body {

282

    pub line_terminators: Vec<LineTerminator>,

283

    pub space0: Whitespace,

284

    pub value: Bytes,

285

    pub line_terminator0: LineTerminator,

286

287

288

/// Check that variable name is not reserved

289

/// (would conflicts with an existing function)

290

860

pub fn is_variable_reserved(name: &str) -> bool {

291

860

    ["getEnv", "newDate", "newUuid"].contains(&name)

292

293

294

#[derive(Clone, Debug, PartialEq, Eq)]

295

pub struct Filter {

296

    pub source_info: SourceInfo,

297

    pub value: FilterValue,

298

299

300

#[derive(Clone, Debug, PartialEq, Eq)]

301

pub enum FilterValue {

302

    Base64Decode,

303

    Base64Encode,

304

    Base64UrlSafeDecode,

305

    Base64UrlSafeEncode,

306

    Count,

307

    DaysAfterNow,

308

    DaysBeforeNow,

309

    Decode {

310

        space0: Whitespace,

311

        encoding: Template,

312

},

313

    First,

314

    Format {

315

        space0: Whitespace,

316

        fmt: Template,

317

},

318

    DateFormat {

319

        space0: Whitespace,

320

        fmt: Template,

321

},

322

    HtmlEscape,

323

    HtmlUnescape,

324

    JsonPath {

325

        space0: Whitespace,

326

        expr: Template,

327

},

328

    Last,

329

    Location,

330

    Nth {

331

        space0: Whitespace,

332

        n: IntegerValue,

333

},

334

    Regex {

335

        space0: Whitespace,

336

        value: RegexValue,

337

},

338

    Replace {

339

        space0: Whitespace,

340

        old_value: Template,

341

        space1: Whitespace,

342

        new_value: Template,

343

},

344

    ReplaceRegex {

345

        space0: Whitespace,

346

        pattern: RegexValue,

347

        space1: Whitespace,

348

        new_value: Template,

349

},

350

    Split {

351

        space0: Whitespace,

352

        sep: Template,

353

},

354

    ToDate {

355

        space0: Whitespace,

356

        fmt: Template,

357

},

358

    ToFloat,

359

    ToHex,

360

    ToInt,

361

    ToString,

362

    UrlDecode,

363

    UrlEncode,

364

    UrlQueryParam {

365

        space0: Whitespace,

366

        param: Template,

367

},

368

    Utf8Decode,

369

    Utf8Encode,

370

    XPath {

371

        space0: Whitespace,

372

        expr: Template,

373

},

374

375

376

impl FilterValue {

377

    /// Returns the Hurl identifier for this filter type.

378

2240

    pub fn identifier(&self) -> &'static str {

379

2240

        match self {

380

75

            FilterValue::Base64Decode => "base64Decode",

381

35

            FilterValue::Base64Encode => "base64Encode",

382

50

            FilterValue::Base64UrlSafeDecode => "base64UrlSafeDecode",

383

35

            FilterValue::Base64UrlSafeEncode => "base64UrlSafeEncode",

384

450

            FilterValue::Count => "count",

385

25

            FilterValue::DaysAfterNow => "daysAfterNow",

386

50

            FilterValue::DaysBeforeNow => "daysBeforeNow",

387

75

            FilterValue::Decode { .. } => "decode",

388

40

            FilterValue::First => "first",

389

50

            FilterValue::Format { .. } => "format",

390

100

            FilterValue::DateFormat { .. } => "dateFormat",

391

35

            FilterValue::HtmlEscape => "htmlEscape",

392

45

            FilterValue::HtmlUnescape => "htmlUnescape",

393

80

            FilterValue::JsonPath { .. } => "jsonpath",

394

40

            FilterValue::Last => "last",

395

80

            FilterValue::Location => "location",

396

175

            FilterValue::Nth { .. } => "nth",

397

60

            FilterValue::Regex { .. } => "regex",

398

115

            FilterValue::Replace { .. } => "replace",

399

45

            FilterValue::ReplaceRegex { .. } => "replaceRegex",

400

40

            FilterValue::Split { .. } => "split",

401

120

            FilterValue::ToDate { .. } => "toDate",

402

60

            FilterValue::ToFloat => "toFloat",

403

65

            FilterValue::ToHex => "toHex",

404

60

            FilterValue::ToInt => "toInt",

405

30

            FilterValue::ToString => "toString",

406

35

            FilterValue::UrlDecode => "urlDecode",

407

35

            FilterValue::UrlEncode => "urlEncode",

408

45

            FilterValue::UrlQueryParam { .. } => "urlQueryParam",

409

25

            FilterValue::Utf8Decode => "utf8Decode",

410

25

            FilterValue::Utf8Encode => "utf8Encode",

411

40

            FilterValue::XPath { .. } => "xpath",

412

413

414

415

416

#[derive(Clone, Debug, PartialEq, Eq)]

417

pub enum IntegerValue {

418

    Literal(I64),

419

    Placeholder(Placeholder),

420

421

422

impl fmt::Display for IntegerValue {

423

5

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

424

5

        match self {

425

5

            IntegerValue::Literal(v) => write!(f, "{v}"),

426

            IntegerValue::Placeholder(v) => write!(f, "{v}"),

427

428

429