Completed the refactor to a more robust system.

Author: majora2007

easyjava.py

@@ -8,10 +8,7 @@
 
 from gooey import Gooey, GooeyParser
 
-#import parse as parse
 from parse import DataParser
-from typeinfo import TypeInfo
-from util import camel_case, first_upper, first_chars, spinal_case, pyinstaller_get_full_path
 from generator import Generator
 
 def get_argument(argument, default="None"):
@@ -33,95 +30,6 @@ def init_args():
     return parser.parse_args()
 
 
-
-def parse_data(data_file):
-    types = []
-    lines = []
-    parser = DataParser()
-    with open(data_file, 'r') as in_file:
-        lines = in_file.read().splitlines() 
-    
-
-    header = lines[0].split('|')
-    print(header)
-
-    line_data = []
-    for line in lines[1:]:
-        line_data = [c for c in line.split('|') if c != '' and c != ' ']
-        if len(line_data) is len(lines[0]):
-            break
-    
-    for idx, cell in enumerate(line_data):
-        types.append(TypeInfo(parser.parse_type(cell), camel_case(header[idx]), header[idx]))
-    
-    return types
-
-def generate_entity_file(entity_name, types):
-    print('Generating {0}.java'.format(entity_name))    
-
-    declarations = ''
-    for t in types:
-        declarations = declarations + t.generate_definitition() + '\n'
-    
-    getter_setter = ''
-    for t in types:
-        getter_setter = getter_setter + t.generate_getter() + '\n' + t.generate_setter() + '\n'
-    
-    to_string = '" ' + entity_name + ' ['
-
-    for t in types:
-        # "[%ENTITY%] [[%VARIABLE%]=" + [%VARIABLE%] + ", Name=" + name + ", Designation=" + designation + ", Salary=" + salary + "]";
-        to_string = to_string + t.var_name + '= " + ' + t.var_name + ' + ", '
-    to_string = ''.join(to_string[:len(to_string)-3]) + '"]";'
-    
-    template = ''
-    path = pyinstaller_get_full_path('templates/Entity.java') #os.path.abspath(os.path.join(os.getcwd(), 'templates/Entity.java')) # Local only
-
-    with open(path, 'r') as in_file:
-        template = in_file.read()
-
-    template = template.replace('[%ENTITY%]', first_upper(entity_name)).replace('[%DECLARATION%]', declarations).replace('[%GETTER_SETTER%]', getter_setter).replace('[%TOSTRING%]', to_string)
-    with open(first_upper(entity_name) + '.java', 'w+') as out_file:
-        out_file.write(template)
-
-def generate_entity_row_mapper(entity_name, types):
-    print('Generating {0}RowMapper.java'.format(entity_name))   
-
-    template = ''
-    path = pyinstaller_get_full_path('templates/EntityRowMapper.java') # os.path.abspath(os.path.join(os.getcwd(), 'templates/EntityRowMapper.java')) # Local only
-
-    with open(path, 'r') as in_file:
-        template = in_file.read()
-    
-    entity_var_name = first_chars(entity_name)
-
-    row_maps = ''
-    for t in types:
-        row_maps = row_maps + '\t\t' + entity_var_name + t.generate_rowmap_method() + '\n'
-    
-    template = template.replace('[%ENTITY%]', first_upper(entity_name)).replace('[%ENTITYVAR%]', entity_var_name).replace('[%ROWMAPPER%]', row_maps)
-    
-    with open(first_upper(entity_name) + 'RowMapper.java', 'w+') as out_file:
-        out_file.write(template)
-
-def generate_entity_typescript(entity_name, types):
-    print('Generating {0}.ts'.format(spinal_case(entity_name).lower()))   
-
-    template = ''
-    path = pyinstaller_get_full_path('templates/entity.ts') # os.path.abspath(os.path.join(os.getcwd(), 'templates/entity.ts')) # Local only
-    with open(path, 'r') as in_file:
-        template = in_file.read()
-
-    definitions = ''
-    for t in types:
-        definitions = definitions + '  ' + t.generate_ts_definition() + '\n'
-    
-    template = template.replace('[%ENTITY%]', first_upper(entity_name)).replace('[%DEFINITIONS%]', definitions)
-    
-    with open(spinal_case(entity_name).lower() + '.ts', 'w+') as out_file:
-        out_file.write(template)
-
-
 @Gooey
 def main(program_name='Easy Java', program_description='Generate POJOs and Row Mappers from data output'):
     args = init_args()
