introhive_expression_language 0.6.8

data/lib/introhive_expression_language/iel/evaluator.rb

@@ -0,0 +1,166 @@
+require_relative 'evaluation_context'
+require_relative 'evaluation_error'
+require_relative 'sexp_parser'
+require_relative 'std_lib'
+require_relative 'symbol_detail'
+require_relative 'parser'
+require_relative 'node_util'
+
+module Platform
+  module IEL
+    class Evaluator
+      def self.eval_expr(expr, ctx)
+        ast = Parser.parse(expr)
+        eval_node(ast, ctx)
+      end
+
+      def self.eval_block_expr(expr, ctx)
+        ast = Parser.parse(expr)
+        eval_block(ast, ctx)
+      end
+
+      def self.eval_node(node, ctx)
+        case node.kind
+        when :list
+          eval_list_node(node, ctx)
+        when :symbol
+          deref_symbol(node, ctx)
+        else
+          node
+        end
+      end
+
+      def self.eval_list_node(node, ctx)
+        # First special form - function application
+        if function_application?(node, ctx)
+          apply_fn(node, ctx)
+        else
+          SexpParser::Node.list(
+              node.value.map {|child_node| eval_node(child_node, ctx)},
+              node.source)
+        end
+      end
+
+      def self.function_application?(node, ctx)
+        node.kind == :list && node.value.first && node.value.first.kind == :symbol && ctx[node.value.first.value] && ctx[node.value.first.value].kind == :native_function
+      end
+
+      def self.deref_symbol(symbol_node, ctx)
+        target = ctx[symbol_node.value]
+        raise EvaluationError.new("symbol '#{symbol_node.value}' at #{symbol_node.source} not found", target) if target.nil?
+        target
+      end
+
+      def self.apply_fn(node, ctx)
+        # Decode the function name.
+        name_node = node.value.first
+        raise EvaluationError.new('symbol expected', name_node) if name_node.nil?
+        raise EvaluationError.new('function application requires symbol', name_node) if name_node.kind != :symbol
+        symbol_name = name_node.value
+
+        # Get the detail of this symbol from the provided context.
+        detail_node = ctx[symbol_name]
+        raise EvaluationError.new("function '#{symbol_name}' is not found", detail_node) if detail_node.nil?
+        fn_proc = detail_node.value[:proc]
+        arg_list = detail_node.value[:arg_list]
+
+        # Create a new context overriding the provided context.
+        this_ctx = EvaluationContext.new(ctx)
+
+        # Decode the parameters and bind each to the new context.
+        if arg_list.size == 1 && arg_list[0].start_with?('va_')
+          # Varargs - build a list and bind as single arg
+          this_ctx[arg_list[0]] = SexpParser::Node.list(node.value.drop(1).map do |arg_node|
+            if arg_list[0].end_with?('__')
+              arg_node
+            else
+              eval_node(arg_node, ctx)
+            end
+          end, node.source)
+        else
+          # Args are bound by placement and the number must match.
+          raise EvaluationError.new("function '#{symbol_name}' requires #{arg_list.size} arguments but #{node.value.size - 1} are provided.", node) if arg_list.size != node.value.size - 1
+          node.value.drop(1).each_with_index do |arg_node, index|
+            arg_name = arg_list[index]
+            this_ctx[arg_name] = if arg_name.end_with?('__')
+                                   arg_node
+                                 else
+                                   eval_node(arg_node, ctx)
+                                 end
+          end
+        end
+
+        # Invoke the function.
+        rv = fn_proc.call(this_ctx)
+        raise EvaluationError.new("function '#{symbol_name}' does not return a node", rv) unless rv.is_a?(SexpParser::Node)
+        rv
+      end
+
+      # Evaluate each item inside this "block" of code (e.g. a list) and return the last evaluated result.
+      # e.g.
+      # [
+      #   [puts "hello"]
+      #   [puts "world"]
+      #   123
+      # ]
+      # hello
+      # world
+      # => 123
+      def self.eval_block(node, ctx)
+        rv = nil
+        node.value.each do |child_node|
+          rv = Evaluator.eval_node(child_node, ctx)
+        end
+        rv
+      end
+
+      # Wraps a native function so that it can be invoked in an expression.
+      # The native function MUST accept the evaluation context as its first param.
+      # The remaining params are mapped as iel mandatory args.
+      def self.wrap_native_function(&fn)
+        arg_list = fn.parameters.drop(1).map {|_kind, name| name.to_s}
+
+        wrapped_fn = lambda do |ctx|
+          args = [ctx] + arg_list.map {|name| ctx[name]}
+          fn.call(*args)
+        end
+
+        SexpParser::Node.new(
+            :native_function,
+            0,
+            {
+                proc: wrapped_fn,
+                arg_list: arg_list
+            }
+        )
+      end
+
+      # Returns the numeric value of this node. It does not evaluate the node first, just returns its numeric value if
+      # possible.
+      def self.numeric_value_of(node)
+        if node.kind == :numeric_literal
+          node.value
+        elsif node.kind == :string_literal
+          node.value.to_f
+        else
+          0
+        end
+      end
+
+      # Returns the string value of this node. It does not evaluate the node first, just returns its string value if
+      # possible.
+      def self.string_value_of(node)
+        if node.kind == :numeric_literal
+          node.value.to_s
+        elsif node.kind == :string_literal
+          node.value
+        elsif node.kind == :list
+          node.value.map {|item| string_value_of(item)}.join
+        else
+          ''
+        end
+      end
+    end
+
+  end
+end

