bel_parser 1.0.0.alpha.27-java

data/lib/bel_parser/parsers/expression/term.rl

@@ -0,0 +1,157 @@
+# begin: ragel
+=begin
+%%{
+  machine bel;
+
+  include 'parameter.rl';
+
+  action start_function {
+    @buffers[:function] = []
+  }
+
+  action append_function {
+    @buffers[:function] << fc
+  }
+
+  action finish_function {
+    @buffers[:function] = identifier(utf8_string(@buffers[:function]))
+  }
+
+  action term_init {
+    @buffers[:term_stack] = [ term() ]
+  }
+
+  action inner_term_init {
+    @buffers[:term_stack] << term()
+  }
+
+  action term_fx {
+    fx                        = @buffers[:function]
+    @buffers[:term_stack][-1] = @buffers[:term_stack][-1] << function(fx)
+  }
+
+  action term_argument {
+    @buffers[:term_stack][-1] = @buffers[:term_stack][-1] << argument(@buffers[:parameter])
+    @buffers[:parameter]      = nil
+  }
+
+  action fxbt {
+    fpc -= @buffers[:function].length + 1
+    fcall inner_term;
+  }
+
+  action fxret {
+    inner_term = @buffers[:term_stack].pop
+    @buffers[:term_stack][-1] = @buffers[:term_stack][-1] << argument(inner_term)
+    fret;
+  }
+
+  action yield_term_ast  {
+    yield @buffers[:term_stack][-1]
+  }
+
+  inner_term :=
+    IDENT >inner_term_init >start_function $append_function %finish_function
+    SP*
+    '(' @term_fx
+      (
+        BEL_PARAMETER %term_argument |
+        IDENT >start_function $append_function '(' @fxbt
+      )
+      (
+        SP* ',' SP*
+        (
+          BEL_PARAMETER %term_argument |
+          IDENT >start_function $append_function '(' @fxbt
+        )
+      )*
+    ')' @fxret;
+
+  outer_term =
+    IDENT >term_init >start_function $append_function %finish_function
+    SP*
+    '(' @term_fx
+      (
+        BEL_PARAMETER %term_argument |
+        IDENT >start_function $append_function '(' @fxbt
+      )
+      (
+        SP* ',' SP*
+        (
+          BEL_PARAMETER %term_argument |
+          IDENT >start_function $append_function '(' @fxbt
+        )
+      )*
+    ')';
+
+  term :=
+    outer_term %yield_term_ast NL;
+}%%
+=end
+# end: ragel
+
+require_relative '../ast/node'
+require_relative '../mixin/buffer'
+require_relative '../nonblocking_io_wrapper'
+
+module BELParser
+  module Parsers
+    module Expression
+      module Term
+
+        class << self
+
+          MAX_LENGTH = 1024 * 128 # 128K
+
+          def parse(content)
+            return nil unless content
+
+            Parser.new(content).each do |obj|
+              yield obj
+            end
+          end
+        end
+
+        private
+
+        class Parser
+          include Enumerable
+          include BELParser::Parsers::Buffer
+          include BELParser::Parsers::AST::Sexp
+
+          def initialize(content)
+            @content = content
+      # begin: ragel        
+            %% write data;
+      # end: ragel        
+          end
+
+          def each
+            @buffers = {}
+            stack    = []
+            data     = @content.unpack('C*')
+            p        = 0
+            pe       = data.length
+            eof      = data.length
+
+      # begin: ragel        
+            %% write init;
+            %% write exec;
+      # end: ragel        
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  $stdin.each_line do |line|
+    BELParser::Parsers::Expression::Term.parse(line) { |obj|
+      puts obj.inspect
+    }
+  end
+end
+
+# vim: ft=ruby ts=2 sw=2:
+# encoding: utf-8

data/lib/bel_parser/parsers/line_parser.rb

