pione 0.1.0

data/lib/pione/model/variable.rb

@@ -0,0 +1,87 @@
+module Pione::Model
+  # Variable represent variable name objects. A variable object can evaluates
+  # its value with the variable table.
+  class Variable < BasicModel
+    set_pione_model_type TypeAny
+
+    attr_reader :name
+
+    # Creates a variable with name.
+    # @param [String] name
+    #   variable name
+    def initialize(name)
+      @name = name.to_s
+      super()
+    end
+
+    # Evaluates self variable name in the table and returns it. Return self if
+    # the variable name is unbound in the table.
+    # @param [VariableTable] vtable
+    #   variable table for evaluation
+    # @return [BasicModel]
+    #   evaluation result
+    def eval(vtable)
+      val = vtable.get(self)
+      raise UnboundVariableError.new(self) if val.nil?
+      return val
+    end
+
+    # Returns true because variable is a variable.
+    # @return [Boolean]
+    #   true
+    def include_variable?
+      true
+    end
+
+    def set_toplevel(b)
+      @toplevel = b
+    end
+
+    # Returns true if the variable is defined in toplevel.
+    # @return [Boolean]
+    #   true if the variable is defined in toplevel
+    def toplevel?
+      @toplevel
+    end
+
+    # @api private
+    def task_id_string
+      "Variable<#{@name}>"
+    end
+
+    # @api private
+    def textize
+      "$%s" % [@name]
+    end
+
+    # Comparisons with other variable.
+    # @api private
+    def <=>(other)
+      unless other.kind_of?(self.class)
+        raise ArgumentError.new(other)
+      end
+      @name <=> other.name
+    end
+
+    # Return true if other is a variable object which name is same as myself.
+    # @api private
+    def ==(other)
+      other.kind_of?(self.class) && @name == other.name
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @name.hash
+    end
+
+    # @api private
+    def inspect
+      "#<Pione::Model::Variable @name=%s>" % @name.inspect
+    end
+
+    # @api private
+    alias :to_s :inspect
+  end
+end

data/lib/pione/parser/block-parser.rb

@@ -0,0 +1,83 @@
+module Pione
+  module Parser
+    # BlockParser is a set of parser atoms for rule block.
+    module BlockParser
+      include Parslet
+      include SyntaxError
+      include CommonParser
+      include LiteralParser
+      include ExprParser
+      include FlowElementParser
+
+      # @!attribute [r] block
+      #   +block+ matches flow block or action block.
+      #   @return [Parslet::Atoms::Entity] +block+ atom
+      rule(:block) {
+        flow_block |
+        action_block
+      }
+
+      # @!attribute [r] flow_block
+      #   +flow_block+ matches flow block.
+      #   @return [Parslet::Atoms::Entity] +flow_block+ atom
+      #   @example
+      #     Flow
+      #       rule A
+      #       if $X
+      #         rule B
+      #       end
+      #     End
+      rule(:flow_block) {
+        ( flow_block_begin_line >>
+          (flow_element.repeat(1) |
+            syntax_error("flow elements not found", [:flow_element])) >>
+          (block_end_line |
+            syntax_error("block end not found", [:keyword_End]))
+         ).as(:flow_block)
+      }
+
+      # @!attribute [r] action_block
+      #   +action_block+ matches action block.
+      #   @return [Parslet::Atoms::Entity] +action_block+ atom
+      #   @example
+      #     Action
+      #       echo "abc" > out.txt
+      #     End
+      rule(:action_block) {
+        ( action_block_begin_line >>
+          ( (block_end_line.absent? >> any).repeat(1).as(:content) |
+            syntax_error("empty action block", [])) >>
+          ( block_end_line |
+            syntax_error("block end not found", [:keyword_End]))
+        ).as(:action_block)
+      }
+
+      # @!attribute [r] flow_block_begin_line
+      #   +flow_block_begin_line+ matches flow block heading.
+      #   @return [Parslet::Atoms::Entity] +flow_block_begin_line+ atom
+      #   @example
+      #     Flow
+      rule(:flow_block_begin_line) {
+        space? >> keyword_Flow >> str('-').repeat >> line_end
+      }
+
+      # @!attribute [r] action_block_begin_line
+      #   +flow_block_begin_line+ matches action block heading.
+      #   @return [Parslet::Atoms::Entity] +action_block_begin_line+ atom
+      #   @example
+      #     Action
+      rule(:action_block_begin_line) {
+        space? >> keyword_Action.as(:key) >> str('-').repeat >> line_end
+      }
+
+      # @!attribute [r] block_end_line
+      #   +block_end_line+ matches block end keyword.
+      #   @return [Parslet::Atoms::Entity] +block_end_line+ atom
+      #   @example
+      #     End
+      rule(:block_end_line) {
+        space? >> str('-').repeat >> keyword_End >> line_end
+      }
+    end
+  end
+end

data/lib/pione/parser/common-parser.rb

@@ -0,0 +1,145 @@
+module Pione
+  module Parser
+    # CommonParser is a set of symbols, keywords, and utility parsers.
+    module CommonParser
+      include Parslet
+
+      #
+      # symbols
+      #
+
+      SYMBOLS = {
+        :squote => '\'',
+        :dquote => '"',
+        :backslash => "\\",
+        :dot => '.',
+        :comma => ',',
+        :lparen => '(',
+        :rparen =>')',
+        :lbrace => '{',
+        :rbrace => '}',
+        :slash => '/',
+        :plus => '+',
+        :minus => '-',
+        :question => '?',
+        :vbar => '|',
+        :ampersand => '&',
+        :doller => '$',
+        :colon => ':',
+        :equals => '=',
+        :exclamation => '!',
+        :less_than => '<',
+        :greater_than => '>',
+        :asterisk => '*',
+        :percent => '%',
+        :atmark => '@',
+        :hat => '^',
+        :sharp => '#',
+        :lsbracket => '[',
+        :rsbracket => ']'
+      }
+
+      # make symbols
+      SYMBOLS.each do |key, val|
+        rule(key) { str(val) }
+      end
+
+      # @!attribute [r] symbols
+      #   +symbols+ matches all symbols in PIONE document.
+      #   @return [Parslet::Atoms::Entity] +symbols+ atom
+      rule(:symbols) {
+        SYMBOLS.keys.inject(nil) do |res, elt|
+          res ? res | send(elt) : send(elt)
+        end
+      }
+
+      #
+      # keywords
+      #
+
+      KEYWORDS = {
+        :keyword_Rule => 'Rule',
+        :keyword_Flow => 'Flow',
+        :keyword_Action => 'Action',
+        :keyword_End => 'End',
+        :keyword_input => 'input',
+        :keyword_output => 'output',
+        :keyword_param => 'param',
+        :keyword_feature => 'feature',
+        :keyword_rule => 'rule',
+        :keyword_if => 'if',
+        :keyword_else => 'else',
+        :keyword_case => 'case',
+        :keyword_when => 'when',
+        :keyword_end => 'end',
+        :keyword_package => 'package',
+        :keyword_require => 'require',
+        :keyword_true => 'true',
+        :keyword_false => 'false',
+        :keyword_and => 'and',
+        :keyword_or => 'or'
+      }
+
+      # make keywords
+      KEYWORDS.each do |key, val|
+        rule(key) { str(val) }
+      end
+
+      #
+      # utilities
+      #
+
+      # @!attribute [r] identifier
+      #   +identifier+ matches any sequences excluding space, symbols, and
+      #     line end.
+      #   @return [Parslet::Atoms::Entity] +identifier+ atom
+      rule(:identifier) {
+        ((space | symbols | line_end).absent? >> any).repeat(1)
+      }
+
+      # @!attribute [r] digit
+      #   +digit+ matches 0-9.
+      #   @return [Parslet::Atoms::Entity] +digit+ atom
+      rule(:digit) { match('[0-9]') }
+
+      # @!attribute [r] space
+      #   +space+ matches sequences of space character or tab.
+      #   @return [Parslet::Atoms::Entity] +space+ atom
+      rule(:space) { match("[ \t]").repeat(1) }
+
+      # @!attribute [r] space?
+      #   +space?+ matches +space+ atom or empty.
+      #   @return [Parslet::Atoms::Entity] +space?+ atom
+      rule(:space?) { space.maybe }
+
+      # @!attribute [r] pad
+      #   +space?+ matches space character, tab, and newline.
+      #   @return [Parslet::Atoms::Entity] +pad+ atom
+      rule(:pad) { match("[ \t\n]").repeat(1) }
+
+      # @!attribute [r] pad?
+      #   +space?+ matches +pad+ atom or empty.
+      #   @return [Parslet::Atoms::Entity] +pad?+ atom
+      rule(:pad?) { pad.maybe }
+
+      # @!attribute [r] line_end
+      #   +line_end+ matches a space sequence until line end.
+      #   @return [Parslet::Atoms::Entity] +line_end+ atom
+      rule(:line_end) { space? >> (str("\n") | any.absent?) }
+
+      # @!attribute [r] empty_lines
+      #   +empty_line+ matches empty lines.
+      #   @return [Parslet::Atoms::Entity] +empty_line+ atom
+      rule(:empty_lines) {
+        (space? >> str("\n")).repeat(1) >>
+        (space? >> any.absent?).maybe
+      }
+
+      # @!attribute [r] empty_lines?
+      #   +empty_lines?+ matches empty lines or empty.
+      #   @return [Parslet::Atoms::Entity] empty_line? atom
+      rule(:empty_lines?) { empty_lines.maybe }
+    end
+  end
+end
+

