textbringer-tree-sitter 1.2.0 → 1.2.2

data/samples/sample.cs

@@ -0,0 +1,273 @@
+// Line comment
+/* Block comment */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace SampleNamespace
+{
+    // --- Enums ---
+    public enum Color
+    {
+        Red,
+        Green,
+        Blue
+    }
+
+    // --- Interfaces ---
+    public interface IGreetable
+    {
+        string Greet();
+    }
+
+    // --- Abstract class ---
+    public abstract class Animal
+    {
+        public abstract string Speak();
+        public virtual string Name { get; set; } = "Unknown";
+    }
+
+    // --- Struct ---
+    public struct Point
+    {
+        public double X { get; init; }
+        public double Y { get; init; }
+
+        public double Distance(Point other)
+        {
+            return Math.Sqrt(Math.Pow(X - other.X, 2) + Math.Pow(Y - other.Y, 2));
+        }
+    }
+
+    // --- Record ---
+    public record Person(string Name, int Age);
+
+    // --- Sealed class ---
+    public sealed class Dog : Animal, IGreetable
+    {
+        public override string Speak() => "Woof!";
+
+        public string Greet() => $"I'm {Name}";
+    }
+
+    // --- Generic class ---
+    public class Container<T> where T : class, new()
+    {
+        private readonly List<T> _items = new();
+
+        public void Add(T item) => _items.Add(item);
+        public T? Get(int index) => index < _items.Count ? _items[index] : null;
+        public int Count => _items.Count;
+    }
+
+    // --- Static class ---
+    public static class MathHelper
+    {
+        public const double Pi = 3.14159;
+        public static readonly int MaxValue = int.MaxValue;
+
+        public static int Add(int a, int b) => a + b;
+        public static async Task<int> AddAsync(int a, int b)
+        {
+            await Task.Delay(100);
+            return a + b;
+        }
+    }
+
+    // --- Main class ---
+    public class Program
+    {
+        // --- Delegate & Event ---
+        public delegate void MessageHandler(string message);
+        public event MessageHandler? OnMessage;
+
+        public static void Main(string[] args)
+        {
+            // --- Strings ---
+            string simple = "Hello, World!";
+            string interpolated = $"Result: {1 + 2}";
+            string verbatim = @"C:\Users\test\file.txt";
+            string raw = """
+                Raw string literal
+                with "quotes" inside
+                """;
+            char ch = 'A';
+            string escaped = "tab\tnewline\n";
+
+            // --- Numbers ---
+            int integer = 42;
+            long big = 1234567890L;
+            float f = 3.14f;
+            double d = 2.71828;
+            decimal money = 19.99m;
+            int hex = 0xFF;
+            int bin = 0b1010;
+
+            // --- Booleans & Null ---
+            bool flag = true;
+            bool nope = false;
+            string? nullable = null;
+
+            // --- var ---
+            var inferred = "inferred type";
+
+            // --- Control flow ---
+            if (integer > 0)
+            {
+                Console.WriteLine("positive");
+            }
+            else if (integer < 0)
+            {
+                Console.WriteLine("negative");
+            }
+            else
+            {
+                Console.WriteLine("zero");
+            }
+
+            switch (integer)
+            {
+                case 1:
+                    Console.WriteLine("one");
+                    break;
+                case 2:
+                    Console.WriteLine("two");
+                    break;
+                default:
+                    Console.WriteLine("other");
+                    break;
+            }
+
+            // --- Switch expression ---
+            string result = integer switch
+            {
+                > 0 => "positive",
+                < 0 => "negative",
+                _ => "zero"
+            };
+
+            // --- Loops ---
+            for (int i = 0; i < 10; i++)
+            {
+                if (i == 5) break;
+                if (i == 3) continue;
+            }
+
+            foreach (var item in new[] { 1, 2, 3 })
+            {
+                Console.WriteLine(item);
+            }
+
+            int j = 10;
+            while (j > 0)
+            {
+                j--;
+            }
+
+            do
+            {
+                j++;
+            } while (j < 5);
+
+            // --- Operators ---
+            int sum = 1 + 2;
+            bool logic = true && false || !true;
+            int ternary = sum > 0 ? sum : -sum;
+            string coalesce = nullable ?? "default";
+            int? nullableInt = null;
+            int safe = nullableInt ?? 0;
+
+            // --- Type checks ---
+            object obj = "test";
+            if (obj is string s)
+            {
+                Console.WriteLine(s.Length);
+            }
+            var cast = obj as string;
+            var typeOf = typeof(string);
+            var sizeOf = sizeof(int);
+
+            // --- Exception handling ---
+            try
+            {
+                throw new InvalidOperationException("oops");
+            }
+            catch (InvalidOperationException ex) when (ex.Message.Contains("oops"))
+            {
+                Console.WriteLine(ex.Message);
+            }
+            catch (Exception)
+            {
+                Console.WriteLine("unexpected");
+            }
+            finally
+            {
+                Console.WriteLine("cleanup");
+            }
+
+            // --- Pattern matching ---
+            object value = 42;
+            if (value is int n and > 0)
+            {
+                Console.WriteLine($"Positive int: {n}");
+            }
+
+            // --- LINQ ---
+            var numbers = new List<int> { 1, 2, 3, 4, 5 };
+            var evens = from num in numbers
+                        where num % 2 == 0
+                        orderby num descending
+                        select num;
+
+            // --- Lambda ---
+            Func<int, int> square = x => x * x;
+            Action<string> print = msg => Console.WriteLine(msg);
+
+            // --- Async/Await ---
+            RunAsync().Wait();
+
+            // --- Record usage ---
+            var person = new Person("Alice", 30);
+            var older = person with { Age = 31 };
+
+            // --- Struct usage ---
+            var p1 = new Point { X = 1.0, Y = 2.0 };
+            var p2 = new Point { X = 4.0, Y = 6.0 };
+            Console.WriteLine(p1.Distance(p2));
+
+            // --- Using/lock ---
+            lock (obj)
+            {
+                Console.WriteLine("synchronized");
+            }
+
+            // --- Goto ---
+            goto end;
+        end:
+            Console.WriteLine("done");
+        }
+
+        private static async Task RunAsync()
+        {
+            var result = await MathHelper.AddAsync(1, 2);
+            Console.WriteLine(result);
+        }
+
+        // --- Yield ---
+        public static IEnumerable<int> Fibonacci()
+        {
+            int a = 0, b = 1;
+            while (true)
+            {
+                yield return a;
+                (a, b) = (b, a + b);
+            }
+        }
+
+        // --- Operator overloading ---
+        public static implicit operator string(Program p) => "Program";
+        public static explicit operator int(Program p) => 0;
+    }
+}

