From b522f7fb3cd0801e5d1d3587681f68ebd510b809 Mon Sep 17 00:00:00 2001
From: Ben Hauser <ben@hauser.id>
Date: Sat, 25 Jul 2020 21:41:14 +0300
Subject: [PATCH 1/4] refactor: make wrapper logic more generic via **kwargs

---
 solcx/exceptions.py |   2 +-
 solcx/wrapper.py    | 175 ++++++++++----------------------------------
 2 files changed, 38 insertions(+), 139 deletions(-)

diff --git a/solcx/exceptions.py b/solcx/exceptions.py
index d891023..e188527 100644
--- a/solcx/exceptions.py
+++ b/solcx/exceptions.py
@@ -8,7 +8,7 @@ class SolcError(Exception):
 
     def __init__(
         self,
-        command: str,
+        command: list,
         return_code: int,
         stdin_data: Optional[str],
         stdout_data: str,
diff --git a/solcx/wrapper.py b/solcx/wrapper.py
index 3166d31..9763fc8 100644
--- a/solcx/wrapper.py
+++ b/solcx/wrapper.py
@@ -1,6 +1,5 @@
-from __future__ import absolute_import
-
 import subprocess
+from typing import Any
 
 from semantic_version import Version
 
@@ -9,155 +8,44 @@
 
 
 def solc_wrapper(
-    solc_binary=None,
-    stdin=None,
-    help=None,
-    version=None,
-    combined_json=None,
-    optimize=None,
-    optimize_runs=None,
-    libraries=None,
-    output_dir=None,
-    gas=None,
-    assemble=None,
-    link=None,
-    source_files=None,
-    import_remappings=None,
-    ast=None,
-    ast_json=None,
-    asm=None,
-    asm_json=None,
-    opcodes=None,
-    bin=None,
-    bin_runtime=None,
-    clone_bin=None,
-    abi=None,
-    hashes=None,
-    userdoc=None,
-    devdoc=None,
-    formal=None,
-    allow_paths=None,
-    base_path=None,
-    standard_json=None,
-    success_return_code=None,
-    evm_version=None,
+    solc_binary: str = None,
+    stdin: str = None,
+    source_files: list = None,
+    import_remappings: list = None,
+    success_return_code: int = None,
+    **kwargs: Any,
 ):
     if solc_binary is None:
         solc_binary = get_executable()
 
     command = [solc_binary]
 
-    solc_version = Version(solc_binary.rsplit("-v")[-1].split("\\")[0])
-    solc_minor = solc_version.minor
-
-    if help:
-        command.append("--help")
-        if success_return_code is None:
-            success_return_code = 1
+    if "help" in kwargs:
+        success_return_code = 1
     elif success_return_code is None:
         success_return_code = 0
 
-    if version:
-        command.append("--version")
-
-    if optimize:
-        command.append("--optimize")
-
-    if optimize_runs is not None:
-        command.extend(("--optimize-runs", str(optimize_runs)))
-
-    if link:
-        command.append("--link")
-
-    if libraries is not None:
-        command.extend(("--libraries", libraries))
-
-    if output_dir is not None:
-        command.extend(("--output-dir", output_dir))
-
-    if combined_json:
-        if solc_minor >= 5:
-            combined_json = combined_json.replace(",clone-bin", "")
-        command.extend(("--combined-json", combined_json))
-
-    if gas:
-        command.append("--gas")
-
-    if allow_paths:
-        command.extend(("--allow-paths", allow_paths))
-
-    if standard_json:
-        command.append("--standard-json")
-
-    if assemble:
-        command.append("--assemble")
-
-    if import_remappings is not None:
-        command.extend(import_remappings)
-
     if source_files is not None:
         command.extend(source_files)
 
-    # Output configuration
-    if ast_json:
-        command.append("--ast-json")
-
-    if asm:
-        command.append("--asm")
-
-    if asm_json:
-        command.append("--asm-json")
-
-    if opcodes:
-        command.append("--opcodes")
-
-    if bin:
-        command.append("--bin")
-
-    if bin_runtime:
-        command.append("--bin-runtime")
-
-    if abi:
-        command.append("--abi")
-
-    if hashes:
-        command.append("--hashes")
-
-    if userdoc:
-        command.append("--userdoc")
-
-    if devdoc:
-        command.append("--devdoc")
-
-    if evm_version:
-        command.extend(("--evm-version", evm_version))
-
-    # unsupported by <0.6.9
-    if base_path:
-        if solc_version <= Version("0.6.8"):
-            raise AttributeError(
-                "solc {} does not support the --base-path flag".format(solc_version)
-            )
-        command.extend(("--base-path", base_path))
-
-    # unsupported by >=0.6.0
-    if ast:
-        if solc_minor >= 6:
-            raise AttributeError(f"solc 0.{solc_minor}.x does not support the --ast flag")
-        command.append("--ast")
-
-    # unsupported by >=0.5.0
-    if clone_bin:
-        if solc_minor >= 5:
-            raise AttributeError(f"solc 0.{solc_minor}.x does not support the --clone-bin flag")
-        command.append("--clone-bin")
-
-    if formal:
-        if solc_minor >= 5:
-            raise AttributeError(f"solc 0.{solc_minor}.x does not support the --formal flag")
-        command.append("--formal")
+    if import_remappings is not None:
+        command.extend(import_remappings)
 
-    if not standard_json and not source_files:
+    for key, value in kwargs.items():
+        if value is None or value is False:
+            continue
+
+        key = f"--{key.replace('_', '-')}"
+        if value is True:
+            command.append(key)
+        elif isinstance(value, (int, str)):
+            command.extend([key, str(value)])
+        elif isinstance(value, (list, tuple)):
+            command.extend([key, ",".join(str(i) for i in value)])
+        else:
+            raise TypeError(f"Invalid type for {key}: {type(value)}")
+
+    if "standard_json" not in kwargs and not source_files:
         # indicates that solc should read from stdin
         command.append("-")
 
@@ -175,6 +63,17 @@ def solc_wrapper(
     stdoutdata, stderrdata = proc.communicate(stdin)
 
     if proc.returncode != success_return_code:
+        solc_version = Version(solc_binary.rsplit("-v")[-1].split("\\")[0])
+        if stderrdata.startswith("unrecognised option"):
+            # unrecognised option '<FLAG>'
+            flag = stderrdata.split("'")[1]
+            raise AttributeError(f"solc {solc_version} - unsupported flag: {flag}")
+        if stderrdata.startswith("Invalid option"):
+            # Invalid option to <FLAG>: <OPTION>
+            flag, option = stderrdata.split(": ")
+            flag = flag.split(" ")[-1]
+            raise ValueError(f"solc {solc_version} - invalid option for {flag} flag: {option}")
+
         raise SolcError(
             command=command,
             return_code=proc.returncode,

From 6debe4a7ffe60817d52b63a580a5cf92b3a5de28 Mon Sep 17 00:00:00 2001
From: Ben Hauser <ben@hauser.id>
Date: Sat, 25 Jul 2020 22:52:33 +0300
Subject: [PATCH 2/4] refactor: parse combined_json inputs from help message

---
 solcx/main.py | 43 +++++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 20 deletions(-)

diff --git a/solcx/main.py b/solcx/main.py
index af07b84..8c2374e 100644
--- a/solcx/main.py
+++ b/solcx/main.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import
-
 import functools
 import json
 import re
@@ -31,7 +29,13 @@ def get_solc_version() -> Version:
     return Version(strip_zeroes_from_month_and_day(version_string))
 
 
-def _parse_compiler_output(stdoutdata):
+def _get_combined_json_outputs() -> str:
+    help_str = solc_wrapper(help=True)[0].split("\n")
+    combined_json_args = next(i for i in help_str if i.startswith("  --combined-json"))
+    return combined_json_args.split(" ")[-1]
+
+
+def _parse_compiler_output(stdoutdata) -> dict:
     output = json.loads(stdoutdata)
 
     contracts = output.get("contracts", {})
@@ -47,20 +51,9 @@ def _parse_compiler_output(stdoutdata):
     return contracts
 
 
-ALL_OUTPUT_VALUES = (
-    "abi",
-    "asm",
-    "ast",
-    "bin",
-    "bin-runtime",
-    "clone-bin",
-    "devdoc",
-    "opcodes",
-    "userdoc",
-)
-
-
-def compile_source(source, allow_empty=False, output_values=ALL_OUTPUT_VALUES, **kwargs):
+def compile_source(
+    source: str, allow_empty: bool = False, output_values: list = None, **kwargs
+) -> dict:
     if "stdin" in kwargs:
         raise ValueError("The `stdin` keyword is not allowed in the `compile_source` function")
     if "combined_json" in kwargs:
@@ -68,7 +61,11 @@ def compile_source(source, allow_empty=False, output_values=ALL_OUTPUT_VALUES, *
             "The `combined_json` keyword is not allowed in the `compile_source` function"
         )
 
-    combined_json = ",".join(output_values)
+    if output_values is None:
+        combined_json = _get_combined_json_outputs()
+    else:
+        combined_json = ",".join(output_values)
+
     compiler_kwargs = dict(stdin=source, combined_json=combined_json, **kwargs)
 
     stdoutdata, stderrdata, command, proc = solc_wrapper(**compiler_kwargs)
@@ -86,13 +83,19 @@ def compile_source(source, allow_empty=False, output_values=ALL_OUTPUT_VALUES, *
     return contracts
 
 
-def compile_files(source_files, allow_empty=False, output_values=ALL_OUTPUT_VALUES, **kwargs):
+def compile_files(
+    source_files: str, allow_empty: bool = False, output_values: list = None, **kwargs
+) -> dict:
     if "combined_json" in kwargs:
         raise ValueError(
             "The `combined_json` keyword is not allowed in the `compile_files` function"
         )
 
-    combined_json = ",".join(output_values)
+    if output_values is None:
+        combined_json = _get_combined_json_outputs()
+    else:
+        combined_json = ",".join(output_values)
+
     compiler_kwargs = dict(source_files=source_files, combined_json=combined_json, **kwargs)
 
     stdoutdata, stderrdata, command, proc = solc_wrapper(**compiler_kwargs)

From df1908312903e600a1ea928384c84a953c6ffbe1 Mon Sep 17 00:00:00 2001
From: Ben Hauser <ben@hauser.id>
Date: Sat, 25 Jul 2020 22:55:22 +0300
Subject: [PATCH 3/4] test: update compile tests

---
 tests/test_compile.py | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/tests/test_compile.py b/tests/test_compile.py
index 7feec6f..0b53442 100644
--- a/tests/test_compile.py
+++ b/tests/test_compile.py
@@ -6,9 +6,8 @@
 
 import solcx
 from solcx.exceptions import ContractsNotFound
-from solcx.main import ALL_OUTPUT_VALUES
 
-# interfaces and compact-format do not return anything
+# these values should work for all compatible solc versions
 combined_json_values = (
     "abi",
     "asm",
@@ -16,7 +15,6 @@
     "bin",
     "bin-runtime",
     "devdoc",
-    "hashes",
     "metadata",
     "opcodes",
     "srcmap",
@@ -33,11 +31,8 @@ def setup(all_versions):
 def _compile_assertions(output, key):
     assert output
     assert key in output
-    for value in ALL_OUTPUT_VALUES:
-        if value == "clone-bin" and solcx.get_solc_version().minor >= 5:
-            assert value not in output[key]
-        else:
-            assert value in output[key]
+    for value in combined_json_values:
+        assert value in output[key]
 
 
 def test_compile_source(foo_source):
@@ -55,8 +50,6 @@ def test_compile_source_empty():
 
 @pytest.mark.parametrize("key", combined_json_values)
 def test_compile_source_output_types(foo_source, key):
-    if key == "hashes" and str(solcx.get_solc_version().truncate()) == "0.4.11":
-        return
     output = solcx.compile_source(foo_source, output_values=[key])
     assert key in output["<stdin>:Foo"]
 
@@ -76,8 +69,6 @@ def test_compile_files_empty():
 
 @pytest.mark.parametrize("key", combined_json_values)
 def test_compile_files_output_types(foo_path, key):
-    if key == "hashes" and str(solcx.get_solc_version().truncate()) == "0.4.11":
-        return
     output = solcx.compile_files([foo_path], output_values=[key])
     assert key in output[f"{foo_path}:Foo"]
 

From ce113ed2aa05156c3fa2f047f6b03f3df1f4c2a7 Mon Sep 17 00:00:00 2001
From: Ben Hauser <ben@hauser.id>
Date: Sat, 25 Jul 2020 23:35:04 +0300
Subject: [PATCH 4/4] refactor: use fixed keyword arguments for main compile
 functions

---
 solcx/main.py | 101 +++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 83 insertions(+), 18 deletions(-)

diff --git a/solcx/main.py b/solcx/main.py
index 8c2374e..7e45017 100644
--- a/solcx/main.py
+++ b/solcx/main.py
@@ -52,21 +52,46 @@ def _parse_compiler_output(stdoutdata) -> dict:
 
 
 def compile_source(
-    source: str, allow_empty: bool = False, output_values: list = None, **kwargs
+    source: str,
+    output_values: list = None,
+    import_remappings: list = None,
+    base_path: str = None,
+    allow_paths: list = None,
+    output_dir: str = None,
+    overwrite: bool = False,
+    evm_version: str = None,
+    revert_strings: bool = False,
+    metadata_hash: str = None,
+    metadata_literal: bool = False,
+    optimize: bool = False,
+    optimize_runs: int = None,
+    no_optimize_yul: bool = False,
+    yul_optimizations: int = None,
+    allow_empty: bool = False,
 ) -> dict:
-    if "stdin" in kwargs:
-        raise ValueError("The `stdin` keyword is not allowed in the `compile_source` function")
-    if "combined_json" in kwargs:
-        raise ValueError(
-            "The `combined_json` keyword is not allowed in the `compile_source` function"
-        )
 
     if output_values is None:
         combined_json = _get_combined_json_outputs()
     else:
         combined_json = ",".join(output_values)
 
-    compiler_kwargs = dict(stdin=source, combined_json=combined_json, **kwargs)
+    compiler_kwargs = dict(
+        stdin=source,
+        combined_json=combined_json,
+        import_remappings=import_remappings,
+        base_path=base_path,
+        allow_paths=allow_paths,
+        output_dir=output_dir,
+        overwrite=overwrite,
+        evm_version=evm_version,
+        revert_strings=revert_strings,
+        metadata_hash=metadata_hash,
+        metadata_literal=metadata_literal,
+        optimize=optimize,
+        optimize_runs=optimize_runs,
+        no_optimize_yul=no_optimize_yul,
+        yul_optimizations=yul_optimizations,
+    )
 
     stdoutdata, stderrdata, command, proc = solc_wrapper(**compiler_kwargs)
 
@@ -84,19 +109,45 @@ def compile_source(
 
 
 def compile_files(
-    source_files: str, allow_empty: bool = False, output_values: list = None, **kwargs
+    source_files: str,
+    output_values: list = None,
+    import_remappings: list = None,
+    base_path: str = None,
+    allow_paths: list = None,
+    output_dir: str = None,
+    overwrite: bool = False,
+    evm_version: str = None,
+    revert_strings: bool = False,
+    metadata_hash: str = None,
+    metadata_literal: bool = False,
+    optimize: bool = False,
+    optimize_runs: int = None,
+    no_optimize_yul: bool = False,
+    yul_optimizations: int = None,
+    allow_empty: bool = False,
 ) -> dict:
-    if "combined_json" in kwargs:
-        raise ValueError(
-            "The `combined_json` keyword is not allowed in the `compile_files` function"
-        )
-
     if output_values is None:
         combined_json = _get_combined_json_outputs()
     else:
         combined_json = ",".join(output_values)
 
-    compiler_kwargs = dict(source_files=source_files, combined_json=combined_json, **kwargs)
+    compiler_kwargs = dict(
+        source_files=source_files,
+        combined_json=combined_json,
+        import_remappings=import_remappings,
+        base_path=base_path,
+        allow_paths=allow_paths,
+        output_dir=output_dir,
+        overwrite=overwrite,
+        evm_version=evm_version,
+        revert_strings=revert_strings,
+        metadata_hash=metadata_hash,
+        metadata_literal=metadata_literal,
+        optimize=optimize,
+        optimize_runs=optimize_runs,
+        no_optimize_yul=no_optimize_yul,
+        yul_optimizations=yul_optimizations,
+    )
 
     stdoutdata, stderrdata, command, proc = solc_wrapper(**compiler_kwargs)
 
@@ -113,7 +164,14 @@ def compile_files(
     return contracts
 
 
-def compile_standard(input_data, allow_empty=False, **kwargs):
+def compile_standard(
+    input_data,
+    base_path: str = None,
+    allow_paths: list = None,
+    output_dir: str = None,
+    overwrite: bool = False,
+    allow_empty=False,
+):
     if not input_data.get("sources") and not allow_empty:
         raise ContractsNotFound(
             command=None,
@@ -123,10 +181,17 @@ def compile_standard(input_data, allow_empty=False, **kwargs):
             stderr_data=None,
         )
 
-    stdoutdata, stderrdata, command, proc = solc_wrapper(
-        stdin=json.dumps(input_data), standard_json=True, **kwargs
+    compiler_kwargs = dict(
+        stdin=json.dumps(input_data),
+        standard_json=True,
+        base_path=base_path,
+        allow_paths=allow_paths,
+        output_dir=output_dir,
+        overwrite=overwrite,
     )
 
+    stdoutdata, stderrdata, command, proc = solc_wrapper(**compiler_kwargs)
+
     compiler_output = json.loads(stdoutdata)
     if "errors" in compiler_output:
         has_errors = any(error["severity"] == "error" for error in compiler_output["errors"])