data/lib/introhive_expression_language/iel/node_util.rb

@@ -0,0 +1,65 @@
+module Platform
+  module IEL
+    # Converts data from and to standard node graph formats.
+    class NodeUtil
+      # Recursively convert the given native value to a node using standard representations.
+      # The following types are converted:
+      # Hash               => nested list e.g. [[a 1] [b 2]]
+      # String, Time (etc) => string_literal
+      # Fixnum, Float      => numeric_literal, nan
+      # Array              => list
+      # nil                => nil
+      # Boolean            => boolean
+      #
+      # e.g.
+      # [{:z => 123, 5 => 6}, [9, 8, 7.1, "hi", false, [nil]]]
+      # is transformed to:
+      # [[["z" 123] [5 6]] [9 8 7.1 "hi" false [nil]]]
+      def self.from_native(value)
+        if value.is_a? Hash
+          Platform::IEL::SexpParser::Node.list([SexpParser::Node.symbol('assoc')] + value.map { |k, v| SexpParser::Node.list([from_native(k), from_native(v)]) })
+        elsif value.is_a? Array
+          Platform::IEL::SexpParser::Node.list(value.map(&method(:from_native)))
+        elsif value.is_a? Numeric
+          Platform::IEL::SexpParser::Node.numeric_literal(value)
+        elsif value.is_a? NilClass
+          Platform::IEL::SexpParser::Node.nil
+        elsif value.is_a? TrueClass
+          Platform::IEL::SexpParser::Node.boolean(true)
+        elsif value.is_a? FalseClass
+          Platform::IEL::SexpParser::Node.boolean(false)
+        elsif value.is_a? Symbol
+          Platform::IEL::SexpParser::Node.symbol(value.to_s)
+        else
+          Platform::IEL::SexpParser::Node.string_literal(value.to_s)
+        end
+      end
+
+      # Recursively
+      def self.to_native(node)
+        case node.kind
+        when :string_literal, :numeric_literal, :boolean
+          node.value
+        when :symbol
+          node.value.to_sym
+        when :nil
+          nil
+        when :nan
+          Float::NAN
+        when :list
+          if node.value.size > 0 && node.value[0].kind == :symbol && node.value[0].value == 'assoc'
+            Hash[node.value.drop(1).map do |kv_pair|
+              if kv_pair.kind == :list && kv_pair.value.size >= 2
+                [to_native(kv_pair.value[0]), to_native(kv_pair.value[1])]
+              end
+            end.compact]
+          else
+            node.value.map { |n| to_native(n) }
+          end
+        else
+          raise ArgumentError, "Unable to convert kind #{node.kind} to native value"
+        end
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/parser.rb