data/samples/sample.ex

@@ -0,0 +1,307 @@
+# Single line comment
+
+# Elixir sample - functional programming on the BEAM
+
+# --- Module ---
+defmodule Sample do
+  @moduledoc """
+  Sample module demonstrating Elixir syntax.
+  """
+
+  # --- Module attributes ---
+  @max_size 100
+  @pi 3.14159
+  @greeting "Hello, World!"
+
+  # --- Structs ---
+  defmodule Point do
+    @enforce_keys [:x, :y]
+    defstruct [:x, :y, z: 0.0]
+  end
+
+  defmodule User do
+    defstruct [:name, :age, active: true]
+  end
+
+  # --- Types ---
+  @type color :: :red | :green | :blue
+  @type result :: {:ok, any()} | {:error, String.t()}
+
+  # --- Functions ---
+  @doc "Add two numbers"
+  @spec add(number(), number()) :: number()
+  def add(a, b) do
+    a + b
+  end
+
+  @spec greet(String.t(), String.t()) :: String.t()
+  def greet(name, greeting \\ "Hello") do
+    "#{greeting}, #{name}!"
+  end
+
+  # --- Pattern matching in function heads ---
+  def describe(:red), do: "Red color"
+  def describe(:green), do: "Green color"
+  def describe(:blue), do: "Blue color"
+  def describe(_), do: "Unknown color"
+
+  # --- Guards ---
+  def classify(n) when is_integer(n) and n > 0, do: :positive
+  def classify(n) when is_integer(n) and n < 0, do: :negative
+  def classify(0), do: :zero
+  def classify(_), do: :not_a_number
+
+  # --- Private functions ---
+  defp helper(value) do
+    value * 2
+  end
+
+  # --- Default arguments ---
+  def repeat(str, times \\ 3) do
+    String.duplicate(str, times)
+  end
+
+  # --- Multi-clause with when ---
+  def safe_divide(a, b) when b != 0 do
+    {:ok, a / b}
+  end
+
+  def safe_divide(_a, 0) do
+    {:error, "Division by zero"}
+  end
+
+  # --- Main function ---
+  def run do
+    # --- Atoms ---
+    status = :ok
+    error = :error
+    module_atom = Sample
+
+    # --- Strings ---
+    simple = "Hello, World!"
+    interpolated = "Sum: #{1 + 2}"
+    escaped = "tab\tnewline\n"
+    heredoc = """
+    This is a heredoc
+    with #{interpolated}
+    """
+    charlist = 'charlist (list of integers)'
+    sigil_string = ~s(sigil string with #{interpolated})
+    sigil_raw = ~S(raw sigil, no #{interpolation})
+    regex = ~r/pattern[a-z]+/i
+    wordlist = ~w(apple banana cherry)a
+
+    # --- Numbers ---
+    integer = 42
+    negative = -17
+    hex = 0xFF
+    octal = 0o77
+    binary = 0b1010
+    float_val = 3.14
+    scientific = 1.5e10
+    underscore = 1_000_000
+
+    # --- Booleans & Nil ---
+    yes = true
+    no = false
+    nothing = nil
+
+    # --- Collections ---
+    list = [1, 2, 3, 4, 5]
+    tuple = {1, "hello", true}
+    map = %{name: "Alice", age: 30}
+    keyword = [name: "Alice", age: 30]
+    mapset = MapSet.new([1, 2, 3])
+    range = 1..10
+    struct = %Point{x: 1.0, y: 2.0}
+
+    # --- Operators ---
+    sum = 1 + 2
+    diff = 5 - 3
+    prod = 4 * 2
+    quot = 10 / 3
+    int_div = div(10, 3)
+    modulo = rem(10, 3)
+    concat = "Hello" <> " " <> "World"
+    list_concat = [1, 2] ++ [3, 4]
+    list_diff = [1, 2, 3] -- [2]
+    logic = true and false
+    logic2 = true or false
+    logic3 = not false
+    strict_and = true && false
+    strict_or = true || false
+    strict_not = !nil
+    pipe = "hello" |> String.upcase() |> String.reverse()
+    equality = 1 == 1.0
+    strict_eq = 1 === 1
+
+    # --- Pattern matching ---
+    {a, b, c} = {1, 2, 3}
+    [head | tail] = [1, 2, 3, 4]
+    %{name: name} = %{name: "Alice", age: 30}
+    ^integer = 42  # Pin operator
+
+    # --- Control flow ---
+    # If/else
+    if integer > 0 do
+      IO.puts("positive")
+    else
+      IO.puts("non-positive")
+    end
+
+    # Unless
+    unless integer == 0 do
+      IO.puts("not zero")
+    end
+
+    # Case
+    case {1, 2, 3} do
+      {1, x, 3} when x > 0 ->
+        IO.puts("matched: #{x}")
+      _ ->
+        IO.puts("no match")
+    end
+
+    # Cond
+    cond do
+      integer > 100 -> IO.puts("big")
+      integer > 0 -> IO.puts("positive")
+      true -> IO.puts("other")
+    end
+
+    # With
+    with {:ok, result} <- safe_divide(10, 3),
+         formatted <- Float.round(result, 2) do
+      IO.puts("Result: #{formatted}")
+    else
+      {:error, reason} -> IO.puts("Error: #{reason}")
+    end
+
+    # --- Loops (recursion + Enum) ---
+    Enum.each(1..5, fn i ->
+      IO.puts(i)
+    end)
+
+    doubled = Enum.map(list, &(&1 * 2))
+    evens = Enum.filter(list, &(rem(&1, 2) == 0))
+    total = Enum.reduce(list, 0, &(&1 + &2))
+
+    # Comprehension
+    for x <- 1..10, rem(x, 2) == 0, do: x * x
+    for {k, v} <- map, into: %{}, do: {k, "#{v}!"}
+
+    # --- Anonymous functions ---
+    square = fn x -> x * x end
+    result = square.(5)
+
+    multi = fn
+      0 -> "zero"
+      n when n > 0 -> "positive"
+      _ -> "negative"
+    end
+
+    # Capture operator
+    double = &(&1 * 2)
+    add_fn = &add/2
+
+    # --- Try / Rescue / Catch ---
+    try do
+      raise "Something went wrong"
+    rescue
+      e in RuntimeError ->
+        IO.puts("Caught: #{e.message}")
+    catch
+      :throw, value ->
+        IO.puts("Caught throw: #{value}")
+    after
+      IO.puts("cleanup")
+    end
+
+    # --- Processes ---
+    pid = spawn(fn -> IO.puts("spawned") end)
+    send(pid, {:hello, "world"})
+
+    receive do
+      {:hello, msg} ->
+        IO.puts("Got: #{msg}")
+    after
+      1000 ->
+        IO.puts("timeout")
+    end
+
+    # --- Structs ---
+    user = %User{name: "Alice", age: 30}
+    updated = %{user | age: 31}
+    IO.puts("#{user.name} is #{user.age}")
+
+    # --- Bitstrings ---
+    <<a::8, b::8, rest::binary>> = "Hello"
+    bits = <<1::1, 0::1, 1::1>>
+
+    # --- Protocols ---
+    # (defined separately)
+
+    :ok
+  end
+end
+
+# --- Protocol ---
+defprotocol Displayable do
+  @doc "Convert to display string"
+  def display(value)
+end
+
+defimpl Displayable, for: Integer do
+  def display(value), do: "Integer: #{value}"
+end
+
+defimpl Displayable, for: BitString do
+  def display(value), do: "String: #{value}"
+end
+
+# --- Macros ---
+defmodule MyMacro do
+  defmacro unless(condition, do: block) do
+    quote do
+      if !unquote(condition) do
+        unquote(block)
+      end
+    end
+  end
+end
+
+# --- Use / Import / Alias / Require ---
+defmodule Consumer do
+  alias Sample.Point
+  alias Sample.User, as: U
+  import Enum, only: [map: 2, filter: 2]
+  require Logger
+  use GenServer
+
+  def init(state) do
+    {:ok, state}
+  end
+end
+
+# --- GenServer example ---
+defmodule Counter do
+  use GenServer
+
+  # Client API
+  def start_link(initial \\ 0) do
+    GenServer.start_link(__MODULE__, initial, name: __MODULE__)
+  end
+
+  def increment, do: GenServer.cast(__MODULE__, :increment)
+  def get_count, do: GenServer.call(__MODULE__, :get)
+
+  # Server callbacks
+  @impl true
+  def init(count), do: {:ok, count}
+
+  @impl true
+  def handle_cast(:increment, count), do: {:noreply, count + 1}
+
+  @impl true
+  def handle_call(:get, _from, count), do: {:reply, count, count}
+end