loot/loot-condition-interpreter | Build 14679793593 | src/function/parse.rs | Coveralls

18

    pub fn parse(input: &str) -> IResult<&str, ComparisonOperator> {

18✔

19

        alt((

18✔

20

            value(ComparisonOperator::Equal, tag("==")),

18✔

21

            value(ComparisonOperator::NotEqual, tag("!=")),

18✔

22

            value(ComparisonOperator::LessThanOrEqual, tag("<=")),

18✔

23

            value(ComparisonOperator::GreaterThanOrEqual, tag(">=")),

18✔

24

            value(ComparisonOperator::LessThan, tag("<")),

18✔

25

            value(ComparisonOperator::GreaterThan, tag(">")),

18✔

26

))

18✔

27

        .parse(input)

18✔

28

18✔

35

fn is_in_game_path(path: &Path) -> bool {

76✔

36

    let mut previous_component = Component::CurDir;

76✔

37

    for component in path.components() {

89✔

38

        match (component, previous_component) {

89✔

40

            | (Component::ParentDir, Component::ParentDir) => return false,

12✔

41

            (Component::CurDir, _) => {}

5✔

42

            _ => previous_component = component,

72✔

46

    true

64✔

47

76✔

49

fn build_regex(input: &str) -> Result<(&'static str, Regex), regex::Error> {

16✔

50

    RegexBuilder::new(input)

16✔

51

        .case_insensitive(true)

16✔

52

        .build()

16✔

53

        .map(|r| ("", r))

16✔

54

16✔

56

fn parse_regex(input: &str) -> ParsingResult<Regex> {

3✔

57

    build_regex(input).map_err(|e| Err::Failure(ParsingErrorKind::from(e).at(input)))

3✔

58

3✔

60

fn parse_anchored_regex(input: &str) -> ParsingResult<Regex> {

13✔

61

    build_regex(&format!("^{input}$"))

13✔

62

        .map_err(|e| Err::Failure(ParsingErrorKind::from(e).at(input)))

13✔

63

13✔

65

fn not_in_game_directory(input: &str, path: PathBuf) -> Err<ParsingError<&str>> {

12✔

66

    Err::Failure(ParsingErrorKind::PathIsNotInGameDirectory(path).at(input))

12✔

67

12✔

69

fn parse_path(input: &str) -> IResult<&str, PathBuf> {

32✔

70

    map(

32✔

71

        delimited(tag("\""), is_not(INVALID_PATH_CHARS), tag("\"")),

32✔

72

        PathBuf::from,

32✔

73

32✔

74

    .parse(input)

32✔

75

32✔

77

fn parse_size(input: &str) -> ParsingResult<u64> {

2✔

78

    str::parse(input)

2✔

79

        .map(|c| ("", c))

2✔

80

        .map_err(|e| Err::Failure(ParsingErrorKind::from(e).at(input)))

2✔

81

2✔

83

fn parse_file_size_args(input: &str) -> ParsingResult<(PathBuf, u64)> {

2✔

84

    let mut parser = (

2✔

85

        map_err(parse_path),

2✔

86

        map_err(whitespace(tag(","))),

2✔

87

        map_parser(digit1, parse_size),

2✔

88

);

2✔

90

    let (remaining_input, (path, _, size)) = parser.parse(input)?;

2✔

92

    if is_in_game_path(&path) {

2✔

93

        Ok((remaining_input, (path, size)))

1✔

95

        Err(not_in_game_directory(input, path))

1✔

97

2✔

99

fn parse_version(input: &str) -> IResult<&str, String> {

18✔

100

    map(

18✔

101

        delimited(tag("\""), is_not("\""), tag("\"")),

18✔

102

        |version: &str| version.to_owned(),

18✔

103

18✔

104

    .parse(input)

18✔

105

18✔

107

fn parse_version_args(input: &str) -> ParsingResult<(PathBuf, String, ComparisonOperator)> {

16✔

108

    let parser = (

16✔

109

        parse_path,

16✔

110

        whitespace(tag(",")),

16✔

111

        parse_version,

16✔

112

        whitespace(tag(",")),

16✔

113

        ComparisonOperator::parse,

16✔

114

);

16✔

116

    let (remaining_input, (path, _, version, _, comparator)) = map_err(parser).parse(input)?;

16✔

118

    if is_in_game_path(&path) {

16✔

119

        Ok((remaining_input, (path, version, comparator)))

14✔

121

        Err(not_in_game_directory(input, path))

2✔

123

16✔

125

fn parse_filename_version_args(

2✔

126

    input: &str,

2✔

127

) -> ParsingResult<(PathBuf, Regex, String, ComparisonOperator)> {

2✔

128

    let mut parser = (

2✔

129

        delimited(map_err(tag("\"")), parse_regex_path, map_err(tag("\""))),

2✔

130

        map_err(whitespace(tag(","))),

2✔

131

        map_err(parse_version),

2✔

132

        map_err(whitespace(tag(","))),

2✔

133

        map_err(ComparisonOperator::parse),

2✔

134

);

2✔

136

    let (remaining_input, ((path, regex), _, version, _, comparator)) = parser.parse(input)?;

2✔

138

    if regex.captures_len() != 2 {

2✔

139

        return Err(Err::Failure(

1✔

140

            ParsingErrorKind::InvalidRegexUnknown.at(input),

1✔

141

));

1✔

142

1✔

143

1✔

144

    Ok((remaining_input, (path, regex, version, comparator)))

1✔

145

2✔

147

fn parse_description_contains_args(input: &str) -> ParsingResult<(PathBuf, Regex)> {

1✔

148

    let mut parser = (

1✔

149

        map_err(parse_path),

1✔

150

        map_err(whitespace(tag(","))),

1✔

151

        delimited(

1✔

152

            map_err(tag("\"")),

1✔

153

            map_parser(is_not("\""), parse_regex),

1✔

154

            map_err(tag("\"")),

1✔

155

),

1✔

156

);

1✔

158

    let (remaining_input, (path, _, regex)) = parser.parse(input)?;

1✔

160

    Ok((remaining_input, (path, regex)))

1✔

161

1✔

163

fn parse_crc(input: &str) -> ParsingResult<u32> {

13✔

164

    u32::from_str_radix(input, 16)

13✔

165

        .map(|c| ("", c))

13✔

166

        .map_err(|e| Err::Failure(ParsingErrorKind::from(e).at(input)))

13✔

167

13✔

169

fn parse_checksum_args(input: &str) -> ParsingResult<(PathBuf, u32)> {

13✔

170

    let mut parser = (

13✔

171

        map_err(parse_path),

13✔

172

        map_err(whitespace(tag(","))),

13✔

173

        map_parser(hex_digit1, parse_crc),

13✔

174

);

13✔

176

    let (remaining_input, (path, _, crc)) = parser.parse(input)?;

13✔

178

    if is_in_game_path(&path) {

12✔

179

        Ok((remaining_input, (path, crc)))

11✔

181

        Err(not_in_game_directory(input, path))

1✔

183

13✔

185

fn parse_non_regex_path(input: &str) -> ParsingResult<PathBuf> {

37✔

186

    let (remaining_input, path) = map(is_not(INVALID_NON_REGEX_PATH_CHARS), |path: &str| {

37✔

187

        PathBuf::from(path)

37✔

188

})

37✔

189

    .parse(input)?;

37✔

191

    if is_in_game_path(&path) {

37✔

192

        Ok((remaining_input, path))

29✔

194

        Err(not_in_game_directory(input, path))

8✔

196

37✔

200

fn parse_regex_path(input: &str) -> ParsingResult<(PathBuf, Regex)> {

12✔

201

    let (remaining_input, string) = is_not(INVALID_REGEX_PATH_CHARS)(input)?;

12✔

203

    if string.ends_with('/') {

12✔

204

        return Err(Err::Failure(

3✔

205

            ParsingErrorKind::PathEndsInADirectorySeparator(string.into()).at(input),

3✔

206

));

3✔

207

9✔

208

9✔

209

    let (parent_path_slice, regex_slice) = string.rsplit_once('/').unwrap_or((".", string));

9✔

210

9✔

211

    let parent_path = PathBuf::from(parent_path_slice);

9✔

212

9✔

213

    if !is_in_game_path(&parent_path) {

9✔

215

9✔

217

    let regex = parse_anchored_regex(regex_slice)?.1;

9✔

219

    Ok((remaining_input, (parent_path, regex)))

8✔

220

12✔

222

fn parse_regex_filename(input: &str) -> ParsingResult<Regex> {

2✔

223

    map_parser(is_not(INVALID_REGEX_PATH_CHARS), parse_anchored_regex).parse(input)

2✔

224

2✔

228

    pub fn parse(input: &str) -> ParsingResult<Function> {

91✔

229

        alt((

91✔

230

            map(

91✔

231

                delimited(

91✔

232

                    map_err(tag("file(\"")),

91✔

233

                    parse_non_regex_path,

91✔

234

                    map_err(tag("\")")),

91✔

235

),

91✔

236

                Function::FilePath,

91✔

237

),

91✔

238

            map(

91✔

239

                delimited(

91✔

240

                    map_err(tag("file(\"")),

91✔

241

                    parse_regex_path,

91✔

242

                    map_err(tag("\")")),

91✔

243

),

91✔

244

                |(path, regex)| Function::FileRegex(path, regex),

91✔

245

),

91✔

246

            map(

91✔

247

                delimited(

91✔

248

                    map_err(tag("file_size(")),

91✔

249

                    parse_file_size_args,

91✔

250

                    map_err(tag(")")),

91✔

251

),

91✔

252

                |(path, size)| Function::FileSize(path, size),

91✔

253

),

91✔

254

            map(

91✔

255

                delimited(

91✔

256

                    map_err(tag("readable(\"")),

91✔

257

                    parse_non_regex_path,

91✔

258

                    map_err(tag("\")")),

91✔

259

),

91✔

260

                Function::Readable,

91✔

261

),

91✔

262

            map(

91✔

263

                delimited(

91✔

264

                    map_err(tag("is_executable(\"")),

91✔

265

                    parse_non_regex_path,

91✔

266

                    map_err(tag("\")")),

91✔

267

),

91✔

268

                Function::IsExecutable,

91✔

269

),

91✔

270

            map(

91✔

271

                delimited(

91✔

272

                    map_err(tag("active(\"")),

91✔

273

                    parse_non_regex_path,

91✔

274

                    map_err(tag("\")")),

91✔

275

),

91✔

276

                Function::ActivePath,

91✔

277

),

91✔

278

            map(

91✔

279

                delimited(

91✔

280

                    map_err(tag("active(\"")),

91✔

281

                    parse_regex_filename,

91✔

282

                    map_err(tag("\")")),

91✔

283

),

91✔

284

                Function::ActiveRegex,

91✔

285

),

91✔

286

            map(

91✔

287

                delimited(

91✔

288

                    map_err(tag("is_master(\"")),

91✔

289

                    parse_non_regex_path,

91✔

290

                    map_err(tag("\")")),

91✔

291

),

91✔

292

                Function::IsMaster,

91✔

293

),

91✔

294

            map(

91✔

295

                delimited(

91✔

296

                    map_err(tag("many(\"")),

91✔

297

                    parse_regex_path,

91✔

298

                    map_err(tag("\")")),

91✔

299

),

91✔

300

                |(path, regex)| Function::Many(path, regex),

91✔

301

),

91✔

302

            map(

91✔

303

                delimited(

91✔

304

                    map_err(tag("many_active(\"")),

91✔

305

                    parse_regex_filename,

91✔

306

                    map_err(tag("\")")),

91✔

307

),

91✔

308

                Function::ManyActive,

91✔

309

),

91✔

310

            map(

91✔

311

                delimited(

91✔

312

                    map_err(tag("version(")),

91✔

313

                    parse_version_args,

91✔

314

                    map_err(tag(")")),

91✔

315

),

91✔

316

                |(path, version, comparator)| Function::Version(path, version, comparator),

91✔

317

),

91✔

318

            map(

91✔

319

                delimited(

91✔

320

                    map_err(tag("product_version(")),

91✔

321

                    parse_version_args,

91✔

322

                    map_err(tag(")")),

91✔

323

),

91✔

324

                |(path, version, comparator)| Function::ProductVersion(path, version, comparator),

91✔

325

),

91✔

326

            map(

91✔

327

                delimited(

91✔

328

                    map_err(tag("filename_version(")),

91✔

329

                    parse_filename_version_args,

91✔

330

                    map_err(tag(")")),

91✔

331

),

91✔

332

                |(path, regex, version, comparator)| {

91✔

333

                    Function::FilenameVersion(path, regex, version, comparator)

1✔

334

},

91✔

335

),

91✔

336

            map(

91✔

337

                delimited(

91✔

338

                    map_err(tag("checksum(")),

91✔

339

                    parse_checksum_args,

91✔

340

                    map_err(tag(")")),

91✔

341

),

91✔

342

                |(path, crc)| Function::Checksum(path, crc),

91✔

343

),

91✔

344

            map(

91✔

345

                delimited(

91✔

346

                    map_err(tag("description_contains(")),

91✔

347

                    parse_description_contains_args,

91✔

348

                    map_err(tag(")")),

91✔

349

),

91✔

350

                |(path, regex)| Function::DescriptionContains(path, regex),

91✔

351

),

91✔

352

))

91✔

353

        .parse(input)

91✔

354

91✔

362

    fn parse_regex_should_produce_case_insensitive_regex() {

1✔

363

        let (_, regex) = parse_regex("cargo.*").unwrap();

1✔

364

1✔

365

        assert!(regex.is_match("Cargo.toml"));

1✔

366

1✔

369

    fn parse_regex_should_produce_a_regex_that_does_partially_match() {

1✔

370

        let (_, regex) = parse_regex("argo.").unwrap();

1✔

371

1✔

372

        assert!(regex.is_match("Cargo.toml"));

1✔

373

1✔

376

    fn parse_anchored_regex_should_produce_case_insensitive_regex() {

1✔

377

        let (_, regex) = parse_anchored_regex("cargo.*").unwrap();

1✔

378

1✔

379

        assert!(regex.is_match("Cargo.toml"));

1✔

380

1✔

383

    fn parse_anchored_regex_should_produce_a_regex_that_does_not_partially_match() {

1✔

384

        let (_, regex) = parse_anchored_regex("cargo.").unwrap();

1✔

385

1✔

386

        assert!(!regex.is_match("Cargo.toml"));

1✔

387

1✔

390

    fn function_parse_should_parse_a_file_path_function() {

1✔

391

        let output = Function::parse("file(\"Cargo.toml\")").unwrap();

1✔

392

1✔

393

        assert!(output.0.is_empty());

1✔

394

        match output.1 {

1✔

395

            Function::FilePath(f) => assert_eq!(Path::new("Cargo.toml"), f),

1✔

398

1✔

401

    fn function_parse_should_error_if_the_file_path_is_outside_the_game_directory() {

1✔

402

        assert!(Function::parse("file(\"../../Cargo.toml\")").is_err());

1✔

403

1✔

406

    fn function_parse_should_parse_a_file_regex_function_with_no_parent_path() {

1✔

407

        let output = Function::parse("file(\"Cargo.*\")").unwrap();

1✔

408

1✔

409

        assert!(output.0.is_empty());

1✔

410

        match output.1 {

1✔

411

            Function::FileRegex(p, r) => {

1✔

412

                assert_eq!(PathBuf::from("."), p);

1✔

413

                assert_eq!(Regex::new("^Cargo.*$").unwrap().as_str(), r.as_str());

1✔

417

1✔

420

    fn function_parse_should_parse_a_file_regex_function_with_a_parent_path() {

1✔

421

        let output = Function::parse("file(\"subdir/Cargo.*\")").unwrap();

1✔

422

1✔

423

        assert!(output.0.is_empty());

1✔

424

        match output.1 {

1✔

425

            Function::FileRegex(p, r) => {

1✔

426

                assert_eq!(PathBuf::from("subdir"), p);

1✔

427

                assert_eq!(Regex::new("^Cargo.*$").unwrap().as_str(), r.as_str());

1✔

431

1✔

434

    fn function_parse_should_error_if_given_a_file_regex_function_ending_in_a_forward_slash() {

1✔

435

        assert!(Function::parse("file(\"sub\\dir/\")").is_err());

1✔

436

1✔

439

    fn function_parse_should_error_if_the_file_regex_parent_path_is_outside_the_game_directory() {

1✔

440

        assert!(Function::parse("file(\"../../Cargo.*\")").is_err());

1✔

441

1✔

444

    fn function_parse_should_parse_a_file_size_function() {

1✔

445

        let output = Function::parse("file_size(\"Cargo.toml\", 1234)").unwrap();

1✔

446

1✔

447

        assert!(output.0.is_empty());

1✔

448

        match output.1 {

1✔

449

            Function::FileSize(f, s) => {

1✔

450

                assert_eq!(Path::new("Cargo.toml"), f);

1✔

451

                assert_eq!(1234, s);

1✔

455

1✔

458

    fn function_parse_should_error_if_the_file_size_is_outside_the_game_directory() {

1✔

459

        assert!(Function::parse("file_size(\"../../Cargo.toml\", 1234)").is_err());

1✔

460

1✔

463

    fn function_parse_should_parse_a_readable_function() {

1✔

464

        let output = Function::parse("readable(\"Cargo.toml\")").unwrap();

1✔

465

1✔

466

        assert!(output.0.is_empty());

1✔

467

        match output.1 {

1✔

468

            Function::Readable(f) => assert_eq!(Path::new("Cargo.toml"), f),

1✔

471

1✔

474

    fn function_parse_should_error_if_the_readable_path_is_outside_the_game_directory() {

1✔

475

        assert!(Function::parse("readable(\"../../Cargo.toml\")").is_err());

1✔

476

1✔

479

    fn function_parse_should_parse_an_is_executable_function() {

1✔

480

        let output = Function::parse("is_executable(\"Cargo.toml\")").unwrap();

1✔

481

1✔

482

        assert!(output.0.is_empty());

1✔

483

        match output.1 {

1✔

484

            Function::IsExecutable(f) => assert_eq!(Path::new("Cargo.toml"), f),

1✔

487

1✔

490

    fn function_parse_should_error_if_the_is_executable_path_is_outside_the_game_directory() {

1✔

491

        assert!(Function::parse("is_executable(\"../../Cargo.toml\")").is_err());

1✔

492

1✔

495

    fn function_parse_should_parse_an_active_path_function() {

1✔

496

        let output = Function::parse("active(\"Cargo.toml\")").unwrap();

1✔

497

1✔

498

        assert!(output.0.is_empty());

1✔

499

        match output.1 {

1✔

500

            Function::ActivePath(f) => assert_eq!(Path::new("Cargo.toml"), f),

1✔

503

1✔

506

    fn function_parse_should_error_if_the_active_path_is_outside_the_game_directory() {

1✔

507

        // Trying to check if a path that isn't a plugin in the data folder is

1✔

508

        // active is pointless, but it's not worth having a more specific check.

1✔

509

        assert!(Function::parse("active(\"../../Cargo.toml\")").is_err());

1✔

510

1✔

513

    fn function_parse_should_parse_an_active_regex_function() {

1✔

514

        let output = Function::parse("active(\"Cargo.*\")").unwrap();

1✔

515

1✔

516

        assert!(output.0.is_empty());

1✔

517

        match output.1 {

1✔

518

            Function::ActiveRegex(r) => {

1✔

519

                assert_eq!(Regex::new("^Cargo.*$").unwrap().as_str(), r.as_str());

1✔

523

1✔

526

    fn function_parse_should_parse_an_is_master_function() {

1✔

527

        let output = Function::parse("is_master(\"Blank.esm\")").unwrap();

1✔

528

1✔

529

        assert!(output.0.is_empty());

1✔

530

        match output.1 {

1✔

531

            Function::IsMaster(f) => assert_eq!(Path::new("Blank.esm"), f),

1✔

534

1✔

537

    fn function_parse_should_error_if_the_is_master_path_is_outside_the_game_directory() {

1✔

538

        // Trying to check if a path that isn't a plugin in the data folder is

1✔

539

        // active is pointless, but it's not worth having a more specific check.

1✔

540

        assert!(Function::parse("is_master(\"../../Blank.esm\")").is_err());

1✔

541

1✔

544

    fn function_parse_should_parse_a_many_function_with_no_parent_path() {

1✔

545

        let output = Function::parse("many(\"Cargo.*\")").unwrap();

1✔

546

1✔

547

        assert!(output.0.is_empty());

1✔

548

        match output.1 {

1✔

549

            Function::Many(p, r) => {

1✔

550

                assert_eq!(PathBuf::from("."), p);

1✔

551

                assert_eq!(Regex::new("^Cargo.*$").unwrap().as_str(), r.as_str());

1✔

555

1✔

558

    fn function_parse_should_parse_a_many_function_with_a_parent_path() {

1✔

559

        let output = Function::parse("many(\"subdir/Cargo.*\")").unwrap();

1✔

560

1✔

561

        assert!(output.0.is_empty());

1✔

562

        match output.1 {

1✔

563

            Function::Many(p, r) => {

1✔

564

                assert_eq!(PathBuf::from("subdir"), p);

1✔

565

                assert_eq!(Regex::new("^Cargo.*$").unwrap().as_str(), r.as_str());

1✔

569

1✔

572

    fn function_parse_should_error_if_given_a_many_function_ending_in_a_forward_slash() {

1✔

573

        assert!(Function::parse("many(\"subdir/\")").is_err());

1✔

574

1✔

577

    fn function_parse_should_error_if_the_many_parent_path_is_outside_the_game_directory() {

1✔

578

        assert!(Function::parse("file(\"../../Cargo.*\")").is_err());

1✔

579

1✔

582

    fn function_parse_should_parse_a_many_active_function() {

1✔

583

        let output = Function::parse("many_active(\"Cargo.*\")").unwrap();

1✔

584

1✔

585

        assert!(output.0.is_empty());

1✔

586

        match output.1 {

1✔

587

            Function::ManyActive(r) => {

1✔

588

                assert_eq!(Regex::new("^Cargo.*$").unwrap().as_str(), r.as_str());

1✔

592

1✔

595

    fn function_parse_should_parse_a_checksum_function() {

1✔

596

        let output = Function::parse("checksum(\"Cargo.toml\", DEADBEEF)").unwrap();

1✔

597

1✔

598

        assert!(output.0.is_empty());

1✔

599

        match output.1 {

1✔

600

            Function::Checksum(path, crc) => {

1✔

601

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

602

                assert_eq!(0xDEAD_BEEF, crc);

1✔

606

1✔

609

    fn function_parse_should_error_if_the_checksum_path_is_outside_the_game_directory() {

1✔

610

        assert!(Function::parse("checksum(\"../../Cargo.toml\", DEADBEEF)").is_err());

1✔

611

1✔

614

    fn function_parse_should_parse_a_version_equals_function() {

1✔

615

        let output = Function::parse("version(\"Cargo.toml\", \"1.2\", ==)").unwrap();

1✔

616

1✔

617

        assert!(output.0.is_empty());

1✔

618

        match output.1 {

1✔

619

            Function::Version(path, version, comparator) => {

1✔

620

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

621

                assert_eq!("1.2", version);

1✔

622

                assert_eq!(ComparisonOperator::Equal, comparator);

1✔

626

1✔

629

    fn function_parse_should_parse_a_version_not_equals_function() {

1✔

630

        let output = Function::parse("version(\"Cargo.toml\", \"1.2\", !=)").unwrap();

1✔

631

1✔

632

        assert!(output.0.is_empty());

1✔

633

        match output.1 {

1✔

634

            Function::Version(path, version, comparator) => {

1✔

635

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

636

                assert_eq!("1.2", version);

1✔

637

                assert_eq!(ComparisonOperator::NotEqual, comparator);

1✔

641

1✔

644

    fn function_parse_should_parse_a_version_less_than_function() {

1✔

645

        let output = Function::parse("version(\"Cargo.toml\", \"1.2\", <)").unwrap();

1✔

646

1✔

647

        assert!(output.0.is_empty());

1✔

648

        match output.1 {

1✔

649

            Function::Version(path, version, comparator) => {

1✔

650

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

651

                assert_eq!("1.2", version);

1✔

652

                assert_eq!(ComparisonOperator::LessThan, comparator);

1✔

656

1✔

659

    fn function_parse_should_parse_a_version_greater_than_function() {

1✔

660

        let output = Function::parse("version(\"Cargo.toml\", \"1.2\", >)").unwrap();

1✔

661

1✔

662

        assert!(output.0.is_empty());

1✔

663

        match output.1 {

1✔

664

            Function::Version(path, version, comparator) => {

1✔

665

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

666

                assert_eq!("1.2", version);

1✔

667

                assert_eq!(ComparisonOperator::GreaterThan, comparator);

1✔

671

1✔

674

    fn function_parse_should_parse_a_version_less_than_or_equal_to_function() {

1✔

675

        let output = Function::parse("version(\"Cargo.toml\", \"1.2\", <=)").unwrap();

1✔

676

1✔

677

        assert!(output.0.is_empty());

1✔

678

        match output.1 {

1✔

679

            Function::Version(path, version, comparator) => {

1✔

680

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

681

                assert_eq!("1.2", version);

1✔

682

                assert_eq!(ComparisonOperator::LessThanOrEqual, comparator);

1✔

686

1✔

689

    fn function_parse_should_parse_a_version_greater_than_or_equal_to_function() {

1✔

690

        let output = Function::parse("version(\"Cargo.toml\", \"1.2\", >=)").unwrap();

1✔

691

1✔

692

        assert!(output.0.is_empty());

1✔

693

        match output.1 {

1✔

694

            Function::Version(path, version, comparator) => {

1✔

695

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

696

                assert_eq!("1.2", version);

1✔

697

                assert_eq!(ComparisonOperator::GreaterThanOrEqual, comparator);

1✔

701

1✔

704

    fn function_parse_should_parse_a_version_with_a_path_containing_backslashes() {

1✔

705

        let output = Function::parse("version(\"..\\Cargo.toml\", \"1.2\", ==)").unwrap();

1✔

706

1✔

707

        assert!(output.0.is_empty());

1✔

708

        match output.1 {

1✔

709

            Function::Version(path, version, comparator) => {

1✔

710

                assert_eq!(Path::new("..\\Cargo.toml"), path);

1✔

711

                assert_eq!("1.2", version);

1✔

712

                assert_eq!(ComparisonOperator::Equal, comparator);

1✔

716

1✔

719

    fn function_parse_should_error_if_the_version_path_is_outside_the_game_directory() {

1✔

720

        assert!(Function::parse("version(\"../../Cargo.toml\", \"1.2\", ==)").is_err());

1✔

721

1✔

724

    fn function_parse_should_parse_a_product_version_equals_function() {

1✔

725

        let output = Function::parse("product_version(\"Cargo.toml\", \"1.2\", ==)").unwrap();

1✔

726

1✔

727

        assert!(output.0.is_empty());

1✔

728

        match output.1 {

1✔

729

            Function::ProductVersion(path, version, comparator) => {

1✔

730

                assert_eq!(Path::new("Cargo.toml"), path);

1✔

731

                assert_eq!("1.2", version);

1✔

732

                assert_eq!(ComparisonOperator::Equal, comparator);

1✔

736

1✔

739

    fn function_parse_should_error_if_the_product_version_path_is_outside_the_game_directory() {

1✔

740

        assert!(Function::parse("product_version(\"../../Cargo.toml\", \"1.2\", ==)").is_err());

1✔

741

1✔

744

    fn function_parse_should_parse_a_filename_version_equals_function() {

1✔

745

        let output =

1✔

746

            Function::parse("filename_version(\"subdir/Cargo (.+).toml\", \"1.2\", ==)").unwrap();

1✔

747

1✔

748

        assert!(output.0.is_empty());

1✔

749

        match output.1 {

1✔

750

            Function::FilenameVersion(path, regex, version, comparator) => {

1✔

751

                assert_eq!(PathBuf::from("subdir"), path);

1✔

752

                assert_eq!(

1✔

753

                    Regex::new("^Cargo (.+).toml$").unwrap().as_str(),

1✔

754

                    regex.as_str()

1✔

755

);

1✔

756

                assert_eq!("1.2", version);

1✔

757

                assert_eq!(ComparisonOperator::Equal, comparator);

1✔

761

1✔

764

    fn function_parse_should_error_if_the_filename_version_regex_does_not_contain_an_explicit_capture_group(

1✔

765

) {

1✔

766

        assert!(

1✔

767

            Function::parse("filename_version(\"subdir/Cargo .+.toml\", \"1.2\", ==)").is_err()

1✔

768

);

1✔

769

1✔

772

    fn function_parse_should_parse_a_description_contains_function() {

1✔

773

        let lowercase_non_ascii = "\u{20ac}\u{192}.";

1✔

774

        let function = format!("description_contains(\"Blank.esp\", \"{lowercase_non_ascii}\")");

1✔

775

        let output = Function::parse(&function).unwrap();

1✔

776

1✔

777

        assert!(output.0.is_empty());

1✔

778

        match output.1 {

1✔

779

            Function::DescriptionContains(p, r) => {

1✔

780

                assert_eq!(PathBuf::from("Blank.esp"), p);

1✔

781

                assert_eq!(

1✔

782

                    Regex::new(lowercase_non_ascii).unwrap().as_str(),

1✔

783

                    r.as_str()

1✔

784

);

1✔

788

1✔

loot / loot-condition-interpreter / 14679793593

Source File
Press 'n' to go to next uncovered line, 'b' for previous

loot / loot-condition-interpreter / 14679793593

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous