srsh 0.8.0 → 1.0.0

data/docs/js/app.js

@@ -0,0 +1,203 @@
+(function () {
+  "use strict";
+
+  const repository = "https://github.com/RobertFlexx/RSH";
+  const api = "https://api.github.com/repos/RobertFlexx/RSH/releases/latest";
+  const pages = new Map();
+
+  document.querySelectorAll("[data-page]").forEach(function (page) {
+    pages.set(page.getAttribute("data-page"), page);
+  });
+
+  function routeFromHash() {
+    const raw = (window.location.hash || "#/").slice(1);
+    const pieces = raw.split("#");
+    const path = (pieces[0] || "/").replace(/^\//, "");
+    return {
+      page: path || "home",
+      anchor: pieces[1] || ""
+    };
+  }
+
+  function showRoute() {
+    const route = routeFromHash();
+    const pageName = pages.has(route.page) ? route.page : "home";
+
+    pages.forEach(function (page, name) {
+      page.classList.toggle("active", name === pageName);
+    });
+
+    document.querySelectorAll("[data-route]").forEach(function (link) {
+      const current = link.getAttribute("data-route") === pageName;
+      link.classList.toggle("current", current);
+      if (current) link.setAttribute("aria-current", "page");
+      else link.removeAttribute("aria-current");
+    });
+
+    const titles = {
+      home: "SRSH 1.0: Simple Ruby Shell",
+      manual: "RSH language manual | SRSH 1.0",
+      download: "Download SRSH 1.0",
+      examples: "RSH examples | SRSH 1.0",
+      project: "Project information | SRSH 1.0"
+    };
+    document.title = titles[pageName] || titles.home;
+
+    document.querySelectorAll(".toc a").forEach(function (link) {
+      link.classList.toggle("current", Boolean(route.anchor) && link.getAttribute("href").endsWith("#" + route.anchor));
+    });
+
+    if (route.anchor) {
+      window.setTimeout(function () {
+        const target = document.getElementById(route.anchor);
+        if (target) target.scrollIntoView({ block: "start" });
+      }, 0);
+    } else {
+      window.scrollTo(0, 0);
+    }
+  }
+
+  window.addEventListener("hashchange", showRoute);
+  showRoute();
+
+  const notice = document.querySelector("[data-copy-notice]");
+  let noticeTimer;
+
+  function showNotice(message) {
+    if (!notice) return;
+    notice.textContent = message;
+    notice.hidden = false;
+    window.clearTimeout(noticeTimer);
+    noticeTimer = window.setTimeout(function () {
+      notice.hidden = true;
+    }, 1400);
+  }
+
+  function fallbackCopy(text) {
+    const field = document.createElement("textarea");
+    field.value = text;
+    field.setAttribute("readonly", "");
+    field.style.position = "fixed";
+    field.style.left = "-10000px";
+    document.body.appendChild(field);
+    field.select();
+
+    try {
+      document.execCommand("copy");
+      showNotice("Copied.");
+    } catch (error) {
+      showNotice("Copy failed.");
+    }
+
+    field.remove();
+  }
+
+  document.addEventListener("click", function (event) {
+    const button = event.target.closest("[data-copy-target]");
+    if (!button) return;
+
+    const target = document.getElementById(button.getAttribute("data-copy-target"));
+    if (!target) return;
+    const text = target.textContent.replace(/\n$/, "");
+
+    if (navigator.clipboard && window.isSecureContext) {
+      navigator.clipboard.writeText(text).then(function () {
+        showNotice("Copied.");
+      }).catch(function () {
+        fallbackCopy(text);
+      });
+    } else {
+      fallbackCopy(text);
+    }
+  });
+
+  const searchForm = document.querySelector("[data-doc-search]");
+  const searchResults = document.querySelector("[data-search-results]");
+
+  if (searchForm && searchResults) {
+    searchForm.addEventListener("submit", function (event) {
+      event.preventDefault();
+      const input = searchForm.querySelector("input[type='search']");
+      const query = input ? input.value.trim().toLowerCase() : "";
+      searchResults.replaceChildren();
+
+      if (!query) {
+        window.location.hash = "#/manual";
+        searchResults.hidden = true;
+        return;
+      }
+
+      const matches = Array.from(document.querySelectorAll("[data-doc-section]")).filter(function (section) {
+        return section.textContent.toLowerCase().includes(query);
+      }).slice(0, 10);
+
+      const heading = document.createElement("strong");
+      heading.textContent = matches.length ? "Manual entries:" : "No manual entries found.";
+      searchResults.appendChild(heading);
+
+      if (matches.length) {
+        const list = document.createElement("ul");
+        matches.forEach(function (section) {
+          const item = document.createElement("li");
+          const link = document.createElement("a");
+          link.href = "#/manual#" + section.id;
+          link.textContent = section.getAttribute("data-title") || section.id;
+          item.appendChild(link);
+          list.appendChild(item);
+        });
+        searchResults.appendChild(list);
+      }
+
+      searchResults.hidden = false;
+    });
+  }
+
+  function findAsset(release, preferredName, pattern) {
+    const assets = Array.isArray(release.assets) ? release.assets : [];
+    return assets.find(function (asset) {
+      return asset.name === preferredName;
+    }) || assets.find(function (asset) {
+      return pattern.test(asset.name);
+    });
+  }
+
+  function setDownload(kind, url) {
+    if (!url) return;
+    document.querySelectorAll("[data-download='" + kind + "']").forEach(function (link) {
+      link.href = url;
+    });
+  }
+
+  fetch(api, {
+    headers: { "Accept": "application/vnd.github+json" }
+  }).then(function (response) {
+    if (!response.ok) throw new Error("No published release");
+    return response.json();
+  }).then(function (release) {
+    const tag = String(release.tag_name || "1.0.0");
+    const version = tag.replace(/^v/, "");
+    const gem = findAsset(release, "srsh.gem", /^srsh-[0-9].*\.gem$/);
+    const source = findAsset(release, "srsh-source.tar.gz", /^srsh-[0-9].*\.tar\.gz$/);
+    const checksums = findAsset(release, "SHA256SUMS", /^SHA256SUMS$/);
+
+    document.querySelectorAll("[data-latest-version]").forEach(function (element) {
+      element.textContent = version;
+    });
+
+    setDownload("gem", gem && gem.browser_download_url);
+    setDownload("source", source && source.browser_download_url);
+    setDownload("checksums", checksums && checksums.browser_download_url);
+
+    const date = release.published_at ? new Date(release.published_at).toLocaleDateString() : "";
+    document.querySelectorAll("[data-release-status]").forEach(function (element) {
+      element.textContent = date ? "Published " + date + "." : "Published on GitHub.";
+    });
+  }).catch(function () {
+    document.querySelectorAll("[data-release-status]").forEach(function (element) {
+      element.textContent = "Release details are available from the GitHub release page.";
+    });
+    setDownload("gem", repository + "/releases/latest/download/srsh.gem");
+    setDownload("source", repository + "/releases/latest/download/srsh-source.tar.gz");
+    setDownload("checksums", repository + "/releases/latest/download/SHA256SUMS");
+  });
+})();

data/examples/bridge.rsh

@@ -0,0 +1,8 @@
+#!/usr/bin/env srsh
+
+# @self is handy for libc-ish symbols already visible in the current process.
+bridge c from "@self"
+  strlen(cstr) -> usize
+end
+
+= "strlen('simple ruby shell')=#{c.strlen("simple ruby shell")}"

data/examples/calculator.rsh

@@ -0,0 +1,253 @@
+#!/usr/bin/env srsh
+
+emit "SRSH Calculator"
+emit "type help for commands"
+emit ""
+
+$CALC_SRC := ""
+$CALC_POS := 0
+$CALC_ERR := ""
+$CALC_ANS := 0
+$CALC_RUN := "yes"
+
+:: peek()
+    ? int($CALC_POS) >= len($CALC_SRC)
+        ^ ""
+    .?
+    ^ $CALC_SRC[int($CALC_POS)]
+.::
+
+:: bump()
+    $CALC_POS := int($CALC_POS) + 1
+    ^ 0
+.::
+
+:: skip()
+    @? int($CALC_POS) < len($CALC_SRC)
+        c := peek()
+        ? c == " " or c == "\t"
+            ignored := bump()
+        :?
+            ^!
+        .?
+    .@
+    ^ 0
+.::
+
+:: number()
+    ignored := skip()
+    text := ""
+    dots := 0
+    digits := 0
+
+    @? int($CALC_POS) < len($CALC_SRC)
+        c := peek()
+        ? contains("0123456789", c)
+            text ++= c
+            digits += 1
+            ignored := bump()
+        :?
+            ? c == "." and dots == 0
+                text ++= c
+                dots := 1
+                ignored := bump()
+            :?
+                ^!
+            .?
+        .?
+    .@
+
+    ? digits == 0
+        $CALC_ERR := "expected number at column " ++ str(int($CALC_POS) + 1)
+        ^ 0
+    .?
+
+    ^ float(text)
+.::
+
+:: ipow(base, exponent)
+    n := int(exponent)
+    ? float(n) != float(exponent)
+        $CALC_ERR := "^ requires an integer exponent"
+        ^ 0
+    .?
+
+    negative := no
+    ? n < 0
+        negative := yes
+        n := 0 - n
+    .?
+
+    result := 1.0
+    @ n -> i
+        result *= base
+    .@
+
+    ? negative
+        ? result == 0
+            $CALC_ERR := "division by zero"
+            ^ 0
+        .?
+        result := 1.0 / result
+    .?
+    ^ result
+.::
+
+:: primary()
+    ignored := skip()
+    c := peek()
+
+    ? c == ""
+        $CALC_ERR := "expected value"
+        ^ 0
+    .?
+
+    ? c == "+"
+        ignored := bump()
+        ^ primary()
+    .?
+
+    ? c == "-"
+        ignored := bump()
+        ^ 0 - primary()
+    .?
+
+    ? c == "("
+        ignored := bump()
+        value := expression()
+        ignored := skip()
+        ? peek() != ")"
+            ? $CALC_ERR == ""
+                $CALC_ERR := "missing ')' at column " ++ str(int($CALC_POS) + 1)
+            .?
+            ^ value
+        .?
+        ignored := bump()
+        ^ value
+    .?
+
+    ^ number()
+.::
+
+:: power()
+    left := primary()
+    ? $CALC_ERR != ""
+        ^ left
+    .?
+
+    ignored := skip()
+    ? peek() == "^"
+        ignored := bump()
+        right := power()
+        ^ ipow(left, right)
+    .?
+    ^ left
+.::
+
+:: term()
+    value := power()
+
+    @? $CALC_ERR == ""
+        ignored := skip()
+        op := peek()
+        ? op != "*" and op != "/" and op != "%"
+            ^!
+        .?
+
+        ignored := bump()
+        rhs := power()
+        ? $CALC_ERR != ""
+            ^ value
+        .?
+
+        ? op == "*"
+            value *= rhs
+        :?
+            ? op == "/"
+                ? rhs == 0
+                    $CALC_ERR := "division by zero"
+                    ^ value
+                .?
+                value /= rhs
+            :?
+                ? rhs == 0
+                    $CALC_ERR := "modulo by zero"
+                    ^ value
+                .?
+                value := int(value) % int(rhs)
+            .?
+        .?
+    .@
+    ^ value
+.::
+
+:: expression()
+    value := term()
+
+    @? $CALC_ERR == ""
+        ignored := skip()
+        op := peek()
+        ? op != "+" and op != "-"
+            ^!
+        .?
+
+        ignored := bump()
+        rhs := term()
+        ? $CALC_ERR != ""
+            ^ value
+        .?
+
+        ? op == "+"
+            value += rhs
+        :?
+            value -= rhs
+        .?
+    .@
+    ^ value
+.::
+
+:: evaluate()
+    $CALC_POS := 0
+    $CALC_ERR := ""
+    value := expression()
+    ignored := skip()
+
+    ? $CALC_ERR == "" and int($CALC_POS) < len($CALC_SRC)
+        $CALC_ERR := "unexpected '" ++ peek() ++ "' at column " ++ str(int($CALC_POS) + 1)
+    .?
+
+    ? $CALC_ERR != ""
+        emit "error: " ++ $CALC_ERR
+        ^ 0
+    .?
+
+    $CALC_ANS := value
+    emit "= " ++ str(value)
+    ^ value
+.::
+
+@? $CALC_RUN == "yes"
+    printf "calc> "
+    read CALC_SRC
+    ?? $CALC_SRC
+    | "" ->
+        ignored := 0
+    | "q" ->
+        $CALC_RUN := "no"
+    | "quit" ->
+        $CALC_RUN := "no"
+    | "exit" ->
+        $CALC_RUN := "no"
+    | "ans" ->
+        emit "= " ++ str(float($CALC_ANS))
+    | "clear" ->
+        clear
+    | "help" ->
+        emit "operators: + - * / % ^ and parentheses"
+        emit "commands: ans, clear, help, quit"
+    | _ ->
+        ignored := evaluate()
+    .??
+.@
+
+emit "bye :P"

data/examples/defer.rsh

@@ -0,0 +1,14 @@
+#!/usr/bin/env srsh
+
+tmp := "/tmp/srsh-defer-example-#{status()}"
+
+fn demo(path)
+  writefile(path, "temporary")
+  defer rmfile(path)
+
+  = "inside: #{exists(path)}"
+  return readfile(path)
+end
+
+= demo(tmp)
+= "after: #{exists(tmp)}"

data/examples/hot.rsh

@@ -0,0 +1,14 @@
+#!/usr/bin/env srsh
+
+root := $1
+? root == "" => root := "."
+branch := $(git branch --show-current 2>/dev/null)
+? branch == "" => branch := "no-branch"
+
+ruby := glob(root ++ "/**/*.rb")
+  |> reject(::p => contains(p, "/vendor/"))
+  |> map(::p => %[path: p, bytes: len(readfile(p))])
+  |> sort(::x => 0 - x.bytes)
+
+= "#{len(ruby)} ruby files on #{branch}"
+@ ruby -> item => = "#{item.bytes}  #{item.path}"

data/examples/meta.rsh

@@ -0,0 +1,20 @@
+#!/usr/bin/env srsh
+
+name := $1
+? name == "" => name := "gang"
+dry := $2 == "--dry"
+
+code greeting
+  emit "wsg #{name}"
+  emit "cwd=#{cwd()}"
+end
+
+if dry
+  emit "would run:"
+  = sourceof(greeting)
+else
+  run(greeting)
+end
+
+formula := "len(name) * 2"
+= "meta expression result=#{eval(formula)}"

data/examples/modules/text.rsh

@@ -0,0 +1,6 @@
+prefix := "srsh"
+
+fn tag(value) => "[#{prefix}] #{value}"
+
+fn clean(lines_in) =>
+  lines_in |> map(::x => x.trim()) |> reject(::x => x == "")

data/examples/modules.rsh

@@ -0,0 +1,6 @@
+#!/usr/bin/env srsh
+
+use "./modules/text.rsh" as text
+
+rows := [" hello ", "", "world"] |> text.clean
+@ rows -> row => = text.tag(row)

data/examples/paste.rsh

@@ -0,0 +1,15 @@
+# This file is intentionally shaped like something you'd paste at the prompt.
+space sys
+  task kernel() =>
+    cmd("uname", "-srmo").check().out.trim()
+
+  task uptime() =>
+    cmd("uptime", "-p").check().out.trim()
+end
+
+jobs := [
+  sys.kernel(),
+  sys.uptime()
+]
+
+= await_all(jobs)

data/examples/plugin.rb

@@ -0,0 +1,8 @@
+SRSH.builtin('wsg') do |args|
+  puts "wsg #{args[1] || 'gng'} :P"
+  0
+end
+
+SRSH.hook(:post_cmd) do |command, status|
+  # Ruby plugins have the full power of Ruby. Treat them as trusted code.
+end

data/examples/power.rsh

@@ -0,0 +1,65 @@
+#!/usr/bin/env srsh
+
+# Objects, functions, tasks and safe process values in one script.
+
+space mathx
+  fn square(x) => x * x
+  fn positive(x) => x > 0
+end
+
+trait Labeled
+  fn label() => "#{self.name}:#{self.bias}"
+end
+
+proto Worker(name, bias := 0) with Labeled
+  slot name := name
+  slot bias := bias
+
+  fn score(x) => mathx.square(x) + self.bias
+
+  task score_later(x)
+    sleep(0.002)
+    return self.score(x)
+  end
+end
+
+workers := [0,1,2,3] |> map(::i => Worker("w#{i}", i))
+jobs := enumerate(workers) |> map(::pair => pair[1].score_later(pair[0] + 2))
+= "async scores=#{await_all(jobs)}"
+
+hits := atom(0)
+parallel(0 ..< 64, ::i => hits.swap(::n => n + 1), 8)
+= "thread-safe hits=#{hits.get()}"
+
+ch := chan(1)
+task send_one(out, value)
+  out.send(value)
+  return value
+end
+producer := send_one(ch, "hello from task")
+= ch.recv(1)
+producer.await(1)
+ch.close()
+
+head, second, *tail := [10,20,30,40]
+= "destructure=#{head + second}; rest=#{tail}"
+
+try
+  assert(workers |> len == 4, "worker count changed")
+  = workers |> map(::w => w.label())
+catch err
+  = "error: #{err.message}"
+finally
+  emit "checked workers"
+end
+
+safe := cmd("printf", "%s", "argv stays data")
+= safe.capture()
+
+code later
+  = "code values are parsed before they run"
+end
+run(later)
+
+fn cube(x) => x ** 3
+= "functional=#{[1,2,3,4] |> filter(mathx.positive) |> map(cube) |> sum}"

data/examples/tour.rsh

@@ -0,0 +1,38 @@
+# RSH 1.0 language tour
+name := "Ruby shell"
+ports := [22, 80, 443]
+server := %[name: "main", tls: yes]
+
+emit "hello from " ++ name
+
+? 443 in ports
+  emit "https enabled"
+:?
+  emit "no https"
+.?
+
+@ 3 -> tick
+  emit "tick " ++ str(tick + 1)
+.@
+
+:: greet(who, count := 2)
+  @ int(count) -> i
+    emit "hey " ++ str(who) ++ " #" ++ str(i + 1)
+  .@
+  ^ count
+.::
+
+greet("gang", 3)
+
+platform := env("OSTYPE") ?? "unknown"
+?? platform
+| "darwin" ->
+  emit "mac"
+| "linux" ->
+  emit "linux"
+| _ ->
+  emit "some unix-ish thing"
+.??
+
+# Normal shell remains normal shell.
+printf 'srsh\n' | tr a-z A-Z

data/ext/srsh_native/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS << ' -O3' unless $CFLAGS.include?('-O')
+create_makefile('srsh_native')