data/lib/pione/parser/document-parser.rb

@@ -0,0 +1,58 @@
+module Pione
+  module Parser
+    # DocumentParser is a parser for PIONE rule document.
+    class DocumentParser < Parslet::Parser
+      include CommonParser
+      include LiteralParser
+      include FeatureExprParser
+      include ExprParser
+      include FlowElementParser
+      include BlockParser
+      include RuleDefinitionParser
+
+      def parse(str)
+        super(str.gsub(/^(?!#!)#.*/, ""))
+      end
+
+      #
+      # root
+      #
+
+      root(:rule_definitions)
+
+      #
+      # document statement
+      #
+
+      rule(:document_statements) {
+        document_statement.repeat.as(:document_statements)
+      }
+
+      # document_statement
+      rule(:document_statement) {
+        package_line |
+        require_line
+      }
+
+      # package_line
+      rule(:package_line) {
+        ( space? >>
+          keyword_package >>
+          space >>
+          package_name >>
+          line_end
+        ).as(:package)
+      }
+
+      # require_line
+      rule(:require_line) {
+        ( space? >>
+          keyword_require >>
+          space >>
+          package_name >>
+          line_end
+        ).as(:require)
+      }
+    end
+  end
+end

data/lib/pione/parser/error-message.yml

@@ -0,0 +1,4 @@
+parameters_missing_colon:
+  "Parameter elements should be 'key:value' form, but colon is missing."
+parameters_missing_value:
+  "It should be parameter value."

data/lib/pione/parser/expr-parser.rb

@@ -0,0 +1,266 @@
+module Pione
+  module Parser
+    # ExprParser is a set of parser atoms for PIONE expressions.
+    module ExprParser
+      include Parslet
+      include SyntaxError
+      include CommonParser
+      include LiteralParser
+      include FeatureExprParser
+
+      # @!attribute [r] expr
+      #   +expr+ matches all expressions in PIONE document.
+      #   @return [Parslet::Atoms::Entity] +expr+ atom
+      #   @example
+      #     1 + 1
+      #   @example
+      #     (1 + 1).next
+      #   @example
+      #     ("abc" + "def")[1]
+      #   @example
+      #     true
+      #   @example
+      #     '*.txt'.as_string
+      rule(:expr) {
+        ( expr_operator_application |
+          assignment |
+          (expr_element.as(:receiver) >>
+            (index | message).repeat(1).as(:messages)) |
+          expr_element
+        ).as(:expr)
+      }
+
+      # @!attribute [r] expr_element
+      #   +expr_element+ matches simple expressions.
+      #   @return [Parslet::Atoms::Entity] +expr_element+ atom
+      #   @example
+      #     true
+      #   @example
+      #     "abc"[0]
+      #   @example
+      #     'abc'.as_string
+      #   @example
+      #     (1 + 1)
+      #   @example
+      #     ("abc".index(1, 1))
+      rule(:expr_element) {
+        ( (atomic_expr.as(:receiver) >> indexes) |
+          (atomic_expr.as(:receiver) >> messages) |
+          atomic_expr |
+          lparen >> expr >> rparen
+        )
+      }
+
+      # @!attribute [r] atomic_expr
+      #   +expr+ matches atomic expressions.
+      #   @return [Parslet::Atoms::Entity] +atomic_expr+ atom
+      #   @example
+      #     true
+      #   @example
+      #     0.1
+      #   @example
+      #     1
+      #   @example
+      #     "abc"
+      #   @example
+      #     $var
+      #   @example
+      #     '*.txt'
+      #   @example
+      #     {var: 1}
+      #   @example
+      #     $abc:test
+      #   @example
+      #     abc
+      rule(:atomic_expr) {
+        boolean |
+        float |
+        integer |
+        string |
+        data_name |
+        rule_expr |
+        feature_expr |
+        parameters |
+        variable
+      }
+
+      # @!attribute [r] rule_expr
+      #   +rule_expr+ matches rule expressions.
+      #   @return [Parslet::Atoms::Entity] +rule_expr+ atom
+      #   @example
+      #     &abc:test
+      #   @example
+      #     :test
+      #   @example
+      #     test
+      rule(:rule_expr) {
+        ( package_name.as(:package) >> colon >> rule_name.as(:expr) |
+          colon >> rule_name |
+          rule_name
+        ).as(:rule_expr)
+      }
+
+      # @!attribute [r] expr_operator
+      #   +expr_operator+ matches expression operators.
+      #   @return [Parslet::Atoms::Entity] +expr_operator+ atom
+      #   @example
+      #     :=, ==, !=, >=, >, <=, <, &&, ||, +, -, *, /, %, or, and
+      rule(:expr_operator) {
+        equals >> equals |
+        exclamation >> equals |
+        less_than >> equals |
+        less_than |
+        greater_than >> equals |
+        greater_than |
+        ampersand >> ampersand |
+        vbar >> vbar |
+        plus |
+        minus |
+        asterisk |
+        slash |
+        percent |
+        keyword_or |
+        keyword_and
+      }
+
+      # @!attribute [r] expr_operator_application
+      #   +expr_operator_application+ matches operator application.
+      #   @return [Parslet::Atoms::Entity] +expr_operator_application+ atom
+      #   @example
+      #     X + X
+      rule(:expr_operator_application) {
+        ( expr_element.as(:left) >>
+          pad? >>
+          expr_operator.as(:operator) >>
+          pad? >>
+          expr.as(:right)
+        ).as(:expr_operator_application)
+      }
+
+      # @!attribute [r] assignment
+      #   +assignment+ matches variable assignment.
+      #   @return [Parslet::Atoms::Entity] +assignment+ atom
+      #   @example
+      #     $X := 1
+      rule(:assignment) {
+        ( variable.as(:symbol) >>
+          space? >>
+          colon >> equals >>
+          pad? >>
+          expr.as(:value)
+        ).as(:assignment)
+      }
+
+      # @!attribute [r] messages
+      #   +messages+ matches message list.
+      #   @return [Parslet::Atoms::Entity] +messages+ atom
+      #   @example
+      #     .params("-w").sync
+      rule(:messages) {
+        message.repeat(1).as(:messages)
+      }
+
+      # @!attribute [r] message
+      #   +message+ matches message sending.
+      #   @return [Parslet::Atoms::Entity] +message+ atom
+      #   @example
+      #     # message with no arguments
+      #     .to_string
+      #   @example
+      #     # message with arguments
+      #     .params("-w")
+      rule(:message) {
+        ( dot >>
+          identifier.as(:message_name) >>
+          message_parameters.maybe
+        ).as(:message)
+      }
+
+      # @!attribute [r] message_parameters
+      #   +message_parameters+ matches message parameters.
+      #   @return [Parslet::Atoms::Entity] +message_parameters+ atom
+      #   @example
+      #     ("-w")
+      #   @example
+      #     (true, false)
+      rule(:message_parameters) {
+        lparen >>
+        pad? >>
+        message_parameters_elements.maybe.as(:message_parameters) >>
+        pad? >>
+        rparen
+      }
+
+      # @!attribute [r] message_parameters_elements
+      #   +message_parameters_elements+ matches message parameters.
+      #   @return [Parslet::Atoms::Entity] +message_parameters_elements+ atom
+      #   @example
+      #     (true)
+      #   @example
+      #     (true, true, true)
+      rule(:message_parameters_elements) {
+        expr >> message_parameters_elements_rest.repeat
+      }
+
+      # @!attribute [r] message_paramters_elements_rest
+      #   +message_parameters_elements+ matches message parameters rest.
+      #   @return [Parslet::Atoms::Entity] +message_paramters_elements_rest+ atom
+      #   @example
+      #     , true
+      rule(:message_parameters_elements_rest) {
+        pad? >> comma >> pad? >> expr
+      }
+
+      # @!attribute [r] indexes
+      #   +indexes+ matches object index list.
+      #   @return [Parslet::Atoms::Entity] +indexes+ atom
+      #   @example
+      #     [1][2][3]
+      rule(:indexes) {
+        index.repeat(1).as(:indexes)
+      }
+
+      # @!attribute [r] index
+      #   +index+ matches object index.
+      #   @return [Parslet::Atoms::Entity] +index+ atom
+      #   @example
+      #     [1]
+      #     [1,1]
+      #     [1,2,3]
+      rule(:index) {
+        ( lsbracket >>
+          space? >>
+          ( index_arguments.as(:index) |
+            syntax_error("it should be index arguments", :expr)) >>
+          space? >>
+          rsbracket
+        )
+      }
+
+      # @!attribute [r] index_arguments
+      #   +index_arguments+ matches arguments of object index.
+      #   @return [Parslet::Atoms::Entity] +index_arguments+ atom
+      #   @example
+      #     1
+      #     1,1
+      #     1,2,3
+      rule(:index_arguments) {
+        expr.repeat(1,1) >> space? >> index_arguments_rest.repeat
+      }
+
+      # @!attribute [r] index_arguments_rest
+      #   +index_arguments_rest+ matches argument tail of object index.
+      #   @return [Parslet::Atoms::Entity] +index_arguments_rest+ atom
+      #   @example
+      #     ,1
+      rule(:index_arguments_rest) {
+        space? >>
+        comma >>
+        space? >>
+        ( expr |
+          syntax_error("it should be expr", :expr)
+        )
+      }
+    end
+  end
+end