@@ -130,16 +38,7 @@ def main(program_name='Easy Java', program_description='Generate POJOs and Row M
 
     gen = Generator()
     gen.load_file(data_file)
-    gen.generate_entity_files(entity, os.getcwd())
-    exit()
-
-    types = parse_data(data_file)
-
-    generate_entity_file(entity, types)
-    generate_entity_row_mapper(entity, types)
-
-    if bool(args.typescript):
-        generate_entity_typescript(entity, types)
+    gen.generate_entity_files(entity, os.getcwd(), bool(args.typescript))
 
 
 if __name__ == '__main__':

generator.py

@@ -3,12 +3,16 @@
 
 from parse import DataParser
 from util import camel_case, first_upper, first_chars, spinal_case, pyinstaller_get_full_path
+from languagetype import Language
 
 DEFINITION_TEMPLATE = '\tprivate {0} {1};'
 GETTER_TEMPLATE = '\tpublic {0} get{1}() {{\n\t\treturn this.{2};\n\t}}'
 SETTER_TEMPLATE = '\tpublic void set{0}({1} {2}) {{\n\t\tthis.{2} = {2};\n\t}}'
 TOSTRING_TEMPLATE = '"[{0}] [{1}]"'
 TOSTRING_INNER_TEMPLATE = '{}=" + {} + "'
+ROWMAP_SETTER_TEMPLATE = '\t\t{0}.set{1}(rs.get{1}("{2}"));'
+TYPESCRIPT_DEFINITION_TEMPLATE = '  {0}: {1};'
+
 
 class Generator(object):
     data = []
@@ -42,16 +46,16 @@ def load_file(self, data_file):
         for idx, cell in enumerate(line_data):
             self.types[header[idx]] = self.parser.parse_type(cell), camel_case(header[idx])
 
-        # {'ACTIONITEMIMPACTID': ('int', 'actionItemImpactId'), 'ACTIONITEMID': ('int', 'actionItemId'), 'APPID': ('int', 'appId'), 'APPNAME': (None, 'appName'), 'UPDATEDBY': ('String', 'updatedBy'), 'LASTUPDATED': ('String', 'lastUpdated'), 'DISTANCE': ('float', 'distance')}
-        print(self.types)
+        print(self.types) # TODO: Pretty print the mappings to the console
 
-    def generate_entity_files(self, entity_name, folder_path):
+    def generate_entity_files(self, entity_name, folder_path, create_typescript=False):
         if not os.path.isdir(folder_path):
-            # Create folder
             os.mkdir(folder_path)
 
-        # Make Bean
         self._make_bean(entity_name, folder_path)
+        self._make_bean_rowmapper(entity_name, folder_path)
+        if create_typescript:
+            self._make_typescript(entity_name, folder_path)
 
     def _make_bean(self, entity_name, folder_path):
         if not entity_name[0].isupper():
@@ -60,20 +64,9 @@ def _make_bean(self, entity_name, folder_path):
         print('Generating {0}.java'.format(entity_name))
 
         declarations = '\n'.join(self._generate_definitions())
-        
         getter_setter = '\n'.join(self._generate_getters_setters())
-
         to_string = self._generate_tostring(entity_name)
 
-        
-        #to_string = '" ' + entity_name + ' ['
-
-        
-        #for t in types:
-            # "[%ENTITY%] [[%VARIABLE%]=" + [%VARIABLE%] + ", Name=" + name + ", Designation=" + designation + ", Salary=" + salary + "]";
-        #    to_string = to_string + t.var_name + '= " + ' + t.var_name + ' + ", '
-        #to_string = ''.join(to_string[:len(to_string)-3]) + '"]";' 
-        
         template = ''
         path = pyinstaller_get_full_path('templates/Entity.java')
 
@@ -87,20 +80,73 @@ def _make_bean(self, entity_name, folder_path):
         with open(output_path, 'w+') as out_file:
             out_file.write(template)
 
+    def _make_bean_rowmapper(self, entity_name, folder_path):
+        if not entity_name[0].isupper():
+            entity_name = first_upper(entity_name)
+
+        print('Generating {0}RowMapper.java'.format(entity_name))
+
+        template = ''
+        path = pyinstaller_get_full_path('templates/EntityRowMapper.java')
+
+        with open(path, 'r') as in_file:
+            template = in_file.read()
+        
+        row_maps = '\n'.join(self._generate_rowmap(entity_name))
+        
+        template = template.replace('[%ENTITY%]', first_upper(entity_name)).replace('[%ENTITYVAR%]', first_chars(entity_name)).replace('[%ROWMAPPER%]', row_maps)
+        output_path = os.path.join(folder_path, entity_name + 'RowMapper.java')
+        
+        with open(output_path, 'w+') as out_file:
+            out_file.write(template)
+    
+    def _make_typescript(self, entity_name, folder_path):
+        print('Generating {0}.ts'.format(spinal_case(entity_name).lower()))   
+
+        template = ''
+        path = pyinstaller_get_full_path('templates/entity.ts')
+        with open(path, 'r') as in_file:
+            template = in_file.read()
+
+        definitions = '\n'.join(self._generate_typescript_definitions())
+        
+        template = template.replace('[%ENTITY%]', first_upper(entity_name)).replace('[%DEFINITIONS%]', definitions)
+        output_path = os.path.join(folder_path, spinal_case(entity_name).lower() + '.ts')
+
+        with open(output_path, 'w+') as out_file:
+            out_file.write(template)
+    
+    def _generate_typescript_definitions(self):
+        code_lines = []
+        for key in self.types:
+            var = self.types[key]
+            code_lines.append(TYPESCRIPT_DEFINITION_TEMPLATE.format(var[1], self.parser.translate_type(var[0], Language.Typescript)))
+        return code_lines
+    
+    def _generate_rowmap(self, entity_name):
+        entity_var_name = first_chars(entity_name)
+
+        code_lines = []
+        for key in self.types:
+            var = self.types[key]
+            code_lines.append(ROWMAP_SETTER_TEMPLATE.format(entity_var_name, first_upper(var[1]), key))
+        return code_lines
+    
     def _generate_getters_setters(self):
         code_lines = []
         for key in self.types:
             var = self.types[key]
-            code_lines.append(GETTER_TEMPLATE.format(var[0], first_upper(var[1]), var[1]))
-            code_lines.append(SETTER_TEMPLATE.format(var[0], first_upper(var[1]), var[1]))
-        print(code_lines)
+            java_type = self.parser.translate_type(var[0], Language.Java)
+            print('GETTER: Type for {0}: {1}'.format(var[1], java_type))
+            code_lines.append(GETTER_TEMPLATE.format(java_type, first_upper(var[1]), var[1]))
+            code_lines.append(SETTER_TEMPLATE.format(first_upper(java_type), java_type,  var[1]))
         return code_lines
 
     def _generate_definitions(self):
         code_lines = []
         for key in self.types:
             var = self.types[key]
-            code_lines.append(DEFINITION_TEMPLATE.format(var[0], var[1]))
+            code_lines.append(DEFINITION_TEMPLATE.format(self.parser.translate_type(var[0], Language.Java), var[1]))
         print(code_lines)
         return code_lines
 

languagetype.py

@@ -1,7 +1,11 @@
 from enum import Enum
 
+class Language(Enum):
+    Java = 'java'
+    Typescript = 'typescript'
+
 class LanguageType(Enum):
-    string = 1
-    integer = 2
-    float = 3
-    boolean = 4
+    string = 'string'
+    integer = 'integer'
+    float = 'float'
+    boolean = 'boolean'

parse.py

@@ -1,52 +1,68 @@
 from rule import ParseRule, RenameRule
-from languagetype import LanguageType
+from languagetype import LanguageType, Language
 
 default_rules = [
     # (E)thernet to the cell site - (P)lanning and (D)esign (D)atabase
-    ParseRule('matches', r'[^\|\d\.]*', 'String'),
+    ParseRule('matches', r'[^\|\d\.]*', LanguageType.string),
     # ma0585
-    ParseRule('matches', r'[a-z]+[0-9]+', 'String'),
+    ParseRule('matches', r'[a-z]+[0-9]+', LanguageType.string),
     # 05/01/2020
-    ParseRule('matches', r'\d{2}\/\d{2}\/\d{4}', 'String'),
+    ParseRule('matches', r'\d{2}\/\d{2}\/\d{4}', LanguageType.string),
     # 0123
-    ParseRule('matches', r'0\d+', 'String'),
+    ParseRule('matches', r'0\d+', LanguageType.string),
     # 0.234
-    ParseRule('matches', r'\d?\.\d*', 'float'),
+    ParseRule('matches', r'\d?\.\d*', LanguageType.float),
     # 123
-    ParseRule('matches', r'\d*', 'int'),
+    ParseRule('matches', r'\d*', LanguageType.integer),
 ]
 
 java_rename_rules = [
-    RenameRule('Java', 'string', 'String'),
-    RenameRule('Java', 'integer', 'int'),
-    RenameRule('Java', 'float', 'float'),
+    RenameRule(LanguageType.string, 'String'),
+    RenameRule(LanguageType.integer, 'int'),
+    RenameRule(LanguageType.float, 'float'),
 ]
 
-"""
+typescript_rename_rules = [
+    RenameRule(LanguageType.string, 'string'),
+    RenameRule(LanguageType.integer, 'number'),
+    RenameRule(LanguageType.float, 'number'),
+]
+
+
 language_type_rules = {
-    'Java': java_rename_rules,
-} """
+    Language.Java: java_rename_rules,
+    Language.Typescript: typescript_rename_rules
+}
+
 
 class DataParser(object):
     """ Responsible for infering text values into language types based on a set of rules """
 
     rules = []
 
