hohn/codeql
1
0
Fork 0
mirror of https://github.com/github/codeql.git synced 2025-12-16 16:53:25 +01:00
Code Issues Packages Projects Releases Wiki Activity

Swift: autopep8 all python files

Browse Source 
Additionally set up a pre-commit hook and a CI check for that.
This commit is contained in:
Paolo Tranquilli
2022-06-23 17:05:21 +02:00
parent 43d449f1f7
commit 7334b4e03a
9 changed files with 157 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
.github/workflows/swift-codegen.yml vendored
View File

@@ -15,14 +15,18 @@ jobs:
- uses: actions/checkout@v3 - uses: actions/checkout@v3
- uses: ./.github/actions/fetch-codeql - uses: ./.github/actions/fetch-codeql
- uses: bazelbuild/setup-bazelisk@v2 - uses: bazelbuild/setup-bazelisk@v2
- uses: actions/setup-python@v3
- uses: pre-commit/action@v3.0.0
name: Check that python code is properly formatted
with:
extra_args: autopep8 --all-files
- name: Run unit tests - name: Run unit tests
run: | run: |
bazel test //swift/codegen/test --test_output=errors bazel test //swift/codegen/test --test_output=errors
- name: Check that QL generated code was checked in - uses: pre-commit/action@v3.0.0
run: | name: Check that QL generated code was checked in
bazel run //swift/codegen with:
git add swift extra_args: swift-codegen --all-files
git diff --exit-code HEAD
- name: Generate C++ files - name: Generate C++ files
run: | run: |
bazel run //swift/codegen:codegen -- --generate=trap,cpp --cpp-output=$PWD/swift-generated-headers bazel run //swift/codegen:codegen -- --generate=trap,cpp --cpp-output=$PWD/swift-generated-headers

6
.pre-commit-config.yaml
View File

@@ -15,6 +15,12 @@ repos:
- id: clang-format - id: clang-format
files: ^swift/.*\.(h|c|cpp)$ files: ^swift/.*\.(h|c|cpp)$
- repo: https://github.com/pre-commit/mirrors-autopep8
rev: v1.6.0
hooks:
- id: autopep8
files: ^swift/codegen/.*\.py
- repo: local - repo: local
hooks: hooks:
- id: codeql-format - id: codeql-format

2
swift/codegen/.pep8 Normal file
View File

@@ -0,0 +1,2 @@
[pep8]
max_line_length = 120

8
swift/codegen/generators/dbschemegen.py
View File

@@ -46,10 +46,10 @@ def cls_to_dbscheme(cls: schema.Class):
keyset=keyset, keyset=keyset,
name=inflection.tableize(cls.name), name=inflection.tableize(cls.name),
columns=[ columns=[
Column("id", type=dbtype(cls.name), binding=binding), Column("id", type=dbtype(cls.name), binding=binding),
] + [ ] + [
Column(f.name, dbtype(f.type)) for f in cls.properties if f.is_single Column(f.name, dbtype(f.type)) for f in cls.properties if f.is_single
] ]
) )
# use property-specific tables for 1-to-many and 1-to-at-most-1 properties # use property-specific tables for 1-to-many and 1-to-at-most-1 properties
for f in cls.properties: for f in cls.properties:

62
swift/codegen/test/test_cppgen.py
View File

@@ -30,8 +30,8 @@ def test_empty_class(generate):
assert generate([ assert generate([
schema.Class(name="MyClass"), schema.Class(name="MyClass"),
]) == [ ]) == [
cpp.Class(name="MyClass", final=True, trap_name="MyClasses") cpp.Class(name="MyClass", final=True, trap_name="MyClasses")
] ]
def test_two_class_hierarchy(generate): def test_two_class_hierarchy(generate):
@@ -40,9 +40,9 @@ def test_two_class_hierarchy(generate):
schema.Class(name="A", derived={"B"}), schema.Class(name="A", derived={"B"}),
schema.Class(name="B", bases={"A"}), schema.Class(name="B", bases={"A"}),
]) == [ ]) == [
base, base,
cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"), cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"),
] ]
def test_complex_hierarchy_topologically_ordered(generate): def test_complex_hierarchy_topologically_ordered(generate):
@@ -78,23 +78,23 @@ def test_class_with_field(generate, type, expected, property_cls, optional, repe
assert generate([ assert generate([
schema.Class(name="MyClass", properties=[property_cls("prop", type)]), schema.Class(name="MyClass", properties=[property_cls("prop", type)]),
]) == [ ]) == [
cpp.Class(name="MyClass", cpp.Class(name="MyClass",
fields=[cpp.Field("prop", expected, is_optional=optional, fields=[cpp.Field("prop", expected, is_optional=optional,
is_repeated=repeated, trap_name=trap_name)], is_repeated=repeated, trap_name=trap_name)],
trap_name="MyClasses", trap_name="MyClasses",
final=True) final=True)
] ]
def test_class_with_predicate(generate): def test_class_with_predicate(generate):
assert generate([ assert generate([
schema.Class(name="MyClass", properties=[schema.PredicateProperty("prop")]), schema.Class(name="MyClass", properties=[schema.PredicateProperty("prop")]),
]) == [ ]) == [
cpp.Class(name="MyClass", cpp.Class(name="MyClass",
fields=[cpp.Field("prop", "bool", trap_name="MyClassProp", is_predicate=True)], fields=[cpp.Field("prop", "bool", trap_name="MyClassProp", is_predicate=True)],
trap_name="MyClasses", trap_name="MyClasses",
final=True) final=True)
] ]
@pytest.mark.parametrize("name", @pytest.mark.parametrize("name",
@@ -104,11 +104,11 @@ def test_class_with_overridden_unsigned_field(generate, name):
schema.Class(name="MyClass", properties=[ schema.Class(name="MyClass", properties=[
schema.SingleProperty(name, "bar")]), schema.SingleProperty(name, "bar")]),
]) == [ ]) == [
cpp.Class(name="MyClass", cpp.Class(name="MyClass",
fields=[cpp.Field(name, "unsigned")], fields=[cpp.Field(name, "unsigned")],
trap_name="MyClasses", trap_name="MyClasses",
final=True) final=True)
] ]
def test_class_with_overridden_underscore_field(generate): def test_class_with_overridden_underscore_field(generate):
@@ -116,11 +116,11 @@ def test_class_with_overridden_underscore_field(generate):
schema.Class(name="MyClass", properties=[ schema.Class(name="MyClass", properties=[
schema.SingleProperty("something_", "bar")]), schema.SingleProperty("something_", "bar")]),
]) == [ ]) == [
cpp.Class(name="MyClass", cpp.Class(name="MyClass",
fields=[cpp.Field("something", "bar")], fields=[cpp.Field("something", "bar")],
trap_name="MyClasses", trap_name="MyClasses",
final=True) final=True)
] ]
@pytest.mark.parametrize("name", cpp.cpp_keywords) @pytest.mark.parametrize("name", cpp.cpp_keywords)
@@ -129,11 +129,11 @@ def test_class_with_keyword_field(generate, name):
schema.Class(name="MyClass", properties=[ schema.Class(name="MyClass", properties=[
schema.SingleProperty(name, "bar")]), schema.SingleProperty(name, "bar")]),
]) == [ ]) == [
cpp.Class(name="MyClass", cpp.Class(name="MyClass",
fields=[cpp.Field(name + "_", "bar")], fields=[cpp.Field(name + "_", "bar")],
trap_name="MyClasses", trap_name="MyClasses",
final=True) final=True)
] ]
if __name__ == '__main__': if __name__ == '__main__':

204
swift/codegen/test/test_qlgen.py
View File

@@ -128,9 +128,9 @@ def test_one_empty_class(generate_classes):
assert generate_classes([ assert generate_classes([
schema.Class("A") schema.Class("A")
]) == { ]) == {
"A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"), "A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
ql.Class(name="A", final=True)), ql.Class(name="A", final=True)),
} }
def test_hierarchy(generate_classes): def test_hierarchy(generate_classes):
@@ -140,16 +140,16 @@ def test_hierarchy(generate_classes):
schema.Class("B", bases={"A"}, derived={"D"}), schema.Class("B", bases={"A"}, derived={"D"}),
schema.Class("A", derived={"B", "C"}), schema.Class("A", derived={"B", "C"}),
]) == { ]) == {
"A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"), "A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
ql.Class(name="A")), ql.Class(name="A")),
"B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"), "B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"),
ql.Class(name="B", bases=["A"], imports=[stub_import_prefix + "A"])), ql.Class(name="B", bases=["A"], imports=[stub_import_prefix + "A"])),
"C.qll": (ql.Stub(name="C", base_import=gen_import_prefix + "C"), "C.qll": (ql.Stub(name="C", base_import=gen_import_prefix + "C"),
ql.Class(name="C", bases=["A"], imports=[stub_import_prefix + "A"])), ql.Class(name="C", bases=["A"], imports=[stub_import_prefix + "A"])),
"D.qll": (ql.Stub(name="D", base_import=gen_import_prefix + "D"), "D.qll": (ql.Stub(name="D", base_import=gen_import_prefix + "D"),
ql.Class(name="D", final=True, bases=["B", "C"], ql.Class(name="D", final=True, bases=["B", "C"],
imports=[stub_import_prefix + cls for cls in "BC"])), imports=[stub_import_prefix + cls for cls in "BC"])),
} }
def test_hierarchy_imports(generate_import_list): def test_hierarchy_imports(generate_import_list):
@@ -184,12 +184,12 @@ def test_single_property(generate_classes):
schema.Class("MyObject", properties=[ schema.Class("MyObject", properties=[
schema.SingleProperty("foo", "bar")]), schema.SingleProperty("foo", "bar")]),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject", final=True, properties=[ ql.Class(name="MyObject", final=True, properties=[
ql.Property(singular="Foo", type="bar", tablename="my_objects", ql.Property(singular="Foo", type="bar", tablename="my_objects",
tableparams=["this", "result"]), tableparams=["this", "result"]),
])), ])),
} }
def test_single_properties(generate_classes): def test_single_properties(generate_classes):
@@ -200,16 +200,16 @@ def test_single_properties(generate_classes):
schema.SingleProperty("three", "z"), schema.SingleProperty("three", "z"),
]), ]),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject", final=True, properties=[ ql.Class(name="MyObject", final=True, properties=[
ql.Property(singular="One", type="x", tablename="my_objects", ql.Property(singular="One", type="x", tablename="my_objects",
tableparams=["this", "result", "_", "_"]), tableparams=["this", "result", "_", "_"]),
ql.Property(singular="Two", type="y", tablename="my_objects", ql.Property(singular="Two", type="y", tablename="my_objects",
tableparams=["this", "_", "result", "_"]), tableparams=["this", "_", "result", "_"]),
ql.Property(singular="Three", type="z", tablename="my_objects", ql.Property(singular="Three", type="z", tablename="my_objects",
tableparams=["this", "_", "_", "result"]), tableparams=["this", "_", "_", "result"]),
])), ])),
} }
@pytest.mark.parametrize("is_child", [False, True]) @pytest.mark.parametrize("is_child", [False, True])
@@ -218,13 +218,13 @@ def test_optional_property(generate_classes, is_child):
schema.Class("MyObject", properties=[ schema.Class("MyObject", properties=[
schema.OptionalProperty("foo", "bar", is_child=is_child)]), schema.OptionalProperty("foo", "bar", is_child=is_child)]),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject", final=True, properties=[ ql.Class(name="MyObject", final=True, properties=[
ql.Property(singular="Foo", type="bar", tablename="my_object_foos", ql.Property(singular="Foo", type="bar", tablename="my_object_foos",
tableparams=["this", "result"], tableparams=["this", "result"],
is_optional=True, is_child=is_child), is_optional=True, is_child=is_child),
])), ])),
} }
@pytest.mark.parametrize("is_child", [False, True]) @pytest.mark.parametrize("is_child", [False, True])
@@ -233,12 +233,12 @@ def test_repeated_property(generate_classes, is_child):
schema.Class("MyObject", properties=[ schema.Class("MyObject", properties=[
schema.RepeatedProperty("foo", "bar", is_child=is_child)]), schema.RepeatedProperty("foo", "bar", is_child=is_child)]),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject", final=True, properties=[ ql.Class(name="MyObject", final=True, properties=[
ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos", ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
tableparams=["this", "index", "result"], is_child=is_child), tableparams=["this", "index", "result"], is_child=is_child),
])), ])),
} }
@pytest.mark.parametrize("is_child", [False, True]) @pytest.mark.parametrize("is_child", [False, True])
@@ -247,13 +247,13 @@ def test_repeated_optional_property(generate_classes, is_child):
schema.Class("MyObject", properties=[ schema.Class("MyObject", properties=[
schema.RepeatedOptionalProperty("foo", "bar", is_child=is_child)]), schema.RepeatedOptionalProperty("foo", "bar", is_child=is_child)]),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject", final=True, properties=[ ql.Class(name="MyObject", final=True, properties=[
ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos", ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
tableparams=["this", "index", "result"], is_optional=True, tableparams=["this", "index", "result"], is_optional=True,
is_child=is_child), is_child=is_child),
])), ])),
} }
def test_predicate_property(generate_classes): def test_predicate_property(generate_classes):
@@ -261,13 +261,13 @@ def test_predicate_property(generate_classes):
schema.Class("MyObject", properties=[ schema.Class("MyObject", properties=[
schema.PredicateProperty("is_foo")]), schema.PredicateProperty("is_foo")]),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject", final=True, properties=[ ql.Class(name="MyObject", final=True, properties=[
ql.Property(singular="isFoo", type="predicate", tablename="my_object_is_foo", ql.Property(singular="isFoo", type="predicate", tablename="my_object_is_foo",
tableparams=["this"], tableparams=["this"],
is_predicate=True), is_predicate=True),
])), ])),
} }
@pytest.mark.parametrize("is_child", [False, True]) @pytest.mark.parametrize("is_child", [False, True])
@@ -277,18 +277,18 @@ def test_single_class_property(generate_classes, is_child):
schema.SingleProperty("foo", "Bar", is_child=is_child)]), schema.SingleProperty("foo", "Bar", is_child=is_child)]),
schema.Class("Bar"), schema.Class("Bar"),
]) == { ]) == {
"MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"), "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class( ql.Class(
name="MyObject", final=True, imports=[stub_import_prefix + "Bar"], properties=[ name="MyObject", final=True, imports=[stub_import_prefix + "Bar"], properties=[
ql.Property(singular="Foo", type="Bar", tablename="my_objects", ql.Property(singular="Foo", type="Bar", tablename="my_objects",
tableparams=[ tableparams=[
"this", "result"], "this", "result"],
is_child=is_child), is_child=is_child),
], ],
)), )),
"Bar.qll": (ql.Stub(name="Bar", base_import=gen_import_prefix + "Bar"), "Bar.qll": (ql.Stub(name="Bar", base_import=gen_import_prefix + "Bar"),
ql.Class(name="Bar", final=True)), ql.Class(name="Bar", final=True)),
} }
def test_class_dir(generate_classes): def test_class_dir(generate_classes):
@@ -297,12 +297,12 @@ def test_class_dir(generate_classes):
schema.Class("A", derived={"B"}, dir=dir), schema.Class("A", derived={"B"}, dir=dir),
schema.Class("B", bases={"A"}), schema.Class("B", bases={"A"}),
]) == { ]) == {
f"{dir}/A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "another.rel.path.A"), f"{dir}/A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "another.rel.path.A"),
ql.Class(name="A", dir=dir)), ql.Class(name="A", dir=dir)),
"B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"), "B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"),
ql.Class(name="B", final=True, bases=["A"], ql.Class(name="B", final=True, bases=["A"],
imports=[stub_import_prefix + "another.rel.path.A"])), imports=[stub_import_prefix + "another.rel.path.A"])),
} }
def test_class_dir_imports(generate_import_list): def test_class_dir_imports(generate_import_list):
@@ -382,8 +382,8 @@ def test_test_source_present(opts, generate_tests):
assert generate_tests([ assert generate_tests([
schema.Class("A"), schema.Class("A"),
]) == { ]) == {
"A/A.ql": ql.ClassTester(class_name="A"), "A/A.ql": ql.ClassTester(class_name="A"),
} }
def test_test_source_present_with_dir(opts, generate_tests): def test_test_source_present_with_dir(opts, generate_tests):
@@ -391,8 +391,8 @@ def test_test_source_present_with_dir(opts, generate_tests):
assert generate_tests([ assert generate_tests([
schema.Class("A", dir=pathlib.Path("foo")), schema.Class("A", dir=pathlib.Path("foo")),
]) == { ]) == {
"foo/A/A.ql": ql.ClassTester(class_name="A"), "foo/A/A.ql": ql.ClassTester(class_name="A"),
} }
def test_test_total_properties(opts, generate_tests): def test_test_total_properties(opts, generate_tests):
@@ -405,13 +405,13 @@ def test_test_total_properties(opts, generate_tests):
schema.PredicateProperty("y", "int"), schema.PredicateProperty("y", "int"),
]), ]),
]) == { ]) == {
"B/B.ql": ql.ClassTester(class_name="B", properties=[ "B/B.ql": ql.ClassTester(class_name="B", properties=[
ql.PropertyForTest( ql.PropertyForTest(
getter="getX", is_single=True, type="string"), getter="getX", is_single=True, type="string"),
ql.PropertyForTest( ql.PropertyForTest(
getter="y", is_predicate=True, type="predicate"), getter="y", is_predicate=True, type="predicate"),
]) ])
} }
def test_test_partial_properties(opts, generate_tests): def test_test_partial_properties(opts, generate_tests):
@@ -424,13 +424,13 @@ def test_test_partial_properties(opts, generate_tests):
schema.RepeatedProperty("y", "int"), schema.RepeatedProperty("y", "int"),
]), ]),
]) == { ]) == {
"B/B.ql": ql.ClassTester(class_name="B"), "B/B.ql": ql.ClassTester(class_name="B"),
"B/B_getX.ql": ql.PropertyTester(class_name="B", "B/B_getX.ql": ql.PropertyTester(class_name="B",
property=ql.PropertyForTest(getter="getX", type="string")), property=ql.PropertyForTest(getter="getX", type="string")),
"B/B_getY.ql": ql.PropertyTester(class_name="B", "B/B_getY.ql": ql.PropertyTester(class_name="B",
property=ql.PropertyForTest(getter="getY", is_repeated=True, property=ql.PropertyForTest(getter="getY", is_repeated=True,
type="int")), type="int")),
} }
def test_test_properties_deduplicated(opts, generate_tests): def test_test_properties_deduplicated(opts, generate_tests):
@@ -444,14 +444,14 @@ def test_test_properties_deduplicated(opts, generate_tests):
schema.Class("B", bases={"Base"}, derived={"Final"}), schema.Class("B", bases={"Base"}, derived={"Final"}),
schema.Class("Final", bases={"A", "B"}), schema.Class("Final", bases={"A", "B"}),
]) == { ]) == {
"Final/Final.ql": ql.ClassTester(class_name="Final", properties=[ "Final/Final.ql": ql.ClassTester(class_name="Final", properties=[
ql.PropertyForTest( ql.PropertyForTest(
getter="getX", is_single=True, type="string"), getter="getX", is_single=True, type="string"),
]), ]),
"Final/Final_getY.ql": ql.PropertyTester(class_name="Final", "Final/Final_getY.ql": ql.PropertyTester(class_name="Final",
property=ql.PropertyForTest(getter="getY", is_repeated=True, property=ql.PropertyForTest(getter="getY", is_repeated=True,
type="int")), type="int")),
} }
def test_test_properties_skipped(opts, generate_tests): def test_test_properties_skipped(opts, generate_tests):
@@ -467,8 +467,8 @@ def test_test_properties_skipped(opts, generate_tests):
"b", "int", pragmas=["bar", "skip_qltest", "baz"]), "b", "int", pragmas=["bar", "skip_qltest", "baz"]),
]), ]),
]) == { ]) == {
"Derived/Derived.ql": ql.ClassTester(class_name="Derived"), "Derived/Derived.ql": ql.ClassTester(class_name="Derived"),
} }
def test_test_base_class_skipped(opts, generate_tests): def test_test_base_class_skipped(opts, generate_tests):
@@ -480,8 +480,8 @@ def test_test_base_class_skipped(opts, generate_tests):
]), ]),
schema.Class("Derived", bases={"Base"}), schema.Class("Derived", bases={"Base"}),
]) == { ]) == {
"Derived/Derived.ql": ql.ClassTester(class_name="Derived"), "Derived/Derived.ql": ql.ClassTester(class_name="Derived"),
} }
def test_test_final_class_skipped(opts, generate_tests): def test_test_final_class_skipped(opts, generate_tests):

1
swift/codegen/test/test_schema.py
View File

@@ -266,7 +266,6 @@ A:
""") """)
def test_class_with_pragmas(load): def test_class_with_pragmas(load):
ret = load(""" ret = load("""
A: A:

5
swift/codegen/test/test_trapgen.py
View File

@@ -122,8 +122,9 @@ def test_one_table_overridden_underscore_named_field(generate_traps):
assert generate_traps([ assert generate_traps([
dbscheme.Table(name="foos", columns=[dbscheme.Column("whatever_", "bar")]), dbscheme.Table(name="foos", columns=[dbscheme.Column("whatever_", "bar")]),
]) == [ ]) == [
cpp.Trap("foos", name="Foos", fields=[cpp.Field("whatever", "bar")]), cpp.Trap("foos", name="Foos", fields=[cpp.Field("whatever", "bar")]),
] ]
def test_one_table_no_tags(generate_tags): def test_one_table_no_tags(generate_tags):
assert generate_tags([ assert generate_tags([

1
swift/integration-tests/cross-references/test.py
View File

@@ -4,4 +4,3 @@ run_codeql_database_create([
'swift package clean', 'swift package clean',
'swift build' 'swift build'
], lang='swift') ], lang='swift')