kapusta 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f08d47c985c44cde4016b3f4188f1a59a4a4b72ae752d3876af8ab7c66c12069
-  data.tar.gz: d9b96c75f4a99de5bbdb9e7bdbdf258bfda5bf7791d13ffe2d115a655627f8b0
+  metadata.gz: 62ac0b0f6d3ce6116b82110191b5c36783ed1689e2567076dbe68fc66e6ab3f7
+  data.tar.gz: 6b705edf9d441c4f753e8420b0e8bc6a2327d91f6ab9041a603c3afe6546487b
 SHA512:
-  metadata.gz: f936f5546667301b2bf9a96f0a16f8b61f6ea0b6fefc6c10a87c8a794b60b376274d2672b24e2a23b269adc3d932d418442dfdbce6d8957569a6ae426d0a3a4f
-  data.tar.gz: fb523b8572d114ee9e5b87c4a993607b9ab610a82f3aa0886a1465064877d956768fde168f7e58e2cfe2f31cddc8efddf82473d6addeab97f7c112d8d1fadcbb
+  metadata.gz: 243b1e47fd6a5684f7b4d2a9bf46e27d6b96883fb3cf71bf4f90edb4d48f0e5afa006c2da0191f5fc3cb116e37b506243b0f7030b90a6c6096629173e98074de
+  data.tar.gz: 825b21b71cb0eacb24623beff28dc2fcb1b542cf50268d78ebcfba2b156bf634992975fb1f1a3a0e27f407c51e54c8eb96683d544f861de5f5cc51731fc819c3

data/README.md

@@ -2,7 +2,7 @@
 
 Kapusta is a Lisp for the Ruby runtime.
 
-It is inspired by Fennel. It is not intended to be production-ready like Clojure: that would be a lot of work, and Ruby is already a rich, elegant language.
+It is inspired by [Fennel](https://fennel-lang.org). It is not intended to be production-ready like Clojure: that would be a lot of work, and Ruby is already a rich, elegant language.
 
 Instead, Kapusta aims to bring some of the simplicity and joy of Lisp to Ruby. Where Lua is intentionally minimal, and Fennel follows that design for good reason, Kapusta exists mostly for fun. You can use it for small apps, LeetCode, DragonRuby, or maybe even Rails.
 
@@ -10,6 +10,14 @@ For more information about Kapusta, see the official Fennel documentation and tu
 
 ## Usage
 
+```
+gem install kapusta
+kapfmt --fix examples/fizzbuzz.kap
+kapusta examples/fizzbuzz.kap
+```
+
+or
+
 ```
 exe/kapusta examples/fizzbuzz.kap
 ```
@@ -37,7 +45,7 @@ Kapusta keeps most core Fennel forms. The main differences come from Ruby's runt
 Kapusta-specific additions:
 
 - `module` and `class` for Ruby host structure, including file-header forms
-- `ivar` / `cvar` / `gvar` escape hatches
+- `ivar` (`@var`) / `cvar` (`@@var`) / `gvar` (`$var`) escape hatches
 - `try` / `catch` / `finally` plus `raise` for exceptions
 - `(ruby "...")` raw host escape hatch
 - a trailing symbol-keyed hash is emitted as Ruby keyword arguments

data/examples/accumulator.kap

@@ -13,4 +13,4 @@
 (let [acc (Accumulator.new 10)]
   (acc.add! 5)
   (acc.add! 7)
-  (puts (acc.value)))
+  (print (acc.value)))

data/examples/anagram.kap

@@ -8,6 +8,6 @@
   (= (normalize-word a)
     (normalize-word b)))
 
-(puts (anagram? "listen" "silent"))
-(puts (anagram? "apple" "papel"))
-(puts (anagram? "hello" "world"))
+(print (anagram? "listen" "silent"))
+(print (anagram? "apple" "papel"))
+(print (anagram? "hello" "world"))

data/examples/binary-search.kap

@@ -12,5 +12,5 @@
 
 (let [found (binary-search [1 3 5 7 9 11] 7)
       missing (binary-search [1 3 5 7 9 11] 2)]
-  (puts found)
-  (puts (missing.inspect)))
+  (print found)
+  (print missing))

data/examples/block-sort.kap

@@ -1,3 +1,3 @@
 (let [xs [3 1 2]
       sorted (xs.sort (fn [a b] (b.<=> a)))]
-  (puts (sorted.join ", ")))
+  (print (sorted.join ", ")))

data/examples/blocks-and-kwargs.kap

@@ -0,0 +1,20 @@
+(require "fileutils")
+
+(let [tmp-dir (File.expand_path "tmp" Dir.pwd)
+      path (File.join tmp-dir "blocks-and-kwargs.txt")]
+  (try
+    (do
+      (FileUtils.mkdir_p tmp-dir)
+      (File.open path
+        "w"
+        {:encoding "UTF-8"}
+        (fn [io] (: io :write "Ada\nLin\n")))
+      (File.open path
+        "r"
+        {:encoding "UTF-8"}
+        (fn [io]
+          (let [content (: io :read)]
+            (print (content.strip))
+            (print (length (content.lines)))))))
+    (finally
+      (FileUtils.rm_f path))))

data/examples/calc.kap

@@ -7,4 +7,4 @@
     [:div a b] (/ (eval-expr a) (eval-expr b))
     _ (raise (ArgumentError.new (.. "unknown op: " (expr.inspect))))))
 
-(puts (eval-expr [:add [:num 2] [:mul [:num 3] [:num 4]]]))
+(print (eval-expr [:add [:num 2] [:mul [:num 3] [:num 4]]]))

data/examples/counter.kap

@@ -16,4 +16,4 @@
 (let [c (Counter.new 10)]
   (c.tick)
   (c.tick)
-  (puts (c.value)))
+  (print (c.value)))

data/examples/doto.kap

@@ -1,2 +1,2 @@
 (let [xs (doto [] (: :push 1) (: :push 2) (: :push 3))]
-  (puts (xs.join ", ")))
+  (print (xs.join ", ")))

data/examples/even-squares.kap

@@ -4,4 +4,4 @@
       (: :select (fn [n] (n.even?)))
       (: :map (fn [n] (* n n))))
 ]
-  (puts (even-squares.join ", ")))
+  (print (even-squares.join ", ")))

data/examples/exceptions.kap

@@ -8,7 +8,7 @@
     (catch ArgumentError e
       (.. "bad: " s))
     (finally
-      (puts (.. "seen: " s)))))
+      (print (.. "seen: " s)))))
 
 (each [_ s (ipairs ["12" "oops"])]
-  (puts (parse-score s)))
+  (print (parse-score s)))

data/examples/files.kap

@@ -0,0 +1,13 @@
+(require "fileutils")
+
+(let [tmp-dir (File.expand_path "tmp" Dir.pwd)
+      path (File.join tmp-dir "file-io-example.txt")
+      body "Ada\nLin"]
+  (try
+    (do
+      (FileUtils.mkdir_p tmp-dir)
+      (File.write path body)
+      (print (File.read path))
+      (print (length (File.readlines path))))
+    (finally
+      (FileUtils.rm_f path))))

data/examples/greet.kap

@@ -1,2 +1,2 @@
 (let [name (or (. ARGV 0) "world")]
-  (puts (.. "Hello, " name "!")))
+  (print (.. "Hello, " name "!")))

data/examples/inheritance.kap

@@ -0,0 +1,13 @@
+(let [animal-class (class Zoo.Animal
+                     (fn initialize [name] (set (ivar name) name))
+                     (fn name [] (ivar name))
+                     (fn kingdom [] "animalia")
+                     (fn label [] (.. (self.name) " the animal")))
+      dog-class (class Zoo.Dog [Zoo.Animal]
+                  (fn label [] (.. (self.name) " the dog"))
+                  (fn bark [] "woof"))
+      dog (dog-class.new "Poppy")]
+  (print (= dog-class.superclass animal-class)
+    (dog.kingdom)
+    (dog.label)
+    (dog.bark)))

data/examples/kwargs.kap

@@ -1 +1 @@
-(puts (format "%<name>s has %<count>d tasks" {:name "Ada" :count 3}))
+(print (format "%<name>s has %<count>d tasks" {:name "Ada" :count 3}))

data/examples/match.kap

@@ -4,6 +4,6 @@
     {: name} (.. name ": no score")
     _ "unknown"))
 
-(puts (describe-user {:name "Ada" :stats {:score 9}}))
-(puts (describe-user {:name "Lin"}))
-(puts (describe-user {}))
+(print (describe-user {:name "Ada" :stats {:score 9}}))
+(print (describe-user {:name "Lin"}))
+(print (describe-user {}))

