Merge pull request #3 from dxworks/victorc/update_languages

Victorc/update languages

Author: vchircu

.DS_Store

@@ -0,0 +1,35 @@
+---
+alwaysApply: true
+---
+# The fundamental development guideline for making any changes
+
+# Running command in terminal
+
+This project use nix to manage the development envioroment. So we need to run `nix develop` once first in every new terminal window to start the nix enviroment. For AI agent, add `nix develop -c` before any terminal command: 
+
+```
+nix develop -c <command>
+```
+
+
+## Run Test
+
+Always run all tests instead of just one test file
+
+```bash
+nix develop -c python -m pytest   # Run all tests
+```
+
+## Run All Test and Format checking
+
+
+```bash
+nix develop -c make
+```
+
+
+## Automated test practices
+
+* All code and logic need to be covered by unit test
+* Try to test end to end, external observable pre and post state change, as much as possible
+* Don't mock any code unless it's about file system

.appveyor.yml

@@ -0,0 +1,17 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+
+# When fixing an issue (e.g. from Github issues) please:
+
+1. find where is the right place to add a new unit test to reproduce the issue
+2. add a new unit test
+3. run all test to see if the test really fails
+4. fix the issue until all test pass
+5. clean up
+6. run all unit test at last to confirm things are still working.
+
+follow [basic-development.mdc](mdc:.cursor/rules/basic-development.mdc)
+

.cursor/rules/basic-development.mdc

@@ -0,0 +1,151 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+
+# Adding Language Support to Lizard Code Analyzer
+
+This guide explains how to add or modify support for programming languages in the Lizard code complexity analyzer.
+
+## Overview
+
+Lizard uses a state machine-based approach to parse code. Each language implementation consists of:
+
+1. A language reader class that inherits from `CodeReader`
+2. Token generation and processing logic
+3. Language-specific state handling
+
+## Step-by-Step Guide
+
+### 1. Create Language Reader Class
+
+Create a new file in `lizard_languages/` named after your language (e.g., `mylang.py`). The basic structure should be:
+
+```python
+from .code_reader import CodeReader
+from .clike import CCppCommentsMixin  # If language has C-style comments
+
+class MyLanguageReader(CodeReader, CCppCommentsMixin):
+    # File extensions for your language
+    ext = ['mylang']
+    
+    # Language names (used in command line args)
+    language_names = ['mylanguage', 'mylang']
+    
+    def __init__(self, context):
+        super(MyLanguageReader, self).__init__(context)
+        # Initialize language-specific state machine
+```
+
+### 2. Implement Token Generation
+
+Define how your language's code should be tokenized:
+
+```python
+@staticmethod
+def generate_tokens(source_code, addition='', token_class=None):
+    # Add language-specific token patterns
+    addition = addition + r"|pattern1|pattern2"
+    
+    # Use existing token generator or create custom one
+    return CodeReader.generate_tokens(source_code, addition, token_class)
+```
+
+### 3. State Machine Implementation
+
+Choose one of these approaches:
+
+a. For C-like languages:
+   - Inherit from `CLikeReader` or extend `CLikeStates`
+   - Customize token handling as needed
+
+b. For custom syntax:
+   - Create a custom state machine class
+   - Implement state transitions for your language
+
+### 4. Add Test Cases
+
+Create test file in `test/test_languages/testMyLang.py`:
+
+```python
+import unittest
+from lizard import analyze_file, FileAnalyzer, get_extensions
+from lizard_languages import MyLanguageReader
+
+class TestMyLanguage(unittest.TestCase):
+    def setUp(self):
+        self.analyzer = FileAnalyzer(get_extensions([MyLanguageReader]))
+    
+    def test_basic_parsing(self):
+        result = analyze_file.analyze_source_code("test.mylang", code)
+        self.assertEqual(expected, result.function_list[0].cyclomatic_complexity)
+```
+
+## Key Concepts
+
+### State Machine
+- Use `CodeStateMachine` for handling language states
+- Implement state transitions for:
+  - Function declarations
+  - Nested scopes
+  - Control structures
+
+### Token Processing
+- Handle special tokens (strings, comments, etc.)
+- Track nesting levels and scope
+- Count cyclomatic complexity
+
+### Metrics Collection
+- Function/method identification
+- Complexity calculation
+- NLOC (Non-empty Lines of Code)
+- CCN (Cyclomatic Complexity Number)
+
+## Best Practices
+
+1. **Inheritance**: 
+   - Use existing base classes when possible
+   - Share common functionality through mixins
+
+2. **Testing**:
+   - Cover basic syntax
+   - Test edge cases
+   - Include complex real-world examples
+
+3. **Performance**:
+   - Optimize token generation
+   - Minimize state transitions
+   - Use efficient regex patterns
+
+4. **Maintenance**:
+   - Document language-specific behaviors
+   - Keep state machine logic simple
+   - Follow existing patterns in the codebase
+
+## Examples
+
+Reference existing implementations:
+- `javascript.py` for dynamic languages
+- `clike.py` for C-style languages
+- `python.py` for indentation-based languages
+
+## Integration
+
+1. Add your reader to `lizard_languages/__init__.py`
+2. Update documentation if needed
+3. Add test cases
+4. Verify with real code samples
+
+## Testing Your Implementation
+
+```bash
+python -m pytest   # Run all tests
+python -m pytest test/test_languages/testMyLang.py  # Test specific language
+```
+
+Remember to handle:
+- Comments (single-line, multi-line)
+- String literals
+- Language-specific keywords
+- Special syntax constructs

.cursor/rules/issue.mdc

@@ -40,3 +40,6 @@ dist/
 .idea
 .pytest_cache/
 .local/
+
+.DS_Store
+.venv/

.cursor/rules/lizard-rule.mdc

@@ -1,10 +1,8 @@
 language: python
 
 python:
-  - 2.7
-  - 3.4
-  - 3.5
   - 3.8
+  - 3.10
   - pypy
   - pypy3
 

.gitignore

@@ -1,5 +1,108 @@
 # Change Log
 
+## 1.18.0
+
+### New Features
+- Add R language support with comprehensive function parsing
+- Add Structured Text (St) language support
+- Add C++ lambda expression support for improved parsing
+- Add Nesting Depth feature for better code analysis
+
+### Improvements
+- Enhanced R function parsing for multiple assignments
+- Improved string interpolation handling in Go
+- Better function nesting detection
+- Updated documentation to include new supported languages
+
+### Bug Fixes
+- Fix nesting depth calculation issues
+- Fix function nesting problems
+- Various parsing improvements across multiple languages
+
+## 1.17.30
+
+Fix TypeScript function detection issue.
+
+## 1.17.29
+
+Fix modern PHP issues.
+
+## 1.17.28
+
+Fix Java function count issue.
+
+## 1.17.27
+
+Fix Java function count issue.
+
+## 1.17.26
+
+A blank release to fix the installation issue.
+
+## 1.17.25
+
+Bug fixes. "lizard forgive" for python
+
+## 1.17.24
+
+Added support for `#lizard forgive global` to suppress warnings for all code outside of functions, for languages like Python, Perl, etc, that allow global code.
+
+`#lizard forgive` at the global level will suppress warnings for all code after it.
+
+## 1.17.23
+
+Bug fixes.
+
+## 1.17.22
+
+Add Complete Perl support.
+
+## 1.17.21
+
+Add Perl support.
+
+## 1.17.19
+
+Bug fixes.
+
+## 1.17.18
+
+Bug fixes.
+
+## 1.17.17
+
+Bug fixes.
+
+## 1.17.16
+
+Add support for gitignore files.
+A few bug fixes.
+
+## 1.17.15
+
+Add VueJS support.
+
+## 1.17.14
+
+Add TSX support.
+
+## 1.17.13
+
+Bug fix:
+  Replace re.NOFLAG with 0 to make it compatible with Python 3.10+
+
+## 1.17.12
+
+Bug fix:
+  Fortran support for ELSEIF
+
+## 1.17.9
+
+Bug fix:
+  Java generic like List<? extends String>
+  JSX file extension
+
+
 ## 1.17.8
 
 Add Fortran to the language supported