atomy 0.1.1

data/kernel/repl.ay

@@ -0,0 +1,140 @@
+namespace(atomy)
+
+title"The REPL"
+
+require("readline")
+
+doc"
+  The basics of a REPL - reading, evaluating, and printing in a loop. More \
+  flexibility is provided by various signals. See \hl{repl} for a fancier \
+  REPL, which builds upon this, and \hl{ReplDebugger}.
+
+  When showing the prompt, \hl{#prompt} is signaled with a \hl{#use-prompt} \
+  restart available. Invoke this restart and pass along a string to \
+  override the prompt, which defaults to \code{>>}.
+
+  Input preceded by a colon (\code{:}) and followed by an alphanumeric \
+  character is assumed to be a \italic{special command}. These are not \
+  evaluated, and are signaled as \hl{#special(\italic{text})}.
+
+  When the user sends \code{EOF} (Ctrl+D) or an interrupt (Ctrl+C), \
+  \hl{#quit} is signaled.
+
+  When the user enters code, \hl{#input(\italic{text})} is signaled. The code\
+  is evaluated with two restarts registered: \code{#retry} for re-attempting \
+  evaluation, and \code{#abort}, for canceling the evaluation. After the code\
+  is evaluated, \hl{#evaluated(\italic{result})} is signaled.
+
+  \hl{#loop} is signaled before the loop starts over again (i.e., after the \
+  input is handled).
+" spec {
+  bnd is-a?(Binding)
+} for:
+  basic-repl(bnd = TOPLEVEL_BINDING) :=
+    loop:
+      prompt =
+        with-restarts(use-prompt(p) -> p):
+          signal(#prompt)
+          ">> "
+
+      in =
+        { Readline readline(prompt)
+        } rescue:
+          Interrupt -> do { signal(#quit), "" }
+
+      in match:
+        nil -> signal(#quit)
+
+        "" -> #ok
+
+        String ? (=~ r"^:[[:alnum:]]") ->
+          signal(#special(in [1 .. -1]))
+
+        source -> do:
+          signal(#input(source))
+
+          try = {
+            with-restarts(retry -> try [], abort -> #ok):
+              res = Atomy::Compiler evaluate(source, bnd)
+              signal(#evaluated(res))
+          }
+
+          try []
+
+      signal(#loop)
+
+
+doc"
+  An interactive debugger REPL for handling errors. This will list the \
+  results along with a number, allow the user to continue evaluating code, \
+  and once they enter a \italic{special command} in the form of \
+  \code{:\italic{number}}, the specified restart will be invoked.
+" for:
+  class(ReplDebugger):
+    class(<< self):
+      show-backtrace(e) := do:
+        Rubinius::Backtrace backtrace(e backtrace) _/show print
+        debug(e)
+
+      run(e) := do:
+        DefaultDebugger show-error-banner(e)
+
+        with-restarts(backtrace -> show-backtrace(e)):
+          debug(e)
+
+      debug(e) := do:
+        DefaultDebugger show-options-for(e)
+
+        { basic-repl } bind:
+          #prompt -> restart(#use-prompt, "[!]> ")
+
+          #special(n ? (=~ r"\d+")) ->
+            ^restarts [n to-i] invoke
+
+          #quit -> exit(1)
+
+dynamic(debugger, ReplDebugger)
+
+doc"
+  A more feature-filled REPL, providing persistent history and setting \
+  \hl{^debugger} to \hl{ReplDebugger}.
+
+  History will be managed and appended to a file specified by \hl{history} \
+  upon termination.
+" spec {
+  history is-a?(String)
+  bnd is-a?(Binding)
+} for:
+  repl(history = nil, bnd = TOPLEVEL_BINDING) := do:
+    when(history && File exists?(history)):
+      File open(history, "r") [f]:
+        f readlines each [l]:
+          Readline::HISTORY << l strip
+
+    SANE_HISTORY = []
+
+    { let(debugger = ReplDebugger):
+        frame = 0
+
+        { let(atomy/pretty/colored? = true):
+            basic-repl(bnd)
+        } bind:
+          #prompt ->
+            restart(#use-prompt, "[" + frame to-s + "]> ")
+
+          #loop ->
+            (frame += 1)
+
+          #quit -> exit(0)
+
+          #input(str) -> (SANE_HISTORY << str)
+
+          #special("h") ->
+            ":h\thelp" print
+
+          #evaluated(r) ->
+            (" => " + r show) print
+    } ensuring:
+      when(history):
+        File open(history, "a") [f]:
+          f puts(*SANE_HISTORY)

data/kernel/therie.ay

@@ -0,0 +1,204 @@
+namespace(therie)
+
+title"Testing with Therie"
+
+doc"
+Therie is a small and simple behavioral-style testing suite that comes with \
+Atomy. To use it, you should use the \hl{therie} namespace, which provides \
+the following methods.
+
+\atomy{
+  use(therie)
+}
+"
+
+dynamic(nesting-level, 0)
+
+doc"
+  A trivial container of \hl{passed} and \hl{failed} counts, with accessors \
+  for both.
+" for:
+  class(Stats):
+    attr-accessor(#passed, #failed)
+
+    export:
+      initialize := do:
+        @passed = 0
+        @failed = 0
+
+      inspect := f"Stats(@passed = %d, @failed = %d)" [@passed, @failed]
+
+  dynamic(stats, nil)
+
+
+section("Structure"):
+  doc"\evaluate{use(therie)}"
+
+  doc"
+    Run \hl{tests} and keep track of how many passed and how many failed, \
+    printing the stats at the end and returning them.
+  " spec {
+    => Stats
+  } for {
+    theorize(&tests) :=
+      let(stats = Stats new):
+        tests call
+        "\n" display
+
+        ^stats onto:
+          f"total of %d tests (%s passed, %s failed)" [
+            failed + passed
+            passed to-s colored(#green)
+            if(failed == 0)
+              then: "0"
+              else: failed to-s colored(#red)
+          ] display
+
+          "\n" display
+
+        ^stats
+  } examples:
+    theorize:
+      describe("foo"):
+        it("does x"): true should-be(false)
+        it("does x"): true should-be(true)
+
+
+  doc"
+    Logically group together a set of behavior.
+
+    Prints out \hl{what}, with each test in \hl{body} indented afterward.
+  " for {
+    describe(what, &body) := do:
+      f"- %s" [what] indented print
+
+      let(nesting-level = ^nesting-level + 1):
+        body call
+
+      nil
+  } examples:
+    describe("foo"):
+      it("does x"): true should-be(false)
+      it("does x"): true should-be(true)
+
+
+  doc"
+    Describe some behavior that the tests in \hl{body} will demonstrate.
+  " for {
+    it(description, &tests) := do:
+      { tests call
+        f"✓ %s" [description] indented colored(#green) print
+      } rescue {
+        e -> do:
+          when(^stats):
+            ^stats failed += 1
+
+          f"✗ %s" [description] indented colored(#red) print
+          f"  ` %s: %s" [
+            e class name
+            e message
+          ] indented colored(#yellow) print
+
+          e backtrace first(5) each [l]:
+            f"    %s" [l colored(#cyan)] indented print
+      } else:
+        when(^stats):
+          ^stats passed += 1
+
+      nil
+  } examples:
+    it("adds correctly"): (2 + 2) should-be(4)
+    it("adds correctly"): (1 + 2) should-be(4)
+
+
+section("Tests"):
+  doc"\evaluate{use(therie)}"
+
+  doc"
+    Test that \hl{predicate} is satisified by \hl{o} by evaluating it with \
+    \hl{o} as \hl{self}.
+  " for {
+    o should(&check) :=
+      unless(o onto(&check)):
+        raise(f"assertion failed for %v" [o])
+  } examples:
+    (2 + 2) should: even?
+    (2 + 2) should: odd?
+
+
+  doc"
+    Test for \hl{x == y}.
+  " for {
+    x should-be(y) :=
+      unless(x == y):
+        raise(f"expected %v, got %v" [y, x])
+  } examples:
+    (2 + 2) should-be(4)
+    (1 + 2) should-be(4)
+
+
+  doc"
+    Test that executing \hl{x} will raise an exception of class \hl{y}.
+  " spec {
+    x respond-to?(#call)
+    y is-a?(Class)
+  } for {
+    x should-raise(y) :=
+      x rescue {
+        e ->
+          unless(e kind-of?(y)):
+            raise(f"expected exception %s, got: %s" [y, e])
+      } else:
+          raise("#should-raise - no exception raised")
+  } examples:
+    { abc } should-raise(NoMethodError)
+    { #ok } should-raise(NoMethodError)
+
+
+  doc"
+    Test that executing \hl{x} will signal an error of class \hl{y}.
+  " spec {
+    x respond-to?(#call)
+    y is-a?(Class)
+  } for {
+    x should-error(y) :=
+      { with-restarts(errored -> nil):
+          x call
+          raise("#should-error - no error signaled")
+      } bind {
+        (e: ExceptionError) ->
+          raise(e exception)
+
+        (e: Error) -> do:
+          when(e kind-of?(y)):
+            restart(#errored)
+
+          raise(f"expected error %s, got: %s" [y, e message])
+      }
+  } examples:
+    { error(#foo) } should-error(SimpleError)
+    { #ok } should-error(SimpleError)
+
+
+-- helpers
+String indented := " " * (^nesting-level * 2) + self
+
+String colored(color) := do:
+  -- only makes sense to colorize if we're outputting to a terminal
+  unless(^output-port tty?):
+    return(self)
+
+  codes =
+    [ #black
+      #red
+      #green
+      #yellow
+      #blue
+      #magenta
+      #cyan
+      #white
+    ] zip((0 .. 7) to-a)
+
+  hash = Hash [codes]
+
+  "\e[9" + hash [color] to-s + "m" + self + "\e[0m"

data/lib/ast/binary_send.rb

@@ -0,0 +1,44 @@
+module Atomy
+  module AST
+    class BinarySend < Node
+      children :lhs, :rhs
+      attributes :operator
+      slots [:private, "false"], :namespace?
+      generate
+
+      alias :method_name :operator
+
+      def register_macro(body, let = false)
+        Atomy::Macro.register(
+          @operator,
+          [@lhs, @rhs].collect do |n|
+            Atomy::Macro.macro_pattern n
+          end,
+          body,
+          let
+        )
+      end
+
+      def message_name
+        Atomy.namespaced(@namespace, @operator)
+      end
+
+      def prepare
+        resolve.expand
+      end
+
+      def bytecode(g)
+        pos(g)
+        @lhs.compile(g)
+        g.push_literal message_name.to_sym unless @namespace == "_"
+        @rhs.compile(g)
+        if @namespace == "_"
+          g.send @operator.to_sym, 1
+        else
+          g.send :atomy_send, 2
+          #g.call_custom method_name.to_sym, 1
+        end
+      end
+    end
+  end
+end

data/lib/ast/block.rb

@@ -0,0 +1,268 @@
+module Atomy
+  module AST
+    class Block < Rubinius::AST::Iter
+      include NodeLike
+      extend SentientNode
+
+      children [:contents], [:arguments]
+      generate
+
+      def block_arguments
+        BlockArguments.new @arguments
+      end
+
+      def block_body
+        BlockBody.new @line, @contents
+      end
+
+      def body
+        InlinedBody.new @line, @contents
+      end
+
+      alias :caller :body
+
+      def bytecode(g)
+        pos(g)
+
+        state = g.state
+        state.scope.nest_scope self
+
+        blk = new_block_generator g, block_arguments
+
+        blk.push_state self
+        blk.state.push_super state.super
+        blk.state.push_eval state.eval
+
+        blk.state.push_name blk.name
+
+        # Push line info down.
+        pos(blk)
+
+        block_arguments.bytecode(blk)
+
+        blk.state.push_block
+        blk.push_modifiers
+        blk.break = nil
+        blk.next = nil
+        blk.redo = blk.new_label
+        blk.redo.set!
+
+        block_body.compile(blk)
+
+        blk.pop_modifiers
+        blk.state.pop_block
+        blk.ret
+        blk.close
+        blk.pop_state
+
+        blk.splat_index = block_arguments.splat_index
+        blk.local_count = local_count
+        blk.local_names = local_names
+
+        g.create_block blk
+
+        g.push_cpath_top
+        g.find_const :Proc
+        g.swap
+        g.send :__from_block__, 1
+      end
+
+      def as_message(send)
+        case send.receiver
+        when Send
+          if send.receiver.method_name == "[]"
+            dup.tap do |b|
+              b.arguments = send.receiver.arguments
+            end.as_message(send.receiver)
+          else
+            send.receiver.dup.tap do |s|
+              s.block = self
+            end
+          end
+        when Variable, Unquote,
+             Constant, ScopedConstant, ToplevelConstant
+          send.receiver = send.receiver.to_send
+          as_message(send)
+        when List
+          dup.tap do |b|
+            b.arguments = send.receiver.elements
+          end
+        else
+          unless send.method_name
+            raise "unknown receiver for block: #{send.receiver.inspect}"
+          end
+        end
+      end
+    end
+
+    class InlinedBody < Node
+      children [:expressions]
+      generate
+
+      attr_accessor :parent
+
+      def variables
+        @variables ||= {}
+      end
+
+      def local_count
+        @parent.local_names
+      end
+
+      def local_names
+        @parent.local_names
+      end
+
+      def allocate_slot
+        @parent.allocate_slot
+      end
+
+      def nest_scope(scope)
+        scope.parent = self
+      end
+
+      def search_local(name)
+        if variable = variables[name]
+          variable.nested_reference
+        else
+          @parent.search_local(name)
+        end
+      end
+
+      def pseudo_local(name)
+        if variable = variables[name]
+          variable.nested_reference
+        elsif reference = @parent.search_local(name)
+          reference.depth += 1
+          reference
+        end
+      end
+
+      def new_local(name)
+        variables[name] =
+          @parent.new_local(name + ":" + @parent.allocate_slot.to_s)
+      end
+
+      def new_nested_local(name)
+        @parent.new_local(name).nested_reference
+      end
+
+      def empty?
+        @expressions.empty?
+      end
+
+      def setup(g)
+        g.state.scope.nest_scope self
+
+        blk = g.state.block?
+        ens = g.state.ensure?
+        res = g.state.rescue?
+        lop = g.state.loop?
+        msn = g.state.masgn?
+
+        g.push_state self
+
+        g.state.push_block if blk
+        g.state.push_ensure if ens
+        g.state.push_rescue(res) if res
+        g.state.push_loop if lop
+        g.state.push_masgn if msn
+      end
+
+      def reset(g)
+        g.pop_state
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        setup(g)
+
+        g.push_nil if empty?
+
+        @expressions.each_with_index do |node,idx|
+          g.pop unless idx == 0
+          node.compile(g)
+        end
+
+        reset(g)
+      end
+    end
+
+    class BlockArguments
+      attr_reader :arguments
+
+      def initialize(args)
+        @arguments = args.collect(&:to_pattern)
+      end
+
+      def bytecode(g)
+        return if @arguments.empty?
+
+        if @arguments.last.kind_of?(Patterns::BlockPass)
+          g.push_block_arg
+          @arguments.pop.deconstruct(g)
+        end
+
+        g.cast_for_splat_block_arg
+        @arguments.each do |a|
+          if a.kind_of?(Patterns::Splat)
+            a.pattern.deconstruct(g)
+            return
+          else
+            g.shift_array
+            a.match(g)
+          end
+        end
+        g.pop
+      end
+
+      def local_names
+        @arguments.collect { |a| a.local_names }.flatten
+      end
+
+      def size
+        @arguments.size
+      end
+
+      def locals
+        local_names.size
+      end
+
+      def required_args
+        size
+      end
+
+      def total_args
+        size
+      end
+
+      def splat_index
+        @arguments.each do |a,i|
+          return i if a.kind_of?(Patterns::Splat)
+        end
+        nil
+      end
+    end
+
+    class BlockBody < Node
+      children [:expressions]
+      generate
+
+      def empty?
+        @expressions.empty?
+      end
+
+      def bytecode(g)
+        pos(g)
+
+        g.push_nil if empty?
+
+        @expressions.each_with_index do |node,idx|
+          g.pop unless idx == 0
+          node.compile(g)
+        end
+      end
+    end
+  end
+end