solidity wrapper rewrite

- exposed plain functions
- using --libraries from the solc compiler instead of string substituion

Author: hackaugusto

ethereum/_solidity.py

@@ -1,115 +1,242 @@
+# -*- coding: utf8 -*-
 import re
 import subprocess
 import os
-import yaml  # use yaml instead of json to get non unicode
+
+import yaml
+
+BINARY = 'solc'
 
 
 class CompileError(Exception):
     pass
 
 
-class solc_wrapper(object):
+def get_compiler_path():
+    """ Return the path to the solc compiler.
 
-    "wraps solc binary"
+    This funtion will search for the solc binary in the $PATH and return the
+    path of the first executable occurence.
+    """
+    for path in os.getenv('PATH', '').split(os.pathsep):
+        path = path.strip('"')
+        executable_path = os.path.join(path, BINARY)
 
-    @classmethod
-    def compiler_available(cls):
-        program = 'solc'
+        if os.path.isfile(executable_path) and os.access(executable_path, os.X_OK):
+            return executable_path
 
-        def is_exe(fpath):
-            return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+    return None
 
-        fpath, fname = os.path.split(program)
-        if fpath:
-            if is_exe(program):
-                return program
-        else:
-            for path in os.environ["PATH"].split(os.pathsep):
-                path = path.strip('"')
-                exe_file = os.path.join(path, program)
-                if is_exe(exe_file):
-                    return exe_file
 
-        return None
+def get_solidity():
+    """ Return the singleton used to interact with the solc compiler. """
+    if get_compiler_path() is None:
+        return None  # the compiler wasn't found in $PATH
 
