PrimeIntellect/SWE-rebench-V2-Filtered-Easy-Verified huggingface dataset:
Repository: zeit-ui/react (ts)
Issue: Table.Column not updating label prop when it's updated.
<!-- Please do NOT DELETE the template. -->
<!-- No template issues will be closed. -->

# Bug report 🐞

## Version & Environment

  - Chrome latest
  - Version of `zeit-ui/react`: ^1.8.0-canary.0

## Expection

When using a table like this:

```
() => {
  const data = [
    { property: 'type', description: 'Content type', type: 'secondary | warning', default: '-' },
    { property: 'Component', description: 'DOM element to use', type: 'string', default: '-' },
    { property: 'bold', description: 'Bold style', type: 'boolean', default: 'true' },
  ]
  const [state, setState] = React.useState(0)
  React.useEffect(() => {
    const interval = setInterval(() => {
      setState((old) => old + 1)
    }, 1000)
    return () => {
      clearInterval(interval)
    }
  }, [])
  return (
    <Table data={data}>
      <Table.Column prop="property" label="property" />
      <Table.Column prop="description" label={`description: ${state}`} />
      <Table.Column prop="type" label="type" />
      <Table.Column prop="default" label="default" />
    </Table>
  )
}
```

The description is not being updated. This is a "minimal" reproducable example, I'm not doing exactly this in my application.

## Actual results (or Errors)

The description label isn't being updated, even though the variable `state` is being updated. 


Pull request description: fix(table): children of column should be kept in sync
## Checklist

- [x] Fix linting errors
- [x] Tests have been added / updated (or snapshots)

## Change information

fixed #359 

Patch:
diff --git a/components/table/table-column.tsx b/components/table/table-column.tsx
index 41acb39..45e2935 100644
--- a/components/table/table-column.tsx
+++ b/components/table/table-column.tsx
@@ -28,7 +28,7 @@ const TableColumn: React.FC<React.PropsWithChildren<TableColumnProps>> = ({
         value: `${prop}`.trim(),
         width,
       })
-  }, [label, prop, width])
+  }, [children, label, prop, width])
 
   return null
 }


Test patch:
diff --git a/components/table/__tests__/index.test.tsx b/components/table/__tests__/index.test.tsx
index cfae28a..2457046 100644
--- a/components/table/__tests__/index.test.tsx
+++ b/components/table/__tests__/index.test.tsx
@@ -185,4 +185,22 @@ describe('Table', () => {
     expect(wrapper.find('thead').find('tr').at(0).text()).toBe('test2')
     expect(() => wrapper.unmount()).not.toThrow()
   })
+
+  it('the changes of children should be tracked', () => {
+    const Mock = ({ label }: { label: string }) => {
+      return (
+        <Table data={data}>
+          <Table.Column prop="description">{label}</Table.Column>
+        </Table>
+      )
+    }
+    const wrapper = mount(<Mock label="test1" />)
+    expect(wrapper.find('thead').find('tr').at(0).text()).toBe('test1')
+
+    act(() => {
+      wrapper.setProps({ label: 'test2' })
+    })
+    expect(wrapper.find('thead').find('tr').at(0).text()).toBe('test2')
+    expect(() => wrapper.unmount()).not.toThrow()
+  })
 })
Repository: jsonata-js/jsonata (js)
Issue: $eval returns empty object if the context value is an empty array
When $eval is provided an empty array, it always returns empty object.

Example:
```
$eval("{ 'test': 1 }", [])
```

Output:
```json
{}
```

Expected Output:
```json
{
  "test": 1
}
```
Pull request description: $eval() - array inputs should be wrapped
The logic for handling the second parameter to this function should be the same as for handling the input to any expression.
This includes wrapping a top level array input in a singleton sequence so it gets treated as a single input.
This code was missing from this function and is added here.

resolves #463 

Signed-off-by: andrew-coleman <andrew_coleman@uk.ibm.com>

