feat: make it usable

Author: amanv8060

.github/workflows/deploy.yml

@@ -0,0 +1,53 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches: [ main ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.21'
+
+      - name: Build WASM
+        run: |
+          chmod +x scripts/build_wasm.sh
+          ./scripts/build_wasm.sh
+
+      - name: Build static files
+        run: |
+          mkdir -p dist/static/samples
+          cp -r static/* dist/static/
+          cp templates/index.html dist/index.html
+          cp static/samples/*.go dist/static/samples/
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './dist'
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4 

.gitignore

@@ -0,0 +1,13 @@
+# Logs
+logs/
+*.log
+
+# Build artifacts
+dist/
+code-complexity-viz
+
+# WASM files
+static/analyzer.wasm
+static/wasm_exec.js
+
+.idea/

README.md

@@ -1,3 +1,68 @@
 # Code Complexity Visualizer
 
-A tool to analyze and visualize code complexity metrics for Go programs.
+A web-based tool for analyzing and visualizing various code complexity metrics in Go source files.
+
+🔗 [Try the Live Demo](https://amanv8060.github.io/code-complexity-viz)
+
+## Usage Modes
+
+### Browser Analysis (WASM)
+- Runs entirely in your browser
+- No server required
+- Perfect for quick analysis
+- Available in the live demo
+
+### Server Analysis
+- Full feature set
+- Handles larger files
+- Better performance
+- Requires local setup
+
+## Features
+
+### Complexity Metrics
+- **Cyclomatic Complexity (McCabe)**: Measures the number of linearly independent paths through code
+- **Cognitive Complexity**: Measures how difficult it is to understand the code's control flow
+- **Halstead Metrics**:
+  - Volume: Measures the size of the implementation
+  - Difficulty: Indicates how hard the code is to understand
+  - Effort: Estimates the effort required to maintain the code
+- **Maintainability Index**: A composite metric indicating overall maintainability (0-100 scale)
+- **Lines of Code**: Physical lines of code per function
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/aman/code-complexity-viz
+cd code-complexity-viz
+```
+
+2. Install dependencies:
+```bash
+go mod tidy
+```
+
+3. Run the server:
+```bash
+go run main.go
+```
+
+4. Open `http://localhost:8080` in your browser
+
+## Usage
+
+1. Upload a Go source file using the web interface
+2. Click "Analyze" to process the file
+3. View the visualization of complexity metrics
+4. Use the dropdown to switch between different metrics
+5. Hover over bars to see detailed metrics for each function
+
+### Limitations
+- Maximum file size: 5MB
+- Only analyzes `.go` files
+- Functions must be syntactically valid Go code
+
+## License
+
+MIT License - See LICENSE file for details

analyzer/complexity.go

@@ -22,15 +22,19 @@ type Operand struct {
 
 // MetricsResult stores the complexity metrics for a single file or function
 type MetricsResult struct {
-	Name                   string  `json:"name"`
-	CyclomaticComplexity  int     `json:"cyclomaticComplexity"`
-	CognitiveComplexity   int     `json:"cognitiveComplexity"`
-	LinesOfCode           int     `json:"linesOfCode"`
-	HalsteadVolume        float64 `json:"halsteadVolume"`
-	HalsteadDifficulty    float64 `json:"halsteadDifficulty"`
-	HalsteadEffort        float64 `json:"halsteadEffort"`
-	MaintainabilityIndex  float64 `json:"maintainabilityIndex"`
-	NestingLevel          int     `json:"nestingLevel"`
+	Name                 string  `json:"name"`
+	CyclomaticComplexity int     `json:"cyclomaticComplexity"`
+	CognitiveComplexity  int     `json:"cognitiveComplexity"`
+	LinesOfCode          int     `json:"linesOfCode"`
+	HalsteadVolume       float64 `json:"halsteadVolume"`
+	HalsteadDifficulty   float64 `json:"halsteadDifficulty"`
+	HalsteadEffort       float64 `json:"halsteadEffort"`
+	MaintainabilityIndex float64 `json:"maintainabilityIndex"`
+	NestingLevel         int     `json:"nestingLevel"`
+	NestedDepth          int     `json:"nestedDepth"`
+	CommentDensity       float64 `json:"commentDensity"`
+	FunctionParameters   int     `json:"functionParameters"`
+	ReturnStatements     int     `json:"returnStatements"`
 }
 
 // FileAnalyzer handles the analysis of a single file
@@ -132,8 +136,8 @@ func (fa *FileAnalyzer) calculateHalsteadMetrics(node ast.Node) (volume, difficu
 
 	n1 := float64(len(operators)) // unique operators
 	n2 := float64(len(operands))  // unique operands
-	N1 := float64(0)             // total operators
-	N2 := float64(0)             // total operands
+	N1 := float64(0)              // total operators
+	N2 := float64(0)              // total operands
 
 	for _, count := range operators {
 		N1 += float64(count)
@@ -177,19 +181,31 @@ func (fa *FileAnalyzer) AnalyzeFunction(funcDecl *ast.FuncDecl) *MetricsResult {
 	cyclomaticComplexity := fa.CalculateCyclomaticComplexity(funcDecl)
 	cognitiveComplexity := fa.CalculateCognitiveComplexity(funcDecl)
 	linesOfCode := fa.CountLinesOfCode(funcDecl)
-	
+
 	volume, difficulty, effort := fa.calculateHalsteadMetrics(funcDecl)
-	
+
 	// Add validation for edge cases
 	if volume <= 0 {
 		volume = 1 // Avoid log(0) in maintainability index calculation
 	}
 	if linesOfCode <= 0 {
 		linesOfCode = 1
 	}
-	
+
 	maintainabilityIndex := fa.CalculateMaintainabilityIndex(cyclomaticComplexity, volume, linesOfCode)
 
+	// Calculate nested depth
+	nestedDepth := fa.calculateNestedDepth(funcDecl)
+	
+	// Calculate comment density
+	commentDensity := fa.calculateCommentDensity(funcDecl)
+	
+	// Count parameters
+	paramCount := len(funcDecl.Type.Params.List)
+	
+	// Count return statements
+	returnCount := fa.countReturnStatements(funcDecl)
+
 	// Ensure all metrics are valid
 	if math.IsNaN(volume) || math.IsInf(volume, 0) {
 		volume = 0
@@ -205,14 +221,18 @@ func (fa *FileAnalyzer) AnalyzeFunction(funcDecl *ast.FuncDecl) *MetricsResult {
 	}
 
 	return &MetricsResult{
-		Name:                  funcDecl.Name.Name,
+		Name:                 funcDecl.Name.Name,
 		CyclomaticComplexity: cyclomaticComplexity,
 		CognitiveComplexity:  cognitiveComplexity,
 		LinesOfCode:          linesOfCode,
 		HalsteadVolume:       math.Round(volume*100) / 100,
 		HalsteadDifficulty:   math.Round(difficulty*100) / 100,
 		HalsteadEffort:       math.Round(effort*100) / 100,
 		MaintainabilityIndex: math.Round(maintainabilityIndex*100) / 100,
+		NestedDepth:        nestedDepth,
+		CommentDensity:     commentDensity,
+		FunctionParameters: paramCount,
+		ReturnStatements:   returnCount,
 	}
 }
 
@@ -229,3 +249,44 @@ func (fa *FileAnalyzer) AnalyzeFile() []*MetricsResult {
 
 	return results
 }
+
+// Add new analysis methods
+func (fa *FileAnalyzer) calculateNestedDepth(node ast.Node) int {
+	maxDepth := 0
+	currentDepth := 0
+
+	ast.Inspect(node, func(n ast.Node) bool {
+		switch n.(type) {
+		case *ast.IfStmt, *ast.ForStmt, *ast.RangeStmt, *ast.SwitchStmt, *ast.SelectStmt:
+			currentDepth++
+			if currentDepth > maxDepth {
+				maxDepth = currentDepth
+			}
+			return true
+		}
+		currentDepth = 0
+		return true
+	})
+
+	return maxDepth
+}
+
+func (fa *FileAnalyzer) calculateCommentDensity(node ast.Node) float64 {
+	comments := len(fa.ast.Comments)
+	lines := fa.CountLinesOfCode(node)
+	if lines == 0 {
+		return 0
+	}
+	return float64(comments) / float64(lines)
+}
+
+func (fa *FileAnalyzer) countReturnStatements(node ast.Node) int {
+	count := 0
+	ast.Inspect(node, func(n ast.Node) bool {
+		if _, ok := n.(*ast.ReturnStmt); ok {
+			count++
+		}
+		return true
+	})
+	return count
+}

go.mod

@@ -1,33 +1,38 @@
 module github.com/aman/code-complexity-viz
 
-go 1.22.11
+go 1.21
 
 require (
-	github.com/bytedance/sonic v1.11.6 // indirect
-	github.com/bytedance/sonic/loader v0.1.1 // indirect
-	github.com/cloudwego/base64x v0.1.4 // indirect
-	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/gin-contrib/cors v1.5.0
+	github.com/gin-contrib/gzip v0.0.6
+	github.com/gin-contrib/secure v0.0.1
+	github.com/gin-gonic/gin v1.9.1
+)
+
+require (
+	github.com/bytedance/sonic v1.11.2 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+	github.com/chenzhuoyu/iasm v0.9.1 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
-	github.com/gin-gonic/gin v1.10.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.20.0 // indirect
+	github.com/go-playground/validator/v10 v10.18.0 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.1 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	golang.org/x/arch v0.8.0 // indirect
-	golang.org/x/crypto v0.23.0 // indirect
-	golang.org/x/net v0.25.0 // indirect
-	golang.org/x/sys v0.20.0 // indirect
-	golang.org/x/text v0.15.0 // indirect
-	google.golang.org/protobuf v1.34.1 // indirect
+	golang.org/x/arch v0.7.0 // indirect
+	golang.org/x/crypto v0.19.0 // indirect
+	golang.org/x/net v0.21.0 // indirect
+	golang.org/x/sys v0.17.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/protobuf v1.32.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )