PrimeIntellect/SWE-rebench-V2-Filtered-Easy-Verified huggingface dataset:
Repository: MiSawa/xq (rust)
Issue: Panics on comparison of booleans
Comparison on booleans panics.

```sh
 $ xq -n 'false < true'
thread 'main' panicked at 'internal error: entered unreachable code', src/intrinsic/comparator.rs:99:17
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
```

xq: 0.1.0-d3808e624efc78b26ebd3c464bea59132f83aec8
Pull request description: Fix boolean comparison. Resolves #15

Patch:
diff --git a/src/intrinsic/comparator.rs b/src/intrinsic/comparator.rs
index fc41f92..a603c02 100644
--- a/src/intrinsic/comparator.rs
+++ b/src/intrinsic/comparator.rs
@@ -73,6 +73,7 @@ impl<'a> Ord for ComparableValue<'a> {
             (Null, Null) | (Boolean(true), Boolean(true)) | (Boolean(false), Boolean(false)) => {
                 Equal
             }
+            (Boolean(lhs), Boolean(rhs)) => Ord::cmp(lhs, rhs),
             (Number(lhs), Number(rhs)) => Ord::cmp(&lhs, &rhs),
             (String(lhs), String(rhs)) => Ord::cmp(&lhs, &rhs),
             (Array(lhs), Array(rhs)) => Iterator::cmp(


Test patch:
diff --git a/tests/hand_written/mod.rs b/tests/hand_written/mod.rs
index 9d9711a..11f6091 100644
--- a/tests/hand_written/mod.rs
+++ b/tests/hand_written/mod.rs
@@ -44,3 +44,30 @@ test!(
     "3.9 2147483647 2147483648.0"
     "#
 );
+
+test!(
+    boolean_comparison,
+    r#"
+    [
+    false < false, false < true, true < false, false < false,
+    false <= false, false <= true, true <= false, false <= false,
+    false > false, false > true, true > false, false > false,
+    false >= false, false >= true, true >= false, false >= false,
+    false == false, false == true, true == false, false == false,
+    false != false, false != true, true != false, false != false
+    ]
+    "#,
+    r#"
+    null
+    "#,
+    r#"
+    [
+    false, true, false, false,
+    true, true, false, true,
+    false, false, true, false,
+    true, false, true, true,
+    true, false, false, true,
+    false, true, true, false
+    ]
+    "#
+);
\ No newline at end of file
Repository: platers/obsidian-linter (ts)
Issue: Bug: incorrect/spurious transformation être → êtree.
## Describe the Bug

When a text contains "être", this word is **transformed into "êtree"**, which is **incorrect** (in French).

## How to Reproduce

Steps to reproduce the behavior:

0. Make sure that "**Auto-correct common misspellings**" is On in the Linter settings.
1. Type "être" in a note.
2. Launch the linter.

## Expected Behavior

The word "être" should instead not be touched.

## Device

- [X] Desktop
- Mobile not tested

Pull request description: Fix Unicode Issue with Autocorrect
Fixes #633 

When checking for words to autocorrect, make sure unicode is supported since `\w` is not unicode aware.

Changes Made:
- Updated the regex in order to include unicode values as well
- Added a test to make sure it would not happen where the scenario in question happens again

Patch:
diff --git a/src/rules/auto-correct-common-misspellings.ts b/src/rules/auto-correct-common-misspellings.ts
index 2287ccd..5eeecf9 100644
--- a/src/rules/auto-correct-common-misspellings.ts
+++ b/src/rules/auto-correct-common-misspellings.ts
@@ -23,7 +23,7 @@ export default class AutoCorrectCommonMisspellings extends RuleBuilder<AutoCorre
   }
   apply(text: string, options: AutoCorrectCommonMisspellingsOptions): string {
     return ignoreListOfTypes([IgnoreTypes.yaml, IgnoreTypes.code, IgnoreTypes.inlineCode, IgnoreTypes.math, IgnoreTypes.inlineMath, IgnoreTypes.link, IgnoreTypes.wikiLink, IgnoreTypes.tag, IgnoreTypes.image, IgnoreTypes.url], text, (text) => {
-      const wordRegex = /[\w\-'’`]+/g;
+      const wordRegex = /[\p{L}\p{N}\p{Pc}\p{M}\-'’`]+/gu;
 
       return text.replaceAll(wordRegex, (word: string) => {
         const lowercasedWord = word.toLowerCase();


Test patch:
diff --git a/__tests__/auto-correct-common-misspellings.test.ts b/__tests__/auto-correct-common-misspellings.test.ts
index 1ec9f89..469ad84 100644
--- a/__tests__/auto-correct-common-misspellings.test.ts
+++ b/__tests__/auto-correct-common-misspellings.test.ts
@@ -27,5 +27,14 @@ ruleTest({
         ![absoltely not a changed](absoltely.not.changed.md)
       `,
     },
+    {
+      testName: 'Doesn\'t auto-correct words that start with unicode specific characters when not in correction list',
+      before: dedent`
+        être
+      `,
+      after: dedent`
+        être
+      `,
+    },
   ],
 });
Repository: unexpectedjs/unexpected (js)
Issue: Accept "not to be defined" (equivalent to "to be undefined")
Occasionally I write `"not to be defined"`, and run my tests, then remember that I need to phrase it `"to be undefined"`.  It would be nice if Unexpected accepted either one (with both meaning the same thing).
Pull request description: Allow "not to be defined" to check for undefined.
Closes #649

Patch:
diff --git a/documentation/assertions/any/to-be-defined.md b/documentation/assertions/any/to-be-defined.md
index 668592e3..8a0b2a51 100644
--- a/documentation/assertions/any/to-be-defined.md
+++ b/documentation/assertions/any/to-be-defined.md
@@ -5,6 +5,12 @@ expect('Hello world!', 'to be defined');
 expect({ foo: { bar: 'baz' } }, 'to be defined');
 ```
 
+This assertion can be negated using the `not` flag:
+
+```js
+expect(undefined, 'not to be defined');
+```
+
 In case of a failing expectation you get the following output:
 
 ```js
diff --git a/lib/assertions.js b/lib/assertions.js
index 9f82a321..0a23eb94 100644
--- a/lib/assertions.js
+++ b/lib/assertions.js
@@ -77,8 +77,8 @@ module.exports = expect => {
     expect(typeof subject === 'undefined', '[not] to be truthy');
   });
 
-  expect.addAssertion('<any> to be defined', (expect, subject) => {
-    expect(subject, 'not to be undefined');
+  expect.addAssertion('<any> [not] to be defined', (expect, subject) => {
+    expect(subject, '[!not] to be undefined');
   });
 
   expect.addAssertion('<number|NaN> [not] to be NaN', (expect, subject) => {


Test patch:
diff --git a/test/assertions/to-be.spec.js b/test/assertions/to-be.spec.js
index de616063..c450e1fa 100644
--- a/test/assertions/to-be.spec.js
+++ b/test/assertions/to-be.spec.js
@@ -15,6 +15,7 @@ describe('to be assertion', () => {
     expect(false, 'not to be true');
     expect(false, 'to be false');
     expect(true, 'not to be false');
+    expect(undefined, 'not to be defined');
     expect(undefined, 'to be undefined');
     expect(false, 'to be defined');
     expect({}, 'to be defined');
Repository: maizzle/framework (js)
Issue: Support defining `build.templates.source` as a function
Would be useful in cases where you have to do some work before figuring out which paths to source templates from.

- [x] must return path(s) as `string` or `array`
  - [x] throw if otherwise
- [x] expose `page` object

Pull request description: refactor template source
This PR: 

- adds support for defining `templates.source` as a function
- supports defining `templates.source` as either a string or an array

For example, you can now do something like this:

```js
module.exports = {
  build: {
    templates: {
      source: () => ['src/some/templates', 'src/other/templates'],
      // ...
    }
  }
}
```

Closes #560 

Patch:
diff --git a/src/generators/output/to-disk.js b/src/generators/output/to-disk.js
index 3674ffd..7ab8a06 100644
--- a/src/generators/output/to-disk.js
+++ b/src/generators/output/to-disk.js
@@ -31,13 +31,16 @@ module.exports = async (env, spinner, config) => {
     ? config.tailwind.compiled
     : await Tailwind.compile('@tailwind components; @tailwind utilities;', '', {}, config)
 
+  // Parse each template config object
   await asyncForEach(templatesConfig, async templateConfig => {
     const outputDir = get(templateConfig, 'destination.path', `build_${env}`)
 
     await fs.remove(outputDir)
 
+    const source = typeof templateConfig.source === 'function' ? templateConfig.source() : templateConfig.source
+
     await fs
-      .copy(templateConfig.source, outputDir)
+      .copy(source, outputDir)
       .then(async () => {
         const extensions = Array.isArray(templateConfig.filetypes)
           ? templateConfig.filetypes.join('|')


Test patch:
diff --git a/test/test-todisk.js b/test/test-todisk.js
index d4cc644..c1aaf48 100644
--- a/test/test-todisk.js
+++ b/test/test-todisk.js
@@ -416,3 +416,20 @@ test('throws if it cannot spin up local development server', async t => {
     await Maizzle.serve('local', {})
   }, {instanceOf: TypeError})
 })
+
+test('works with templates.source defined as function', async t => {
+  const {files} = await Maizzle.build('production', {
+    build: {
+      fail: 'silent',
+      templates: {
+        source: () => 'test/stubs/templates',
+        destination: {
+          path: t.context.folder
+        }
+      }
+    }
+  })
+
+  t.true(fs.pathExistsSync(t.context.folder))
+  t.is(files.length, 3)
+})