Patch:
diff --git a/src/jsonata.js b/src/jsonata.js
index aa40ccf..bfc8db9 100644
--- a/src/jsonata.js
+++ b/src/jsonata.js
@@ -1759,6 +1759,11 @@ var jsonata = (function() {
         var input = this.input;
         if(typeof focus !== 'undefined') {
             input = focus;
+            // if the input is a JSON array, then wrap it in a singleton sequence so it gets treated as a single input
+            if(Array.isArray(input) && !isSequence(input)) {
+                input = createSequence(input);
+                input.outerWrapper = true;
+            }
         }
 
         try {


Test patch:
diff --git a/test/test-suite/groups/function-eval/case008.json b/test/test-suite/groups/function-eval/case008.json
new file mode 100644
index 0000000..e22d718
--- /dev/null
+++ b/test/test-suite/groups/function-eval/case008.json
@@ -0,0 +1,34 @@
+[
+    {
+        "expr": "$eval(\"{ 'test': 1 }\", [])",
+        "data": {},
+        "bindings": {},
+        "result": {
+            "test": 1
+        }
+    },
+    {
+        "expr": "$eval(\"{ 'test': 1 }\")",
+        "data": [],
+        "bindings": {},
+        "result": {
+            "test": 1
+        }
+    },
+    {
+        "expr": "$eval(\"{ 'test': 1 }\", [1,2,3])",
+        "data": [],
+        "bindings": {},
+        "result": {
+            "test": 1
+        }
+    },
+    {
+        "expr": "$eval(\"{ 'test': 1 }\")",
+        "data": [1,2,3],
+        "bindings": {},
+        "result": {
+            "test": 1
+        }
+    }
+]
Repository: tomarrell/lbadd (go)
Issue: parser: select expression doesn't work
Try to parse `SELECT amount * price AS total_price FROM items`. This will throw a lot of errors, although the production

`SELECT result-column ...`

with `result_column` using the `expr` production, and `expr` using the `expr binary-operator expr` allows such a statement.
Pull request description: Patched result column
Fixes #146 

Fixed bug, result column can take recursive expr.

Adds test for proof.

Patch:
diff --git a/internal/parser/simple_parser_rules.go b/internal/parser/simple_parser_rules.go
index 86adae8..ff58f4a 100644
--- a/internal/parser/simple_parser_rules.go
+++ b/internal/parser/simple_parser_rules.go
@@ -3731,7 +3731,12 @@ func (p *simpleParser) parseResultColumn(r reporter) (stmt *ast.ResultColumn) {
 				stmt.Period = period
 			}
 		} else {
-			stmt.Expr = &ast.Expr{LiteralValue: tableNameOrAsteriskOrExpr}
+			recExpr := p.parseExprRecursive(&ast.Expr{LiteralValue: tableNameOrAsteriskOrExpr}, r)
+			if recExpr != nil {
+				stmt.Expr = recExpr
+			} else {
+				stmt.Expr = &ast.Expr{LiteralValue: tableNameOrAsteriskOrExpr}
+			}
 		}
 		next, ok := p.optionalLookahead(r)
 		if !ok || next.Type() == token.EOF || next.Type() == token.StatementSeparator {


Test patch:
diff --git a/internal/parser/parser_test.go b/internal/parser/parser_test.go
index 3f37014..49de30a 100644
--- a/internal/parser/parser_test.go
+++ b/internal/parser/parser_test.go
@@ -9611,6 +9611,40 @@ func TestSingleStatementParse(t *testing.T) {
 				},
 			},
 		},
+		{
+			`SELECT stms's result column with recursive expr`,
+			"SELECT amount * price AS total_price FROM items",
+			&ast.SQLStmt{
+				SelectStmt: &ast.SelectStmt{
+					SelectCore: []*ast.SelectCore{
+						{
+							Select: token.New(1, 1, 0, 6, token.KeywordSelect, "SELECT"),
+							ResultColumn: []*ast.ResultColumn{
+								{
+									Expr: &ast.Expr{
+										Expr1: &ast.Expr{
+											LiteralValue: token.New(1, 8, 7, 6, token.Literal, "amount"),
+										},
+										BinaryOperator: token.New(1, 15, 14, 1, token.BinaryOperator, "*"),
+										Expr2: &ast.Expr{
+											LiteralValue: token.New(1, 17, 16, 5, token.Literal, "price"),
+										},
+									},
+									As:          token.New(1, 23, 22, 2, token.KeywordAs, "AS"),
+									ColumnAlias: token.New(1, 26, 25, 11, token.Literal, "total_price"),
+								},
+							},
+							From: token.New(1, 38, 37, 4, token.KeywordFrom, "FROM"),
+							JoinClause: &ast.JoinClause{
+								TableOrSubquery: &ast.TableOrSubquery{
+									TableName: token.New(1, 43, 42, 5, token.Literal, "items"),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
 	}
 
 	for _, input := range inputs {
Repository: reata/sqllineage (python)
Issue: Table/Column Lineage Mixed up For Self Dependent SQL
```sql
INSERT OVERWRITE TABLE foo
SELECT col FROM foo
WHERE flag IS NOT NULL
```

```
Statements(#): 1
Source Tables:
    <default>.foo
    <default>.foo.col
Target Tables:
    <default>.foo
    <default>.foo.col
```

Column lineage is displayed by mistake here.
Pull request description: fix: table/column lineage mixed up for self dependent SQL
Closes #219 

Patch:
diff --git a/sqllineage/core/holders.py b/sqllineage/core/holders.py
index d9ce561..d82a013 100644
--- a/sqllineage/core/holders.py
+++ b/sqllineage/core/holders.py
@@ -215,11 +215,11 @@ class SQLLineageHolder(ColumnLineageMixin):
         intermediate_tables -= self.__retrieve_tag_tables(NodeTag.SELFLOOP)
         return intermediate_tables
 
-    def __retrieve_tag_tables(self, tag) -> Set[Table]:
+    def __retrieve_tag_tables(self, tag) -> Set[Union[Path, Table]]:
         return {
             table
             for table, attr in self.graph.nodes(data=True)
-            if attr.get(tag) is True
+            if attr.get(tag) is True and isinstance(table, DATASET_CLASSES)
         }
 
     @staticmethod


Test patch:
diff --git a/tests/test_insert.py b/tests/test_insert.py
index 1be5160..b01e1aa 100644
--- a/tests/test_insert.py
+++ b/tests/test_insert.py
@@ -56,6 +56,16 @@ def test_insert_overwrite_values():
 
 
 def test_insert_overwrite_from_self():
+    assert_table_lineage_equal(
+        """INSERT OVERWRITE TABLE foo
+SELECT col FROM foo
+WHERE flag IS NOT NULL""",
+        {"foo"},
+        {"foo"},
+    )
+
+
+def test_insert_overwrite_from_self_with_join():
     assert_table_lineage_equal(
         """INSERT OVERWRITE TABLE tab_1
 SELECT tab_2.col_a from tab_2
Repository: edvardchen/eslint-plugin-i18next (js)
Issue: Some strings should not be checked
I found this plugin really useful, there are some cases where it complains about strings that should not be checked,

for example:

    document.addEventListener('click', () => {})

or also:

    <svg id='my-icon' viewbox='0 0 32 36' />

If somebody can give me some hint where to start I can try providing a pull request.
Pull request description: fix: whitelist addEventListener and few SVG attributes
Fixes #4 

Patch:
diff --git a/lib/rules/no-literal-string.js b/lib/rules/no-literal-string.js
index ee08c14..7dc4956 100644
--- a/lib/rules/no-literal-string.js
+++ b/lib/rules/no-literal-string.js
@@ -72,10 +72,15 @@ module.exports = {
       }
 
       if (calleeName === 'require') return true;
+
       return calleeWhitelists.simple.indexOf(calleeName) !== -1;
     }
 
-    const atts = ['className', 'style', 'styleName', 'src', 'type', 'id'];
+    const atts = [
+      'className', 'style', 'styleName', 'src', 'type', 'id',
+      // SVG related attributes.
+      'viewBox', 'cx', 'cy', 'r', 'rx', 'ry', 'd', 'x1', 'y1', 'x2', 'y2', 'fill', 'stroke', 'strokeWidth', 'points'
+    ];
     function isValidAttrName(name) {
       return atts.includes(name);
     }
@@ -279,6 +284,7 @@ module.exports = {
 };
 
 const popularCallee = [
+  'addEventListener',
   //
   // ─── VUEX CALLEE ────────────────────────────────────────────────────────────────
   //


Test patch:
diff --git a/tests/lib/rules/no-literal-string.js b/tests/lib/rules/no-literal-string.js
index 51cffbc..89fd6ab 100644
--- a/tests/lib/rules/no-literal-string.js
+++ b/tests/lib/rules/no-literal-string.js
@@ -37,6 +37,7 @@ ruleTester.run('no-literal-string', rule, {
     { code: 'a.includes("ios")' },
     { code: 'export * from "hello_export_all";' },
     { code: 'export { a } from "hello_export";' },
+    { code: 'document.addEventListener("click", (event) => { event.preventDefault() })' },
     { code: 'require("hello");' },
     { code: 'const a = require(["hello"]);' },
     { code: 'const a = require(["hel" + "lo"]);' },
@@ -57,7 +58,11 @@ ruleTester.run('no-literal-string', rule, {
     // JSX
     { code: '<div className="primary"></div>' },
     { code: '<div className={a ? "active": "inactive"}></div>' },
-    { code: '<div>{i18next.t("foo")}</div>' }
+    { code: '<div>{i18next.t("foo")}</div>' },
+    { code: '<svg viewBox="0 0 20 40"></svg>' },
+    { code: '<line x1="0" y1="0" x2="10" y2="20" />' },
+    { code: '<path d="M10 10" />' },
+    { code: '<circle cx="10" cy="10" r="2" fill="red" />' }
   ],
 
   invalid: [