"""pyperf benchmark for RegexLexer lexing throughput.

    python bench_lexers.py -o base.json     # on master
    python bench_lexers.py -o patch.json    # on the branch
    python -m pyperf compare_to base.json patch.json
"""
import pyperf
from pygments.lexers import PythonLexer, JavascriptLexer, CLexer, RubyLexer

PYTHON = '''import os, sys
from collections import defaultdict


class Cache(dict):
    """A small bounded cache."""

    def __init__(self, maxsize=128):
        self.maxsize = maxsize
        self._hits = 0

    def get_or_set(self, key, factory):
        if key in self:
            self._hits += 1
            return self[key]
        value = self[key] = factory(key)
        return value


def main(argv=None):
    data = defaultdict(list)
    for i, line in enumerate(sys.stdin):
        parts = line.strip().split(",")
        if not parts or parts[0].startswith("#"):
            continue
        data[parts[0]].append(float(parts[1]) * 2 + 1)
    total = sum(v for vs in data.values() for v in vs)
    print(f"{total=:.3f} over {len(data)} keys")
    return 0
'''

JAVASCRIPT = '''const cache = new Map();

function memoize(fn) {
  return function (...args) {
    const key = JSON.stringify(args);
    if (cache.has(key)) return cache.get(key);
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
}

const fib = memoize((n) => (n < 2 ? n : fib(n - 1) + fib(n - 2)));
console.log(`fib(20) = ${fib(20)}`);
'''

C = '''#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct node { int value; struct node *next; } node_t;

static node_t *push(node_t *head, int v) {
    node_t *n = malloc(sizeof(node_t));
    if (!n) { perror("malloc"); exit(1); }
    n->value = v; n->next = head;
    return n;
}

int main(int argc, char **argv) {
    node_t *head = NULL;
    for (int i = 0; i < argc; i++)
        head = push(head, (int)strtol(argv[i], NULL, 10) + 0xFF);
    for (node_t *p = head; p; p = p->next) printf("%d\\n", p->value);
    return 0;
}
'''

RUBY = '''require "json"

class Stack
  def initialize
    @items = []
  end

  def push(x)
    @items << x
    self
  end

  def pop
    @items.pop
  end

  def empty?
    @items.empty?
  end
end

s = Stack.new
[1, 2, 3].each { |n| s.push(n * 2) }
puts s.pop until s.empty?
'''

# Repeat so each measured op lexes a realistic multi-screen file.
CASES = [
    ("python", PythonLexer(), PYTHON * 4),
    ("javascript", JavascriptLexer(), JAVASCRIPT * 4),
    ("c", CLexer(), C * 4),
    ("ruby", RubyLexer(), RUBY * 4),
]


def make(lexer, code):
    def run():
        for _ in lexer.get_tokens(code):
            pass
    return run


if __name__ == "__main__":
    runner = pyperf.Runner()
    for name, lexer, code in CASES:
        runner.bench_func(f"lex {name}", make(lexer, code))