@untangle-code/parser-registry 0.0.0-stage → 0.1.0

package/src/languages/astgrep-backend/__golden__/cpp-basic.cpp

@@ -0,0 +1,65 @@
+// A tiny matrix.
+#include <vector>
+#include <stdexcept>
+#include "matrix.hpp"
+
+namespace linalg {
+
+constexpr int kMax = 1024;
+
+struct Shape {
+    int rows;
+    int cols;
+};
+
+enum class Order { RowMajor, ColMajor };
+
+class Matrix {
+public:
+    /// Builds a matrix.
+    Matrix(int rows, int cols) : rows_(rows), cols_(cols), data_(rows * cols) {}
+
+    double at(int r, int c) const {
+        if (r < 0 || c < 0) {
+            throw std::out_of_range("negative");
+        } else if (r >= rows_ || c >= cols_) {
+            throw std::out_of_range("bounds");
+        }
+        return data_[r * cols_ + c];
+    }
+
+    void fill(double v) {
+        for (int i = 0; i < rows_; ++i) {
+            for (int j = 0; j < cols_; ++j) {
+                if (i == j && v > 0 || v == 0) {
+                    data_[i * cols_ + j] = v;
+                }
+            }
+        }
+        try {
+            while (rows_ > kMax) {
+                throw std::runtime_error("too big");
+            }
+        } catch (const std::exception &e) {
+            data_.clear();
+        }
+    }
+
+private:
+    int rows_;
+    int cols_;
+    std::vector<double> data_;
+};
+
+template <typename T>
+T twice(T v) {
+    return v + v;
+}
+
+Matrix identity(int n) {
+    Matrix m(n, n);
+    m.fill(1.0);
+    return m;
+}
+
+}  // namespace linalg

package/src/languages/astgrep-backend/__golden__/csharp-basic.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using Sys = System.Text;
+
+namespace Example.Caching
+{
+    /// <summary>A tiny cache.</summary>
+    public interface ICache<T>
+    {
+        T Get(string key);
+    }
+
+    public enum Mode { Read, Write }
+
+    public struct Slot
+    {
+        public int Size;
+    }
+
+    public class Cache : ICache<string>, IDisposable
+    {
+        private readonly Dictionary<string, string> _items = new();
+        public const int Max = 16;
+
+        public Cache(Dictionary<string, string> items)
+        {
+            _items = items;
+        }
+
+        public string Name { get; set; }
+
+        /// <summary>Reads one entry.</summary>
+        public string Get(string key)
+        {
+            if (key == null || key.Length == 0)
+            {
+                throw new ArgumentNullException(nameof(key));
+            }
+            else if (_items.Count > Max)
+            {
+                _items.Clear();
+            }
+
+            try
+            {
+                foreach (var kv in _items)
+                {
+                    if (kv.Key == key) return kv.Value;
+                }
+                for (int i = 0; i < Max; i++)
+                {
+                    while (i < 0) { i++; }
+                }
+                switch (key)
+                {
+                    case "a":
+                        return "A";
+                    case "b":
+                        return "B";
+                    default:
+                        break;
+                }
+            }
+            catch (InvalidOperationException e)
+            {
+                Console.WriteLine(e.Message);
+            }
+            return key.Length > 0 ? key : null;
+        }
+
+        public void Dispose() => _items.Clear();
+    }
+}

package/src/languages/astgrep-backend/__golden__/go-basic.go

@@ -0,0 +1,93 @@
+// Package worker drains a queue.
+package worker
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	ts "time"
+)
+
+// ErrClosed is returned once the pool is closed.
+var ErrClosed = errors.New("closed")
+
+const maxRetries = 3
+
+// Job is one unit of work.
+type Job struct {
+	ID      string
+	Payload []byte
+}
+
+// Runner runs jobs.
+type Runner interface {
+	Run(ctx context.Context, j Job) error
+}
+
+type pool struct {
+	jobs   chan Job
+	runner Runner
+}
+
+// NewPool builds a pool.
+func NewPool(r Runner, size int) *pool {
+	return &pool{jobs: make(chan Job, size), runner: r}
+}
+
+// Drain consumes jobs until the context ends.
+func (p *pool) Drain(ctx context.Context) error {
+	for {
+		select {
+		case j, ok := <-p.jobs:
+			if !ok {
+				return ErrClosed
+			}
+			if err := p.runOne(ctx, j); err != nil && !errors.Is(err, ErrClosed) {
+				return fmt.Errorf("job %s: %w", j.ID, err)
+			}
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func (p *pool) runOne(ctx context.Context, j Job) error {
+	for attempt := 0; attempt < maxRetries; attempt++ {
+		err := p.runner.Run(ctx, j)
+		if err == nil {
+			return nil
+		}
+		switch {
+		case errors.Is(err, ErrClosed):
+			return err
+		default:
+			ts.Sleep(ts.Millisecond)
+		}
+	}
+	return ErrClosed
+}
+
+func describe(v any) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	case int, int64:
+		return fmt.Sprint(x)
+	default:
+		return "?"
+	}
+}
+
+func each(items []Job, fn func(Job) bool) int {
+	n := 0
+	for i, it := range items {
+		if i > 0 && fn(it) || len(it.ID) == 0 {
+			n++
+		}
+	}
+	go func() {
+		defer func() { _ = recover() }()
+		_ = n
+	}()
+	return n
+}

package/src/languages/astgrep-backend/__golden__/java-basic.java

@@ -0,0 +1,62 @@
+package com.example.ledger;
+
+import java.util.List;
+import java.util.Map;
+import static java.util.Collections.emptyList;
+
+/** A ledger of entries. */
+public class Ledger implements AutoCloseable {
+    private final Map<String, Long> balances;
+    public static final int MAX = 100;
+
+    public Ledger(Map<String, Long> balances) {
+        this.balances = balances;
+    }
+
+    /** Applies one entry. */
+    public long apply(String account, long amount) throws IllegalStateException {
+        if (account == null || account.isEmpty()) {
+            throw new IllegalStateException("account");
+        } else if (amount == 0) {
+            return 0;
+        }
+        long current = balances.getOrDefault(account, 0L);
+        long next = current + amount;
+        try {
+            for (int i = 0; i < MAX && next > 0; i++) {
+                next -= 1;
+            }
+            while (next < 0) { next++; }
+            switch (account) {
+                case "a":
+                    next = 1;
+                    break;
+                case "b":
+                case "c":
+                    next = 2;
+                    break;
+                default:
+                    break;
+            }
+        } catch (RuntimeException e) {
+            next = current;
+        } finally {
+            balances.put(account, next);
+        }
+        return next > 0 ? next : 0;
+    }
+
+    interface Visitor {
+        void visit(String key);
+    }
+
+    enum Kind { DEBIT, CREDIT }
+
+    record Entry(String account, long amount) {}
+
+    @Override
+    public void close() {
+        List<String> keys = emptyList();
+        keys.forEach(k -> balances.remove(k));
+    }
+}

package/src/languages/astgrep-backend/__golden__/kotlin-basic.kt

@@ -0,0 +1,58 @@
+package com.example.cache
+
+import kotlin.math.max
+import java.util.concurrent.ConcurrentHashMap as CMap
+
+const val LIMIT = 32
+
+/** A cache entry. */
+data class Entry(val key: String, val size: Int)
+
+interface Store {
+    fun get(key: String): Entry?
+}
+
+enum class Mode { READ, WRITE }
+
+object Registry {
+    val all = mutableListOf<String>()
+}
+
+/** In-memory store. */
+class MemStore(private val items: CMap<String, Entry>) : Store {
+    var name: String = ""
+
+    override fun get(key: String): Entry? {
+        if (key.isEmpty()) {
+            return null
+        } else if (items.size > LIMIT) {
+            items.clear()
+        }
+        for ((k, v) in items) {
+            if (k == key && v.size > 0 || v.size == 0) {
+                return v
+            }
+        }
+        var i = 0
+        while (i < LIMIT) {
+            i++
+        }
+        return try {
+            when (key) {
+                "a" -> items["a"]
+                "b", "c" -> items["b"]
+                else -> null
+            }
+        } catch (e: IllegalStateException) {
+            null
+        }
+    }
+
+    fun sizes(): List<Int> = items.values.map { it.size }
+
+    companion object {
+        fun empty(): MemStore = MemStore(CMap())
+    }
+}
+
+fun biggest(a: Int, b: Int): Int = if (a > b) max(a, b) else b

package/src/languages/astgrep-backend/__golden__/php-basic.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace App\Billing;
+
+use App\Money;
+use App\Contracts\Payable as PayableContract;
+
+const TAX = 0.19;
+
+interface Payable
+{
+    public function total(): float;
+}
+
+trait HasLines
+{
+    public function lineCount(): int
+    {
+        return count($this->lines);
+    }
+}
+
+/** An invoice. */
+class Invoice implements Payable
+{
+    use HasLines;
+
+    private array $lines = [];
+    public const CURRENCY = 'EUR';
+
+    public function __construct(array $lines)
+    {
+        $this->lines = $lines;
+    }
+
+    /** Sums all lines. */
+    public function total(): float
+    {
+        if (empty($this->lines)) {
+            return 0.0;
+        } elseif (count($this->lines) > 100) {
+            throw new \RuntimeException('too many');
+        }
+
+        $sum = 0.0;
+        foreach ($this->lines as $line) {
+            if ($line['amount'] > 0 && !$line['void'] || $line['forced']) {
+                $sum += $line['amount'];
+            }
+        }
+        for ($i = 0; $i < 3; $i++) {
+            while ($sum < 0) { $sum++; }
+        }
+        try {
+            switch (self::CURRENCY) {
+                case 'EUR':
+                    $sum *= (1 + TAX);
+                    break;
+                default:
+                    break;
+            }
+        } catch (\Throwable $e) {
+            $sum = 0.0;
+        }
+        return $sum > 0 ? $sum : 0.0;
+    }
+}
+
+function makeInvoice(array $lines): Invoice
+{
+    return new Invoice($lines);
+}

package/src/languages/astgrep-backend/__golden__/ruby-basic.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'helper'
+
+# A report builder.
+module Reporting
+  MAX = 10
+
+  class Report
+    attr_reader :rows
+
+    def initialize(rows)
+      @rows = rows
+    end
+
+    # Renders the report.
+    def render(format = :text)
+      raise ArgumentError, 'no rows' if @rows.empty?
+
+      out = []
+      @rows.each_with_index do |row, i|
+        next if row.nil?
+        if i.zero?
+          out << header(row)
+        elsif i > MAX
+          break
+        else
+          out << body(row)
+        end
+      end
+
+      case format
+      when :json then JSON.dump(out)
+      when :text then out.join("\n")
+      else
+        raise "unknown #{format}"
+      end
+    rescue StandardError => e
+      warn(e.message)
+      ''
+    end
+
+    private
+
+    def header(row)
+      row.to_s.upcase
+    end
+
+    def body(row)
+      row.to_s if row && !row.empty? || row == 0
+    end
+
+    def self.build(rows)
+      new(rows)
+    end
+  end
+
+  def self.quick(rows)
+    Report.build(rows).render
+  end
+end

package/src/languages/astgrep-backend/__golden__/rust-basic.rs

@@ -0,0 +1,82 @@
+//! A tiny store.
+use std::collections::HashMap;
+use std::fmt::{self, Display};
+
+pub const LIMIT: usize = 8;
+
+/// A stored record.
+#[derive(Debug, Clone)]
+pub struct Record {
+    pub id: String,
+    pub size: usize,
+}
+
+pub enum Slot {
+    Empty,
+    Filled(Record),
+}
+
+pub trait Store {
+    fn get(&self, id: &str) -> Option<&Record>;
+    fn put(&mut self, r: Record) -> Result<(), String>;
+}
+
+pub struct MemStore {
+    items: HashMap<String, Record>,
+}
+
+impl MemStore {
+    /// Builds an empty store.
+    pub fn new() -> Self {
+        MemStore { items: HashMap::new() }
+    }
+
+    fn check(&self, r: &Record) -> Result<(), String> {
+        if r.size > LIMIT {
+            return Err("too big".to_string());
+        } else if r.id.is_empty() {
+            return Err("no id".to_string());
+        }
+        Ok(())
+    }
+}
+
+impl Store for MemStore {
+    fn get(&self, id: &str) -> Option<&Record> {
+        self.items.get(id)
+    }
+
+    fn put(&mut self, r: Record) -> Result<(), String> {
+        self.check(&r)?;
+        let slot = match self.items.get(&r.id) {
+            Some(existing) if existing.size == r.size => Slot::Filled(existing.clone()),
+            Some(_) => Slot::Empty,
+            None => Slot::Empty,
+        };
+        if let Slot::Filled(_) = slot {
+            return Ok(());
+        }
+        while self.items.len() > LIMIT {
+            self.items.clear();
+        }
+        for (k, v) in self.items.iter() {
+            if v.size == 0 && !k.is_empty() || k == "x" {
+                continue;
+            }
+        }
+        self.items.insert(r.id.clone(), r);
+        Ok(())
+    }
+}
+
+impl Display for Record {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.id)
+    }
+}
+
+pub fn count_all(stores: &[MemStore]) -> usize {
+    stores.iter().map(|s| s.items.len()).sum()
+}
+
+type Alias = HashMap<String, Record>;