-    @classmethod
-    def contract_names(cls, code):
-        return re.findall(r'^\s*(contract|library) (\S*) ', code, re.MULTILINE)
+    return solc_wrapper
+
+
+def solc_arguments(libraries=None, combined='bin,abi', optimize=True):
+    """ Build the arguments to call the solc binary. """
+    args = [
+        '--combined-json', combined,
+        '--add-std',
+    ]
+
+    if optimize:
+        args.append('--optmize')
+
+    if libraries is not None:
+        addresses = [
+            '{name}:{address}'.format(name=name, address=address)
+            for name, address in libraries.items()
+        ]
+        args.extend([
+            '--libraries',
+            ','.join(addresses),
+        ])
+
+    return args
+
+
+def solc_parse_output(compiler_output):
+    """ Parses the compiler output. """
+    result = yaml.safe_load(compiler_output)['contracts']
+
+    if 'bin' in result.values()[0]:
+        for value in result.values():
+            value['bin_hex'] = value['bin']
+            value['bin'] = value['bin_hex'].decode('hex')
+
+    for json_data in ('abi', 'devdoc', 'userdoc'):
+        # the values in the output can be configured through the
+        # --combined-json flag, check that it's present in the first value and
+        # assume all values are consistent
+        if json_data not in result.values()[0]:
+            continue
+
+        for value in result.values():
+            value[json_data] = yaml.safe_load(value[json_data])
+
+    return result
+
+
+def compiler_version():
+    """ Return the version of the installed solc. """
+    version_info = subprocess.check_output(['solc', '--version'])
+    match = re.search('^Version: ([0-9a-z.-]+)/', version_info, re.MULTILINE)
+
+    if match:
+        return match.group(1)
+
+
+def solidity_names(code):
+    """ Return the library and contract names in order of appearence. """
+    # the special sequence \s is equivalent to the set [ \t\n\r\f\v]
+    return re.findall(r'(contract|library)\s+([a-zA-Z][a-zA-Z0-9]*)', code, re.MULTILINE)
+
+
+def compile_file(filepath, libraries=None, combined='bin,abi', optimize=True):
+    """ Return the compile contract code.
+
+    Args:
+        filepath (str): The path to the contract source code.
+        libraries (dict): A dictionary mapping library name to address.
+        combined (str: The flags passed to the solidity compiler to defined
+            what output should be used.
+        optimize (bool): Flag to set up compiler optimization.
+
+    Returns:
+        dict: A mapping from the contract name to it's binary.
+    """
+
+    workdir, filename = os.path.split(filepath)
+
+    args = solc_arguments(libraries=libraries, combined=combined, optimize=optimize)
+    args.insert(0, get_compiler_path())
+    args.append(filename)
+
+    output = subprocess.check_output(args, cwd=workdir)
+
+    return solc_parse_output(output)
+
+
+def compile_contract(filepath, contract_name, libraries=None, combined='bin,abi', optimize=True):
+    all_contracts = compile_file(
+        filepath,
+        libraries=libraries,
+        combined=combined,
+        optimize=optimize,
+    )
+
+    return all_contracts[contract_name]
+
+
+def compile_last_contract(filepath, libraries=None, combined='bin,abi', optimize=True):
+    with open(filepath) as handler:
+        all_names = solidity_names(handler.read())
+
+    all_contract_names = [
+        name
+        for kind, name in all_names
+        # if kind == 'contract'
+    ]
+
+    last_contract = all_contract_names[-1]
+
+    return compile_contract(
+        filepath,
+        last_contract,
+        libraries=libraries,
+        combined=combined,
+        optimize=optimize,
+    )
+
+
+def compile_code(sourcecode, libraries=None, combined='bin,abi', optimize=True):
+    args = solc_arguments(libraries=libraries, combined=combined, optimize=optimize)
+    args.insert(0, get_compiler_path())
+
+    process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+    stdoutdata, _ = process.communicate(input=sourcecode)
+
+    return solc_parse_output(stdoutdata)
+
+
+class Solc(object):
+    """ Wraps the solc binary. """
+
+    compiler_available = staticmethod(get_compiler_path)
+    contract_names = staticmethod(solidity_names)
+    compiler_version = staticmethod(compiler_version)
+
+    @staticmethod
+    def _code_or_path(sourcecode, path, contract_name, libraries, combined):
+        if sourcecode and path:
+            raise ValueError('sourcecode and path are mutually exclusive.')
+
+        if path and contract_name:
+            return compile_contract(path, contract_name, libraries=libraries, combined=combined)
+
+        if path:
+            return compile_last_contract(path, libraries=libraries, combined=combined)
+
+        all_names = solidity_names(sourcecode)
+        all_contract_names = [
+            name
+            for kind, name in all_names
+            if kind == 'contract'
+        ]
+        last_contract = all_contract_names[-1]
+
+        result = compile_code(sourcecode, libraries=libraries, combined=combined)
+        return result[last_contract]
 
     @classmethod
     def compile(cls, code, path=None, libraries=None, contract_name=''):
-        "returns binary of last contract in code"
-        sorted_contracts = cls.combined(code, path=path)
-        if contract_name:
-            idx = [x[0] for x in sorted_contracts].index(contract_name)
-        else:
-            idx = -1
-        if libraries:
-            if cls.compiler_version() < "0.1.2":
-                raise CompileError('Compiler does not support libraries. Please update compiler.')
-            for lib_name, lib_address in libraries.iteritems():
-                sorted_contracts[idx][1]['bin'] = sorted_contracts[idx][1]['bin'].replace(
-                    "__{}{}".format(lib_name, "_" * (38 - len(lib_name))), lib_address)
-        return sorted_contracts[idx][1]['bin'].decode('hex')
+        """ Return the binary of last contract in code. """
+        result = cls._code_or_path(code, path, contract_name, libraries, 'bin')
+        return result['bin']
 
     @classmethod
     def mk_full_signature(cls, code, path=None, libraries=None, contract_name=''):
         "returns signature of last contract in code"
-        sorted_contracts = cls.combined(code, path=path)
-        if contract_name:
-            idx = [x[0] for x in sorted_contracts].index(contract_name)
-        else:
-            idx = -1
-        return sorted_contracts[idx][1]['abi']
+
+        result = cls._code_or_path(code, path, contract_name, libraries, 'abi')
+        return result['abi']
 
     @classmethod
     def combined(cls, code, path=None):
