PrimeIntellect/SWE-rebench-V2 huggingface dataset:
Repository: stylelint-scss/stylelint-scss (js)

Issue:
at-rule-no-redundant triggers incorrectly when some (but not all) selector has "&"
Example input in Sass:
```scss
.foo {
  @at-root .bar,
  &baz {
    a: b;
  }
}

.foo {
  .bar,
  &baz {
    a: b;
  }
}
```
https://sass-lang.com/playground/#eJwzNNRLy89XqOZSUHBILNEtys8vUdBLSizSAQqoJSVWgWUUFBKtFJKsgaxarlouLrgO/AoBMc4WWQ==

The rule for `@at-root` will trigger saying it's redundant and should be removed. This implies both rules have the same output, however that's not correct. So rather than showing the linter error when _any_ selector has `&`, it should happen only when `_every_` selector does.

cc: @pamelalozano16 

Pull request:
Check if all selectors followed by @at-root include '&' outside interpolation
Fix #868.

Patch:
diff --git a/src/rules/at-root-no-redundant/index.js b/src/rules/at-root-no-redundant/index.js
index 695f659..6d346c6 100644
--- a/src/rules/at-root-no-redundant/index.js
+++ b/src/rules/at-root-no-redundant/index.js
@@ -38,7 +38,10 @@ function rule(actual, _, context) {
     root.walkAtRules("at-root", node => {
       if (
         node.parent.type === "root" ||
-        node.params.replace(/#{.*}/g, "").includes("&") ||
+        node.params
+          .replace(/#{.*}/g, "")
+          .split(",")
+          .every(param => param.includes("&")) ||
         isWithinKeyframes(node)
       ) {
         if (context.fix) {


Test patch:
diff --git a/src/rules/at-root-no-redundant/__tests__/index.js b/src/rules/at-root-no-redundant/__tests__/index.js
index 880bf74..c63d57e 100644
--- a/src/rules/at-root-no-redundant/__tests__/index.js
+++ b/src/rules/at-root-no-redundant/__tests__/index.js
@@ -62,6 +62,18 @@ testRule({
         }
       }`,
       description: "Other at-rules nested inside @keyframes block."
+    },
+    {
+      code: `
+      .foo {
+        @at-root .bar,
+        &baz {
+          a: b;
+        }
+      }
+      `,
+      description:
+        "@at-root is followed by a nested selector containing`&` outside interpolation."
     }
   ],
   reject: [
@@ -131,6 +143,21 @@ testRule({
       column: 14,
       message: messages.rejected,
       description: "@at-root inside a @keyframes block, nested."
+    },
+    {
+      code: `
+      .foo {
+        @at-root &.bar,
+        &baz {
+          a: b;
+        }
+      }
+      `,
+      line: 3,
+      column: 9,
+      message: messages.rejected,
+      description:
+        "@at-root is followed by selectors all containing `&` outside interpolation."
     }
   ]
 });
@@ -198,6 +225,29 @@ testRule({
       column: 9,
       message: messages.rejected,
       description: "@at-root inside a @keyframes block, nested."
+    },
+    {
+      code: `
+      .foo {
+        @at-root &.bar,
+        &baz {
+          a: b;
+        }
+      }
+      `,
+      fixed: `
+      .foo {
+        &.bar,
+        &baz {
+          a: b;
+        }
+      }
+      `,
+      line: 3,
+      column: 9,
+      message: messages.rejected,
+      description:
+        "@at-root is followed by selectors all containing `&` outside interpolation."
     }
   ]
 });
Repository: diegoholiveira/jsonlogic (go)

Issue:
Issue with map operation
Hey @diegoholiveira 

I'm having an issue when using `map` operation. Basically I'm trying to iterate over an array of arrays, and then using the `in` operation to evaluate for every given array if the passed argument is present in each one. My rule looks like this:
```json
{
  "map": [
    {
      "var": "listOfLists"
    },
    {
      "in": [
        "item_a",
        {
          "var": ""
        }
      ]
    }
  ]
}
```
And the input data:
```json
{
  "listOfLists": [
    ["item_a", "item_b", "item_c"],
    ["item_b", "item_c"],
    ["item_a", "item_c"]
  ]
}
```
So basically I expect to get an array of booleans as output, that informs me for every list if `item_a` was present:
```json
[
    true,
    false,
    true
]
```
But for some reason, this is what I'm getting:
```json
[
    true,
    true
]
```
It looks like it's ignoring false values, showing only the true ones. For the record, I ran the test in the [JsonLogic site](https://jsonlogic.com/play.html) and I get the result I was expecting, so I think It could be an issue with the map implementation.
Thanks!

Pull request:
Ensure all boolean output from map is considered
close #83 

Patch:
diff --git a/arrays.go b/arrays.go
index e7c4f03..559c166 100644
--- a/arrays.go
+++ b/arrays.go
@@ -66,7 +66,7 @@ func _map(values, data interface{}) interface{} {
 	for _, value := range subject.([]interface{}) {
 		v := parseValues(logic, value)
 
-		if isTrue(v) || isNumber(v) {
+		if isTrue(v) || isNumber(v) || isBool(v) {
 			result = append(result, v)
 		}
 	}


Test patch:
diff --git a/internal/issues/0083_test.go b/internal/issues/0083_test.go
new file mode 100644
index 0000000..01fcc1e
--- /dev/null
+++ b/internal/issues/0083_test.go
@@ -0,0 +1,37 @@
+package issues_test
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/diegoholiveira/jsonlogic/v3"
+)
+
+func TestIssue83(t *testing.T) {
+	rule := `{
+	  "map": [
+	    {"var": "listOfLists"},
+	    {"in": ["item_a", {"var": ""}]}
+	  ]
+	}`
+
+	data := `{
+	  "listOfLists": [
+	    ["item_a", "item_b", "item_c"],
+	    ["item_b", "item_c"],
+	    ["item_a", "item_c"]
+	  ]
+	}`
+
+	var result bytes.Buffer
+
+	err := jsonlogic.Apply(strings.NewReader(rule), strings.NewReader(data), &result)
+
+	if assert.Nil(t, err) {
+		expected := `[true,false,true]`
+		assert.JSONEq(t, expected, result.String())
+	}
+}
Repository: clojure-lsp/clojure-lsp (clojure)

Issue:
A colon isn't recognized as a valid character in a symbol
I occasionally like to use colons as an ad hoc namespacing facility when I'm naming vars. Clojure allows this:

```
Clojure 1.10.0
user=> (defn foo:bar [x]
         (* 2 x))
#'user/foo:bar
user=> (foo:bar 3)
6
```

clojure-lsp's definition of a valid symbol doesn't seem to include colons (and perhaps other rare symbols?)

![2020-01-14-123325_541x204_scrot](https://user-images.githubusercontent.com/4909079/72367518-507ec380-36ca-11ea-88c9-86b06f757960.png)

Pull request:
Small patch to fix #100

Patch:
diff --git a/src/clojure_lsp/parser.clj b/src/clojure_lsp/parser.clj
index 92cc58f14..3e837014e 100644
--- a/src/clojure_lsp/parser.clj
+++ b/src/clojure_lsp/parser.clj
@@ -58,7 +58,7 @@
   (z/find-next loc z/right #(not (n/printable-only? (z/node %)))))
 
 (defn ident-split [ident-str]
-  (let [ident-conformed (some-> ident-str (string/replace ":" ""))
+  (let [ident-conformed (some-> ident-str (string/replace #"^::?" ""))
         prefix (string/replace ident-str #"^(::?)?.*" "$1")
         idx (string/index-of ident-conformed "/")]
     (if (and idx (not= idx (dec (count ident-conformed))))


Test patch:
diff --git a/test/clojure_lsp/parser_test.clj b/test/clojure_lsp/parser_test.clj
index 96d43a9b1..b613ae595 100644
--- a/test/clojure_lsp/parser_test.clj
+++ b/test/clojure_lsp/parser_test.clj
@@ -557,3 +557,9 @@
         [_ _ _ _ _  x1 x2 x3] usages]
     (is (= 1 (:argc x1) (:argc x2)))
     (is (= 2 (:argc x3)))))
+
+(deftest colon-symbols
+  (let [code "(def foo:bar 12)"
+        usages (parser/find-usages code :clj {})
+        [_ foobar _] usages]
+    (is (= 'user/foo:bar (:sym foobar)))))
Repository: cypress-io/eslint-plugin-cypress (js)

Issue:
require-data-selectors rule should not apply to cy.get('@alias')
Hello,

I was in the midst of updating Cypress related packages, and updated this package to the latest 2.9.0 release. I also realized there's the **require-data-selectors** rule which I recently enabled as a warning. However, now I have a whole bunch of warnings for places where I use aliases, e.g.
```javascript
cy.get('[data-test=a]').as('a'); // this is fine
cy.get('@a'); // this is a warning
```

Minor issue as this is a non-essential rule to us, but I thought for posterity it is worth mentioning.

Pull request:
fix: Allow aliases in require-data-selectors rule
- Fixes #44

Hi !
This should fix #44.
It considers valid selectors that start with the character `@` as well as those that start with `[data-`.
I've added tests for both string and template literals.
Please let me know if I've missed anything or if there is a formatting problem.
Thanks for maintaining this eslint plugin ! :)

Patch:
diff --git a/lib/rules/require-data-selectors.js b/lib/rules/require-data-selectors.js
index f3f76af..7325cff 100644
--- a/lib/rules/require-data-selectors.js
+++ b/lib/rules/require-data-selectors.js
@@ -40,7 +40,13 @@ function isCallingCyGet (node) {
 function isDataArgument (node) {
   return node.arguments.length > 0 &&
     (
-      (node.arguments[0].type === 'Literal' && String(node.arguments[0].value).startsWith('[data-')) ||
-      (node.arguments[0].type === 'TemplateLiteral' && String(node.arguments[0].quasis[0].value.cooked).startsWith('[data-'))
+      (node.arguments[0].type === 'Literal' && isAliasOrDataSelector(String(node.arguments[0].value))) ||
+      (node.arguments[0].type === 'TemplateLiteral' && isAliasOrDataSelector(String(node.arguments[0].quasis[0].value.cooked)))
     )
 }
+
+function isAliasOrDataSelector (selector) {
+  return ['[data-', '@'].some(function (validValue) {
+    return selector.startsWith(validValue)
+  })
+}


Test patch:
diff --git a/tests/lib/rules/require-data-selectors.js b/tests/lib/rules/require-data-selectors.js
index 92036bb..93968bf 100644
--- a/tests/lib/rules/require-data-selectors.js
+++ b/tests/lib/rules/require-data-selectors.js
@@ -16,6 +16,8 @@ ruleTester.run('require-data-selectors', rule, {
     { code: 'cy.scrollTo(0, 10)', parserOptions },
     { code: 'cy.tick(500)', parserOptions },
     { code: 'cy.get(\`[data-cy=${1}]\`)', parserOptions },
+    { code: 'cy.get("@my-alias")', parserOptions, errors },
+    { code: 'cy.get(`@my-alias`)', parserOptions, errors },
   ],
 
   invalid: [