Merge pull request #52 from kyuridenamida/feature/code_gen_option

asi1024 · web-flow · commit e67a223c8729 · 2019-01-02T21:25:59.000+09:00
Add code gen configuration
diff --git a/MANIFEST.in b/MANIFEST.in
@@ -1,2 +1,3 @@
 recursive-include atcodertools/tools/templates/ *
-include requirements.txt
+include requirements.txt
+include atcodertools/tools/atcodertools-default.toml
diff --git a/atcodertools/codegen/code_gen_config.py b/atcodertools/codegen/code_gen_config.py
@@ -0,0 +1,36 @@
+from typing import TextIO
+
+import toml
+
+INDENT_TYPE_SPACE = 'space'
+INDENT_TYPE_TAB = 'tab'
+
+
+class ConfigInitError(Exception):
+    pass
+
+
+class CodeGenConfig:
+    def __init__(self,
+                 indent_type: str = INDENT_TYPE_SPACE,
+                 indent_width: int = 4,
+                 ):
+
+        if indent_type not in [INDENT_TYPE_SPACE, INDENT_TYPE_TAB]:
+            raise ConfigInitError("indent_type must be 'space' or 'tab'")
+
+        if indent_width < 0:
+            raise ConfigInitError("indent_width must be a positive integer")
+
+        self.indent_type = indent_type
+        self.indent_width = indent_width
+
+    def indent(self, depth):
+        if self.indent_type == INDENT_TYPE_SPACE:
+            return " " * self.indent_width * depth
+        return "\t" * self.indent_width * depth
+
+    @classmethod
+    def load(cls, fp: TextIO):
+        kwargs = toml.load(fp).get("codegen")
+        return CodeGenConfig(**kwargs)
diff --git a/atcodertools/codegen/cpp_code_generator.py b/atcodertools/codegen/cpp_code_generator.py
@@ -1,3 +1,4 @@
+from atcodertools.codegen.code_gen_config import CodeGenConfig
 from atcodertools.models.analyzer.analyzed_variable import AnalyzedVariable
 from atcodertools.models.analyzer.simple_format import Pattern, SingularPattern, ParallelPattern, TwoDimensionalPattern
 from atcodertools.models.predictor.format_prediction_result import FormatPredictionResult
@@ -22,9 +23,10 @@ def _loop_header(var: Variable, for_second_index: bool):
 
 class CppCodeGenerator(CodeGenerator):
 
-    def __init__(self, template: str):
+    def __init__(self, template: str, config: CodeGenConfig = CodeGenConfig()):
         self._template = template
         self._prediction_result = None
+        self._config = config
 
     def generate_code(self, prediction_result: FormatPredictionResult):
         if prediction_result is None:
@@ -157,7 +159,7 @@ def _render_pattern(self, pattern: Pattern):
         return lines
 
     def _indent(self, depth):
-        return "    " * depth
+        return self._config.indent(depth)
 
 
 class NoPredictionResultGiven(Exception):
diff --git a/atcodertools/release_management/version_check.py b/atcodertools/release_management/version_check.py
@@ -41,16 +41,16 @@ def store_version_cache(version):
         f.write("{} {}".format(version, time.time()))
 
 
-def get_latest_version(user_cache=True):
+def get_latest_version(use_cache=True):
     try:
-        if user_cache:
+        if use_cache:
             cached_version = _get_latest_version_cache()
             if cached_version:
                 return cached_version
 
         version = _fetch_latest_version()
 
-        if user_cache:
+        if use_cache:
             store_version_cache(version)
 
         return version
diff --git a/atcodertools/tools/atcodertools-default.toml b/atcodertools/tools/atcodertools-default.toml
@@ -0,0 +1,3 @@
+[codegen]
+indent_type = 'space' # 'tab' or 'space'
+indent_width = 4
diff --git a/atcodertools/tools/envgen.py b/atcodertools/tools/envgen.py
@@ -6,8 +6,9 @@
 from multiprocessing import Pool, cpu_count
 from os.path import expanduser
 from time import sleep
-from typing import Tuple
+from typing import Tuple, Optional
 
+from atcodertools.codegen.code_gen_config import CodeGenConfig
 from atcodertools.codegen.cpp_code_generator import CppCodeGenerator
 from atcodertools.codegen.java_code_generator import JavaCodeGenerator
 from atcodertools.fileutils.create_contest_file import create_examples, create_code_from_prediction_result
@@ -43,7 +44,9 @@ def prepare_procedure(atcoder_client: AtCoderClient,
                       workspace_root_path: str,
                       template_code_path: str,
                       replacement_code_path: str,
-                      lang: str):
+                      lang: str,
+                      config: CodeGenConfig,
+                      ):
     pid = problem.get_alphabet()
     workspace_dir_path = os.path.join(
         workspace_root_path,
@@ -112,7 +115,7 @@ def emit_info(text):
 
         create_code_from_prediction_result(
             result,
-            gen_class(template),
+            gen_class(template, config),
             code_file_path)
         emit_info(
             "Prediction succeeded -- Saved auto-generated code to '{}'".format(code_file_path))
@@ -141,11 +144,11 @@ def emit_info(text):
     emit_info("Saved metadata to {}".format(metadata_path))
 
 
-def func(argv: Tuple[AtCoderClient, Problem, str, str, str, str]):
-    atcoder_client, problem, workspace_root_path, template_code_path, replacement_code_path, lang = argv
+def func(argv: Tuple[AtCoderClient, Problem, str, str, str, str, CodeGenConfig]):
+    atcoder_client, problem, workspace_root_path, template_code_path, replacement_code_path, lang, config = argv
     prepare_procedure(
         atcoder_client, problem, workspace_root_path, template_code_path,
-        replacement_code_path, lang)
+        replacement_code_path, lang, config)
 
 
 def prepare_workspace(atcoder_client: AtCoderClient,
@@ -154,7 +157,9 @@ def prepare_workspace(atcoder_client: AtCoderClient,
                       template_code_path: str,
                       replacement_code_path: str,
                       lang: str,
-                      parallel: bool):
+                      parallel: bool,
+                      config: CodeGenConfig,
+                      ):
     retry_duration = 1.5
     while True:
         problem_list = atcoder_client.download_problem_list(
@@ -165,7 +170,7 @@ def prepare_workspace(atcoder_client: AtCoderClient,
         logging.warning(
             "Failed to fetch. Will retry in {} seconds".format(retry_duration))
 
-    tasks = [(atcoder_client, problem, workspace_root_path, template_code_path, replacement_code_path, lang) for
+    tasks = [(atcoder_client, problem, workspace_root_path, template_code_path, replacement_code_path, lang, config) for
              problem in problem_list]
     if parallel:
         thread_pool = Pool(processes=cpu_count())
@@ -202,41 +207,61 @@ def check_lang(lang: str):
     return lang
 
 
+USER_CONFIG_PATH = os.path.join(
+    expanduser("~"), ".atcodertools.toml")
+DEFAULT_CONFIG_PATH = os.path.abspath(
+    os.path.join(script_dir_path, "./atcodertools-default.toml"))
+
+
+def get_code_gen_config(config_path: Optional[str] = None):
+    def _load(path: str):
+        logging.info("Going to load {} as config".format(path))
+        with open(path, 'r') as f:
+            return CodeGenConfig.load(f)
+
+    if config_path:
+        return _load(config_path)
+
+    if os.path.exists(USER_CONFIG_PATH):
+        return _load(USER_CONFIG_PATH)
+
+    return _load(DEFAULT_CONFIG_PATH)
+
+
 def main(prog, args):
     parser = argparse.ArgumentParser(
         prog=prog,
         formatter_class=argparse.RawTextHelpFormatter)
 
     parser.add_argument("contest_id",
-                        help="contest ID (e.g. arc001)")
+                        help="Contest ID (e.g. arc001)")
 
     parser.add_argument("--without-login",
                         action="store_true",
-                        help="download data without login")
+                        help="Download data without login")
 
     parser.add_argument("--workspace",
-                        help="path to workspace's root directory. This script will create files"
+                        help="Path to workspace's root directory. This script will create files"
                              " in {{WORKSPACE}}/{{contest_name}}/{{alphabet}}/ e.g. ./your-workspace/arc001/A/\n"
                              "[Default] {}".format(DEFAULT_WORKSPACE_DIR_PATH),
                         default=DEFAULT_WORKSPACE_DIR_PATH)
 
     parser.add_argument("--lang",
-                        help="programming language of your template code, {}.\n"
+                        help="Programming language of your template code, {}.\n"
                         .format(" or ".join(SUPPORTED_LANGUAGES)) + "[Default] {}".format(DEFAULT_LANG),
                         default=DEFAULT_LANG,
                         type=check_lang)
 
     parser.add_argument("--template",
-                        help="{0}{1}".format("file path to your template code\n"
-                                             "[Default (C++)] {}\n".format(
-                                                 get_default_template_path('cpp')),
-                                             "[Default (Java)] {}".format(
-                                                 get_default_template_path('java')))
+                        help="File path to your template code\n{0}{1}".format(
+                            "[Default (C++)] {}\n".format(
+                                get_default_template_path('cpp')),
+                            "[Default (Java)] {}".format(
+                                get_default_template_path('java')))
                         )
 
     parser.add_argument("--replacement",
-                        help="{0}{1}".format(
-                            "file path to the replacement code created when template generation is failed.\n"
+                        help="File path to your config file\n{0}{1}".format(
                             "[Default (C++)] {}\n".format(get_default_replacement_path('cpp')),
                             "[Default (Java)] {}".format(
                                 get_default_replacement_path('java')))
@@ -252,6 +277,13 @@ def main(prog, args):
                         help="Save no session cache to avoid security risk",
                         default=False)
 
+    parser.add_argument("--config",
+                        help="File path to your config file\n{0}{1}".format("[Default (Primary)] {}\n".format(
+                            USER_CONFIG_PATH),
+                            "[Default (Secondary)] {}\n".format(
+                            DEFAULT_CONFIG_PATH))
+                        )
+
     args = parser.parse_args(args)
 
     try:
@@ -281,7 +313,9 @@ def main(prog, args):
                       args.replacement if args.replacement is not None else get_default_replacement_path(
                           args.lang),
                       args.lang,
-                      args.parallel)
+                      args.parallel,
+                      get_code_gen_config(args.config)
+                      )
 
 
 if __name__ == "__main__":
