docs: Convert Korean comments to English for better readability

Author: shashax42

docs/extra-lint-rules.md

@@ -1,55 +1,55 @@
-# SAM CLI 추가 Lint 규칙 사용 가이드
+# SAM CLI Extra Lint Rules Usage Guide
 
-AWS SAM CLI의 `validate` 명령어는 템플릿 검증을 위해 [cfn-lint](https://github.com/aws-cloudformation/cfn-lint)를 사용합니다. 
-이제 SAM CLI는 `--extra-lint-rules` 옵션을 통해 추가 lint 규칙을 지원합니다.
+The AWS SAM CLI's `validate` command uses [cfn-lint](https://github.com/aws-cloudformation/cfn-lint) for template validation. 
+SAM CLI now supports additional lint rules through the `--extra-lint-rules` option.
 
-## 사용 방법
+## Usage
 
 ```bash
 sam validate --lint --extra-lint-rules="cfn_lint_serverless.rules"
 ```
 
-## 인스톨러로 SAM CLI 설치 시 고려사항
+## Considerations when Installing SAM CLI with the Installer
 
-SAM CLI를 인스톨러(설치 프로그램)로 설치한 경우, SAM CLI는 자체 Python 환경을 사용합니다. 이 경우 추가 규칙 모듈이 해당 환경에 설치되어 있어야 합니다. 이 때 두 가지 접근 방식이 있습니다:
+When SAM CLI is installed using the installer, it uses its own Python environment. In this case, additional rule modules must be installed in that environment. There are two approaches:
 
-1. **인스톨러 Python 환경에 패키지 설치**: 인스톨러의 Python 환경에 필요한 패키지를 설치합니다.
-2. **모듈 경로를 전체 경로로 지정**: 사용자 환경에 설치된 패키지의 전체 경로를 지정합니다.
+1. **Install packages in the installer's Python environment**: Install the required packages in the installer's Python environment.
+2. **Specify the full path to the module**: Specify the full path to the package installed in the user's environment.
 
-## 사용 예제
+## Usage Examples
 
-### 서버리스 규칙 사용 (cfn-lint-serverless)
+### Using Serverless Rules (cfn-lint-serverless)
 
 ```bash
-# 먼저 패키지 설치
+# First, install the package
 pip install cfn-lint-serverless
 
-# SAM 템플릿 검증 실행
+# Run SAM template validation
 sam validate --lint --extra-lint-rules="cfn_lint_serverless.rules"
 ```
 
-### 여러 규칙 모듈 사용
+### Using Multiple Rule Modules
 
-#### 방법 1: 콤마(,)로 구분하여 지정
+#### Method 1: Specify Multiple Modules Separated by Commas
 
-여러 규칙 모듈을 콤마(,)로 구분하여 한 번의 옵션으로 지정할 수 있습니다:
+You can specify multiple rule modules separated by commas in a single option:
 
 ```bash
 sam validate --lint --extra-lint-rules="module1.rules,module2.rules,module3.rules"
 ```
 
-각 모듈은 자동으로 분리되어 cfn-lint에 전달됩니다.
+Each module is automatically separated and passed to cfn-lint.
 
-#### 방법 2: 옵션을 여러 번 사용
+#### Method 2: Use the Option Multiple Times
 
-`--extra-lint-rules` 옵션을 여러 번 사용하여 여러 규칙 모듈을 지정할 수도 있습니다:
+You can also specify multiple rule modules by using the `--extra-lint-rules` option multiple times:
 
 ```bash
 sam validate --lint --extra-lint-rules="module1.rules" --extra-lint-rules="module2.rules"
 ```
 
-## 참고사항
+## Notes
 
-* 과거에 사용하던 `--serverless-rules` 옵션은 deprecated 되었습니다. 
-* 새로운 `--extra-lint-rules` 옵션을 사용하는 것이 좋습니다.
-* 인스톨러로 SAM CLI를 설치한 경우 추가 규칙이 작동하지 않으면 인스톨러의 Python 환경에 패키지가 설치되어 있는지 확인하세요.
+* The previously used `--serverless-rules` option is deprecated.
+* It is recommended to use the new `--extra-lint-rules` option.
+* If you installed SAM CLI using the installer and additional rules are not working, check if the package is installed in the installer's Python environment.

samcli/commands/validate/validate.py

@@ -81,13 +81,13 @@ class SamTemplate:
 def cli(ctx, template_file, config_file, config_env, lint, save_params, serverless_rules, extra_lint_rules):
     # All logic must be implemented in the ``do_cli`` method. This helps with easy unit testing
 
-    # serverless_rules 옵션이 사용되면 경고 표시 및 extra_lint_rules로 변환
+    # Show warning and convert to extra_lint_rules if serverless_rules is used
     if serverless_rules and not extra_lint_rules:
         click.secho(
             "Warning: --serverless-rules is deprecated. Please use --extra-lint-rules=\"cfn_lint_serverless.rules\" instead.",
             fg="yellow"
         )
-        # 이전 옵션을 새 옵션으로 변환
+        # Convert old option to new option
         extra_lint_rules = "cfn_lint_serverless.rules"
 
     do_cli(ctx, template_file, lint, serverless_rules, extra_lint_rules)  # pragma: no cover
@@ -184,8 +184,8 @@ def _lint(ctx: Context, template: str, template_path: str, serverless_rules: boo
     from cfnlint.runner import InvalidRegionException
     from samcli.lib.telemetry.event import EventTracker
 
-    # 디버그 정보 추가
-    print(f"디버그 정보: serverless_rules 옵션 값 = {serverless_rules}")
+    # Add debug information
+    print(f"Debug info: serverless_rules option value = {serverless_rules}")
 
     cfn_lint_logger = logging.getLogger(CNT_LINT_LOGGER_NAME)
     cfn_lint_logger.propagate = False
@@ -199,24 +199,24 @@ def _lint(ctx: Context, template: str, template_path: str, serverless_rules: boo
         cfn_lint_logger.propagate = True
         cfn_lint_logger.setLevel(logging.DEBUG)
 
-    print(f"디버그 정보: linter_config 초기값 = {linter_config}")
+    print(f"Debug info: initial linter_config = {linter_config}")
 
-    # 두 옵션을 함께 처리하기 위한 변수 초기화
+    # Initialize variable to handle both options together
     rules_to_append = []
 
-    # 이전 serverless_rules 옵션 지원 (deprecated)
+    # Support for previous serverless_rules option (deprecated)
     if serverless_rules:
-        print("디버그 정보: serverless_rules 옵션이 활성화되었습니다.")
+        print("Debug info: serverless_rules option is activated.")
         # Track usage of Serverless Rules
         EventTracker.track_event("UsedFeature", "ServerlessRules")
 
         # Check if cfn-lint-serverless is installed
         import importlib.util
         serverless_spec = importlib.util.find_spec("cfn_lint_serverless")
-        print(f"디버그 정보: cfn_lint_serverless 패키지 설치 여부 = {serverless_spec is not None}")
+        print(f"Debug info: cfn_lint_serverless package installed = {serverless_spec is not None}")
 
         if serverless_spec is None:
-            print("디버그 정보: cfn_lint_serverless 패키지가 설치되어 있지 않습니다.")
+            print("Debug info: cfn_lint_serverless package is not installed.")
             click.secho(
                 "Serverless Rules package (cfn-lint-serverless) is not installed. "
                 "Please install it using: pip install cfn-lint-serverless",
@@ -230,13 +230,13 @@ def _lint(ctx: Context, template: str, template_path: str, serverless_rules: boo
         try:
             # Try to import the package
             import cfn_lint_serverless
-            print("디버그 정보: cfn_lint_serverless 패키지 임포트 성공")
+            print("Debug info: cfn_lint_serverless package import successful")
 
-            # Serverless Rules를 규칙 목록에 추가
+            # Add Serverless Rules to the rule list
             rules_to_append.append("cfn_lint_serverless.rules")
             click.secho("Serverless Rules enabled for linting", fg="green")
         except ImportError as e:
-            print(f"디버그 정보: cfn_lint_serverless 임포트 오류 = {e}")
+            print(f"Debug info: cfn_lint_serverless import error = {e}")
             click.secho(
                 "Serverless Rules package (cfn-lint-serverless) is not installed. "
                 "Please install it using: pip install cfn-lint-serverless",
@@ -247,49 +247,49 @@ def _lint(ctx: Context, template: str, template_path: str, serverless_rules: boo
                 "Please install it using: pip install cfn-lint-serverless"
             )
 
-    # 새로운 extra_lint_rules 옵션 지원
+    # Support for the new extra_lint_rules option
     if extra_lint_rules:
-        print(f"디버그 정보: extra_lint_rules 옵션이 활성화되었습니다. 값: {extra_lint_rules}")
+        print(f"Debug info: extra_lint_rules option is activated. Value: {extra_lint_rules}")
         # Track usage of Extra Lint Rules
         EventTracker.track_event("UsedFeature", "ExtraLintRules")
 
-        # 콤마로 구분된 여러 규칙 모듈을 파싱
+        # Parse comma-separated rule modules
         modules = [module.strip() for module in extra_lint_rules.split(',') if module.strip()]
-        print(f"디버그 정보: 파싱된 규칙 모듈 목록 = {modules}")
+        print(f"Debug info: parsed rule modules list = {modules}")
 
-        # 각 모듈을 규칙 목록에 추가
+        # Add each module to the rule list
         rules_to_append.extend(modules)
         click.secho(f"Extra lint rules enabled: {extra_lint_rules}", fg="green")
 
-    # 규칙이 있으면 linter_config에 추가
+    # Add rules to linter_config if any exist
     if rules_to_append:
-        print(f"디버그 정보: 추가할 규칙 목록 = {rules_to_append}")
+        print(f"Debug info: rules to append = {rules_to_append}")
         linter_config["append_rules"] = rules_to_append
-        print(f"디버그 정보: linter_config 업데이트 = {linter_config}")
+        print(f"Debug info: updated linter_config = {linter_config}")
 
     config = ManualArgs(**linter_config)
-    print(f"디버그 정보: config 생성 완료")
+    print(f"Debug info: config creation completed")
 
     try:
-        print(f"디버그 정보: lint 함수 호출 시작")
+        print(f"Debug info: starting lint function call")
         matches = lint(template, config=config)
-        print(f"디버그 정보: lint 함수 호출 완료, matches = {matches}")
+        print(f"Debug info: lint function call completed, matches = {matches}")
     except InvalidRegionException as ex:
-        print(f"디버그 정보: InvalidRegionException 발생 = {ex}")
+        print(f"Debug info: InvalidRegionException occurred = {ex}")
         raise UserException(
             f"AWS Region was not found. Please configure your region through the --region option.\n{ex}",
             wrapped_from=ex.__class__.__name__,
         ) from ex
     except Exception as e:
-        print(f"디버그 정보: 예외 발생 = {e}")
+        print(f"Debug info: exception occurred = {e}")
         raise
 
     if not matches:
-        print(f"디버그 정보: 템플릿 검증 성공")
+        print(f"Debug info: template validation successful")
         click.secho("{} is a valid SAM Template".format(template_path), fg="green")
         return
 
-    print(f"디버그 정보: 템플릿 검증 실패, matches = {matches}")
+    print(f"Debug info: template validation failed, matches = {matches}")
     click.secho(matches)
 
     raise LinterRuleMatchedException("Linting failed. At least one linting rule was matched to the provided template.")

tests/unit/commands/validate/test_cli.py

@@ -187,14 +187,14 @@ def test_serverless_rules_package_not_installed(self, find_spec_mock, click_patc
 
     @patch("samcli.commands.validate.validate._read_sam_file")
     def test_cli_with_extra_lint_rules(self, mock_read_sam_file):
-        # 테스트 준비
+        # Prepare test
         template = "template"
         extra_lint_rules = "cfn_lint_serverless.rules"
         mock_read_sam_file.return_value = SamTemplate(serialized="", deserialized={})
 
-        # do_cli 함수를 직접 테스트
+        # Test the do_cli function directly
         with patch("samcli.commands.validate.validate._lint") as mock_lint:
-            # do_cli 호출
+            # Call do_cli
             do_cli(
                 ctx=ctx_mock(profile="profile", region="region"), 
                 template=template, 
@@ -203,30 +203,30 @@ def test_cli_with_extra_lint_rules(self, mock_read_sam_file):
                 extra_lint_rules=extra_lint_rules
             )
 
-            # _lint이 올바른 파라미터로 호출되는지 확인
+            # Verify that _lint is called with the correct parameters
             mock_lint.assert_called_once()
             args, kwargs = mock_lint.call_args
-            self.assertEqual(args[2], template)  # template_path 파라미터
-            self.assertEqual(args[3], False)     # serverless_rules 파라미터
-            self.assertEqual(args[4], extra_lint_rules)  # extra_lint_rules 파라미터
+            self.assertEqual(args[2], template)  # template_path parameter
+            self.assertEqual(args[3], False)     # serverless_rules parameter
+            self.assertEqual(args[4], extra_lint_rules)  # extra_lint_rules parameter
 
     @patch("cfnlint.api.lint")
     @patch("samcli.commands.validate.validate.click")
     def test_lint_with_extra_lint_rules(self, click_patch, lint_patch):
-        # 테스트 준비
+        # Prepare test
         template_path = "path_to_template"
         template_contents = "{}"
         extra_lint_rules = "custom.rules.module"
         lint_patch.return_value = []
 
-        # ManualArgs 클래스를 모킹하여 append_rules 속성이 올바르게 설정되는지 확인
+        # Mock ManualArgs class to verify that append_rules property is set correctly
         with patch("samcli.lib.telemetry.event.EventTracker.track_event") as track_patch:
             with patch("cfnlint.api.ManualArgs") as manual_args_mock:
-                # ManualArgs 객체가 append_rules 속성을 가지도록 설정
+                # Set up ManualArgs object to have append_rules property
                 manual_args_instance = Mock()
                 manual_args_mock.return_value = manual_args_instance
 
-                # 테스트 실행
+                # Run test
                 _lint(
                     ctx=ctx_lint_mock(debug=False, region="region"),
                     template=template_contents,
@@ -235,11 +235,11 @@ def test_lint_with_extra_lint_rules(self, click_patch, lint_patch):
                     extra_lint_rules=extra_lint_rules
                 )
 
-                # 이벤트 추적 확인 - ExtraLintRules 이벤트가 추적되는지 확인
+                # Verify event tracking - confirm ExtraLintRules event is being tracked
                 track_patch.assert_any_call("UsedFeature", "CFNLint")
                 track_patch.assert_any_call("UsedFeature", "ExtraLintRules")
 
-                # ManualArgs가 올바른 인자와 함께 호출되는지 확인
+                # Verify ManualArgs is called with correct arguments
                 manual_args_mock.assert_called_once()
                 args, kwargs = manual_args_mock.call_args
                 self.assertIn("append_rules", kwargs)
@@ -248,20 +248,20 @@ def test_lint_with_extra_lint_rules(self, click_patch, lint_patch):
     @patch("cfnlint.api.lint")
     @patch("samcli.commands.validate.validate.click")
     def test_lint_with_multiple_comma_separated_extra_lint_rules(self, click_patch, lint_patch):
-        # 테스트 준비
+        # Prepare test
         template_path = "path_to_template"
         template_contents = "{}"
-        # 콤마로 구분된 여러 규칙 모듈 지정
+        # Specify multiple rule modules separated by commas
         extra_lint_rules = "module1.rules,module2.rules,module3.rules"
         lint_patch.return_value = []
 
-        # ManualArgs 클래스를 모킹하여 append_rules 속성이 올바르게 설정되는지 확인
+        # Mock ManualArgs class to verify that append_rules property is set correctly
         with patch("samcli.lib.telemetry.event.EventTracker.track_event"):
             with patch("cfnlint.api.ManualArgs") as manual_args_mock:
                 manual_args_instance = Mock()
                 manual_args_mock.return_value = manual_args_instance
 
-                # 테스트 실행
+                # Run test
                 _lint(
                     ctx=ctx_lint_mock(debug=False, region="region"),
                     template=template_contents,
@@ -270,31 +270,31 @@ def test_lint_with_multiple_comma_separated_extra_lint_rules(self, click_patch,
                     extra_lint_rules=extra_lint_rules
                 )
 
-                # ManualArgs가 올바른 인자와 함께 호출되는지 확인
+                # Verify ManualArgs is called with correct arguments
                 manual_args_mock.assert_called_once()
                 args, kwargs = manual_args_mock.call_args
                 self.assertIn("append_rules", kwargs)
-                # 콤마로 구분된 각 모듈이 분리되어 리스트에 추가되는지 확인
+                # Verify each comma-separated module is split and added to the list
                 expected_rules = ["module1.rules", "module2.rules", "module3.rules"]
                 self.assertEqual(set(kwargs["append_rules"]), set(expected_rules))
 
     @patch("cfnlint.api.lint")
     @patch("samcli.commands.validate.validate.click")
     @patch("importlib.util.find_spec")
     def test_serverless_rules_deprecated_with_extra_lint_rules(self, find_spec_mock, click_patch, lint_patch):
-        # 테스트 준비
+        # Prepare test
         template_path = "path_to_template"
         template_contents = "{}"
         find_spec_mock.return_value = True
         lint_patch.return_value = []
 
-        # 두 옵션이 모두 제공되었을 때 extra_lint_rules가 우선되는지 확인
+        # Verify when both options are provided, both rules are included
         with patch("samcli.lib.telemetry.event.EventTracker.track_event"):
             with patch("cfnlint.api.ManualArgs") as manual_args_mock:
                 manual_args_instance = Mock()
                 manual_args_mock.return_value = manual_args_instance
 
-                # 테스트 실행 - 두 옵션 모두 사용
+                # Run test - use both options
                 _lint(
                     ctx=ctx_lint_mock(debug=False, region="region"),
                     template=template_contents,
@@ -303,7 +303,7 @@ def test_serverless_rules_deprecated_with_extra_lint_rules(self, find_spec_mock,
                     extra_lint_rules="custom.rules.module"
                 )
 
-                # 검증 - 두 규칙이 모두 추가되는지 확인
+                # Verify both rules are added
                 manual_args_mock.assert_called_once()
                 args, kwargs = manual_args_mock.call_args
                 self.assertIn("append_rules", kwargs)