campa 0.1.0

data/lib/campa/context.rb

@@ -0,0 +1,42 @@
+module Campa
+  class Context
+    attr_accessor :fallback
+
+    def initialize(env = {})
+      @env = env
+    end
+
+    def []=(symbol, value)
+      env[symbol] = value
+    end
+
+    def [](symbol)
+      return env[symbol] if env.include?(symbol)
+
+      fallback[symbol] if !fallback.nil?
+    end
+
+    def include?(symbol)
+      env.include?(symbol) ||
+        (!fallback.nil? && fallback.include?(symbol))
+    end
+
+    def push(new_env = {})
+      # Context is explicit here
+      # (instead of self.class.new)
+      # because we can inherit a context,
+      # like the Lisp::Core does
+      # and then we want a normal context when pushing to it
+      # (and not a Lisp::Core).
+      Context.new(new_env).tap { |c| c.fallback = self }
+    end
+
+    def bindings
+      @bindings ||= env.is_a?(Context) ? env.bindings : env.to_a
+    end
+
+    private
+
+    attr_reader :env
+  end
+end

data/lib/campa/core/load.rb

@@ -0,0 +1,25 @@
+module Campa
+  module Core
+    class Load
+      def initialize
+        @evaler = Evaler.new
+      end
+
+      def call(*paths, env:)
+        verify_presence(paths)
+        paths.reduce(nil) do |_, file|
+          evaler.eval(Reader.new(file), env)
+        end
+      end
+
+      private
+
+      attr_reader :evaler
+
+      def verify_presence(paths)
+        not_here = paths.find { |f| !File.exist?(f) }
+        raise Error::NotFound, not_here if !not_here.nil?
+      end
+    end
+  end
+end

data/lib/campa/core/print.rb

@@ -0,0 +1,20 @@
+module Campa
+  module Core
+    class Print
+      def call(*stuff, env:)
+        string =
+          stuff
+          .map { |s| printer.call(s) }
+          .join(" ")
+        (env[SYMBOL_OUT] || $stdout).print(string)
+        nil
+      end
+
+      private
+
+      def printer
+        @printer ||= Printer.new
+      end
+    end
+  end
+end

data/lib/campa/core/print_ln.rb

@@ -0,0 +1,17 @@
+module Campa
+  module Core
+    class PrintLn
+      def call(*stuff, env:)
+        out = env[SYMBOL_OUT] || $stdout
+        stuff.each { |s| out.puts printer.call(s) }
+        nil
+      end
+
+      private
+
+      def printer
+        @printer ||= Printer.new
+      end
+    end
+  end
+end

data/lib/campa/core/test.rb

@@ -0,0 +1,52 @@
+module Campa
+  module Core
+    class Test
+      TEST_REGEXP = /\Atest(_|-)(.+)$/i
+
+      def initialize
+        @evaler = Campa::Evaler.new
+      end
+
+      def call(*tests, env:)
+        summary = execute_all(tests, env)
+        List.new(
+          List.new(Symbol.new("success"), List.new(*summary[:success])),
+          List.new(Symbol.new("failures"), List.new(*summary[:failures]))
+        )
+      end
+
+      private
+
+      attr_reader :evaler
+
+      def execute_all(tests, env)
+        { success: [], failures: [] }.tap do |summary|
+          env
+            .bindings
+            .select { |(sym, object)| test_func?(sym, object) }
+            .select { |(sym, _)| included?(tests, sym) }
+            .each { |(sym, fn)| add_to_summary(summary, sym, fn, env) }
+        end
+      end
+
+      def test_func?(sym, object)
+        TEST_REGEXP.match?(sym.label) && object.respond_to?(:call)
+      end
+
+      def included?(tests, sym)
+        tests.empty? || tests.include?(TEST_REGEXP.match(sym.label)[2])
+      end
+
+      def add_to_summary(summary, sym, func, env)
+        type = safely_execute(func, env) ? :success : :failures
+        summary[type] << sym
+      end
+
+      def safely_execute(func, env)
+        func.call(env: env)
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/campa/core/test_report.rb

