kapusta 0.1.0

data/lib/kapusta/reader.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Kapusta
+  class Reader
+    WHITESPACE = [' ', "\t", "\n", "\r", "\f", "\v", ','].freeze
+    DELIMS = ['(', ')', '[', ']', '{', '}', '"', ';'].freeze
+
+    def self.read_all(source)
+      new(source).read_all
+    end
+
+    def initialize(source)
+      @src = source
+      @pos = 0
+    end
+
+    def read_all
+      forms = []
+      loop do
+        skip_ws
+        break if eof?
+
+        forms << read_form
+      end
+      forms
+    end
+
+    private
+
+    def eof?
+      @pos >= @src.length
+    end
+
+    def peek
+      @src[@pos]
+    end
+
+    def advance
+      char = @src[@pos]
+      @pos += 1
+      char
+    end
+
+    def skip_ws
+      until eof?
+        char = peek
+        if WHITESPACE.include?(char)
+          advance
+        elsif char == ';'
+          advance until eof? || peek == "\n"
+        else
+          break
+        end
+      end
+    end
+
+    def delim?(char)
+      char.nil? || WHITESPACE.include?(char) || DELIMS.include?(char)
+    end
+
+    def read_form
+      skip_ws
+      raise 'unexpected eof' if eof?
+
+      form =
+        case peek
+        when '(' then read_list
+        when '[' then read_vec
+        when '{' then read_hash
+        when '"' then read_string
+        when '#' then read_hashfn
+        else
+          read_atom
+        end
+
+      read_postfix(form)
+    end
+
+    def read_list
+      advance
+      items = []
+      loop do
+        skip_ws
+        raise 'unclosed (' if eof?
+        break if peek == ')'
+
+        items << read_form
+      end
+      advance
+      List.new(items)
+    end
+
+    def read_vec
+      advance
+      items = []
+      loop do
+        skip_ws
+        raise 'unclosed [' if eof?
+        break if peek == ']'
+
+        items << read_form
+      end
+      advance
+      Vec.new(items)
+    end
+
+    def read_hash
+      advance
+      items = []
+      loop do
+        skip_ws
+        raise 'unclosed {' if eof?
+        break if peek == '}'
+
+        items << read_form
+      end
+      advance
+
+      pairs = []
+      i = 0
+      while i < items.length
+        item = items[i]
+        if item.is_a?(Sym) && item.name == ':'
+          sym = items[i + 1]
+          raise 'bad shorthand' unless sym.is_a?(Sym)
+
+          key = Kapusta.kebab_to_snake(sym.name).to_sym
+          pairs << [key, sym]
+        else
+          pairs << [item, items[i + 1]]
+        end
+        i += 2
+      end
+      HashLit.new(pairs)
+    end
+
+    def read_string
+      advance
+      buffer = +''
+      until eof? || peek == '"'
+        if peek == '\\'
+          advance
+          escaped = advance
+          buffer << case escaped
+                    when 'n' then "\n"
+                    when 't' then "\t"
+                    when 'r' then "\r"
+                    when '\\' then '\\'
+                    when '"' then '"'
+                    when '0' then "\0"
+                    when 'a' then "\a"
+                    when 'b' then "\b"
+                    when 'f' then "\f"
+                    when 'v' then "\v"
+                    else escaped
+                    end
+        else
+          buffer << advance
+        end
+      end
+      raise 'unterminated string' if eof?
+
+      advance
+      buffer
+    end
+
+    def read_hashfn
+      advance
+      form = read_form
+      List.new([Sym.new('hashfn'), form])
+    end
+
+    def read_postfix(form)
+      current = form
+
+      loop do
+        break unless peek == '.'
+
+        start = @pos
+        advance until delim?(peek)
+        token = @src[start...@pos]
+        break unless token.start_with?('.') && token.length > 1
+
+        token[1..].split('.').each do |name|
+          current = List.new([Sym.new(':'), current, Kapusta.kebab_to_snake(name).to_sym])
+        end
+      end
+
+      current
+    end
+
+    def read_atom
+      start = @pos
+      advance until delim?(peek)
+      token = @src[start...@pos]
+      raise 'empty token' if token.empty?
+
+      parse_atom(token)
+    end
+
+    def parse_atom(token)
+      return true if token == 'true'
+      return false if token == 'false'
+      return nil if token == 'nil'
+      return token.to_i if token.match?(/\A-?\d+\z/)
+      return token.to_f if token.match?(/\A-?\d+\.\d+\z/)
+
+      if token.start_with?(':') && token.length > 1
+        Kapusta.kebab_to_snake(token[1..]).to_sym
+      else
+        Sym.new(token)
+      end
+    end
+  end
+end

