crisp 0.0.5 → 0.0.7

data/lib/crisp/functions/core.rb

@@ -1,51 +1,113 @@
 module Crisp
   module Functions
+    # Defining core crisp functions
     class Core
-      def self.load(env)
+      # load the functions and bind them into the given environment
+      def self.load(current_env)
 
+        # reserve nil/true/false in environment
+        current_env['nil'] = nil
+        current_env['true'] = true
+        current_env['false'] = false
+
+        # println
+        # print arguments (seperated by whitspace) including a newline to the standard output
+        #
+        #  (println 123)
+        #  123
         Function.new do
-          print params_evaled.collect(&:to_s).join(' ') + "\n"
-        end.bind('println', env)
+          print args_evaled.collect(&:to_s).join(' ') + "\n"
+        end.bind('println', current_env)
 
+        # def
+        # bind the second argument to the symbol name of the first argument
+        # actually a key/value pair will be stored in the environment
+        #
+        #  (def foo 1)
+        #  => foo
+        #  (println foo)
+        #  1
         Function.new do
-          validate_params_count(2, params.size)
+          validate_args_count(2, args.size)
 
-          value = params_evaled[1]
+          key = args[0].text_value
+          value = args[1].resolve_and_eval(env)
 
           if value.class.name == "Crisp::Function"
-            value.bind(params_values[0], env)
+            value.bind(key, env)
           else
-            env[params_values[0]] = value
+            env[key] = value
           end
-        end.bind('def', env)
+        end.bind('def', current_env)
 
+        # fn
+        # creates a function
+        # the first argument has to be an array containing the argumentlist
+        # the second argument is the function body
+        #
+        #  (fn [a b] (+ a b)
+        #  => ...)
         Function.new do
-          validate_params_count(2, params.size)
+          validate_args_count(2, args.size)
 
-          if params[0].class.name != "Crisp::ArrayLiteral"
-            raise ArgumentError, "no parameter list defined"
+          if args[0].class.name != "Crisp::Nodes::ArrayLiteral"
+            raise ArgumentError, "no argument list defined"
           end
 
-          if params[1].class.name != "Crisp::Operation"
+          if args[1].class.name != "Crisp::Nodes::Operation"
             raise ArgumentError, "no function body defined"
           end
 
-          fn_param_list = params[0].raw_elements
-          fn_operation = params[1]
+          fn_arg_list = args[0].raw_elements
+          fn_operation = args[1]
 
+          # create and return the new function
           Function.new do
-            validate_params_count(fn_param_list.size, params.size)
+            validate_args_count(fn_arg_list.size, args.size)
 
             local_env = Env.new
-            fn_param_list.each_with_index do |key, idx|
-              local_env[key.eval(env)] = params[idx]
+            fn_arg_list.each_with_index do |key, idx|
+              local_env[key.text_value] = args[idx].resolve_and_eval(env)
             end
 
             chained_env = ChainedEnv.new(local_env, env)
 
             fn_operation.eval(chained_env)
           end
-        end.bind('fn', env)
+        end.bind('fn', current_env)
+
+        # if
+        # the if function evaluates the second argument if the condition (first argument) returns not nil or false.
+        # Otherwise the third argument will be evaluated (optional)
+        #
+        #  (if (= 1 2) 1 2)
+        #  => 2
+        Function.new do
+          validate_args_count((2..3), args.size)
+
+          result = args[0].resolve_and_eval(env)
+
+          res = if ![nil, false].include?(result)
+            args[1]
+          elsif args[2]
+            args[2]
+          end
+
+          res ? res.resolve_and_eval(env) : res
+        end.bind('if', current_env)
+
+        # .
+        # perform a native call on an object with optional arguments
+        #
+        #  (. upcase "abc")
+        #  => "ABC"
+        Function.new do
+          meth = args[0].text_value.to_sym
+          target = args[1].resolve_and_eval(env)
+          values = args[2..-1].map { |arg| arg.resolve_and_eval(env) }
+
+          NativeCallInvoker.new(target, meth, values).invoke!
+        end.bind('.', current_env)
 
       end
     end