package/src/languages/astgrep-backend/__golden__/swift-basic.swift

@@ -0,0 +1,73 @@
+import Foundation
+import os.log
+
+let limit = 32
+
+/// A record.
+public struct Record {
+    let id: String
+    var size: Int
+}
+
+public protocol Store {
+    func get(_ id: String) -> Record?
+}
+
+public enum Mode {
+    case read
+    case write
+}
+
+/// In-memory store.
+public final class MemStore: Store {
+    private var items: [String: Record] = [:]
+
+    public init(items: [String: Record]) {
+        self.items = items
+    }
+
+    public func get(_ id: String) -> Record? {
+        guard !id.isEmpty else {
+            return nil
+        }
+        if items.count > limit {
+            items.removeAll()
+        } else if id == "x" {
+            return nil
+        }
+        for (k, v) in items {
+            if k == id && v.size > 0 || v.size == 0 {
+                return v
+            }
+        }
+        var i = 0
+        while i < limit {
+            i += 1
+        }
+        switch id {
+        case "a":
+            return items["a"]
+        case "b", "c":
+            return items["b"]
+        default:
+            break
+        }
+        do {
+            return try load(id)
+        } catch {
+            return nil
+        }
+    }
+
+    private func load(_ id: String) throws -> Record? {
+        return items[id]
+    }
+}
+
+extension MemStore {
+    var count: Int { items.count }
+}
+
+func biggest(_ a: Int, _ b: Int) -> Int {
+    return a > b ? a : b
+}