bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/script/validator.rb

@@ -0,0 +1,65 @@
+require          'concurrent/hash'
+
+require_relative '../parsers/common'
+require_relative '../parsers/expression'
+require_relative '../parsers/bel_script'
+
+require_relative '../ast_filter'
+require_relative '../ast_generator'
+
+require_relative 'state_function'
+require_relative '../language/syntax_function'
+
+module BELParser
+  module Script
+    # Validator defines a BEL Script syntax validator. This validator
+    # expects to receive the BEL Script state for each node. This is
+    # accomplished by initializing with a {StateAggregator} that this
+    # will enumerate.
+    class Validator
+
+      def initialize(state_aggregator)
+        @state_aggregator = state_aggregator
+
+        Validator.require_script_path
+        @syntax_functions = Validator.syntax_constants(Syntax)
+      end
+
+      def each
+        if block_given?
+          @state_aggregator.each do |(line_number, line, ast_node, state)|
+            ast_node.traverse.flat_map do |node|
+              @syntax_functions.flat_map do |func|
+                func.map(node, state)
+              end
+            end.compact.each do |syntax_result|
+              ast_node.add_syntax_error(syntax_result)
+            end
+
+            yield [line_number, line, ast_node, state]
+          end
+        else
+          enum_for(:each)
+        end
+      end
+
+      def self.require_script_path
+        base_path = File.expand_path(File.dirname(__FILE__)) + File::SEPARATOR
+        ['state', 'syntax'].each do |set|
+          Dir[File.join(base_path, set, '*.rb')]
+            .each do |ruby_file|
+              ruby_file.sub!(/^#{Regexp.escape(base_path)}/, '')
+              require_relative ruby_file
+            end
+        end
+      end
+
+      def self.syntax_constants(mod)
+        mod.constants.collect do |symbol|
+          const = mod.const_get(symbol)
+          const if const.respond_to?(:map)
+        end.compact
+      end
+    end
+  end
+end

data/lib/bel_parser/vendor/ast.rb

@@ -0,0 +1,17 @@
+# {AST} is a library for manipulating abstract syntax trees.
+#
+# It embraces immutability; each AST node is inherently frozen at
+# creation, and updating a child node requires recreating that node
+# and its every parent, recursively.
+# This is a design choice. It does create some pressure on
+# garbage collector, but completely eliminates all concurrency
+# and aliasing problems.
+#
+# See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for
+# additional recommendations and design patterns.
+#
+module AST
+  require_relative 'ast/node'
+  require_relative 'ast/processor'
+  require_relative 'ast/sexp'
+end

data/lib/bel_parser/vendor/ast/node.rb

@@ -0,0 +1,254 @@
+module AST
+  # Node is an immutable class, instances of which represent abstract
+  # syntax tree nodes. It combines semantic information (i.e. anything
+  # that affects the algorithmic properties of a program) with
+  # meta-information (line numbers or compiler intermediates).
+  #
+  # Notes on inheritance
+  # ====================
+  #
+  # The distinction between semantics and metadata is important. Complete
+  # semantic information should be contained within just the {#type} and
+  # {#children} of a Node instance; in other words, if an AST was to be
+  # stripped of all meta-information, it should remain a valid AST which
+  # could be successfully processed to yield a result with the same
+  # algorithmic properties.
+  #
+  # Thus, Node should never be inherited in order to define methods which
+  # affect or return semantic information, such as getters for `class_name`,
+  # `superclass` and `body` in the case of a hypothetical `ClassNode`. The
+  # correct solution is to use a generic Node with a {#type} of `:class`
+  # and three children. See also {Processor} for tips on working with such
+  # ASTs.
+  #
+  # On the other hand, Node can and should be inherited to define
+  # application-specific metadata (see also {#initialize}) or customize the
+  # printing format. It is expected that an application would have one or two
+  # such classes and use them across the entire codebase.
+  #
+  # The rationale for this pattern is extensibility and maintainability.
+  # Unlike static ones, dynamic languages do not require the presence of a
+  # predefined, rigid structure, nor does it improve dispatch efficiency,
+  # and while such a structure can certainly be defined, it does not add
+  # any value but incurs a maintaining cost.
+  # For example, extending the AST even with a transformation-local
+  # temporary node type requires making globally visible changes to
+  # the codebase.
+  #
+  class Node
+    # Returns the type of this node.
+    # @return [Symbol]
+    attr_reader :type
+
+    # Returns the children of this node.
+    # The returned value is frozen.
+    # @return [Array]
+    attr_reader :children
+
+    # Returns the precomputed hash value for this node
+    # @return [Fixnum]
+    attr_reader :hash
+
+    # Constructs a new instance of Node.
+    #
+    # The arguments `type` and `children` are converted with `to_sym` and
+    # `to_a` respectively. Additionally, the result of converting `children`
+    # is frozen. While mutating the arguments is generally considered harmful,
+    # the most common case is to pass an array literal to the constructor. If
+    # your code does not expect the argument to be frozen, use `#dup`.
+    #
+    # The `properties` hash is passed to {#assign_properties}.
+    def initialize(type, children=[], properties={})
+      @type, @children = type.to_sym, children.to_a.freeze
+
+      assign_properties(properties)
+
+      @hash = [@type, @children, self.class].hash
+
+      freeze
+    end
+
+    # Test if other object is equal to
+    # @param [Object] other
+    # @return [Boolean]
+    def eql?(other)
+      self.class.eql?(other.class)   &&
+      @type.eql?(other.type)         &&
+      @children.eql?(other.children)
+    end
+
+    # By default, each entry in the `properties` hash is assigned to
+    # an instance variable in this instance of Node. A subclass should define
+    # attribute readers for such variables. The values passed in the hash
+    # are not frozen or whitelisted; such behavior can also be implemented
+    # by subclassing Node and overriding this method.
+    #
+    # @return [nil]
+    def assign_properties(properties)
+      properties.each do |name, value|
+        instance_variable_set :"@#{name}", value
+      end
+
+      nil
+    end
+    protected :assign_properties
+
+    alias   :original_dup :dup
+    private :original_dup
+
+    # Nodes are already frozen, so there is no harm in returning the
+    # current node as opposed to initializing from scratch and freezing
+    # another one.
+    #
+    # @return self
+    def dup
+      self
+    end
+    alias :clone :dup
+
+    # Returns a new instance of Node where non-nil arguments replace the
+    # corresponding fields of `self`.
+    #
+    # For example, `Node.new(:foo, [ 1, 2 ]).updated(:bar)` would yield
+    # `(bar 1 2)`, and `Node.new(:foo, [ 1, 2 ]).updated(nil, [])` would
+    # yield `(foo)`.
+    #
+    # If the resulting node would be identical to `self`, does nothing.
+    #
+    # @param  [Symbol, nil] type
+    # @param  [Array, nil]  children
+    # @param  [Hash, nil]   properties
+    # @return [AST::Node]
+    def updated(type=nil, children=nil, properties=nil)
+      new_type       = type       || @type
+      new_children   = children   || @children
+      new_properties = properties || {}
+
+      if @type == new_type &&
+          @children == new_children &&
+          properties.nil?
+        self
+      else
+        # Maybe change call?
+        original_dup.send :initialize, new_type, new_children, new_properties
+      end
+    end
+
+    # Compares `self` to `other`, possibly converting with `to_ast`. Only
+    # `type` and `children` are compared; metadata is deliberately ignored.
+    #
+    # @return [Boolean]
+    def ==(other)
+      if equal?(other)
+        true
+      elsif other.respond_to? :to_ast
+        other = other.to_ast
+        other.type == self.type &&
+          other.children == self.children
+      else
+        false
+      end
+    end
+
+    # Concatenates `array` with `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def concat(array)
+      updated(nil, @children + array.to_a)
+    end
+
+    alias + concat
+
+    # Appends `element` to `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def append(element)
+      updated(nil, @children + [element])
+    end
+
+    alias << append
+
+    # Returns {#children}. This is very useful in order to decompose nodes
+    # concisely. For example:
+    #
+    #     node = s(:gasgn, :$foo, s(:integer, 1))
+    #     s
+    #     var_name, value = *node
+    #     p var_name # => :$foo
+    #     p value    # => (integer 1)
+    #
+    # @return [Array]
+    def to_a
+      children
+    end
+
+    # Converts `self` to a pretty-printed s-expression.
+    #
+    # @param  [Integer] indent Base indentation level.
+    # @return [String]
+    def to_sexp(indent=0)
+      indented = "  " * indent
+      sexp = "#{indented}(#{fancy_type}"
+
+      first_node_child = children.index do |child|
+        child.is_a?(Node) || child.is_a?(Array)
+      end || children.count
+
+      children.each_with_index do |child, idx|
+        if child.is_a?(Node) && idx >= first_node_child
+          sexp << "\n#{child.to_sexp(indent + 1)}"
+        else
+          sexp << " #{child.inspect}"
+        end
+      end
+
+      sexp << ")"
+
+      sexp
+    end
+
+    alias to_s to_sexp
+
+    # Converts `self` to a s-expression ruby string.
+    # The code return will recreate the node, using the sexp module s()
+    #
+    # @param  [Integer] indent Base indentation level.
+    # @return [String]
+    def inspect(indent=0)
+      indented = "  " * indent
+      sexp = "#{indented}s(:#{@type}"
+
+      first_node_child = children.index do |child|
+        child.is_a?(Node) || child.is_a?(Array)
+      end || children.count
+
+      children.each_with_index do |child, idx|
+        if child.is_a?(Node) && idx >= first_node_child
+          sexp << ",\n#{child.inspect(indent + 1)}"
+        else
+          sexp << ", #{child.inspect}"
+        end
+      end
+
+      sexp << ")"
+
+      sexp
+    end
+
+    # @return [AST::Node] self
+    def to_ast
+      self
+    end
+
+    protected
+
+    # Returns `@type` with all underscores replaced by dashes. This allows
+    # to write symbol literals without quotes in Ruby sources and yet have
+    # nicely looking s-expressions.
+    #
+    # @return [String]
+    def fancy_type
+      @type.to_s.gsub('_', '-')
+    end
+  end
+end

data/lib/bel_parser/vendor/ast/processor.rb

@@ -0,0 +1,12 @@
+module AST
+  # This class includes {AST::Processor::Mixin}; however, it is
+  # deprecated, since the module defines all of the behaviors that
+  # the processor includes.  Any new libraries should use
+  # {AST::Processor::Mixin} instead of subclassing this.
+  #
+  # @deprecated Use {AST::Processor::Mixin} instead.
+  class Processor
+    require_relative 'processor/mixin'
+    include Mixin
+  end
+end

data/lib/bel_parser/vendor/ast/processor/mixin.rb

@@ -0,0 +1,282 @@
+module AST
+  class Processor
+    # The processor module is a module which helps transforming one
+    # AST into another.  In a nutshell, the {#process} method accepts
+    # a {Node} and dispatches it to a handler corresponding to its
+    # type, and returns a (possibly) updated variant of the node.
+    #
+    # The processor module has a set of associated design patterns.
+    # They are best explained with a concrete example. Let's define a
+    # simple arithmetic language and an AST format for it:
+    #
+    # Terminals (AST nodes which do not have other AST nodes inside):
+    #
+    #   * `(integer <int-literal>)`,
+    #
+    # Nonterminals (AST nodes with other nodes as children):
+    #
+    #   * `(add <node> <node>)`,
+    #   * `(multiply <node> <node>)`,
+    #   * `(divide <node> <node>)`,
+    #   * `(negate <node>)`,
+    #   * `(store <node> <string-literal>)`: stores value of `<node>`
+    #     into a variable named `<string-literal>`,
+    #   * `(load <string-literal>)`: loads value of a variable named
+    #     `<string-literal>`,
+    #   * `(each <node> ...): computes each of the `<node>`s and
+    #     prints the result.
+    #
+    # All AST nodes have the same Ruby class, and therefore they don't
+    # know how to traverse themselves. (A solution which dynamically
+    # checks the type of children is possible, but is slow and
+    # error-prone.) So, a class including the module which knows how
+    # to traverse the entire tree should be defined.  Such classes
+    # have a handler for each nonterminal node which recursively
+    # processes children nodes:
+    #
+    #     require 'ast'
+    #
+    #     class ArithmeticsProcessor
+    #       include AST::Processor::Module
+    #       # This method traverses any binary operators such as (add)
+    #       # or (multiply).
+    #       def process_binary_op(node)
+    #         # Children aren't decomposed automatically; it is
+    #         # suggested to use Ruby multiple assignment expansion,
+    #         # as it is very convenient here.
+    #         left_expr, right_expr = *node
+    #
+    #         # AST::Node#updated won't change node type if nil is
+    #         # passed as a first argument, which allows to reuse the
+    #         # same handler for multiple node types using `alias'
+    #         # (below).
+    #         node.updated(nil, [
+    #           process(left_expr),
+    #           process(right_expr)
+    #         ])
+    #       end
+    #       alias_method :on_add,      :process_binary_op
+    #       alias_method :on_multiply, :process_binary_op
+    #       alias_method :on_divide,   :process_binary_op
+    #
+    #       def on_negate(node)
+    #         # It is also possible to use #process_all for more
+    #         # compact code if every child is a Node.
+    #         node.updated(nil, process_all(node))
+    #       end
+    #
+    #       def on_store(node)
+    #         expr, variable_name = *node
+    #
+    #         # Note that variable_name is not a Node and thus isn't
+    #         # passed to #process.
+    #         node.updated(nil, [
+    #           process(expr),
+    #           variable_name
+    #         ])
+    #       end
+    #
+    #       # (load) is effectively a terminal node, and so it does
+    #       # not need an explicit handler, as the following is the
+    #       # default behavior.  Essentially, for any nodes that don't
+    #       # have a defined handler, the node remains unchanged.
+    #       def on_load(node)
+    #         nil
+    #       end
+    #
+    #       def on_each(node)
+    #         node.updated(nil, process_all(node))
+    #       end
+    #     end
+    #
+    # Let's test our ArithmeticsProcessor:
+    #
+    #     include AST::Sexp
+    #     expr = s(:add, s(:integer, 2), s(:integer, 2))
+    #
+    #     p ArithmeticsProcessor.new.process(expr) == expr # => true
+    #
+    # As expected, it does not change anything at all. This isn't
+    # actually very useful, so let's now define a Calculator, which
+    # will compute the expression values:
+    #
+    #     # This Processor folds nonterminal nodes and returns an
+    #     # (integer) terminal node.
+    #     class ArithmeticsCalculator < ArithmeticsProcessor
+    #       def compute_op(node)
+    #         # First, node children are processed and then unpacked
+    #         # to local variables.
+    #         nodes = process_all(node)
+    #
+    #         if nodes.all? { |node| node.type == :integer }
+    #           # If each of those nodes represents a literal, we can
+    #           # fold this node!
+    #           values = nodes.map { |node| node.children.first }
+    #           AST::Node.new(:integer, [
+    #             yield(values)
+    #           ])
+    #         else
+    #           # Otherwise, we can just leave the current node in the
+    #           # tree and only update it with processed children
+    #           # nodes, which can be partially folded.
+    #           node.updated(nil, nodes)
+    #         end
+    #       end
+    #
+    #       def on_add(node)
+    #         compute_op(node) { |left, right| left + right }
+    #       end
+    #
+    #       def on_multiply(node)
+    #         compute_op(node) { |left, right| left * right }
+    #       end
+    #     end
+    #
+    # Let's check:
+    #
+    #     p ArithmeticsCalculator.new.process(expr) # => (integer 4)
+    #
+    # Excellent, the calculator works! Now, a careful reader could
+    # notice that the ArithmeticsCalculator does not know how to
+    # divide numbers. What if we pass an expression with division to
+    # it?
+    #
+    #     expr_with_division = \
+    #       s(:add,
+    #         s(:integer, 1),
+    #         s(:divide,
+    #           s(:add, s(:integer, 8), s(:integer, 4)),
+    #           s(:integer, 3))) # 1 + (8 + 4) / 3
+    #
+    #     folded_expr_with_division = ArithmeticsCalculator.new.process(expr_with_division)
+    #     p folded_expr_with_division
+    #     # => (add
+    #     #      (integer 1)
+    #     #      (divide
+    #     #        (integer 12)
+    #     #        (integer 3)))
+    #
+    # As you can see, the expression was folded _partially_: the inner
+    # `(add)` node which could be computed was folded to
+    # `(integer 12)`, the `(divide)` node is left as-is because there
+    # is no computing handler for it, and the root `(add)` node was
+    # also left as it is because some of its children were not
+    # literals.
+    #
+    # Note that this partial folding is only possible because the
+    # _data_ format, i.e. the format in which the computed values of
+    # the nodes are represented, is the same as the AST itself.  # # Let's extend our ArithmeticsCalculator class further.  # #     class ArithmeticsCalculator #       def on_divide(node) #         compute_op(node) { |left, right| left / right }
+    #       end
+    #
+    #       def on_negate(node)
+    #         # Note how #compute_op works regardless of the operator
+    #         # arity.
+    #         compute_op(node) { |value| -value }
+    #       end
+    #     end
+    #
+    # Now, let's apply our renewed ArithmeticsCalculator to a partial
+    # result of previous evaluation:
+    #
+    #     p ArithmeticsCalculator.new.process(expr_with_division) # => (integer 5)
+    #
+    # Five! Excellent. This is also pretty much how CRuby 1.8 executed
+    # its programs.
+    #
+    # Now, let's do some automated bug searching. Division by zero is
+    # an error, right? So if we could detect that someone has divided
+    # by zero before the program is even run, that could save some
+    # debugging time.
+    #
+    #     class DivisionByZeroVerifier < ArithmeticsProcessor
+    #       class VerificationFailure < Exception; end
+    #
+    #       def on_divide(node)
+    #         # You need to process the children to handle nested divisions
+    #         # such as:
+    #         # (divide
+    #         #   (integer 1)
+    #         #   (divide (integer 1) (integer 0))
+    #         left, right = process_all(node)
+    #
+    #         if right.type == :integer &&
+    #            right.children.first == 0
+    #           raise VerificationFailure, "Ouch! This code divides by zero."
+    #         end
+    #       end
+    #
+    #       def divides_by_zero?(ast)
+    #         process(ast)
+    #         false
+    #       rescue VerificationFailure
+    #         true
+    #       end
+    #     end
+    #
+    #     nice_expr = \
+    #       s(:divide,
+    #         s(:add, s(:integer, 10), s(:integer, 2)),
+    #         s(:integer, 4))
+    #
+    #     p DivisionByZeroVerifier.new.divides_by_zero?(nice_expr)
+    #     # => false. Good.
+    #
+    #     bad_expr = \
+    #       s(:add, s(:integer, 10),
+    #         s(:divide, s(:integer, 1), s(:integer, 0)))
+    #
+    #     p DivisionByZeroVerifier.new.divides_by_zero?(bad_expr)
+    #     # => true. WHOOPS. DO NOT RUN THIS.
+    #
+    # Of course, this won't detect more complex cases... unless you
+    # use some partial evaluation before! The possibilites are
+    # endless. Have fun.
+    module Mixin
+      # Dispatches `node`. If a node has type `:foo`, then a handler
+      # named `on_foo` is invoked with one argument, the `node`; if
+      # there isn't such a handler, {#handler_missing} is invoked
+      # with the same argument.
+      #
+      # If the handler returns `nil`, `node` is returned; otherwise,
+      # the return value of the handler is passed along.
+      #
+      # @param  [AST::Node, nil] node
+      # @return [AST::Node, nil]
+      def process(node)
+        return if node.nil?
+
+        node = node.to_ast
+
+        # Invoke a specific handler
+        on_handler = :"on_#{node.type}"
+        if respond_to? on_handler
+          new_node = send on_handler, node
+        else
+          new_node = handler_missing(node)
+        end
+
+        node = new_node if new_node
+
+        node
+      end
+
+      # {#process}es each node from `nodes` and returns an array of
+      # results.
+      #
+      # @param  [Array<AST::Node>] nodes
+      # @return [Array<AST::Node>]
+      def process_all(nodes)
+        nodes.to_a.map do |node|
+          process node
+        end
+      end
+
+      # Default handler. Does nothing.
+      #
+      # @param  [AST::Node] node
+      # @return [AST::Node, nil]
+      def handler_missing(node)
+      end
+    end
+  end
+end