data/examples/module-header.kap

@@ -1,6 +1,7 @@
+; File header forms map directly to Ruby modules.
 (module HeaderDemo)
 
 (fn self.greet [name]
   (.. "Hello, " name "!"))
 
-(puts (self.greet "Ada"))
+(print (self.greet "Ada"))

data/examples/palindrome.kap

@@ -3,6 +3,6 @@
         normalized (lower.gsub (ruby "/[^a-z]/") "")]
     (= normalized (normalized.reverse))))
 
-(puts (palindrome? "racecar"))
-(puts (palindrome? "A man, a plan, a canal: Panama"))
-(puts (palindrome? "kapusta"))
+(print (palindrome? "racecar"))
+(print (palindrome? "A man, a plan, a canal: Panama"))
+(print (palindrome? "kapusta"))

data/examples/pangram.kap

@@ -5,5 +5,5 @@
         uniq (chars.uniq)]
     (= (uniq.length) 26)))
 
-(puts (pangram? "The quick brown fox jumps over the lazy dog"))
-(puts (pangram? "Hello, world"))
+(print (pangram? "The quick brown fox jumps over the lazy dog"))
+(print (pangram? "Hello, world"))

data/examples/pcall.kap

@@ -1,9 +1,9 @@
 (let [[ok value] (pcall Integer "12")
       [bad-ok error] (pcall Integer "oops")
       [handled-ok handled] (xpcall Integer (fn [e] (e.message)) "oops")]
-  (puts ok)
-  (puts value)
-  (puts bad-ok)
-  (puts (error.class))
-  (puts handled-ok)
-  (puts handled))
+  (print ok)
+  (print value)
+  (print bad-ok)
+  (print (error.class))
+  (print handled-ok)
+  (print handled))

data/examples/pipeline.kap

@@ -1,6 +1,9 @@
+; Pipelines stay readable as stages stack up.
 (let [words ["red" "green" "blue" "black" "olive"]]
+  ; Filter first so later stages stay focused.
   (-> words
+      ; Keep the shorter words before transforming them.
       (: :select (fn [w] (< (length w) 5)))
       (: :map (fn [w] (w.upcase)))
       (: :sort)
-      (: :each (fn [w] (puts w)))))
+      (: :each (fn [w] (print w)))))

data/examples/points.kap

@@ -6,4 +6,4 @@
     [_ _] "point"))
 
 (each [_ point (ipairs [[0 0] [0 2] [3 0] [3 4]])]
-  (puts (point-kind point)))
+  (print (point-kind point)))

data/examples/record.kap

@@ -3,4 +3,4 @@
     (.. name " / " role " / " (tags.join ", "))))
 
 (let [record {:name "Ada" :role "engineer" :tags ["ruby" "lisp"]}]
-  (puts (format-record record)))
+  (print (format-record record)))

data/examples/regex.kap

@@ -1,9 +1,11 @@
 (fn parse-date [s]
   (let [re (ruby "/\\A(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})\\z/")]
+    ; Match YYYY-MM-DD and expose the named captures.
     (case (re.match s)
       nil nil
       m (m.named-captures))))
 
 (each [_ s (ipairs ["2026-04-23" "hello" "1999-12-31"])]
+  ; Show both successful and failed parses.
   (let [parsed (parse-date s)]
-    (puts (.. s " -> " (parsed.inspect)))))
+    (print (.. s " -> " parsed))))

data/examples/ruby-eval.kap

@@ -1 +1 @@
-(puts (ruby "[1, 2, 3].map { _1 * 10 }.join('-')"))
+(print (ruby "[1, 2, 3].map { _1 * 10 }.join('-')"))

data/examples/safe-lookup.kap

@@ -2,5 +2,5 @@
       missing {}
       name (?. user :profile :name)
       missing-name (?. missing :profile :name)]
-  (puts name)
-  (puts (missing-name.inspect)))
+  (print name)
+  (print missing-name))

data/examples/scopes.kap

@@ -12,7 +12,7 @@
 
 (let [a (ScopeCounter.new)
       b (ScopeCounter.new)]
-  (puts (a.add! 5))
-  (puts (b.add! 4))
-  (puts (ScopeCounter.total))
-  (puts (gvar last-total)))
+  (print (a.add! 5))
+  (print (b.add! 4))
+  (print (ScopeCounter.total))
+  (print (gvar last-total)))