diff --git a/atcodertools/tools/submit.py b/atcodertools/tools/submit.py
@@ -24,11 +24,11 @@ def main(prog, args, credential_supplier=None, use_local_session_cache=True) ->
         formatter_class=argparse.RawTextHelpFormatter)
 
     parser.add_argument("--exec", '-e',
-                        help="file path to the execution target. [Default] Automatically detected exec file",
+                        help="File path to the execution target. [Default] Automatically detected exec file",
                         default=None)
 
     parser.add_argument("--dir", '-d',
-                        help="target directory to test. [Default] Current directory",
+                        help="Target directory to test. [Default] Current directory",
                         default=".")
 
     parser.add_argument("--timeout", '-t',
@@ -37,7 +37,7 @@ def main(prog, args, credential_supplier=None, use_local_session_cache=True) ->
                         default=1)
 
     parser.add_argument("--code", '-c',
-                        help="path to the source code to submit [Default] Code path written in metadata.json",
+                        help="Path to the source code to submit [Default] Code path written in metadata.json",
                         type=str,
                         default=None)
 
diff --git a/atcodertools/tools/tester.py b/atcodertools/tools/tester.py
@@ -230,16 +230,16 @@ def main(prog, args) -> bool:
         formatter_class=argparse.RawTextHelpFormatter)
 
     parser.add_argument("--exec", '-e',
-                        help="file path to the execution target. [Default] Automatically detected exec file",
+                        help="File path to the execution target. [Default] Automatically detected exec file",
                         default=None)
 
     parser.add_argument("--num", '-n',
-                        help="the case number to test (1-origin). All cases are tested if not specified.",
+                        help="The case number to test (1-origin). All cases are tested if not specified.",
                         type=int,
                         default=None)
 
     parser.add_argument("--dir", '-d',
-                        help="target directory to test. [Default] Current directory",
+                        help="Target directory to test. [Default] Current directory",
                         default=".")
 
     parser.add_argument("--timeout", '-t',
diff --git a/requirements.txt b/requirements.txt
@@ -1,3 +1,4 @@
 beautifulsoup4
 requests
-colorama
+colorama
+toml
diff --git a/tests/resources/test_codegen/atcodertools-test.toml b/tests/resources/test_codegen/atcodertools-test.toml
@@ -0,0 +1,2 @@
+[codegen]
+indent_width = 8
diff --git a/tests/test_codegen.py b/tests/test_codegen.py
@@ -3,6 +3,7 @@
 import unittest
 import os
 
+from atcodertools.codegen.code_gen_config import CodeGenConfig, INDENT_TYPE_SPACE, ConfigInitError
 from atcodertools.codegen.code_generator import CodeGenerator
 from atcodertools.codegen.java_code_generator import JavaCodeGenerator
 from atcodertools.codegen.cpp_code_generator import CppCodeGenerator
@@ -81,6 +82,26 @@ def get_generator(self, lang: str) -> CodeGenerator:
         with open(template_file, 'r') as f:
             return self.lang_to_code_generator[lang](f.read())
 
+    def test_load_code_gen_config(self):
+        with open(os.path.join(RESOURCE_DIR, "atcodertools-test.toml"), 'r') as f:
+            config = CodeGenConfig.load(f)
+
+        self.assertEqual(8, config.indent_width)
+        self.assertEqual(INDENT_TYPE_SPACE, config.indent_type)
+
+    def test_init_code_gen_config_with_invalid_parameters(self):
+        self._expect_error_when_init_config(
+            indent_type='SPACE', indent_width=4)
+        self._expect_error_when_init_config(
+            indent_type='space', indent_width=-1)
+
+    def _expect_error_when_init_config(self, **kwargs):
+        try:
+            CodeGenConfig(**kwargs)
+            self.fail("Must not reach here")
+        except ConfigInitError:
+            pass
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_envgen.py b/tests/test_envgen.py
@@ -6,6 +6,7 @@
 from os.path import relpath
 
 from atcodertools.client.atcoder import AtCoderClient
+from atcodertools.codegen.code_gen_config import CodeGenConfig
 from atcodertools.tools.envgen import prepare_workspace, main
 
 RESOURCE_DIR = os.path.join(
@@ -59,7 +60,9 @@ def test_backup(self):
                 TEMPLATE_PATH,
                 REPLACEMENT_PATH,
                 "cpp",
-                False)
+                False,
+                CodeGenConfig(),
+            )
         self.assertDirectoriesEqual(answer_data_dir_path, self.temp_dir)
 
     def assertDirectoriesEqual(self, expected_dir_path, dir_path):
diff --git a/tests/test_version_check.py b/tests/test_version_check.py
@@ -10,7 +10,7 @@
 
 class TestTester(unittest.TestCase):
     def test_get_latest_version_with_no_error(self):
-        get_latest_version(user_cache=False)
+        get_latest_version(use_cache=False)
 
 
 if __name__ == '__main__':

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[codegen]`
	`2`	`+indent_type = 'space' # 'tab' or 'space'`
	`3`	`+indent_width = 4`