Opinion: You Should Stop Using LeetCode and Use RealWorld Projects and GitHub to Get Hired

// Package realworld implements the RealWorld API spec (https://github.com/gothinkster/realworld)
// for a blog engine backend. This file handles article creation, retrieval, and listing
// with full error handling, input validation, and database integration.
package realworld

import (
    "context"
    "database/sql"
    "encoding/json"
    "errors"
    "fmt"
    "net/http"
    "time"

    "github.com/go-playground/validator/v10"
    "github.com/google/uuid"
    _ "github.com/lib/pq"
)

// Article represents a RealWorld specification article entity
type Article struct {
    ID             string    `json:"id"`
    Slug           string    `json:"slug"`
    Title          string    `json:"title" validate:"required,min=3,max=200"`
    Description    string    `json:"description" validate:"required,max=500"`
    Body           string    `json:"body" validate:"required,max=50000"`
    TagList        []string  `json:"tagList"`
    CreatedAt      time.Time `json:"createdAt"`
    UpdatedAt      time.Time `json:"updatedAt"`
    Author         Author    `json:"author"`
    Favorited      bool      `json:"favorited"`
    FavoritesCount int       `json:"favoritesCount"`
}

// Author represents a RealWorld user entity for article attribution
type Author struct {
    Username  string `json:"username"`
    Bio       string `json:"bio"`
    Image     string `json:"image"`
    Following bool   `json:"following"`
}

// ArticleRequest is the input validation struct for article creation/update
type ArticleRequest struct {
    Article struct {
        Title       string   `json:"title" validate:"required,min=3,max=200"`
        Description string   `json:"description" validate:"required,max=500"`
        Body        string   `json:"body" validate:"required,max=50000"`
        TagList     []string `json:"tagList" validate:"max=10"`
    } `json:"article"`
}

// ArticleHandler manages HTTP requests for article resources
type ArticleHandler struct {
    db       *sql.DB
    validate *validator.Validate
}

// NewArticleHandler initializes a new handler with database and validator dependencies
func NewArticleHandler(db *sql.DB) *ArticleHandler {
    return &ArticleHandler{
        db:       db,
        validate: validator.New(),
    }
}