@@ -0,0 +1,92 @@
+require_relative 'common'
+require_relative 'expression'
+require_relative 'bel_script'
+
+# Top-level LINE module.
+module LINE
+  include BELParser::Parsers::Common
+  include BELParser::Parsers::Expression
+  include BELParser::Parsers::BELScript
+
+  BEL_PARSERS = [
+    BELParser::Parsers::Common::BlankLine,
+    BELParser::Parsers::Common::CommentLine,
+    BELParser::Parsers::Common::Identifier,
+    BELParser::Parsers::Common::String,
+    BELParser::Parsers::Common::List,
+    BELParser::Parsers::Expression::Parameter,
+    BELParser::Parsers::Expression::Term,
+    BELParser::Parsers::Expression::Relationship,
+    BELParser::Parsers::Expression::Comment,
+    BELParser::Parsers::Expression::ObservedTerm,
+    BELParser::Parsers::Expression::SimpleStatement,
+    BELParser::Parsers::Expression::NestedStatement,
+    BELParser::Parsers::BELScript::DefineAnnotation,
+    BELParser::Parsers::BELScript::DefineNamespace,
+    BELParser::Parsers::BELScript::Set,
+    BELParser::Parsers::BELScript::Unset
+  ].freeze
+
+  # rubocop:disable MethodLength, AbcSize
+  def self.parse(io)
+    # single line transform
+    line_enum = io
+                .each_line
+                .lazy
+                .map { |line| LINE.normalize_line_terminators(line) }
+
+    # multi-line transform
+    loop do
+      begin
+        line = line_enum.next
+
+        while line.end_with?("\\\n")
+          line.chomp!("\\\n")
+          line += line_enum.next
+        end
+
+        BEL_PARSERS.each do |parser|
+          # rubocop:disable BlockDelimiters
+          parser.parse(line) { |obj|
+            puts "parser: #{parser.inspect},"\
+                 "line: #{line.strip},"\
+                 "object: \n#{obj.inspect}"
+          }
+        end
+      rescue StopIteration
+        return
+      end
+    end
+  end
+
+  def self.normalize_line_terminators(string)
+    return nil unless string
+    string.strip + "\n"
+  end
+
+  def self.map_empty_line(string)
+    if LINE.match_empty_line(string)
+      nil
+    else
+      string
+    end
+  end
+
+  def self.map_comment_line(string)
+    if LINE.match_comment_line(string)
+      nil
+    else
+      string
+    end
+  end
+
+  def self.match_empty_line(string)
+    string =~ /^\s*$/
+  end
+
+  def self.match_comment_line(string)
+    string =~ /^\s*#/
+  end
+end
+
+LINE.parse($stdin) if FILE == $PROGRAM_NAME

data/lib/bel_parser/parsers/mixin/buffer.rb

@@ -0,0 +1,10 @@
+module BELParser
+  module Parsers
+    # Buffer module.
+    module Buffer
+      def utf8_string(buffer)
+        buffer.pack('C*').force_encoding('utf-8')
+      end
+    end
+  end
+end

data/lib/bel_parser/parsers/nonblocking_io_wrapper.rb

@@ -0,0 +1,50 @@
+# Provides a platform-independent, non-blocking wrapper for reading an
+# {http://ruby-doc.org/core-2.2.2/IO.html IO}-like object. This wrapper
+# object must be enumerated using the {#each} method.
+class NonblockingIOWrapper
+  # Initialize this wrapper around the +io+ object and read at most
+  # +read_length+ bytes in a non-blocking manner.
+  #
+  # @param [IO]     io          an IO-like object
+  # @param [Fixnum] read_length the buffer length to read
+  def initialize(io, read_length = (128 * 1024))
+    @io          = io
+    @read_length = read_length
+    @read_method = nonblocking_read(@io)
+  end
+
+  # Yields each buffer read from the wrapped IO-like object to the provided
+  # block (e.g. +{ |block| ... }+). The read length is set on {#initialize}.
+  #
+  # @yield the buffers read from the IO-like object
+  # @yieldparam [String] buffer the read buffer as uninterpreted bytes
+  def each
+    while (buffer = @read_method.call(@read_length))
+      yield buffer
+    end
+  rescue IO::WaitReadable
+    IO.select([@io])
+    retry
+  # rubocop:disable HandleExceptions
+  rescue EOFError
+    # end of stream; parsing complete
+  end
+
+  private
+
+  # Returns the method, appropriate for your platform, to read IO in a
+  # non-blocking manner.
+  #
+  # @example Call directly.
+  #   nonblocking_read(StringIO.new('hello')).call(4)
+  #
+  # @param  [IO] io an IO-like object
+  # @return [Method] a non-blocking read method
+  def nonblocking_read(io)
+    if Gem.win_platform?
+      io.method(:sysread)
+    else
+      io.method(:read_nonblock)
+    end
+  end
+end

data/lib/bel_parser/parsers/serializer.rb