data/lib/crisp/native_call_invoker.rb

@@ -0,0 +1,16 @@
+module Crisp
+  # class for handling native ruby method invokations
+  class NativeCallInvoker
+    # create instance with target object, method to be called and arguments
+    def initialize(target, method, *args)
+      @target = target
+      @method = method
+      @args = args.flatten
+    end
+
+    # invoke the native ruby call
+    def invoke!
+      @target.send(@method, *@args)
+    end
+  end
+end

data/lib/crisp/nodes.rb

@@ -1,62 +1,33 @@
 module Crisp
-  class Base < Treetop::Runtime::SyntaxNode
-    def eval(env)
-      nil
-    end
-  end
-
-  class Operation < Base
-    def eval(env)
-      env[self.func_identifier.text_value].eval(env, self.element_list.elements.collect(&:element))
-    end
-  end
-
-  class Block < Base
-    def eval(env)
-      last_result = nil
-
-      elements.each do |op|
-        last_result = op.eval(env)
-      end
-
-      last_result
-    end
-  end
-
-  class ArrayLiteral < Base
-    def eval(env)
-      raw_elements.map { |e| e.eval(env) }
-    end
-
-    def raw_elements
-      self.element_list.elements.collect(&:element)
-    end
-  end
-
-  class Primitive < Base
-  end
-
-  class Number < Primitive
-    def eval(env)
-      text_value.to_i
-    end
-  end
-
-  class Float < Primitive
-    def eval(env)
-      text_value.to_f
-    end
-  end
-
-  class StringLiteral < Primitive
-    def eval(env)
-      text_value[1..-2]
-    end
-  end
-
-  class Symbol < Primitive
-    def eval(env)
-      text_value.to_sym
-    end
+  module Nodes
+    # require all used node types
+    #
+    # hierarchy:
+    #
+    #   Base
+    #   + Operation
+    #   + Block
+    #   + Array
+    #   + Primitive
+    #     + Integer
+    #     + Float
+    #     + String
+    #     + Symbol
+    #     + True
+    #     + False
+    #     + Nil
+
+    require 'crisp/nodes/base'
+    require 'crisp/nodes/operation'
+    require 'crisp/nodes/block'
+    require 'crisp/nodes/array_literal'
+    require 'crisp/nodes/primitive'
+    require 'crisp/nodes/integer_literal'
+    require 'crisp/nodes/float_literal'
+    require 'crisp/nodes/string_literal'
+    require 'crisp/nodes/symbol_literal'
+    require 'crisp/nodes/true_literal'
+    require 'crisp/nodes/false_literal'
+    require 'crisp/nodes/nil_literal'
   end
 end

data/lib/crisp/nodes/array_literal.rb

@@ -0,0 +1,21 @@
+module Crisp
+  module Nodes
+    # The array node
+    class ArrayLiteral < Base
+      # eval each array element and return it as array
+      def eval(env)
+        raw_elements.map { |e| e.eval(env) }
+      end
+
+      # an array resolves to its raw elements
+      def resolve(env)
+        raw_elements.map { |e| e.resolve(env) }
+      end
+
+      # return an array with the raw parsed array elements
+      def raw_elements
+        self.element_list.elements.collect(&:element)
+      end
+    end
+  end
+end

data/lib/crisp/nodes/base.rb

@@ -0,0 +1,22 @@
+module Crisp
+  module Nodes
+    # The base node
+    class Base < Treetop::Runtime::SyntaxNode
+      # this is only an abstract method
+      def eval(env)
+        raise "abstract method!"
+      end
+
+      # this is only an abstract method
+      def resolve(env)
+        raise "abstract method!"
+      end
+
+      # resolves the node and evals it it is a crisp operation node
+      def resolve_and_eval(env)
+        res = self.resolve(env)
+        res.class.name == "Crisp::Nodes::Operation" ? res.eval(env) : res
+      end
+    end
+  end
+end

