janet_sandbox 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37d030736271dabc94ac931ad2cd3af8c5cfc1ccf8570b47cba5ab1c5c9c3907
-  data.tar.gz: fbd1407297ff9a11c2c561e262c368d404363c6097e936e76940d6b5dff6ec4f
+  metadata.gz: 5adec66ce21c7b331ee3909c772e72d400344d3290a3476dbcf227244a5d0ba1
+  data.tar.gz: c7b59916442200fe158320af167ec5eca20bc5e00b8eed23d9fd48520178ecad
 SHA512:
-  metadata.gz: 4fcf025e8c2f3ae4b40db1e459d15ffa6e07188a758eb0c98c9254ad043aef99aa406b4e7539b521afd2cd221550fd5cfbba85d14eceee2226a2de67be7424fc
-  data.tar.gz: c2b3a8624af767fbeff5bf457008337b999b6a1c0a542d22f3a85ceac8bdc3a6cec762de22360ca4cc66026652a3a59241289e7d6fa9050c55d73cf0f3220ac9
+  metadata.gz: 760a3cdf9d5c816f97b9eb1b537863a2ddbf0efe3d53c57ae285afadc15f1b50616d17fab7e022f70eccc3645a478f688eac8acfcace1f51e5f3897c6174cefa
+  data.tar.gz: 957146cdd157de22c3f5dda4f4ac7bfdda7782efe52962dcb32d07bdacecfe95b6d49643eaedd154b6c1b70f81735b4672c038b2e7331151294ffaa54090b36a

data/lib/janet_sandbox/dsls/code_inspector.janet

@@ -0,0 +1,283 @@
+# Code Inspector DSL
+#
+# Provides functions for parsing and inspecting Janet code structure
+# without executing it. Useful for building visual logic editors,
+# syntax validators, and code analysis tools.
+# This also provides a way to take that tree and turn it back into source text.
+#
+# Register in your application:
+#
+#   JanetSandbox.configure do |config|
+#     config.register_dsl(:code_inspector, JanetSandbox::BuiltinDsls::CODE_INSPECTOR)
+#     config.enable_dsl(:code_inspector)
+#   end
+
+(defn- node-type [node]
+  "Determine the type string for a Janet value"
+  (cond
+    (tuple? node)   (if (= (tuple/type node) :brackets) "array" "call")
+    (array? node)   "array"
+    (struct? node)  "struct"
+    (table? node)   "table"
+    (symbol? node)  "symbol"
+    (keyword? node) "keyword"
+    (number? node)  "number"
+    (string? node)  "string"
+    (boolean? node) "boolean"
+    (nil? node)     "nil"
+    (fiber? node)   "fiber"
+    (function? node) "function"
+    (cfunction? node) "cfunction"
+    (buffer? node)  "buffer"
+    "unknown"))
+
+(defn to-tree [node]
+  "Convert a Janet value into a structured tree representation.
+
+   Returns a table with :type and type-specific fields:
+   - call: {:type \"call\" :op <string> :args [<children>]}
+   - array: {:type \"array\" :items [<children>]}
+   - struct/table: {:type \"struct\"|\"table\" :pairs [{:key <tree> :value <tree>} ...]}
+   - symbol: {:type \"symbol\" :name <string>}
+   - keyword: {:type \"keyword\" :name <string>}
+   - number: {:type \"number\" :value <number>}
+   - string: {:type \"string\" :value <string>}
+   - boolean: {:type \"boolean\" :value <boolean>}
+   - nil: {:type \"nil\"}
+
+   Example:
+     (to-tree (parse \"(if (> x 3) (foo) (bar))\"))
+     # => {:type \"call\" :op \"if\" :args [...]}"
+  (def t (node-type node))
+  (case t
+    "call"
+    {:type "call"
+     :op (string (first node))
+     :args (map to-tree (tuple/slice node 1))}
+
+    "array"
+    {:type "array"
+     :items (map to-tree node)}
+
+    "struct"
+    {:type "struct"
+     :pairs (seq [[k v] :pairs node]
+              {:key (to-tree k) :value (to-tree v)})}
+
+    "table"
+    {:type "table"
+     :pairs (seq [[k v] :pairs node]
+              {:key (to-tree k) :value (to-tree v)})}
+
+    "symbol"
+    {:type "symbol" :name (string node)}
+
+    "keyword"
+    {:type "keyword" :name (string node)}
+
+    "number"
+    {:type "number" :value node}
+
+    "string"
+    {:type "string" :value node}
+
+    "boolean"
+    {:type "boolean" :value node}
+
+    "nil"
+    {:type "nil"}
+
+    # fallback
+    {:type t :value (string node)}))
+
+(defn parse-to-tree [code-string]
+  "Parse a Janet code string and return its tree representation.
+
+   Example:
+     (parse-to-tree \"(if (> x 3) (some-function) (other-function))\")
+     # => {:type \"call\" :op \"if\" :args [
+     #      {:type \"call\" :op \">\" :args [
+     #        {:type \"symbol\" :name \"x\"}
+     #        {:type \"number\" :value 3}]}
+     #      {:type \"call\" :op \"some-function\" :args []}
+     #      {:type \"call\" :op \"other-function\" :args []}]}"
+  (to-tree (parse code-string)))
+
+(defn parse-all-to-tree [code-string]
+  "Parse a Janet code string containing multiple expressions
+   and return an array of tree representations.
+
+   Example:
+     (parse-all-to-tree \"(def x 1) (+ x 2)\")
+     # => [{:type \"call\" :op \"def\" ...} {:type \"call\" :op \"+\" ...}]"
+  (def p (parser/new))
+  (parser/consume p code-string)
+  (def results @[])
+  (while (parser/has-more p)
+    (array/push results (to-tree (parser/produce p))))
+  results)
+
+(defn extract-symbols [node]
+  "Extract all symbol names referenced in a parsed expression.
+   Returns an array of unique symbol name strings.
+
+   Example:
+     (extract-symbols (parse \"(if (> x y) (foo x) (bar y))\"))
+     # => [\"if\" \">\" \"x\" \"y\" \"foo\" \"bar\"]"
+  (def seen @{})
+  (def results @[])
+
+  (defn walk [n]
+    (cond
+      (symbol? n)
+      (let [name (string n)]
+        (unless (seen name)
+          (put seen name true)
+          (array/push results name)))
+
+      (tuple? n)
+      (each child n (walk child))
+
+      (array? n)
+      (each child n (walk child))
+
+      (or (struct? n) (table? n))
+      (eachp [k v] n
+        (walk k)
+        (walk v))))
+
+  (walk node)
+  results)
+
+(defn extract-calls [node]
+  "Extract all function/macro call names from a parsed expression.
+   Returns an array of unique call names (first element of each parentheses tuple).
+   Does not include bracket tuples (e.g., parameter lists like [x y]).
+
+   Example:
+     (extract-calls (parse \"(if (> x 3) (foo) (bar))\"))
+     # => [\"if\" \">\" \"foo\" \"bar\"]"
+  (def seen @{})
+  (def results @[])
+
+  (defn walk [n]
+    (when (tuple? n)
+      # Only process parentheses tuples (actual calls), not bracket tuples
+      (when (= (tuple/type n) :parens)
+        (when (and (> (length n) 0) (symbol? (first n)))
+          (let [name (string (first n))]
+            (unless (seen name)
+              (put seen name true)
+              (array/push results name)))))
+      (each child n (walk child))))
+
+  (walk node)
+  results)
+
+(defn- escape-string [s]
+  "Escape a string for Janet source output"
+  (def buf @"")
+  (each byte s
+    (case byte
+      (chr "\"") (buffer/push buf "\\\"")
+      (chr "\\") (buffer/push buf "\\\\")
+      (chr "\n") (buffer/push buf "\\n")
+      (chr "\r") (buffer/push buf "\\r")
+      (chr "\t") (buffer/push buf "\\t")
+      (buffer/push buf byte)))
+  (string buf))
+
+(defn tree-to-source [tree]
+  "Convert a tree representation back to Janet source code.
+   This is the inverse of parse-to-tree.
+
+   Example:
+     (tree-to-source {:type \"call\" :op \"+\" :args [
+       {:type \"number\" :value 1}
+       {:type \"number\" :value 2}]})
+     # => \"(+ 1 2)\"
+
+     (def tree (parse-to-tree \"(if (> x 3) (foo) (bar))\"))
+     (tree-to-source tree)
+     # => \"(if (> x 3) (foo) (bar))\""
+  (case (tree :type)
+    "call"
+    (let [op (tree :op)
+          args (tree :args)]
+      (if (empty? args)
+        (string "(" op ")")
+        (string "(" op " " (string/join (map tree-to-source args) " ") ")")))
+
+    "array"
+    (let [items (tree :items)]
+      (if (empty? items)
+        "[]"
+        (string "[" (string/join (map tree-to-source items) " ") "]")))
+
+    "struct"
+    (let [pairs (tree :pairs)]
+      (if (empty? pairs)
+        "{}"
+        (string "{"
+                (string/join
+                  (map (fn [p] (string (tree-to-source (p :key)) " " (tree-to-source (p :value))))
+                       pairs)
+                  " ")
+                "}")))
+
+    "table"
+    (let [pairs (tree :pairs)]
+      (if (empty? pairs)
+        "@{}"
+        (string "@{"
+                (string/join
+                  (map (fn [p] (string (tree-to-source (p :key)) " " (tree-to-source (p :value))))
+                       pairs)
+                  " ")
+                "}")))
+
+    "symbol"
+    (tree :name)
+
+    "keyword"
+    (string ":" (tree :name))
+
+    "number"
+    (string (tree :value))
+
+    "string"
+    (string "\"" (escape-string (tree :value)) "\"")
+
+    "boolean"
+    (if (tree :value) "true" "false")
+
+    "nil"
+    "nil"
+
+    # fallback for unknown types
+    (string "<unknown:" (tree :type) ">")))
+
+(defn validate-syntax [code-string]
+  "Check if a code string is syntactically valid Janet.
+   Returns {:valid true} on success, or {:valid false :error <message>} on failure.
+
+   Example:
+     (validate-syntax \"(+ 1 2)\")  # => {:valid true}
+     (validate-syntax \"(+ 1 2\")   # => {:valid false :error \"...\"}"
+  (def p (parser/new))
+  (def [ok err] (protect (parser/consume p code-string)))
+  (cond
+    # Parse error during consume
+    (not ok)
+    {:valid false :error (string err)}
+
+    # Check for parser errors
+    (parser/error p)
+    {:valid false :error (parser/error p)}
+
+    # Check for incomplete input (unclosed parens, strings, etc.)
+    (not= (parser/status p) :root)
+    {:valid false :error (string "unexpected end of input, parser status: " (parser/status p))}
+
+    # All good
+    {:valid true}))

data/lib/janet_sandbox/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JanetSandbox
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: janet_sandbox
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Michael Harris
@@ -91,6 +91,7 @@ files:
 - lib/janet_sandbox.rb
 - lib/janet_sandbox/builtin_dsls.rb
 - lib/janet_sandbox/configuration.rb
+- lib/janet_sandbox/dsls/code_inspector.janet
 - lib/janet_sandbox/engine.rb
 - lib/janet_sandbox/errors.rb
 - lib/janet_sandbox/rails/railtie.rb