kapusta 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f08d47c985c44cde4016b3f4188f1a59a4a4b72ae752d3876af8ab7c66c12069
-  data.tar.gz: d9b96c75f4a99de5bbdb9e7bdbdf258bfda5bf7791d13ffe2d115a655627f8b0
+  metadata.gz: 25c55d7f1c7a4b1dcd3cca0e7a513a74591905e9dfc97e96f015b695d75905a2
+  data.tar.gz: '0940fc49053103149667dd8bf515e159d87a10182bb3fbd5eb152ba63f487e06'
 SHA512:
-  metadata.gz: f936f5546667301b2bf9a96f0a16f8b61f6ea0b6fefc6c10a87c8a794b60b376274d2672b24e2a23b269adc3d932d418442dfdbce6d8957569a6ae426d0a3a4f
-  data.tar.gz: fb523b8572d114ee9e5b87c4a993607b9ab610a82f3aa0886a1465064877d956768fde168f7e58e2cfe2f31cddc8efddf82473d6addeab97f7c112d8d1fadcbb
+  metadata.gz: a3a8cb442fcb6d5157dcf3885e9d6a7323735418e488715e35baea0006b098e8822b8252013eea2636f96a35665db8173556507af293188f632108827f8119d5
+  data.tar.gz: d0f19cbc23c569524cb64c0b70b14d4ea5ed149291acad18528611a7b12c2ff1b4d9c27ce1a239ec07e9c19bb36c5907f294fbca4b0b783bfc2991c880b93fc7

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.
 

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