data/examples/threading.kap

@@ -0,0 +1,28 @@
+(fn append [suffix value]
+  (.. value suffix))
+
+(fn wrap [left right value]
+  (.. left value right))
+
+(fn fetch-name [user]
+  (?. user :profile :name))
+
+(let [thread-last (->> "Ada"
+                       (append " Lovelace")
+                       (wrap "[" "]")
+                       (append "!"))
+      maybe-name (-?>> {:profile {:name "Ada"}}
+                       (fetch-name)
+                       (append "!")
+                       (wrap "<" ">"))
+      missing-name (-?>> {:profile nil}
+                         (fetch-name)
+                         (append "!")
+                         (wrap "<" ">"))
+      thread-first (-?> "kapusta"
+                        (: :upcase)
+                        (: :reverse))
+      missing-first (-?> nil
+                         (: :upcase)
+                         (: :reverse))]
+  (print thread-last maybe-name missing-name thread-first missing-first))

data/examples/tset.kap

@@ -1,4 +1,4 @@
 (let [person {:name "Ada"}]
   (tset person :city "Amsterdam")
-  (puts (person.inspect))
-  (puts (. person :city)))
+  (print person)
+  (print (. person :city)))

data/examples/two-sum.kap

@@ -12,6 +12,6 @@
 (let [first-pair (two-sum [2 7 11 15] 9)
       second-pair (two-sum [3 2 4] 6)
       missing-pair (two-sum [1 2 3] 10)]
-  (puts (first-pair.inspect))
-  (puts (second-pair.inspect))
-  (puts (missing-pair.inspect)))
+  (print first-pair)
+  (print second-pair)
+  (print missing-pair))

data/kapusta.gemspec

@@ -6,12 +6,16 @@ Gem::Specification.new do |spec|
   spec.name = 'kapusta'
   spec.version = Kapusta::VERSION
   spec.authors = ['Evgenii Morozov']
+  spec.homepage = 'https://github.com/evmorov/kapusta'
 
   spec.summary = 'A Lisp for the Ruby runtime'
   spec.description = 'Kapusta is a Lisp for the Ruby runtime.'
   spec.required_ruby_version = '>= 3.1'
 
   spec.metadata['rubygems_mfa_required'] = 'true'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
 
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").select do |path|

data/lib/kapusta/ast.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
 module Kapusta
+  class Comment
+    attr_reader :text
+
+    def initialize(text)
+      @text = text
+    end
+  end
+
   class Sym
     attr_reader :name
 
@@ -43,14 +51,18 @@ module Kapusta
   end
 
   class HashLit
-    attr_reader :pairs
+    attr_reader :entries
+
+    def initialize(entries)
+      @entries = entries
+    end
 
-    def initialize(pairs)
-      @pairs = pairs
+    def pairs
+      @entries.grep(Array)
     end
 
     def all_sym_keys?
-      @pairs.all? { |key, _| key.is_a?(Symbol) }
+      pairs.all? { |key, _| key.is_a?(Symbol) }
     end
   end
 

data/lib/kapusta/cli.rb

@@ -5,7 +5,7 @@ require 'optparse'
 
 module Kapusta
   class CLI
-    Options = Struct.new(:compile, :help, keyword_init: true)
+    Options = Struct.new(:compile, :help, :version, keyword_init: true)
 
     def self.start(argv = ARGV)
       args = argv.dup
@@ -16,6 +16,11 @@ module Kapusta
         return
       end
 
+      if options.version
+        $stdout.puts "kapusta #{Kapusta::VERSION}"
+        return
+      end
+
       if options.compile
         compile_file(args)
       else
@@ -24,12 +29,13 @@ module Kapusta
     end
 
     def self.parse_options(args)
-      options = Options.new(compile: false, help: false)
+      options = Options.new(compile: false, help: false, version: false)
 
       OptionParser.new do |parser|
         parser.banner = usage
         parser.on('-c', '--compile', 'Compile .kap to Ruby') { options.compile = true }
         parser.on('-h', '--help', 'Show this help') { options.help = true }
+        parser.on('-v', '--version', 'Show version') { options.version = true }
       end.order!(args)
 
       options