@@ -0,0 +1,205 @@
+require 'bel_parser/vendor/ast'
+
+module BELParser
+  module Parsers
+
+    def serialize(ast_node)
+      serializer = Serializer.new
+      serializer.process(ast_node)
+      serializer.string
+    end
+
+    # Defines an {AST::Processor::Mixin AST processor} that serializes
+    # all {AST::Node AST node} to a string.
+    class Serializer
+      include ::AST::Processor::Mixin
+
+      attr_reader :string
+
+      def initialize
+        @string = ''
+      end
+
+      def on_annotation_definition(annotation_definition_node)
+        @string << 'DEFINE ANNOTATION '
+        process(annotation_definition_node.keyword)
+        @string << ' AS '
+        process(annotation_definition_node.domain)
+      end
+
+      def on_argument(argument_node)
+        @string << ', ' if @separate_by_comma
+
+        process(argument_node.child)
+        @separate_by_comma = true
+      end
+
+      def on_blank_line(blank_line_node)
+        @string << ''
+      end
+
+      def on_comment_line(comment_line_node)
+        @string << %(##{comment_line_node.children[0]})
+      end
+
+      def on_document_property(document_property_node)
+       name  = document_property_node.name.identifier.string_literal
+       value = document_property_node.value.children[0].string_literal
+       @string << %(SET DOCUMENT #{name} = #{value})
+      end
+
+      def on_domain(domain_node)
+        process(domain_node.child)
+      end
+
+      def on_function(function_node)
+        @string << function_node.identifier.string_literal
+      end
+
+      def on_identifier(identifier_node)
+        @string << identifier_node.string_literal
+      end
+
+      def on_keyword(keyword_node)
+        process(keyword_node.identifier)
+      end
+
+      def on_list(list_node)
+        items = list_node.list_items
+        if !items || items.empty?
+          @string << '{}'
+        else
+          @string << '{ '
+          process(items[0])
+          items[1..-1].each do |rest_item|
+            @string << ', '
+            process(rest_item)
+          end
+          @string << ' }'
+        end
+      end
+
+      def on_list_item(list_item_node)
+        process(list_item_node.children[0])
+      end
+
+      def on_name(name_node)
+        process(name_node.identifier)
+      end
+
+      def on_namespace_definition(namespace_definition_node)
+        @string << 'DEFINE NAMESPACE '
+        process(namespace_definition_node.keyword)
+        @string << ' AS '
+        process(namespace_definition_node.domain)
+      end
+
+      def on_nested_statement(nested_statement_node)
+        process(nested_statement_node.statement)
+      end
+
+      def on_object(object_node)
+        process(object_node.child)
+      end
+
+      def on_observed_term(observed_term_node)
+        process(observed_term_node.statement)
+      end
+
+      def on_parameter(param_node)
+        process(param_node.prefix)
+        process(param_node.value)
+      end
+
+      def on_pattern(pattern_node)
+        @string << 'PATTERN '
+        process(pattern_node.string)
+      end
+
+      def on_prefix(prefix_node)
+        prefix = prefix_node.identifier
+        @string << "#{prefix.string_literal}:" unless prefix.nil?
+      end
+
+      def on_relationship(relationship_node)
+        @string << " #{relationship_node.string_literal} "
+      end
+
+      def on_set(set_node)
+        @string << 'SET '
+        process(set_node.name)
+        @string << ' = '
+        process(set_node.value)
+      end
+
+      def on_simple_statement(simple_statement_node)
+        process(simple_statement_node.statement)
+      end
+
+      def on_statement(statement_node)
+        process(statement_node.subject)
+        return if statement_node.object.child.nil?
+
+        process(statement_node.relationship)
+        object_node = statement_node.object
+        if object_node.statement?
+          @string << '('
+          process(object_node)
+          @string << ')'
+        else
+          process(object_node)
+        end
+      end
+
+      def on_string(string_node)
+        @string << string_node.string_literal
+      end
+
+      def on_subject(subject_node)
+        process(subject_node.term)
+      end
+
+      # Called when visiting nodes of type +term+.
+      def on_term(term_node)
+        @separate_by_comma = false
+        process(term_node.function)
+        @string << '('
+        term_node.arguments.each { |arg| process(arg) }
+        @string << ')'
+      end
+
+      def on_unset(unset_node)
+        @string << 'UNSET '
+        process(unset_node.name)
+      end
+
+      def on_url(url_node)
+        @string << 'URL '
+        process(url_node.string)
+      end
+
+      def on_value(value_node)
+        process(value_node.children[0])
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  $LOAD_PATH.unshift(
+    File.join(
+      File.expand_path(File.dirname(__FILE__)),
+      '..',
+      '..',
+      '..',
+      'lib'))
+  require 'bel_parser'
+
+  types      = ARGV.map(&:to_sym)
+  generator  = BELParser::ASTGenerator.new($stdin)
+  BELParser::ASTFilter.new(generator, *types).each do |(num, line, results)|
+    serializer = BELParser::Parsers::Serializer.new
+    serializer.process(results.first)
+    puts serializer.string
+  end
+end