data/lib/kapusta/support.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Kapusta
+  def self.kebab_to_snake(name)
+    name.tr('-', '_')
+  end
+end

data/lib/kapusta/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kapusta
+  VERSION = '0.1.0'
+end

data/lib/kapusta.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'kapusta/version'
+require_relative 'kapusta/support'
+require_relative 'kapusta/ast'
+require_relative 'kapusta/reader'
+require_relative 'kapusta/env'
+require_relative 'kapusta/compiler'
+
+module Kapusta
+  def self.eval(source, path: '(eval)', **_opts)
+    Compiler.run(source, path:)
+  end
+
+  def self.dofile(path, **_opts)
+    source = File.read(path)
+    self.eval(source, path:)
+  end
+
+  def self.compile(source, path: '(eval)', **_opts)
+    Compiler.compile(source, path:)
+  end
+
+  def self.install!
+    @install ||= begin
+      require 'rubygems'
+      true
+    end
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'kapusta/cli'
+require 'open3'
+require 'rbconfig'
+require 'stringio'
+require 'tmpdir'
+
+def capture_stdout
+  previous_stdout = $stdout
+  $stdout = StringIO.new
+  yield
+  $stdout.string
+ensure
+  $stdout = previous_stdout
+end
+
+def capture_stderr
+  previous_stderr = $stderr
+  $stderr = StringIO.new
+  yield
+  $stderr.string
+ensure
+  $stderr = previous_stderr
+end
+
+RSpec.describe Kapusta::CLI do
+  it 'compiles a .kap file to stdout with --compile' do
+    path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    output = capture_stdout do
+      described_class.start(['--compile', path])
+    end
+
+    expect(output).to include('__kap_print_values("FizzBuzz")')
+    expect(output).not_to include('Kapusta::Compiler::Runtime')
+    expect(output).not_to include('module Kapusta')
+    expect(output).not_to include('def __kap_get_path')
+  end
+
+  it 'rejects extra positional arguments in compile mode' do
+    path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    error_output = capture_stderr do
+      expect { described_class.start(['--compile', path, 'fizzbuzz.rb']) }
+        .to raise_error(SystemExit)
+    end
+
+    expect(error_output).to include('usage: kapusta')
+  end
+
+  it 'emits standalone Ruby that runs with plain ruby' do
+    source_path = File.expand_path('../examples/fizzbuzz.kap', __dir__)
+
+    Dir.mktmpdir do |dir|
+      output_path = File.join(dir, 'fizzbuzz.rb')
+      ruby = Kapusta.compile(File.read(source_path), path: source_path)
+      File.write(output_path, ruby)
+
+      stdout, stderr, status = Open3.capture3(RbConfig.ruby, output_path)
+
+      expect(status.success?).to eq(true), stderr
+      expect(stdout).to include("FizzBuzz\n")
+    end
+  end
+
+  it 'passes remaining arguments through to the Kapusta program' do
+    path = File.expand_path('../examples/greet.kap', __dir__)
+
+    output = capture_stdout do
+      described_class.start([path, 'Ada'])
+    end
+
+    expect(output).to eq("Hello, Ada!\n")
+  end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'stringio'
+
+EXAMPLES_DIR = File.expand_path('../examples', __dir__)
+
+def run_example(name, argv: [])
+  previous_argv = ARGV.dup
+  previous_stdout = $stdout
+  ARGV.replace(argv)
+  $stdout = StringIO.new
+  Kapusta.dofile(File.join(EXAMPLES_DIR, name))
+  $stdout.string
+ensure
+  $stdout = previous_stdout
+  ARGV.replace(previous_argv)
+end
+
+RSpec.describe 'examples' do
+  it 'ackermann.kap' do
+    expect(run_example('ackermann.kap')).to eq("9\n61\n")
+  end
+
+  it 'accumulator.kap' do
+    expect(run_example('accumulator.kap')).to eq("22\n")
+  end
+
+  it 'anagram.kap' do
+    expect(run_example('anagram.kap')).to eq("true\ntrue\nfalse\n")
+  end
+
+  it 'calc.kap' do
+    expect(run_example('calc.kap')).to eq("14\n")
+  end
+
+  it 'binary-search.kap' do
+    expect(run_example('binary-search.kap')).to eq("3\nnil\n")
+  end
+
+  it 'block-sort.kap' do
+    expect(run_example('block-sort.kap')).to eq("3, 2, 1\n")
+  end
+
+  it 'counter.kap' do
+    expect(run_example('counter.kap')).to eq("12\n")
+  end
+
+  it 'doto.kap' do
+    expect(run_example('doto.kap')).to eq("1, 2, 3\n")
+  end
+
+  it 'describe.kap' do
+    expect(run_example('describe.kap')).to eq("-3\tnegative\n0\tzero\n1\tone\n2\tmany\n99\tmany\n")
+  end
+
+  it 'destructure.kap' do
+    expect(run_example('destructure.kap')).to eq("6\nAda\t36\n")
+  end
+
+  it 'egg-count.kap' do
+    expect(run_example('egg-count.kap')).to eq("4\n")
+  end
+
+  it 'even-squares.kap' do
+    expect(run_example('even-squares.kap')).to eq("4, 16, 36\n")
+  end
+
+  it 'exceptions.kap' do
+    expect(run_example('exceptions.kap')).to eq("seen: 12\n12\nseen: oops\nbad: oops\n")
+  end
+
+  it 'factorial.kap' do
+    expect(run_example('factorial.kap')).to eq("0\t1\n1\t1\n5\t120\n6\t720\n10\t3628800\n")
+  end
+
+  it 'fib.kap' do
+    expect(run_example('fib.kap')).to eq("55\n")
+  end
+
+  it 'fizzbuzz.kap' do
+    expected = "1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz\n16\n17\nFizz\n19\nBuzz\n"
+    expect(run_example('fizzbuzz.kap')).to eq(expected)
+  end
+
+  it 'gcd.kap' do
+    expect(run_example('gcd.kap')).to eq("12\n6\n")
+  end
+
+  it 'greet.kap' do
+    expect(run_example('greet.kap', argv: ['Ada'])).to eq("Hello, Ada!\n")
+  end
+
+  it 'hashfn.kap' do
+    expect(run_example('hashfn.kap')).to eq("5\n21\n")
+  end
+
+  it 'leap-year.kap' do
+    expect(run_example('leap-year.kap')).to eq("true\n")
+  end
+
+  it 'min-max.kap' do
+    expect(run_example('min-max.kap')).to eq("1\t9\n")
+  end
+
+  it 'module-header.kap' do
+    expect(run_example('module-header.kap')).to eq("Hello, Ada!\n")
+  end
+
+  it 'pipeline.kap' do
+    expect(run_example('pipeline.kap')).to eq("BLUE\nRED\n")
+  end
+
+  it 'points.kap' do
+    expect(run_example('points.kap')).to eq("origin\ny-axis\nx-axis\npoint\n")
+  end
+
+  it 'primes.kap' do
+    expect(run_example('primes.kap')).to eq("2\n3\n5\n7\n11\n13\n17\n19\n23\n29\n")
+  end
+
+  it 'raindrops.kap' do
+    expect(run_example('raindrops.kap')).to eq("PlingPlang\n")
+  end
+
+  it 'record.kap' do
+    expect(run_example('record.kap')).to eq("Ada / engineer / ruby, lisp\n")
+  end
+
+  it 'regex.kap' do
+    expected = <<~OUT
+      2026-04-23 -> {"year"=>"2026", "month"=>"04", "day"=>"23"}
+      hello -> nil
+      1999-12-31 -> {"year"=>"1999", "month"=>"12", "day"=>"31"}
+    OUT
+    expect(run_example('regex.kap')).to eq(expected)
+  end
+
+  it 'ruby-eval.kap' do
+    expect(run_example('ruby-eval.kap')).to eq("10-20-30\n")
+  end
+
+  it 'kwargs.kap' do
+    expect(run_example('kwargs.kap')).to eq("Ada has 3 tasks\n")
+  end
+
+  it 'match.kap' do
+    expect(run_example('match.kap')).to eq("Ada: 9\nLin: no score\nunknown\n")
+  end
+
+  it 'scopes.kap' do
+    expect(run_example('scopes.kap')).to eq("5\n9\n9\n9\n")
+  end
+
+  it 'pcall.kap' do
+    expected = <<~OUT
+      true
+      12
+      false
+      ArgumentError
+      false
+      invalid value for Integer(): "oops"
+    OUT
+    expect(run_example('pcall.kap')).to eq(expected)
+  end
+
+  it 'palindrome.kap' do
+    expect(run_example('palindrome.kap')).to eq("true\ntrue\nfalse\n")
+  end
+
+  it 'pangram.kap' do
+    expect(run_example('pangram.kap')).to eq("true\nfalse\n")
+  end
+
+  it 'safe-lookup.kap' do
+    expect(run_example('safe-lookup.kap')).to eq("Ada\nnil\n")
+  end
+
+  it 'shapes.kap' do
+    expect(run_example('shapes.kap')).to eq("78.5\n9\n8\n0\n")
+  end
+
+  it 'squares.kap' do
+    expect(run_example('squares.kap')).to eq("1\n4\n9\n16\n25\n")
+  end
+
+  it 'stack.kap' do
+    expect(run_example('stack.kap')).to eq('')
+  end
+
+  it 'sum.kap' do
+    expect(run_example('sum.kap')).to eq("100\n")
+  end
+
+  it 'tset.kap' do
+    expect(run_example('tset.kap')).to eq("{:name=>\"Ada\", :city=>\"Amsterdam\"}\nAmsterdam\n")
+  end
+
+  it 'two-sum.kap' do
+    expect(run_example('two-sum.kap')).to eq("[0, 1]\n[1, 2]\nnil\n")
+  end
+end
+
+RSpec.describe Kapusta do
+  it 'exposes a gem version' do
+    expect(Kapusta::VERSION).to match(/\A\d+\.\d+\.\d+\z/)
+  end
+
+  it 'defaults classes to Object when the superclass is omitted' do
+    source = <<~KAP
+      (let [klass (class Stack
+                    (fn initialize []
+                      nil))]
+        (values (= Stack.superclass Object)
+                (= (Stack.new.class) Stack)
+                (= klass Stack)))
+    KAP
+
+    expect(Kapusta.eval(source)).to eq([true, true, true])
+  end
+
+  it 'still accepts an explicit superclass vector' do
+    source = <<~KAP
+      (let [klass (class KapustaError [StandardError])]
+        (values (= KapustaError.superclass StandardError)
+                (= klass KapustaError)))
+    KAP
+
+    expect(Kapusta.eval(source)).to eq([true, true])
+  end
+
+  it 'preserves nested arithmetic precedence' do
+    source = <<~KAP
+      (values (/ (+ 3 5) 2)
+              (* (+ 1 2) (- 10 4))
+              (% (+ 10 5) 4))
+    KAP
+
+    expect(Kapusta.eval(source)).to eq([4, 18, 3])
+  end
+
+  it 'supports postfix zero-arg method calls on non-symbol expressions' do
+    source = <<~KAP
+      (values [1 2].inspect
+              (+ 1 2).inspect
+              "Listen".downcase.chars.sort.join)
+    KAP
+
+    expect(Kapusta.eval(source)).to eq(['[1, 2]', '3', 'eilnst'])
+  end
+end
+
+RSpec.describe 'errors' do
+  it 'raises on unclosed list' do
+    expect { Kapusta.eval('(fn hello [name] (.. "Hi " name "!")') }
+      .to raise_error(/unclosed \(/)
+  end
+end