-        """compile combined-json with abi,bin,devdoc,userdoc
+        """ Compile combined-json with abi,bin,devdoc,userdoc.
+
         @param code: literal solidity code as a string.
         @param path: absolute path to solidity-file. Note: code & path are exclusive!
         """
-        p = None
-        if path is None:
-            p = subprocess.Popen(['solc', '--add-std', '--optimize', '--combined-json', 'abi,bin,devdoc,userdoc'],
-                                stdin=subprocess.PIPE, stdout=subprocess.PIPE)
-            stdoutdata, stderrdata = p.communicate(input=code)
-        else:
-            assert code is None or len(code) == 0, "`code` and `path` are exclusive!"
-            workdir, fn = os.path.split(path)
-            p = subprocess.Popen(['solc', '--add-std', '--optimize', '--combined-json', 'abi,bin,devdoc,userdoc', fn],
-                                stdout=subprocess.PIPE, cwd=workdir)
-            stdoutdata = p.stdout.read().strip()
-            p.terminate()
-        if p.returncode:
-            raise CompileError('compilation failed')
-        # contracts = json.loads(stdoutdata)['contracts']
-        contracts = yaml.safe_load(stdoutdata)['contracts']
-        for contract_name, data in contracts.items():
-            data['abi'] = yaml.safe_load(data['abi'])
-            data['devdoc'] = yaml.safe_load(data['devdoc'])
-            data['userdoc'] = yaml.safe_load(data['userdoc'])
-
-        names = cls.contract_names(code or open(path).read())
-        assert len(names) <= len(contracts)  # imported contracts are not returned
+
+        contracts = cls._code_or_path(
+            sourcecode=code,
+            path=path,
+            contract_name=None,
+            libraries=None,
+            combined='abi,bin,devdoc,userdoc',
+        )
+
+        if path:
+            with open(path) as handler:
+                code = handler.read()
+
         sorted_contracts = []
-        for name in names:
+        for name in solidity_names(code):
             sorted_contracts.append((name[1], contracts[name[1]]))
         return sorted_contracts
 
-    @classmethod
-    def compiler_version(cls):
-        version_info = subprocess.check_output(['solc', '--version'])
-        match = re.search("^Version: ([0-9a-z.-]+)/", version_info, re.MULTILINE)
-        if match:
-            return match.group(1)
-
     @classmethod
     def compile_rich(cls, code, path=None):
         """full format as returned by jsonrpc"""
 
         return {
             contract_name: {
-                'code': "0x" + contract.get('bin'),
+                'code': '0x' + contract.get('bin'),
                 'info': {
                     'abiDefinition': contract.get('abi'),
                     'compilerVersion': cls.compiler_version(),
@@ -125,51 +252,4 @@ def compile_rich(cls, code, path=None):
         }
 
 
-def get_solidity(try_import=False):
-    if try_import:
-        try:
-            import solidity, tester
-            tester.languages['solidity'] = solidity
-        except ImportError:
-            pass
-    if not solc_wrapper.compiler_available():
-        return None
-    return solc_wrapper
-
-
-if __name__ == '__main__':
-    import tester
-    assert 'solidity' in tester.languages
-
-    one_contract = """
-    contract foo {
-        function seven() returns (int256 y) {
-            y = 7;
-        }
-        function mul2(int256 x) returns (int256 y) {
-            y = x * 2;
-        }
-    }
-    """
-
-    two_contracts = one_contract + """
-    contract baz {
-        function echo(address a) returns (address b) {
-            b = a;
-            return b;
-        }
-        function eight() returns (int256 y) {
-            y = 8;
-        }
-    }
-    """
-
-    # test
-    assert 'solidity' in tester.languages
-
-    s = tester.state()
-
-    c1 = s.abi_contract(one_contract, language='solidity')
-    assert c1.seven() == 7
-    assert c1.mul2(2) == 4
-    assert c1.mul2(-2) == -4
+solc_wrapper = Solc  # pylint: disable=invalid-name