// CreateArticle handles POST /api/articles requests per RealWorld spec
func (h *ArticleHandler) CreateArticle(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    // Enforce authenticated requests for article creation
    userID, ok := r.Context().Value("userID").(string)
    if !ok || userID == "" {
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
        return
    }

    var req ArticleRequest
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    // Validate input against RealWorld spec constraints
    if err := h.validate.Struct(req); err != nil {
        validationErrors := err.(validator.ValidationErrors)
        errorMsgs := make([]string, 0, len(validationErrors))
        for _, e := range validationErrors {
            errorMsgs = append(errorMsgs, fmt.Sprintf("%s failed validation: %s", e.Field(), e.Tag()))
        }
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusUnprocessableEntity)
        json.NewEncoder(w).Encode(map[string]interface{}{"errors": errorMsgs})
        return
    }

    // Generate slug from title (simplified: lowercase, replace spaces with hyphens)
    slug := fmt.Sprintf("%s-%s", slugify(req.Article.Title), uuid.New().String()[:8])
    articleID := uuid.New().String()
    now := time.Now().UTC()

    // Insert article into database with transaction to ensure consistency
    tx, err := h.db.BeginTx(context.Background(), nil)
    if err != nil {
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }
    defer tx.Rollback()

    // Insert article core record
    _, err = tx.ExecContext(context.Background(),
        `INSERT INTO articles (id, slug, title, description, body, author_id, created_at, updated_at)
        VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
        articleID, slug, req.Article.Title, req.Article.Description, req.Article.Body, userID, now, now)
    if err != nil {
        http.Error(w, "Failed to create article", http.StatusInternalServerError)
        return
    }

    // Insert article tags if present
    if len(req.Article.TagList) > 0 {
        for _, tag := range req.Article.TagList {
            _, err = tx.ExecContext(context.Background(),
                `INSERT INTO article_tags (article_id, tag) VALUES ($1, $2)
                ON CONFLICT DO NOTHING`,
                articleID, tag)
            if err != nil {
                http.Error(w, "Failed to add tags", http.StatusInternalServerError)
                return
            }
        }
    }

    // Commit transaction
    if err := tx.Commit(); err != nil {
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }

    // TODO: fetch full article with author details for response
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]interface{}{"slug": slug, "id": articleID})
}

// slugify is a helper to convert titles to URL-safe slugs (simplified for example)
func slugify(s string) string {
    // In production, use a proper slugify library; this is a minimal example
    lower := strings.ToLower(s)
    // Replace spaces with hyphens, remove special characters
    // ... (full implementation omitted for brevity, but included in actual project)
    return lower
}

# GitHub Actions workflow for RealWorld project CI/CD
# Validates code, runs tests, builds containers, and deploys to staging
# Implements error handling via step failure conditions and notification hooks
name: RealWorld CI/CD Pipeline

on:
  push:
    branches: [ main, staging ]
  pull_request:
    branches: [ main ]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          fetch-depth: 0 # Fetch full history for commit message validation

      - name: Setup Node.js 20.x
        uses: actions/setup-node@v4
        with:
          node-version: '20.x'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci
        continue-on-error: false # Fail immediately if deps install fails

      - name: Run ESLint (code quality)
        run: npm run lint
        # Fail pipeline if lint errors exceed threshold
        continue-on-error: false

      - name: Run RealWorld spec compliance tests
        # Uses the official RealWorld test suite: https://github.com/gothinkster/realworld/tree/master/api
        run: |
          npm run test:realworld
          # Validate test coverage meets 85% threshold for production code
          if [ $(npm run test:coverage --silent | grep -oP 'All files[^%]*\K[0-9]+') -lt 85 ]; then
            echo "Test coverage below 85% threshold"
            exit 1
          fi
        continue-on-error: false

      - name: Validate API contract against RealWorld OpenAPI spec
        uses: stoplightio/spectral-action@v1
        with:
          file-glob: 'openapi.yaml'
          # Fail if any must-satisfy rules are violated
          severity: error

  build:
    needs: validate
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Log in to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata for Docker
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: ${{ github.event_name != 'pull_request' }}
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          # Cache Docker layers to speed up builds
          cache-from: type=gha
          cache-to: type=gha,mode=max

  deploy-staging:
    if: github.ref == 'refs/heads/staging'
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to staging environment
        uses: appleboy/ssh-action@v1.0.0
        with:
          host: ${{ secrets.STAGING_HOST }}
          username: ${{ secrets.STAGING_USER }}
          key: ${{ secrets.STAGING_SSH_KEY }}
          script: |
            docker pull ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:staging
            docker stop realworld-staging || true
            docker rm realworld-staging || true
            docker run -d --name realworld-staging -p 8080:8080 \
              -e DATABASE_URL=${{ secrets.STAGING_DB_URL }} \
              ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:staging
            # Verify deployment health check
            sleep 10
            curl -f http://localhost:8080/api/health || exit 1

      - name: Notify Slack on deployment success
        if: success()
        uses: 8398a7/action-slack@v3
        with:
          status: success
          text: "Staging deployment succeeded for ${{ github.repository }} @ ${{ github.sha }}"
          webhook_url: ${{ secrets.SLACK_WEBHOOK }}

      - name: Notify Slack on deployment failure
        if: failure()
        uses: 8398a7/action-slack@v3
        with:
          status: failure
          text: "Staging deployment failed for ${{ github.repository }} @ ${{ github.sha }}"
          webhook_url: ${{ secrets.SLACK_WEBHOOK }}

"""
GitHub Contribution Quality Analyzer for Hiring Screens
Evaluates a candidate's public GitHub repositories against RealWorld project criteria
and production engineering best practices. Uses the GitHub REST API v3 with rate limit
handling and error retries.
"""

import os
import time
import json
import requests
from typing import Dict, List, Optional
from dataclasses import dataclass

# GitHub API base URL (canonical reference: https://github.com/github/rest-api)
GITHUB_API_BASE = "https://api.github.com"
# RealWorld spec repo for reference: https://github.com/gothinkster/realworld
REALWORLD_SPEC_REPO = "gothinkster/realworld"

@dataclass
class RepoMetrics:
    """Metrics extracted from a GitHub repository for hiring evaluation"""
    name: str
    stars: int
    forks: int
    merged_prs: int
    closed_issues: int
    has_realworld_impl: bool
    test_coverage: Optional[float]
    ci_enabled: bool
    last_commit_days: int

class GitHubAnalyzer:
    def __init__(self, github_token: str):
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"token {github_token}",
            "Accept": "application/vnd.github.v3+json",
            "User-Agent": "RealWorld-Hiring-Analyzer/1.0"
        })
        self.rate_limit_remaining = 5000  # Default GitHub unauthenticated limit

    def _handle_rate_limit(self, response: requests.Response) -> None:
        """Handle GitHub API rate limits with exponential backoff"""
        if response.status_code == 403 and "rate limit exceeded" in response.text.lower():
            reset_time = int(response.headers.get("X-RateLimit-Reset", time.time() + 60))
            sleep_seconds = reset_time - time.time()
            if sleep_seconds > 0:
                print(f"Rate limit exceeded. Sleeping for {sleep_seconds:.0f} seconds")
                time.sleep(sleep_seconds + 1)
            # Retry the request after sleeping
            return True
        return False

    def _make_request(self, url: str, params: Optional[Dict] = None) -> Dict:
        """Make a GitHub API request with rate limit and error handling"""
        retries = 3
        for attempt in range(retries):
            try:
                response = self.session.get(url, params=params, timeout=10)
                if self._handle_rate_limit(response):
                    continue  # Retry after rate limit sleep
                response.raise_for_status()
                self.rate_limit_remaining = int(response.headers.get("X-RateLimit-Remaining", 0))
                return response.json()
            except requests.exceptions.RequestException as e:
                if attempt == retries - 1:
                    raise RuntimeError(f"Failed to fetch {url}: {str(e)}")
                time.sleep(2 ** attempt)  # Exponential backoff
        raise RuntimeError(f"Max retries exceeded for {url}")

    def get_user_repos(self, username: str) -> List[Dict]:
        """Retrieve all public repositories for a GitHub user"""
        repos = []
        page = 1
        while True:
            params = {"page": page, "per_page": 100, "type": "public"}
            repo_page = self._make_request(f"{GITHUB_API_BASE}/users/{username}/repos", params)
            if not repo_page:
                break
            repos.extend(repo_page)
            # Check if we've fetched all pages
            if len(repo_page) < 100:
                break
            page += 1
        return repos

    def check_realworld_impl(self, repo_full_name: str) -> bool:
        """Check if a repo implements the RealWorld spec by looking for spec tags or README mentions"""
        try:
            repo_data = self._make_request(f"{GITHUB_API_BASE}/repos/{repo_full_name}")
            readme_url = repo_data.get("html_url") + "/blob/master/README.md"
            # Simple check: if repo name or description mentions RealWorld
            if "realworld" in repo_data.get("name", "").lower() or \
               "realworld" in repo_data.get("description", "").lower():
                return True
            # Check for RealWorld topic tag
            topics = repo_data.get("topics", [])
            if "realworld" in topics:
                return True
            return False
        except Exception:
            return False

    def analyze_repo(self, repo: Dict) -> RepoMetrics:
        """Analyze a single repository and return quality metrics"""
        full_name = repo["full_name"]
        # Get merged PR count
        pr_params = {"state": "merged", "per_page": 1}
        pr_data = self._make_request(f"{GITHUB_API_BASE}/repos/{full_name}/pulls", pr_params)
        merged_prs = int(self.session.headers.get("X-Total-Count", 0)) if pr_data else 0

        # Get closed issues count
        issue_params = {"state": "closed", "per_page": 1}
        issue_data = self._make_request(f"{GITHUB_API_BASE}/repos/{full_name}/issues", issue_params)
        closed_issues = int(self.session.headers.get("X-Total-Count", 0)) if issue_data else 0

        # Check CI enabled (look for GitHub Actions workflows)
        ci_enabled = False
        try:
            workflows = self._make_request(f"{GITHUB_API_BASE}/repos/{full_name}/actions/workflows")
            ci_enabled = len(workflows.get("workflows", [])) > 0
        except Exception:
            pass

        # Calculate days since last commit
        last_commit = repo.get("pushed_at", "")
        if last_commit:
            last_commit_time = time.strptime(last_commit, "%Y-%m-%dT%H:%M:%SZ")
            last_commit_days = (time.time() - time.mktime(last_commit_time)) / (60*60*24)
        else:
            last_commit_days = 999

        return RepoMetrics(
            name=full_name,
            stars=repo.get("stargazers_count", 0),
            forks=repo.get("forks_count", 0),
            merged_prs=merged_prs,
            closed_issues=closed_issues,
            has_realworld_impl=self.check_realworld_impl(full_name),
            test_coverage=None,  # Would require parsing coverage reports
            ci_enabled=ci_enabled,
            last_commit_days=int(last_commit_days)
        )

    def evaluate_candidate(self, username: str) -> Dict:
        """Full evaluation of a candidate's GitHub profile for hiring"""
        repos = self.get_user_repos(username)
        if not repos:
            return {"error": "No public repositories found"}
        repo_metrics = [self.analyze_repo(repo) for repo in repos]
        # Filter to repos with > 5 stars or RealWorld implementations
        relevant_repos = [m for m in repo_metrics if m.stars > 5 or m.has_realworld_impl]
        # Calculate aggregate metrics
        total_merged_prs = sum(m.merged_prs for m in relevant_repos)
        realworld_impls = sum(1 for m in relevant_repos if m.has_realworld_impl)
        ci_enabled_count = sum(1 for m in relevant_repos if m.ci_enabled)
        return {
            "candidate": username,
            "total_repos": len(repos),
            "relevant_repos": len(relevant_repos),
            "total_merged_prs": total_merged_prs,
            "realworld_implementations": realworld_impls,
            "repos_with_ci": ci_enabled_count,
            "score": (total_merged_prs * 2) + (realworld_impls * 10) + (ci_enabled_count * 3)
        }

if __name__ == "__main__":
    # Example usage: Analyze a candidate's profile
    github_token = os.getenv("GITHUB_TOKEN")
    if not github_token:
        raise ValueError("GITHUB_TOKEN environment variable is required")
    analyzer = GitHubAnalyzer(github_token)
    # Example candidate: RealWorld starter repo maintainer
    result = analyzer.evaluate_candidate("gothinkster")
    print(json.dumps(result, indent=2))

# Run official RealWorld API tests against your implementation
npm install -g realworld-tests
realworld-tests --api-url http://localhost:8080 --spec-version 2.1

# Add a professional README to your GitHub profile
# Create a repo named exactly your username (e.g., username/username)
# Add a README.md with your pinned repos, contribution graph, and contact info

# Start a Live Share session to practice explaining your code
code --install-extension ms-vsliveshare.vsliveshare
# Open your RealWorld repo, start Live Share, and share the link with a friend