tessl/pypi-lizard
An extensible cyclomatic complexity analyzer for many programming languages including C/C++, Java, JavaScript, Python, Ruby, Swift, and more.
—
Pending
language-support.mddocs/
Language Support
Language parsing capabilities supporting 26+ programming languages through the lizard_languages package. This system provides extensible language detection and parsing for comprehensive multi-language code analysis.
Capabilities
Language Discovery
Functions for discovering and accessing available language parsers.
def languages():
"""
Returns list of all available language reader classes.
Returns:
list: List of 26 language reader classes for supported languages
Example:
available_langs = languages()
print(f"Supported languages: {len(available_langs)}")
for lang_class in available_langs:
print(f" {lang_class.__name__}: {lang_class.ext}")
"""
def get_reader_for(filename):
"""
Returns appropriate language reader class for a filename.
Uses file extension matching to determine the correct parser.
Args:
filename (str): File path or name to match
Returns:
CodeReader subclass or None: Language reader class if match found, None otherwise
Example:
reader_class = get_reader_for('app.py')
if reader_class:
print(f"Python file detected: {reader_class.__name__}")
reader_class = get_reader_for('script.js')
# Returns JavaScriptReader class
"""Base Language Reader
Base class that all language parsers inherit from, providing common functionality.
class CodeReader:
"""
Base class for all language parsers.
Class Attributes:
ext (list): File extensions supported by the reader
language_names (list): Language names (optional)
_conditions (set): Default condition keywords
"""
@classmethod
def match_filename(cls, filename):
"""
Checks if reader supports a filename based on extension.
Args:
filename (str): Filename to check
Returns:
bool: True if this reader can parse the file
Example:
if PythonReader.match_filename('app.py'):
print("Python file detected")
"""
@staticmethod
def generate_tokens(source_code, addition='', token_class=None):
"""
Tokenizes source code for parsing.
Args:
source_code (str): Source code to tokenize
addition (str): Additional regex patterns (optional)
token_class: Custom token class (optional)
Returns:
generator: Generator yielding tokens from source code
"""
def preprocess(self, tokens):
"""
Preprocesses tokens before parsing.
Override in subclasses for language-specific preprocessing.
Args:
tokens: Token generator
Returns:
generator: Generator yielding preprocessed tokens
"""
def __call__(self, tokens, reader):
"""
Main parsing method that processes tokens.
Args:
tokens: Token generator
reader: File reader context
Returns:
generator: Generator yielding processed tokens
"""Supported Languages
C-Like Languages
Languages with C-style syntax including C, C++, Java, C#, and Objective-C.
class CLikeReader(CodeReader):
"""
C/C++/Objective-C language parser.
Extensions: ['c', 'cpp', 'cc', 'mm', 'cxx', 'h', 'hpp']
Language names: ['cpp', 'c']
Handles: macros, templates, operator overloading, preprocessor directives
"""
class JavaReader(CodeReader):
"""
Java language parser.
Extensions: ['java']
Handles: classes, records, annotations, method references, lambda expressions
"""
class CSharpReader(CLikeReader):
"""
C# language parser.
Extensions: ['cs']
Inherits C-like parsing with C#-specific constructs
"""
class ObjCReader(CLikeReader):
"""
Objective-C language parser.
Extensions: ['m', 'mm']
Handles: Objective-C method syntax, categories, protocols
"""Script Languages
Dynamic scripting languages with flexible syntax.
class PythonReader(CodeReader):
"""
Python language parser.
Extensions: ['py']
Handles: indentation-based nesting, decorators, docstrings, comprehensions
"""
class RubyReader(CodeReader):
"""
Ruby language parser.
Extensions: ['rb']
Handles: blocks, modules, embedded documentation, metaprogramming constructs
"""
class PHPReader(CodeReader):
"""
PHP language parser.
Extensions: ['php']
Handles: mixed HTML/PHP, variable syntax, namespaces
"""
class PerlReader(CodeReader):
"""
Perl language parser.
Extensions: ['pl', 'pm']
Handles: Perl's complex syntax, regular expressions, special variables
"""Web Technologies
Languages and frameworks for web development.
class JavaScriptReader(CodeReader):
"""
JavaScript language parser.
Extensions: ['js', 'cjs', 'mjs']
Handles: closures, arrow functions, prototypes, ES6+ features
"""
class TypeScriptReader(CodeReader):
"""
TypeScript language parser.
Extensions: ['ts']
Handles: type annotations, interfaces, generics, decorators
"""
class JSXReader(CodeReader):
"""
React JSX language parser.
Extensions: ['jsx']
Handles: JSX syntax, React components, embedded expressions
"""
class TSXReader(CodeReader):
"""
TypeScript JSX language parser.
Extensions: ['tsx']
Handles: TypeScript with JSX syntax
"""
class VueReader(CodeReader):
"""
Vue.js single file component parser.
Extensions: ['vue']
Handles: template, script, and style blocks in .vue files
"""Systems Languages
Compiled systems programming languages.
class RustReader(CodeReader):
"""
Rust language parser.
Extensions: ['rs']
Handles: ownership syntax, traits, macros, pattern matching
"""
class GoReader(CodeReader):
"""
Go language parser.
Extensions: ['go']
Handles: goroutines, interfaces, channels, packages
"""
class ZigReader(CodeReader):
"""
Zig language parser.
Extensions: ['zig']
Handles: Zig's systems programming constructs
"""Mobile and Modern Languages
Languages for mobile and modern application development.
class SwiftReader(CodeReader):
"""
Swift language parser.
Extensions: ['swift']
Handles: optionals, closures, protocols, extensions
"""
class KotlinReader(CodeReader):
"""
Kotlin language parser.
Extensions: ['kt', 'kts']
Handles: data classes, coroutines, extensions, null safety
"""Other Supported Languages
Additional languages supported by Lizard.
class FortranReader(CodeReader):
"""Fortran language parser."""
# Extensions: ['f70', 'f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp']
class ScalaReader(CodeReader):
"""Scala language parser."""
# Extensions: ['scala']
class ErlangReader(CodeReader):
"""Erlang language parser."""
# Extensions: ['erl', 'hrl', 'es', 'escript']
class LuaReader(CodeReader):
"""Lua scripting language parser."""
# Extensions: ['lua']
class SolidityReader(CodeReader):
"""Solidity smart contract language parser."""
# Extensions: ['sol']
class GDScriptReader(CodeReader):
"""Godot scripting language parser."""
# Extensions: ['gd']
class TTCNReader(CodeReader):
"""TTCN test language parser."""
# Extensions: ['ttcn', 'ttcnpp']Usage Examples
Language Detection
from lizard_languages import get_reader_for, languages
# Check what languages are supported
all_languages = languages()
print(f"Total supported languages: {len(all_languages)}")
# Detect language for specific files
files = ['app.py', 'script.js', 'main.cpp', 'service.go']
for filename in files:
reader_class = get_reader_for(filename)
if reader_class:
print(f"{filename}: {reader_class.__name__}")
print(f" Supported extensions: {reader_class.ext}")
else:
print(f"{filename}: No parser found")Language-Specific Analysis
import lizard
# Analyze only Python files
results = lizard.analyze(['src/'], lans=['python'])
for file_info in results:
print(f"Python file: {file_info.filename}")
# Analyze multiple specific languages
results = lizard.analyze(['src/'], lans=['python', 'javascript', 'typescript'])
for file_info in results:
print(f"Analyzed: {file_info.filename}")Custom Language Filtering
from lizard_languages import languages
import lizard
# Find all web-related languages
web_languages = []
for lang_class in languages():
if any(ext in ['js', 'ts', 'jsx', 'tsx', 'vue', 'php']
for ext in lang_class.ext):
web_languages.append(lang_class.__name__.replace('Reader', '').lower())
print(f"Web languages: {web_languages}")
# Analyze only web technology files
results = lizard.analyze(['src/'], lans=web_languages)
for file_info in results:
print(f"Web file: {file_info.filename}")Extension and Language Mapping
from lizard_languages import languages
# Create extension to language mapping
ext_to_lang = {}
for lang_class in languages():
lang_name = lang_class.__name__.replace('Reader', '')
for ext in lang_class.ext:
ext_to_lang[ext] = lang_name
# Check what language handles each extension
test_extensions = ['py', 'js', 'ts', 'go', 'rs', 'cpp', 'java']
for ext in test_extensions:
lang = ext_to_lang.get(ext, 'Unknown')
print(f".{ext} files → {lang}")Install with Tessl CLI
npx tessl i tessl/pypi-lizard