@@ -0,0 +1,30 @@
+module Platform
+  module IEL
+    class Parser
+      def self.parse(expr)
+        ast = SexpParser.parse(expr)
+        apply_transforms(ast)
+        ast
+      end
+
+      def self.apply_transforms(node)
+        if node.kind == :list
+          # recursively apply first
+          raise EvaluationError.new("Node can't end with trailing quote", node) if node.value[-1].to_s == "'" #trailing quote
+          node.value.each { |child| apply_transforms(child) }
+          # look for the quote pattern in the nodes
+          loop do
+            match, index = node.value.each_with_index.find { |child, index| child.kind == :symbol && child.value == "'" }
+            break if match.nil?
+            if index + 1 < node.value.size # There's a node following the quote
+              # Replace the two nodes with a single one
+              after_match = node.value.delete_at(index + 1)
+              node.value[index] = SexpParser::Node.list([SexpParser::Node.symbol('quote', match.source), after_match], match.source)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/introhive_expression_language/iel/sexp_parser.rb

@@ -0,0 +1,339 @@
+module Platform
+  module IEL
+    class SexpParser
+      class ParseError < StandardError
+        def initialize(message, source = nil)
+          @source = source
+          super("#{message}#{source.nil? ? '' : " at #{source}"}")
+        end
+      end
+
+      class UnexpectedTokenError < ParseError
+        def initialize(token)
+          super("#{token.kind} unexpected", token.source)
+        end
+      end
+
+      # Parse the given expression and return its AST.
+      # Raises SexpParser::ParseError if a syntax error is encountered.
+      # @expr string in correct format.
+      def self.parse(expr)
+        parse_context = ParseContext.new(expr)
+        node_stack = [Node.new(:list, 0, [], parse_context)]
+        Lexer.tokenize(expr.chars, 0, parse_context) do |token|
+          case token.kind
+          when :string_literal, :numeric_literal, :symbol, :boolean, :nan, :nil
+            node_stack.last.value << token
+          when :list_end
+            raise UnexpectedTokenError, token if node_stack.size == 1
+            value = node_stack.pop
+            raise UnexpectedTokenError, token if value.nil?
+            node_stack.last.value << value
+          when :list_start
+            node_stack.push(Node.new(:list, token.source, [], parse_context))
+          when :comment
+            # Do nothing
+          else
+            raise UnexpectedTokenError, token
+          end
+        end
+        if node_stack.size != 1
+          raise ParseError, 'Unexpected end of input'
+        end
+
+        # Remove containing list if there's only a single item results.
+        if node_stack.first.value.size == 1
+          node_stack = node_stack.first.value
+        end
+
+        node_stack.first
+      end
+
+      class ParseContext
+        attr_reader :code
+
+        def initialize(code)
+          @code = code
+        end
+
+        def code_line(offset)
+          idx = 0
+          line = 1
+          pos = 0
+          last_line_start = 0
+          line_location = 1
+          @code.chars.each do |c|
+            if c == "\n"
+              line += 1
+              pos = 0
+              last_line_start = idx + 1
+            else
+              pos += 1
+            end
+            if idx == offset
+              line_location = pos
+              break
+            end
+            idx += 1
+          end
+
+          code_line = ''
+          @code[last_line_start..-1].chars.each do |c|
+            if c == "\n"
+              break
+            else
+              code_line += c
+            end
+          end
+
+          " at Line #{line}, Pos #{line_location}\n#{code_line}\n#{'-' * (line_location-1)}^"
+        end
+      end
+
+      class Node
+        include Comparable
+        attr_reader :kind, :value, :source, :context
+
+        def initialize(kind, source, value=nil, context=nil)
+          @kind = kind
+          @source = source
+          @value = value
+          @context = context
+        end
+
+        def source_desc
+          if context
+            context.code_line(@source)
+          else
+            " Offset #{@source}"
+          end
+        end
+
+        def <=>(other)
+          [kind, value] <=> [other.kind, other.value]
+        end
+
+        def inspect
+          if value.is_a? Array
+            "[#{value.map { |item| item.inspect}.join(', ')}]"
+          elsif kind == :symbol
+            ":#{value}"
+          elsif kind == :nil
+            'nil'
+          elsif kind == :nan
+            'nan'
+          else
+            value.inspect
+          end
+        end
+
+        def self.symbol(symbol_name, source = 0, context = nil)
+          new(:symbol, source, symbol_name)
+        end
+
+        def self.string_literal(str, source = 0, context = nil)
+          new(:string_literal, source, str)
+        end
+
+        def self.numeric_literal(n, source = 0, context = nil)
+          new(:numeric_literal, source, n)
+        end
+
+        def self.nan(source = 0, context = nil)
+          new(:nan, source)
+        end
+
+        def self.list(contents, source = 0, context = nil)
+          new(:list, source, contents)
+        end
+
+        def self.nil(source = 0, context = nil)
+          new(:nil, source)
+        end
+
+        def self.boolean(boolean_value, source = 0, context = nil)
+          new(:boolean, source, boolean_value)
+        end
+
+        def to_s
+          value
+        end
+      end
+
+      class Lexer
+        SYMBOL_LEADING_CHAR_SE = %q{[\w@+*\/=!<>-]}
+        SYMBOL_LEADING_CHAR = Regexp.new(SYMBOL_LEADING_CHAR_SE)
+        SYMBOL_TRAILING_CHAR_SE = '[\w:@=.()#+*\/!<>?-]'
+        SYMBOL_TRAILING_CHAR = Regexp.new(SYMBOL_TRAILING_CHAR_SE)
+        SYMBOL = Regexp.new("#{SYMBOL_LEADING_CHAR_SE}#{SYMBOL_TRAILING_CHAR_SE}*")
+
+        def self.tokenize(chars, pos, context, &block)
+          self.new.tokenize(chars, pos, context, &block)
+        end
+
+        def tokenize(chars, pos, context, &block)
+          @chars = chars
+          @pos = pos
+          @context = context
+          @block = block
+          while next_token
+          end
+        end
+
+        def next_token
+          case cpeek
+          when nil
+            return false
+          when /\s/
+            cnext
+          when '['
+            @block.call(Node.new(:list_start, @pos, nil, @context))
+            cnext
+          when ']'
+            @block.call(Node.new(:list_end, @pos, nil, @context))
+            cnext
+          when '"'
+            string_literal
+          when "'"
+            quote_symbol
+          when '-'
+            numeric_literal_or_symbol
+          when /[-\d]/
+            numeric_literal
+          when SYMBOL_LEADING_CHAR
+            symbol_or_comment
+          else
+            raise ParseError, "'#{cpeek}' unexpected at #{@pos}"
+          end
+          true
+        end
+
+        def numeric_literal_or_symbol
+          cnext # consume the minus
+          if cpeek =~ /[\d]/
+            numeric_literal('-')
+          else
+            symbol('-')
+          end
+        end
+
+        def string_literal
+          pos = @pos
+          expect('"')
+          s = ''
+          while true
+            case cpeek
+            when nil
+              raise ParseError, "Unexpected end of string literal at #{@pos}"
+            when '"'
+              cnext
+              if cpeek == '"'
+                s += cnext
+              else
+                @block.call(Node.new(:string_literal, pos, s, @context))
+                break
+              end
+            else
+              s += cnext
+            end
+          end
+        end
+
+        def numeric_literal(s = '')
+          pos = @pos - s.length
+          dot_count = 0
+          while true
+            case cpeek
+            when /[\d]/
+              s += cnext
+            when /[.]/
+              dot_count += 1
+              raise ParseError, "Unexpected '.' in numeric literal at #{@pos}" if dot_count > 1
+              s += cnext
+            else
+              @block.call(Node.new(:numeric_literal, pos, s.include?('.') ? s.to_f : s.to_i, @context))
+              break
+            end
+          end
+        end
+
+        def symbol_or_comment(s = '')
+          s += cnext
+          if cpeek == '*'
+            s += cnext
+            comment(s)
+          else
+            symbol(s)
+          end
+        end
+
+        def comment(s = '')
+          pos = @pos
+          maybe_ending = false
+          while true
+            case cpeek
+            when '*'
+              maybe_ending = true
+              s += cnext
+            when '/'
+              s += cnext
+              if maybe_ending
+                @block.call(Node.new(:comment, pos, s, @context))
+                break
+              end
+            else
+              maybe_ending = false
+              next_c = cnext
+              raise ParseError, "Unexpected EOF in comment at #{@pos}" if next_c.nil?
+              s += next_c
+            end
+          end
+        end
+
+        def symbol(s = '')
+          pos = @pos - s.length
+          while true
+            case cpeek
+            when SYMBOL_TRAILING_CHAR
+              s += cnext
+            else
+              case s
+              when 'true'
+                @block.call(Node.new(:boolean, pos, true, @context))
+              when 'false'
+                @block.call(Node.new(:boolean, pos, false, @context))
+              when 'nan'
+                @block.call(Node.new(:nan, pos, nil, @context))
+              when 'nil'
+                @block.call(Node.new(:nil, pos, nil, @context))
+              else
+                @block.call(Node.new(:symbol, pos, s, @context))
+              end
+              break
+            end
+          end
+        end
+
+        def quote_symbol
+          cnext
+          @block.call(Node.new(:symbol, @pos, "'", @context))
+        end
+
+        def expect(c)
+          raise ParseError, "'#{c}' expected at #{@pos}" if cpeek != c
+          cnext
+        end
+
+        def cpeek
+          @chars[@pos]
+        end
+
+        def cnext
+          c = @chars[@pos]
+          @pos += 1
+          c
+        end
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/std_lib.rb

@@ -0,0 +1,43 @@
+require_relative 'std_lib_let'
+require_relative 'std_lib_control'
+require_relative 'std_lib_enum'
+require_relative 'std_lib_math'
+require_relative 'std_lib_string'
+require_relative 'std_lib_assoc'
+require_relative 'std_lib_list'
+require_relative 'std_lib_kind'
+require_relative 'std_lib_json'
+require_relative 'std_lib_number'
+require_relative 'std_lib_logic'
+require_relative 'std_lib_existence'
+require_relative 'std_lib_regexp'
+
+module Platform
+  module IEL
+    class StdLib
+
+      # Declare the standard lib functions in this eval context.
+      def self.declare(defining_context)
+        StdLibLet.declare(defining_context)
+        StdLibControl.declare(defining_context)
+        StdLibEnum.declare(defining_context)
+        StdLibMath.declare(defining_context)
+        StdLibString.declare(defining_context)
+        StdLibAssoc.declare(defining_context)
+        StdLibKind.declare(defining_context)
+        StdLibJson.declare(defining_context)
+        StdLibNumber.declare(defining_context)
+        StdLibLogic.declare(defining_context)
+        StdLibExistence.declare(defining_context)
+        StdLibRegexp.declare(defining_context)
+      end
+
+      # Helper to create a new context with stdlib already defined.
+      def self.new_context
+        ec = EvaluationContext.new
+        declare(ec)
+        ec
+      end
+    end
+  end
+end