-    def __init__(self, rules=default_rules, ):
+    def __init__(self, rules=default_rules):
         self.rules = rules
 
+        # Add a catchall for NoneTypes, but prioritize order of rulelist
+        self.rules.append(ParseRule('matches', r'.*', LanguageType.string))
+
     def parse_type(self, value):
         for rule in self.rules:
             parsed_type = rule.run(value)
 
             if parsed_type is not None:
                 return parsed_type
         return None
-    
-    def translate_type_java(self, parse_type):
-        for rename in java_rename_rules:
-            java_type = rename.run(parse_type)
-            if java_type is None:
+
+    def translate_type(self, parse_type, language):
+        if not language in language_type_rules:
+            return parse_type
+        
+        rules = language_type_rules[language]
+        
+        for rename in rules:
+            translated_type = rename.run(parse_type)
+            if translated_type is None:
                 continue
-            return java_type
+            return translated_type
         return parse_type

parsetest.py

@@ -1,16 +1,24 @@
 import unittest
 from parse import DataParser
 from rule import ParseRule
+from languagetype import Language, LanguageType
 
 
 class Test_TestParse(unittest.TestCase):
     def test_parse_type(self):
         parser = DataParser()
-        self.assertEqual(parser.parse_type('Hippos eat grass'), 'String')
-        self.assertEqual(parser.parse_type('0123'), 'String')
-        self.assertEqual(parser.parse_type('0.43'), 'float')
-        self.assertEqual(parser.parse_type('.32'), 'float')
-        self.assertEqual(parser.parse_type('100'), 'int')
+        self.assertEqual(parser.parse_type('Hippos eat grass'), LanguageType.string)
+        self.assertEqual(parser.parse_type('0123'), LanguageType.string)
+        self.assertEqual(parser.parse_type('0.43'), LanguageType.float)
+        self.assertEqual(parser.parse_type('.32'), LanguageType.float)
+        self.assertEqual(parser.parse_type('100'), LanguageType.integer)
+        self.assertEqual(parser.parse_type('$650 Switcher registration'), LanguageType.string)
+    
+    def test_parse_type_translate(self):
+        parser = DataParser()
+        self.assertEqual(parser.translate_type(LanguageType.string, Language.Java), 'String')
+        self.assertEqual(parser.translate_type(LanguageType.string, Language.Typescript), 'string')
+        self.assertEqual(parser.translate_type(LanguageType.integer, Language.Typescript), 'number')
 
     def test_parse_type_order(self):
         """ Test parsing a type where I order a BigInt mapping in front of int """