diff --git a/src/scripts/pyolian/eolian.py b/src/scripts/pyolian/eolian.py index bed0beab62..fb6963cd4f 100644 --- a/src/scripts/pyolian/eolian.py +++ b/src/scripts/pyolian/eolian.py @@ -35,8 +35,8 @@ except ImportError: _already_halted = False -### Eolian Enums ############################################################ +# Eolian Enums ############################################################## class Eolian_Function_Type(IntEnum): UNRESOLVED = 0 PROPERTY = 1 @@ -45,12 +45,14 @@ class Eolian_Function_Type(IntEnum): METHOD = 4 FUNCTION_POINTER = 5 + class Eolian_Parameter_Direction(IntEnum): UNKNOWN = 0 IN = 1 OUT = 2 INOUT = 3 + class Eolian_Class_Type(IntEnum): UNKNOWN_TYPE = 0 REGULAR = 1 @@ -58,12 +60,14 @@ class Eolian_Class_Type(IntEnum): MIXIN = 3 INTERFACE = 4 + class Eolian_Object_Scope(IntEnum): UNKNOWN = 0 PUBLIC = 1 PRIVATE = 2 PROTECTED = 3 + class Eolian_Typedecl_Type(IntEnum): UNKNOWN = 0 STRUCT = 1 @@ -72,6 +76,7 @@ class Eolian_Typedecl_Type(IntEnum): ALIAS = 4 FUNCTION_POINTER = 5 + class Eolian_Type_Type(IntEnum): UNKNOWN_TYPE = 0 VOID = 1 @@ -79,6 +84,7 @@ class Eolian_Type_Type(IntEnum): CLASS = 3 UNDEFINED = 4 + class Eolian_Type_Builtin_Type(IntEnum): INVALID = 0 BYTE = 1 @@ -141,6 +147,7 @@ class Eolian_Type_Builtin_Type(IntEnum): HASH = 47 VOID_PTR = 48 + class Eolian_Expression_Type(IntEnum): UNKNOWN = 0 INT = 1 @@ -159,18 +166,20 @@ class Eolian_Expression_Type(IntEnum): UNARY = 14 BINARY = 15 + class Eolian_Expression_Mask(IntEnum): - SINT = 1 << 0 - UINT = 1 << 1 - INT = SINT | UINT - FLOAT = 1 << 2 - BOOL = 1 << 3 + SINT = 1 << 0 + UINT = 1 << 1 + INT = SINT | UINT + FLOAT = 1 << 2 + BOOL = 1 << 3 STRING = 1 << 4 - CHAR = 1 << 5 - NULL = 1 << 6 + CHAR = 1 << 5 + NULL = 1 << 6 SIGNED = SINT | FLOAT NUMBER = INT | FLOAT - ALL = NUMBER | BOOL | STRING | CHAR | NULL + ALL = NUMBER | BOOL | STRING | CHAR | NULL + class Eolian_Binary_Operator(IntEnum): INVALID = 0 @@ -186,12 +195,13 @@ class Eolian_Binary_Operator(IntEnum): GE = 10 # >= int, float LE = 11 # <= int, float AND = 12 # && all types - OR = 13 # || all types + OR = 13 # || all types BAND = 14 # & int - BOR = 15 # | int + BOR = 15 # | int BXOR = 16 # ^ int - LSH = 17 # << int - RSH = 18 # >> int + LSH = 17 # << int + RSH = 18 # >> int + class Eolian_Unary_Operator(IntEnum): INVALID = 0 @@ -200,6 +210,7 @@ class Eolian_Unary_Operator(IntEnum): NOT = 3 # ! int, float, bool BNOT = 4 # ~ int + class Eolian_Doc_Token_Type(IntEnum): UNKNOWN = 0 TEXT = 1 @@ -211,12 +222,12 @@ class Eolian_Doc_Token_Type(IntEnum): MARKUP_MONOSPACE = 7 -### internal Classes ######################################################## +# Internal Classes ########################################################## class Iterator(object): """ Generic eina iterator wrapper """ def __init__(self, conv_func, iterator): - self.next = self.__next__ # py2 compat + self.next = self.__next__ # py2 compat self._conv = conv_func self._iter = c_void_p(iterator) self._tmp = c_void_p(0) @@ -251,6 +262,7 @@ class cached_property(object): class EolianBaseObject(object): __instances_cache = {} + def __new__(cls, c_obj_pointer=None, *args, **kargs): # cannot cache without a pointer if c_obj_pointer is None: @@ -307,7 +319,7 @@ class EolianBaseObject(object): return self._obj -### Main Eolian Unit ######################################################## +# Main Eolian Unit ########################################################## class Eolian_Unit(EolianBaseObject): def __repr__(self): @@ -451,7 +463,7 @@ class Eolian_State(Eolian_Unit): def objects_by_file_get(self, file_name): return Iterator(Object, - lib.eolian_state_objects_by_file_get(self, _str_to_bytes(file_name))) + lib.eolian_state_objects_by_file_get(self, _str_to_bytes(file_name))) def class_by_file_get(self, file_name): c_cls = lib.eolian_state_class_by_file_get(self, _str_to_bytes(file_name)) @@ -459,22 +471,22 @@ class Eolian_State(Eolian_Unit): def constants_by_file_get(self, file_name): return Iterator(Constant, - lib.eolian_state_constants_by_file_get(self, _str_to_bytes(file_name))) + lib.eolian_state_constants_by_file_get(self, _str_to_bytes(file_name))) def aliases_by_file_get(self, file_name): return Iterator(Typedecl, - lib.eolian_state_aliases_by_file_get(self, _str_to_bytes(file_name))) + lib.eolian_state_aliases_by_file_get(self, _str_to_bytes(file_name))) def structs_by_file_get(self, file_name): return Iterator(Typedecl, - lib.eolian_state_structs_by_file_get(self, _str_to_bytes(file_name))) + lib.eolian_state_structs_by_file_get(self, _str_to_bytes(file_name))) def enums_by_file_get(self, file_name): return Iterator(Typedecl, - lib.eolian_state_enums_by_file_get(self, _str_to_bytes(file_name))) + lib.eolian_state_enums_by_file_get(self, _str_to_bytes(file_name))) -### Namespace Utility Class ################################################# +# Namespace Utility Class ################################################### class Namespace(object): def __init__(self, unit, namespace_name): @@ -512,55 +524,55 @@ class Namespace(object): def sub_namespaces(self): base = self._name + '.' deep = self._name.count('.') + 1 - return [ ns for ns in self._unit.all_namespaces - if ns.name.startswith(base) and ns.name.count('.') == deep ] + return [ns for ns in self._unit.all_namespaces + if ns.name.startswith(base) and ns.name.count('.') == deep] @property def classes(self): - return sorted([ c for c in self._unit.classes - if c.namespace == self._name ]) + return sorted([c for c in self._unit.classes + if c.namespace == self._name]) @property def regulars(self): - return sorted([ c for c in self._unit.classes - if c.type == Eolian_Class_Type.REGULAR and - c.namespace == self._name]) + return sorted([c for c in self._unit.classes + if c.type == Eolian_Class_Type.REGULAR + and c.namespace == self._name]) @property def abstracts(self): - return sorted([ c for c in self._unit.classes - if c.type == Eolian_Class_Type.ABSTRACT and - c.namespace == self._name]) + return sorted([c for c in self._unit.classes + if c.type == Eolian_Class_Type.ABSTRACT + and c.namespace == self._name]) @property def mixins(self): - return sorted([ c for c in self._unit.classes - if c.type == Eolian_Class_Type.MIXIN and - c.namespace == self._name]) + return sorted([c for c in self._unit.classes + if c.type == Eolian_Class_Type.MIXIN + and c.namespace == self._name]) @property def interfaces(self): - return sorted([ c for c in self._unit.classes - if c.type == Eolian_Class_Type.INTERFACE and - c.namespace == self._name]) + return sorted([c for c in self._unit.classes + if c.type == Eolian_Class_Type.INTERFACE + and c.namespace == self._name]) @property def aliases(self): - return sorted([ td for td in self._unit.aliases - if td.namespace == self._name]) + return sorted([td for td in self._unit.aliases + if td.namespace == self._name]) @property def structs(self): - return sorted([ td for td in self._unit.structs - if td.namespace == self._name]) + return sorted([td for td in self._unit.structs + if td.namespace == self._name]) @property def enums(self): - return sorted([ td for td in self._unit.enums - if td.namespace == self._name]) + return sorted([td for td in self._unit.enums + if td.namespace == self._name]) -### Eolian Classes ########################################################## +# Eolian Classes ############################################################ class Object(EolianBaseObject): def __new__(cls, c_obj_pointer): @@ -680,27 +692,27 @@ class Class(Object): @cached_property def inherits_full(self): - L = [] + li = [] def do_class_recursive(cls): if cls.parent: - L.append(cls.parent) + li.append(cls.parent) for other in cls.extensions: - if other not in L: - L.append(other) + if other not in li: + li.append(other) do_class_recursive(other) do_class_recursive(self) - return L + return li @cached_property def hierarchy(self): - L = [] + li = [] base = self.parent while base: - L.append(base) + li.append(base) base = base.parent - return L + return li @cached_property def ctor_enable(self): @@ -710,10 +722,10 @@ class Class(Object): def dtor_enable(self): return bool(lib.eolian_class_dtor_enable_get(self)) - def function_by_name_get(self, func_name, + def function_by_name_get(self, function_name, ftype=Eolian_Function_Type.UNRESOLVED): f = lib.eolian_class_function_by_name_get(self, - _str_to_bytes(func_name), + _str_to_bytes(function_name), ftype) return Function(f) if f else None @@ -868,36 +880,40 @@ class Function(Object): return Iterator(Function_Parameter, lib.eolian_function_parameters_get(self)) - def values_get(self, ftype): # TODO rename in property_values_get (or implement a proper Property class?) + def values_get(self, ftype): + # TODO rename in property_values_get + # (or implement a proper Property class?) return Iterator(Function_Parameter, lib.eolian_property_values_get(self, ftype)) @property - def getter_values(self): # TODO rename ... + def getter_values(self): # TODO rename ... return self.values_get(Eolian_Function_Type.PROP_GET) @property - def setter_values(self): # TODO rename ... + def setter_values(self): # TODO rename ... return self.values_get(Eolian_Function_Type.PROP_SET) - def keys_get(self, ftype): # TODO rename in property_keys_get (or implement a proper Property class?) + def keys_get(self, ftype): + # TODO rename in property_keys_get + # (or implement a proper Property class?) return Iterator(Function_Parameter, lib.eolian_property_keys_get(self, ftype)) @property - def getter_keys(self): # TODO rename ... + def getter_keys(self): # TODO rename ... return self.keys_get(Eolian_Function_Type.PROP_GET) @property - def setter_keys(self): # TODO rename ... + def setter_keys(self): # TODO rename ... return self.keys_get(Eolian_Function_Type.PROP_SET) def return_type_get(self, ftype): c_type = lib.eolian_function_return_type_get(self, ftype) return Type(c_type) if c_type else None - def return_default_value(self, ftye): - c_expr = lib.eolian_function_return_default_value_get(sel._obj, ftype) + def return_default_value(self, ftype): + c_expr = lib.eolian_function_return_default_value_get(self._obj, ftype) return Expression(c_expr) if c_expr else None def return_documentation(self, ftype): @@ -1019,7 +1035,7 @@ class Implement(Object): class Type(Object): def __repr__(self): - # return "".format(self) + # return "".format(self) return "".format(self) @cached_property @@ -1326,11 +1342,12 @@ class Documentation_Token(object): return self._ref -### internal string encode/decode ########################################### +# internal string encode/decode ############################################# def _str_to_bytes(s): return s.encode('utf-8') + def _str_to_py(s): if s is None: return None @@ -1345,7 +1362,7 @@ def _str_to_py(s): print('WARNING !!!!!!!!! Unknown type: %s' % type(s)) -### internal Object type -> Class mapping ################################### +# internal Object type -> Class mapping ##################################### class _Eolian_Object_Type(IntEnum): UNKNOWN = 0 @@ -1364,6 +1381,7 @@ class _Eolian_Object_Type(IntEnum): CONSTRUCTOR = 13 DOCUMENTATION = 14 + _eolian_type_class_mapping = { _Eolian_Object_Type.UNKNOWN: Object, _Eolian_Object_Type.CLASS: Class, @@ -1382,17 +1400,20 @@ _eolian_type_class_mapping = { _Eolian_Object_Type.DOCUMENTATION: Documentation, } -### module init/shutdown #################################################### + +# module init/shutdown ###################################################### + def _cleanup(): global _already_halted lib.eolian_shutdown() _already_halted = True + lib.eolian_init() atexit.register(_cleanup) -### API coverage statistics ################################################# +# API coverage statistics ################################################### if __name__ == '__main__': import sys diff --git a/src/scripts/pyolian/eolian_lib.py b/src/scripts/pyolian/eolian_lib.py index f219eecfd7..4ab968eb4d 100644 --- a/src/scripts/pyolian/eolian_lib.py +++ b/src/scripts/pyolian/eolian_lib.py @@ -29,7 +29,7 @@ for lib_dir in search_in: file_path = f if not file_path: - raise RuntimeError('Error: cannot find a built eolian library in source tree') + raise RuntimeError('Error: cannot find a built eolian lib in source tree') lib = CDLL(file_path) @@ -42,7 +42,8 @@ lib.eolian_init.restype = c_int lib.eolian_shutdown.argtypes = None lib.eolian_shutdown.restype = c_int -### Eolian_State ############################################################ + +# Eolian_State ############################################################## # EAPI Eolian_State *eolian_state_new(void); lib.eolian_state_new.argtypes = None @@ -124,7 +125,8 @@ lib.eolian_state_structs_by_file_get.restype = c_void_p lib.eolian_state_enums_by_file_get.argtypes = (c_void_p, c_char_p) lib.eolian_state_enums_by_file_get.restype = c_void_p -### Eolian_Unit ############################################################# + +# Eolian_Unit ############################################################### # EAPI Eina_Iterator *eolian_unit_children_get(const Eolian_Unit *unit); lib.eolian_unit_children_get.argtypes = (c_void_p,) @@ -186,7 +188,8 @@ lib.eolian_unit_constant_by_name_get.restype = c_void_p lib.eolian_unit_constants_get.argtypes = (c_void_p,) lib.eolian_unit_constants_get.restype = c_void_p -### Eolian_Object ########################################################### + +# Eolian_Object ############################################################# # EAPI Eolian_Object_Type eolian_object_type_get(const Eolian_Object *obj); lib.eolian_object_type_get.argtypes = (c_void_p,) @@ -224,7 +227,8 @@ lib.eolian_object_namespaces_get.restype = c_void_p lib.eolian_object_is_beta.argtypes = (c_void_p,) lib.eolian_object_is_beta.restype = c_bool -### Eolian_Class ############################################################ + +# Eolian_Class ############################################################## # EAPI Eolian_Class_Type eolian_class_type_get(const Eolian_Class *klass); lib.eolian_class_type_get.argtypes = (c_void_p,) @@ -302,7 +306,8 @@ lib.eolian_class_c_macro_get.restype = c_void_p # Stringshare TO BE FREED lib.eolian_class_c_data_type_get.argtypes = (c_void_p,) lib.eolian_class_c_data_type_get.restype = c_void_p # Stringshare TO BE FREED -### Eolian_Function ######################################################### + +# Eolian_Function ########################################################### # EAPI Eolian_Function_Type eolian_function_type_get(const Eolian_Function *function_id); lib.eolian_function_type_get.argtypes = (c_void_p,) @@ -369,7 +374,8 @@ lib.eolian_property_keys_get.restype = c_void_p lib.eolian_property_values_get.argtypes = (c_void_p, c_int) lib.eolian_property_values_get.restype = c_void_p -### Eolian_Function_Parameter ############################################### + +# Eolian_Function_Parameter ################################################# # EAPI Eolian_Parameter_Direction eolian_parameter_direction_get(const Eolian_Function_Parameter *param); lib.eolian_parameter_direction_get.argtypes = (c_void_p,) @@ -391,7 +397,8 @@ lib.eolian_parameter_documentation_get.restype = c_void_p lib.eolian_parameter_is_optional.argtypes = (c_void_p,) lib.eolian_parameter_is_optional.restype = c_bool -### Eolian_Implement ######################################################## + +# Eolian_Implement ########################################################## # EAPI const Eolian_Class *eolian_implement_class_get(const Eolian_Implement *impl); lib.eolian_implement_class_get.argtypes = (c_void_p,) @@ -425,7 +432,8 @@ lib.eolian_implement_is_prop_get.restype = c_bool lib.eolian_implement_is_prop_set.argtypes = (c_void_p,) lib.eolian_implement_is_prop_set.restype = c_bool -### Eolian_Constructor ###################################################### + +# Eolian_Constructor ######################################################## # EAPI const Eolian_Class *eolian_constructor_class_get(const Eolian_Constructor *ctor); lib.eolian_constructor_class_get.argtypes = (c_void_p,) @@ -439,7 +447,8 @@ lib.eolian_constructor_function_get.restype = c_void_p lib.eolian_constructor_is_optional.argtypes = (c_void_p,) lib.eolian_constructor_is_optional.restype = c_bool -### Eolian_Event ############################################################ + +# Eolian_Event ############################################################## # EAPI Eina_Stringshare *eolian_event_c_macro_get(const Eolian_Event *event); lib.eolian_event_c_macro_get.argtypes = (c_void_p,) @@ -465,7 +474,8 @@ lib.eolian_event_is_hot.restype = c_bool lib.eolian_event_is_restart.argtypes = (c_void_p,) lib.eolian_event_is_restart.restype = c_bool -### Eolian_Part ############################################################# + +# Eolian_Part ############################################################### # EAPI const Eolian_Class *eolian_part_class_get(const Eolian_Part *part); lib.eolian_part_class_get.argtypes = (c_void_p,) @@ -475,7 +485,8 @@ lib.eolian_part_class_get.restype = c_void_p lib.eolian_part_documentation_get.argtypes = (c_void_p,) lib.eolian_part_documentation_get.restype = c_void_p -### Eolian_Typedecl ######################################################### + +# Eolian_Typedecl ########################################################### # EAPI Eolian_Typedecl_Type eolian_typedecl_type_get(const Eolian_Typedecl *tp); lib.eolian_typedecl_type_get.argtypes = (c_void_p,) @@ -549,7 +560,8 @@ lib.eolian_typedecl_free_func_get.restype = c_char_p lib.eolian_typedecl_function_pointer_get.argtypes = (c_void_p,) lib.eolian_typedecl_function_pointer_get.restype = c_void_p -### Eolian_Type ############################################################# + +# Eolian_Type ############################################################### # EAPI Eolian_Type_Type eolian_type_type_get(const Eolian_Type *tp); lib.eolian_type_type_get.argtypes = (c_void_p,) @@ -588,10 +600,11 @@ lib.eolian_type_is_ptr.argtypes = (c_void_p,) lib.eolian_type_is_ptr.restype = c_bool # EAPI Eina_Stringshare *eolian_type_c_type_get(const Eolian_Type *tp); -lib.eolian_type_c_type_get.argtypes = (c_void_p) +lib.eolian_type_c_type_get.argtypes = (c_void_p,) lib.eolian_type_c_type_get.restype = c_void_p # Stringshare TO BE FREED -### Eolian_Expression ####################################################### + +# Eolian_Expression ######################################################### # EAPI Eina_Stringshare *eolian_expression_serialize(const Eolian_Expression *expr); lib.eolian_expression_serialize.argtypes = (c_void_p,) @@ -621,7 +634,8 @@ lib.eolian_expression_unary_operator_get.restype = c_int lib.eolian_expression_unary_expression_get.argtypes = (c_void_p,) lib.eolian_expression_unary_expression_get.restype = c_void_p -### Eolian_Constant ######################################################### + +# Eolian_Constant ########################################################### # EAPI const Eolian_Documentation *eolian_constant_documentation_get(const Eolian_Constant *var); lib.eolian_constant_documentation_get.argtypes = (c_void_p,) @@ -639,7 +653,8 @@ lib.eolian_constant_value_get.restype = c_void_p lib.eolian_constant_is_extern.argtypes = (c_void_p,) lib.eolian_constant_is_extern.restype = c_bool -### Eolian_Documentation #################################################### + +# Eolian_Documentation ###################################################### # EAPI Eina_Stringshare *eolian_documentation_summary_get(const Eolian_Documentation *doc); lib.eolian_documentation_summary_get.argtypes = (c_void_p,) @@ -677,4 +692,3 @@ lib.eolian_doc_token_text_get.restype = c_void_p # char* TO BE FREED # EAPI Eolian_Object_Type eolian_doc_token_ref_resolve(const Eolian_Doc_Token *tok, const Eolian_State *state, const Eolian_Object **data, const Eolian_Object **data2); # lib.eolian_doc_token_ref_resolve.argtypes = (c_void_p, c_void_p, ???, ???) # lib.eolian_doc_token_ref_resolve.restype = c_int - diff --git a/src/scripts/pyolian/generator.py b/src/scripts/pyolian/generator.py index 5d119d3511..71fb312ad6 100755 --- a/src/scripts/pyolian/generator.py +++ b/src/scripts/pyolian/generator.py @@ -41,6 +41,7 @@ PYTHON_PATH, fe: """ import os import datetime +import atexit try: from . import eolian @@ -70,11 +71,13 @@ if not eolian_db.all_eot_files_parse(): if not eolian_db.all_eo_files_parse(): raise(RuntimeError('Eolian, failed to parse all EO files')) + # cleanup the database on exit -import atexit def cleanup_db(): global eolian_db del eolian_db + + atexit.register(cleanup_db) @@ -92,11 +95,12 @@ class Template(pyratemp.Template): filename: Template file to load. (REQUIRED) context: User provided context for the template (dict). """ + def __init__(self, filename, encoding='utf-8', context=None, escape=None, - loader_class=pyratemp.LoaderFile, - parser_class=pyratemp.Parser, - renderer_class=pyratemp.Renderer, - eval_class=pyratemp.EvalPseudoSandbox): + loader_class=pyratemp.LoaderFile, + parser_class=pyratemp.Parser, + renderer_class=pyratemp.Renderer, + eval_class=pyratemp.EvalPseudoSandbox): # Build the global context for the template global_ctx = {} @@ -154,7 +158,7 @@ class Template(pyratemp.Template): eval_class=eval_class) def render(self, filename=None, verbose=True, cls=None, ns=None, - struct=None, enum=None, alias=None, **kargs): + struct=None, enum=None, alias=None, **kargs): # Build the context for the template ctx = {} if kargs: diff --git a/src/scripts/pyolian/test_eolian.py b/src/scripts/pyolian/test_eolian.py index 7e2d1402c0..0271e50117 100755 --- a/src/scripts/pyolian/test_eolian.py +++ b/src/scripts/pyolian/test_eolian.py @@ -99,26 +99,26 @@ class TestEolianUnit(unittest.TestCase): @unittest.skip('Skipped until unit/state support is fixed') def test_children_listing(self): - l = list(eolian_db.children) - self.assertGreater(len(l), 500) - self.assertIsInstance(l[0], eolian.Eolian_Unit) + li = list(eolian_db.children) + self.assertGreater(len(li), 500) + self.assertIsInstance(li[0], eolian.Eolian_Unit) def test_file_listing(self): - l = list(eolian_db.eo_file_paths) - self.assertGreater(len(l), 400) - self.assertTrue(l[0].endswith('.eo')) + li = list(eolian_db.eo_file_paths) + self.assertGreater(len(li), 400) + self.assertTrue(li[0].endswith('.eo')) - l = list(eolian_db.eo_files) - self.assertGreater(len(l), 400) - self.assertTrue(l[0].endswith('.eo')) + li = list(eolian_db.eo_files) + self.assertGreater(len(li), 400) + self.assertTrue(li[0].endswith('.eo')) - l = list(eolian_db.eot_file_paths) - self.assertGreater(len(l), 10) - self.assertTrue(l[0].endswith('.eot')) + li = list(eolian_db.eot_file_paths) + self.assertGreater(len(li), 10) + self.assertTrue(li[0].endswith('.eot')) - l = list(eolian_db.eot_files) - self.assertGreater(len(l), 10) - self.assertTrue(l[0].endswith('.eot')) + li = list(eolian_db.eot_files) + self.assertGreater(len(li), 10) + self.assertTrue(li[0].endswith('.eot')) def test_object_listing(self): unit = eolian_db.unit_by_file_get('efl_ui_win.eo') @@ -137,10 +137,10 @@ class TestEolianUnit(unittest.TestCase): self.assertGreater(count, 5) def test_enum_listing(self): - l = list(eolian_db.enums_by_file_get('efl_ui_win.eo')) - self.assertGreater(len(l), 5) - self.assertIsInstance(l[0], eolian.Typedecl) - self.assertEqual(l[0].type, eolian.Eolian_Typedecl_Type.ENUM) + li = list(eolian_db.enums_by_file_get('efl_ui_win.eo')) + self.assertGreater(len(li), 5) + self.assertIsInstance(li[0], eolian.Typedecl) + self.assertEqual(li[0].type, eolian.Eolian_Typedecl_Type.ENUM) all_count = 0 for enum in eolian_db.enums: @@ -150,10 +150,10 @@ class TestEolianUnit(unittest.TestCase): self.assertGreater(all_count, 50) def test_struct_listing(self): - l = list(eolian_db.structs_by_file_get('eina_types.eot')) - self.assertGreater(len(l), 10) - self.assertIsInstance(l[0], eolian.Typedecl) - self.assertIn(l[0].type, ( + li = list(eolian_db.structs_by_file_get('eina_types.eot')) + self.assertGreater(len(li), 10) + self.assertIsInstance(li[0], eolian.Typedecl) + self.assertIn(li[0].type, ( eolian.Eolian_Typedecl_Type.STRUCT, eolian.Eolian_Typedecl_Type.STRUCT_OPAQUE)) @@ -167,27 +167,27 @@ class TestEolianUnit(unittest.TestCase): self.assertGreater(all_count, 50) def test_alias_listing(self): - l = list(eolian_db.aliases_by_file_get('eina_types.eot')) - self.assertGreater(len(l), 2) - self.assertIsInstance(l[0], eolian.Typedecl) + li = list(eolian_db.aliases_by_file_get('eina_types.eot')) + self.assertGreater(len(li), 2) + self.assertIsInstance(li[0], eolian.Typedecl) all_count = 0 for alias in eolian_db.aliases: self.assertIsInstance(alias, eolian.Typedecl) self.assertIn(alias.type, ( eolian.Eolian_Typedecl_Type.ALIAS, - eolian.Eolian_Typedecl_Type.FUNCTION_POINTER)) # TODO is this correct ?? + eolian.Eolian_Typedecl_Type.FUNCTION_POINTER)) # TODO is this correct ?? all_count += 1 self.assertGreater(all_count, 10) def test_constant_listing(self): - l = list(eolian_db.constants) - self.assertGreater(len(l), 2) - self.assertIsInstance(l[0], eolian.Constant) + li = list(eolian_db.constants) + self.assertGreater(len(li), 2) + self.assertIsInstance(li[0], eolian.Constant) - l = list(eolian_db.constants_by_file_get('efl_gfx_stack.eo')) - self.assertGreater(len(l), 1) - self.assertIsInstance(l[0], eolian.Constant) + li = list(eolian_db.constants_by_file_get('efl_gfx_stack.eo')) + self.assertGreater(len(li), 1) + self.assertIsInstance(li[0], eolian.Constant) def test_class_listing(self): all_count = 0 @@ -219,7 +219,7 @@ class TestEolianNamespace(unittest.TestCase): 'Ector.Software.Buffer', 'Eio.Sentry', 'Eldbus.Model', - ] + ] for ns in eolian_db.all_namespaces: cls = eolian_db.class_by_name_get(ns.name) # Some legacy classes are parsed and still make this fail. @@ -344,8 +344,8 @@ class TestEolianClass(unittest.TestCase): self.assertEqual(cls.c_get_function_name, 'efl_loop_timer_class_get') self.assertEqual(cls.c_macro, 'EFL_LOOP_TIMER_CLASS') self.assertEqual(cls.c_data_type, 'Efl_Loop_Timer_Data') - self.assertEqual([f.name for f in cls.methods], ['timer_reset','timer_loop_reset','timer_delay']) - self.assertEqual([f.name for f in cls.properties], ['timer_interval','time_pending']) + self.assertEqual([f.name for f in cls.methods], ['timer_reset', 'timer_loop_reset', 'timer_delay']) + self.assertEqual([f.name for f in cls.properties], ['timer_interval', 'time_pending']) self.assertGreater(len(list(cls.implements)), 5) self.assertIsInstance(list(cls.implements)[0], eolian.Implement) @@ -399,7 +399,7 @@ class TestEolianImplement(unittest.TestCase): self.assertEqual(im.name, 'Efl.Loop_Timer.timer_delay') self.assertIsInstance(im.class_, eolian.Class) self.assertIsInstance(im.function, eolian.Function) - self.assertIsInstance(im.documentation_get(), eolian.Documentation) # TODO is UNRESOLVED correct ? + self.assertIsInstance(im.documentation_get(), eolian.Documentation) # TODO is UNRESOLVED correct ? self.assertFalse(im.is_auto()) self.assertFalse(im.is_empty()) self.assertFalse(im.is_pure_virtual()) @@ -473,7 +473,7 @@ class TestEolianConstant(unittest.TestCase): self.assertEqual(var.short_name, 'Hint_Expand') self.assertEqual(var.file, 'efl_gfx_hint.eo') self.assertFalse(var.is_extern) - self.assertEqual(list(var.namespaces), ['Efl','Gfx']) + self.assertEqual(list(var.namespaces), ['Efl', 'Gfx']) self.assertIsInstance(var.documentation, eolian.Documentation) self.assertIsInstance(var.type, eolian.Type) self.assertIsInstance(var.value, eolian.Expression) @@ -487,7 +487,7 @@ class TestEolianTypedecl(unittest.TestCase): self.assertEqual(td.name, 'Efl.Net.Http.Version') self.assertEqual(td.short_name, 'Version') self.assertEqual(td.file, 'efl_net_http_types.eot') - self.assertEqual(list(td.namespaces), ['Efl','Net','Http']) + self.assertEqual(list(td.namespaces), ['Efl', 'Net', 'Http']) self.assertIsInstance(td.documentation, eolian.Documentation) self.assertIsNone(td.base_type) # TODO find a better test self.assertIsNone(td.free_func) # TODO find a better test @@ -511,7 +511,7 @@ class TestEolianTypedecl(unittest.TestCase): self.assertEqual(td.name, 'Efl.Gfx.Color32') self.assertEqual(td.short_name, 'Color32') self.assertEqual(td.file, 'efl_canvas_filter_internal.eo') - self.assertEqual(list(td.namespaces), ['Efl','Gfx']) + self.assertEqual(list(td.namespaces), ['Efl', 'Gfx']) self.assertIsInstance(td.documentation, eolian.Documentation) self.assertIsNone(td.base_type) # TODO find a better test self.assertIsNone(td.free_func) # TODO find a better test @@ -544,13 +544,13 @@ class TestEolianType(unittest.TestCase): cls = eolian_db.class_by_name_get('Efl.Loop_Timer') func = cls.function_by_name_get('timer_delay') param = list(func.parameters)[0] - t = param.type # type: double + t = param.type # type double self.assertIsInstance(t, eolian.Type) self.assertEqual(t.name, 'double') self.assertEqual(t.short_name, 'double') self.assertEqual(t.type, eolian.Eolian_Type_Type.REGULAR) self.assertEqual(t.builtin_type, eolian.Eolian_Type_Builtin_Type.DOUBLE) - self.assertEqual(t.file, 'efl_loop_timer.eo') # TODO is this correct ? + self.assertEqual(t.file, 'efl_loop_timer.eo') # TODO is this correct ? self.assertIsNone(t.base_type) # TODO find a better test self.assertIsNone(t.next_type) # TODO find a better test self.assertFalse(t.is_const) @@ -563,7 +563,7 @@ class TestEolianType(unittest.TestCase): cls = eolian_db.class_by_name_get('Efl.Gfx.Entity') func = cls.function_by_name_get('geometry') param = list(func.setter_values)[0] - t = param.type # type: Eina.Rect + t = param.type # type Eina.Rect self.assertIsInstance(t, eolian.Type) self.assertEqual(t.name, 'Eina.Rect') self.assertEqual(t.short_name, 'Rect') @@ -582,7 +582,7 @@ class TestEolianType(unittest.TestCase): cls = eolian_db.class_by_name_get('Efl.Content') func = cls.function_by_name_get('content') param = list(func.setter_values)[0] - t = param.type # type: Efl.Gfx (class interface) + t = param.type # type Efl.Gfx (class interface) self.assertIsInstance(t, eolian.Type) self.assertEqual(t.name, 'Efl.Gfx.Entity') self.assertEqual(t.short_name, 'Entity') @@ -612,11 +612,11 @@ class TestEolianExpression(unittest.TestCase): self.assertIsInstance(exp, eolian.Expression) self.assertEqual(exp.type, eolian.Eolian_Expression_Type.UNARY) self.assertEqual(float(exp.serialize), 32768.0) # TODO is this a bug? isn't -1.0 ? - self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM) # Invalid -> NOP + self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM) # Invalid -> NOP unary = exp.unary_expression self.assertIsInstance(unary, eolian.Expression) self.assertEqual(unary.type, eolian.Eolian_Expression_Type.INT) - self.assertEqual(float(exp.serialize), 32768.0) # Bug too? + self.assertEqual(float(exp.serialize), 32768.0) # Bug too? # TODO test_expression_binary # exp.binary_operator # TODO find a better test (only works for BINARY expr) @@ -624,7 +624,6 @@ class TestEolianExpression(unittest.TestCase): # exp.binary_rhs # TODO find a better test (only works for BINARY expr) - if __name__ == '__main__': # create main eolian state eolian_db = eolian.Eolian_State()