data/lib/crisp/nodes/block.rb

@@ -0,0 +1,22 @@
+module Crisp
+  module Nodes
+    # The block node
+    class Block < Base
+      # eval each element of the block and return the last result
+      def eval(env)
+        last_result = nil
+
+        elements.each do |op|
+          last_result = op.resolve_and_eval(env)
+        end
+
+        last_result
+      end
+
+      # a block resolves to itself
+      def resolve(env)
+        self
+      end
+    end
+  end
+end

data/lib/crisp/nodes/false_literal.rb

@@ -0,0 +1,11 @@
+module Crisp
+  module Nodes
+    # The false node
+    class FalseLiteral < Primitive
+      # yes it resolves to false
+      def resolve(env)
+        false
+      end
+    end
+  end
+end

data/lib/crisp/nodes/float_literal.rb

@@ -0,0 +1,11 @@
+module Crisp
+  module Nodes
+    # The float node
+    class FloatLiteral < Primitive
+      # returns float value
+      def resolve(env)
+        text_value.to_f
+      end
+    end
+  end
+end

data/lib/crisp/nodes/integer_literal.rb

@@ -0,0 +1,11 @@
+module Crisp
+  module Nodes
+    # The integer node
+    class IntegerLiteral < Primitive
+      # returns integer value
+      def resolve(env)
+        text_value.to_i
+      end
+    end
+  end
+end

data/lib/crisp/nodes/nil_literal.rb

@@ -0,0 +1,11 @@
+module Crisp
+  module Nodes
+    # The nil node
+    class NilLiteral < Primitive
+      # yes it resolves to nil
+      def resolve(env)
+        nil
+      end
+    end
+  end
+end

data/lib/crisp/nodes/operation.rb

@@ -0,0 +1,20 @@
+module Crisp
+  module Nodes
+    # The operation node
+    class Operation < Base
+      # get the function binded to the given function name and eval it (including arguments)
+      def eval(env)
+        if self.func_identifier.class.name == "Crisp::Nodes::Operation"
+          self.func_identifier.eval(env).eval(env, self.element_list.elements.collect(&:element))
+        else
+          env[self.func_identifier.text_value].eval(env, self.element_list.elements.collect(&:element))
+        end
+      end
+
+      # an operation resolves to itself
+      def resolve(env)
+        self
+      end
+    end
+  end
+end

data/lib/crisp/nodes/primitive.rb

@@ -0,0 +1,16 @@
+module Crisp
+  module Nodes
+    # The primitive node
+    class Primitive < Base
+      # raise error if trying to eval a primitve
+      def eval(env)
+        raise "cannot eval primitive"
+      end
+
+      # abstract method
+      def resolve(env)
+        raise "abstract method!"
+      end
+    end
+  end
+end

data/lib/crisp/nodes/string_literal.rb

@@ -0,0 +1,11 @@
+module Crisp
+  module Nodes
+    # The string node
+    class StringLiteral < Primitive
+      # return a string
+      def resolve(env)
+        text_value[1..-2]
+      end
+    end
+  end
+end

data/lib/crisp/nodes/symbol_literal.rb

@@ -0,0 +1,15 @@
+module Crisp
+  module Nodes
+    # The symbol node
+    class SymbolLiteral < Primitive
+      # return the value for the key in the env the symbol stays for
+      def resolve(env)
+        if !env.has_key?(text_value)
+          raise Crisp::EnvironmentError, "#{text_value} is unbound"
+        end
+
+        env[text_value]
+      end
+    end
+  end
+end

data/lib/crisp/nodes/true_literal.rb

@@ -0,0 +1,11 @@
+module Crisp
+  module Nodes
+    # The true node
+    class TrueLiteral < Primitive
+      # yes it resolves to true
+      def resolve(env)
+        true
+      end
+    end
+  end
+end