@@ -0,0 +1,59 @@
+module Campa
+  module Core
+    class TestReport
+      def call(result, env:)
+        success, failures = %i[success failures].map { |t| filter(t, result) }
+        out = env[SYMBOL_OUT] || $stdout
+        show_summary(success, failures, out)
+      end
+
+      private
+
+      def show_summary(success, failures, out)
+        out.puts "\n\n#{success.length + failures.length} tests ran"
+
+        if failures.empty?
+          success_summary(success, out)
+        else
+          failure_summary(failures, out)
+        end
+      end
+
+      def filter(type, result)
+        filtered =
+          result
+          .to_a
+          .find { |l| l.head == Symbol.new(type.to_s) }
+        return [] if filtered.nil?
+
+        label_only(filtered)
+      end
+
+      def label_only(filtered)
+        filtered
+          .tail
+          .head
+          .to_a
+          .map(&:label)
+      end
+
+      def success_summary(_success, out)
+        out.puts "Success: none of those returned false"
+
+        true
+      end
+
+      def failure_summary(failures, out)
+        [
+          "FAIL!",
+          "  #{failures.length} tests failed",
+          "  they are:",
+        ].each { |str| out.puts str }
+
+        failures.each { |t| out.puts "    - #{t}" }
+
+        false
+      end
+    end
+  end
+end

data/lib/campa/error/arity.rb

@@ -0,0 +1,11 @@
+module Campa
+  module Error
+    class Arity < ExecutionError
+      def initialize(fun, expected, given)
+        msg = "Arity error when invoking #{fun}: "
+        msg += "expected #{expected} arg(s) but #{given} given"
+        super msg
+      end
+    end
+  end
+end

data/lib/campa/error/illegal_argument.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Error
+    class IllegalArgument < ExecutionError
+      def initialize(given, expected)
+        super "Illegal argument: #{given} was expected to be a #{expected}"
+      end
+    end
+  end
+end

data/lib/campa/error/invalid_number.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Error
+    class InvalidNumber < ExecutionError
+      def initialize(fake_number)
+        super "Invalid number: #{fake_number}"
+      end
+    end
+  end
+end

data/lib/campa/error/missing_delimiter.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Error
+    class MissingDelimiter < ExecutionError
+      def initialize(delimiter)
+        super "#{delimiter} was expected but none was found"
+      end
+    end
+  end
+end

data/lib/campa/error/not_a_function.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Error
+    class NotAFunction < ExecutionError
+      def initialize(label)
+        super "The symbol: #{label} does not resolve to a function"
+      end
+    end
+  end
+end

data/lib/campa/error/not_found.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Error
+    class NotFound < ExecutionError
+      def initialize(path)
+        super "Can't find a file at: #{path}"
+      end
+    end
+  end
+end

data/lib/campa/error/parameters.rb

@@ -0,0 +1,11 @@
+module Campa
+  module Error
+    class Parameters < ExecutionError
+      def initialize(given, expected_type)
+        msg = "Parameter list may only contain #{expected_type}: "
+        msg += "#{given} is not a #{expected_type}"
+        super msg
+      end
+    end
+  end
+end

data/lib/campa/error/reserved.rb

@@ -0,0 +1,11 @@
+module Campa
+  module Error
+    class Reserved < ExecutionError
+      def initialize(label)
+        msg = "Reserved function name: #{label} "
+        msg += "is already taken, sorry about that"
+        super msg
+      end
+    end
+  end
+end

data/lib/campa/error/resolution.rb

@@ -0,0 +1,9 @@
+module Campa
+  module Error
+    class Resolution < ExecutionError
+      def initialize(label)
+        super "Unable to resolve symbol: #{label} in this context"
+      end
+    end
+  end
+end

data/lib/campa/evaler.rb

@@ -0,0 +1,106 @@
+module Campa
+  class Evaler
+    def initialize
+      @printer = Printer.new
+    end
+
+    def call(expression, env = {})
+      context = self.context(env)
+
+      case expression
+      when Numeric, TrueClass, FalseClass, NilClass, String, ::Symbol, List::EMPTY
+        expression
+      when Symbol
+        resolve(expression, context)
+      when List
+        invoke(expression, context)
+      end
+    end
+
+    def eval(reader, env = {})
+      context = self.context(env)
+
+      result = nil
+      while (token = reader.next)
+        result = call(token, context)
+      end
+      result
+    end
+
+    private
+
+    attr_reader :printer
+
+    def context(env)
+      return env if env.is_a?(Context)
+
+      Context.new(env)
+    end
+
+    def resolve(symbol, context)
+      raise Error::Resolution, printer.call(symbol) if !context.include?(symbol)
+
+      context[symbol]
+    end
+
+    def invoke(invocation, context)
+      return invoke_cadr(invocation, context) if cr?(invocation)
+
+      fn = extract_fun(invocation, context)
+      args = args_for_fun(fn, invocation.tail.to_a, context)
+      if with_env?(fn)
+        fn.call(*args, env: context)
+      else
+        fn.call(*args)
+      end
+    end
+
+    def cr?(invocation)
+      invocation.head.is_a?(Symbol) &&
+        invocation.head.label.match?(CR_REGEX)
+    end
+
+    def invoke_cadr(invocation, context)
+      call(
+        List.new(
+          Symbol.new("_cadr"),
+          invocation.head,
+          call(invocation.tail.head, context)
+        ),
+        context
+      )
+    end
+
+    def extract_fun(invocation, context)
+      # probable lambda invocation
+      return call(invocation.head, context) if invocation.head.is_a?(List)
+
+      resolve(invocation.head, context)
+        .then { |rs| rs.is_a?(List) ? call(rs, context) : rs }
+        .tap { |fn| raise not_a_function(invocation) if !fn.respond_to?(:call) }
+    end
+
+    def not_a_function(invocation)
+      Error::NotAFunction.new printer.call(invocation.head)
+    end
+
+    def args_for_fun(fun, args, context)
+      return args if fun.respond_to?(:macro?) && fun.macro?
+
+      args.map { |exp| call(exp, context) }
+    end
+
+    def with_env?(fun)
+      !params_from_fun(fun)
+        .filter { |param| param[0] == :keyreq }
+        .find { |param| param[1] == :env }
+        .nil?
+    end
+
+    def params_from_fun(fun)
+      return fun.parameters if fun.is_a?(Proc)
+
+      fun.method(:call).parameters
+    end
+  end
+end

data/lib/campa/execution_error.rb

@@ -0,0 +1,3 @@
+module Campa
+  class ExecutionError < StandardError; end
+end

data/lib/campa/lambda.rb

@@ -0,0 +1,45 @@
+module Campa
+  class Lambda
+    attr_reader :params, :body, :closure
+
+    def initialize(params, body, closure = Context.new)
+      @params = params
+      @body = Array(body)
+      @closure = closure
+      @evaler = Evaler.new
+    end
+
+    def call(*args, env:)
+      raise arity_error(args) if params.to_a.length != args.length
+
+      @body.reduce(nil) do |_, expression|
+        evaler.call(
+          expression,
+          invocation_env(env, args)
+        )
+      end
+    end
+
+    def ==(other)
+      return false if !other.is_a?(Campa::Lambda)
+
+      params == other.params && body == other.body
+    end
+
+    private
+
+    attr_reader :evaler
+
+    def arity_error(args)
+      Error::Arity.new("lambda", params.to_a.length, args.length)
+    end
+
+    def invocation_env(env, args)
+      closure.push(env.push(Context.new)).tap do |ivk_env|
+        params.each_with_index do |symbol, idx|
+          ivk_env[symbol] = args[idx]
+        end
+      end
+    end
+  end
+end