pione 0.2.2 → 0.3.0

data/lib/pione/parser/flow-element-parser.rb

@@ -1,181 +0,0 @@
-module Pione
-  module Parser
-    # FlowElementParser is a set of parser atoms for flow elements.
-    module FlowElementParser
-      include Parslet
-      include SyntaxError
-      include CommonParser
-      include LiteralParser
-      include ExprParser
-
-      # @!attribute [r] flow_element
-      #   +flow_element+ matches flow element.
-      #   @return [Parslet::Atoms::Entity] +flow_element+ atom
-      #   @example
-      #     # rule calling
-      #     rule A
-      #   @example
-      #     # if block
-      #     if $VAR
-      #       rule A
-      #     end
-      #   @example
-      #     # case block
-      #     case $VAR
-      #     when "A"
-      #       rule A
-      #     when "B"
-      #       rule B
-      #     end
-      #   @example
-      #     # assignment
-      #     $VAR := true
-      rule(:flow_element) {
-        call_rule_line |
-        if_block |
-        case_block |
-        assignment_line
-      }
-
-      # @!attribute [r] call_rule_line
-      #   +call_rule_line+ matches calling rule.
-      #   @return [Parslet::Atoms::Entity] +call_rule_line+ atom
-      #   @example
-      #     rule Test
-      rule(:call_rule_line) {
-        ( space? >>
-          keyword_rule >>
-          space? >>
-          expr >>
-          line_end
-        ).as(:call_rule)
-      }
-
-      # @!attribute [r] if_block
-      #   +if_block+ matches +if+ conditional block.
-      #   @return [Parslet::Atoms::Entity] +if_block+ atom
-      #   @example
-      #     if $Var
-      #       rule Test1
-      #     else
-      #       rule Test2
-      #     end
-      rule(:if_block) {
-        ( if_block_begin >>
-          flow_element.repeat.as(:if_true_elements) >>
-          else_block.maybe.as(:if_else_block) >>
-          (conditional_block_end | syntax_error("keyword 'end' not found", [:end]))
-        ).as(:if_block)
-      }
-
-      # @!attribute [r] if_block_begin
-      #   +if_block_begin+ matches +if+ block condition.
-      #   @return [Parslet::Atoms::Entity] +if_block_begin+ atom
-      #   @example
-      #     if $Var
-      rule(:if_block_begin) {
-        space? >>
-        keyword_if >>
-        space? >>
-        (expr.as(:condition) | syntax_error("condition not found", [:expr])) >>
-        line_end
-      }
-
-      # @!attribute [r] else_block
-      #   +else_block+ matches +else+ block.
-      #   @return [Parslet::Atoms::Entity] +else_block+ atom
-      #   @example
-      #     else
-      #       rule Test1
-      #       rule Test2
-      #       ...
-      rule(:else_block) {
-        ( space? >>
-          keyword_else >>
-          line_end >>
-          flow_element.repeat.as(:elements)
-        ).as(:else_block)
-      }
-
-      # @!attribute [r] conditional_block_end
-      #   +conditional_block_end+ matches conditional block end.
-      #   @return [Parslet::Atoms::Entity] +conditional_block_end+ atom
-      #   @example
-      #     end
-      rule(:conditional_block_end) {
-        space? >> keyword_end >> line_end
-      }
-
-      # @!attribute [r] case_block
-      #   +case_block+ matches conditional block end.
-      #   @return [Parslet::Atoms::Entity] +case_block+ atom
-      #   @example
-      #     case $Var
-      #     when 1
-      #       rule Test1
-      #     when 2
-      #       rule Test2
-      #     else
-      #       rule Test3
-      #     end
-      rule(:case_block) {
-        ( case_block_begin >>
-          when_block.repeat.as(:when_blocks) >>
-          else_block.maybe.as(:case_else_block) >>
-          conditional_block_end
-        ).as(:case_block)
-      }
-
-      # @!attribute [r] case_block_begin
-      #   +case_block_begin+ matches +case+ block beginning.
-      #   @return [Parslet::Atoms::Entity] +case_block_begin+ atom
-      #   @example
-      #     case $Var
-      rule(:case_block_begin) {
-        space? >>
-        keyword_case >>
-        space? >>
-        expr.as(:condition) >>
-        line_end
-      }
-
-      # @!attribute [r] when_block
-      #   +when_block+ matches +when+ block.
-      #   @return [Parslet::Atoms::Entity] +when_block+ atom
-      #   @example
-      #     when 1
-      #       rule Test1
-      #       rule Test2
-      #       ...
-      rule(:when_block) {
-        ( when_block_begin >>
-          flow_element.repeat.as(:elements)
-        ).as(:when_block)
-      }
-
-      # @!attribute [r] when_block_begin
-      #   +when_block_begin+ matches +when+ block beginning.
-      #   @return [Parslet::Atoms::Entity] +when_block_begin+ atom
-      #   @example
-      #     when 1
-      rule(:when_block_begin) {
-        space? >>
-        keyword_when >>
-        space? >>
-        expr.as(:value) >>
-        line_end
-      }
-
-      # @!attribute [r] assignment_line
-      #   +assignment_line+ matches variable assignment line.
-      #   @return [Parslet::Atoms::Entity] +assignment_line+ atom
-      #   @example
-      #     $X := 1
-      rule(:assignment_line) {
-        space? >>
-        assignment >>
-        line_end
-      }
-    end
-  end
-end

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

@@ -1,196 +0,0 @@
-module Pione
-  module Parser
-    # LiteralParser is a set of parser atom for literal descriptions.
-    module LiteralParser
-      include Parslet
-
-      # @!attribute [r] boolean
-      #   +boolean+ matches +true+ or +false+.
-      #   @return [Parslet::Atoms::Entity] +boolean+ atom
-      #   @example
-      #     true
-      #   @example
-      #     false
-      rule(:boolean) {
-        (keyword_true | keyword_false).as(:boolean)
-      }
-
-      # @!attribute [r] string
-      #   +string+ matches string.
-      #   @return [Parslet::Atoms::Entity] +string+ atom
-      #   @example
-      #     "abc"
-      rule(:string) {
-        dquote >>
-        (backslash >> any | dquote.absent? >> any).repeat.as(:string) >>
-        (dquote | syntax_error("It should be double quotation.", :dquote))
-      }
-
-      # @!attribute [r] integer
-      #   +integer+ matches integer number.
-      #   @return [Parslet::Atoms::Entity] +integer+ atom
-      #   @example
-      #     123
-      #   @example
-      #     +123
-      #   @example
-      #     -123
-      rule(:integer) {
-        ( match('[+-]').maybe >>
-          digit.repeat(1)
-        ).as(:integer)
-      }
-
-      # @!attribute [r] float
-      #   +float+ matches float number.
-      #   @return [Parslet::Atoms::Entity] +float+ atom
-      #   @example
-      #     1.0
-      #   @example
-      #     +1.0
-      #   @example
-      #     -1.0
-      #   @example
-      #     1.0e100
-      #   @example
-      #     1.0e+100
-      #   @example
-      #     1.0e-100
-      rule(:float) {
-        ( match('[+-]').maybe >>
-          digit.repeat(1) >>
-          dot >>
-          digit.repeat(1) >>
-          (match('[eE]') >> match('[+-]').maybe >> digit.repeat(1)).maybe
-        ).as(:float)
-      }
-
-      # @!attribute [r] float
-      #   +float+ matches float number.
-      #   @return [Parslet::Atoms::Entity] +float+ atom
-      #   @example
-      #     $VAR
-      #   @example
-      #     $*
-      rule(:variable) {
-        doller >>
-        (asterisk | identifier).as(:variable)
-      }
-
-      # @!attribute [r] data_name
-      #   +data_name+ matches data name.
-      #   @return [Parslet::Atoms::Entity] +data_name+ atom
-      #   @example
-      #     'result.txt'
-      #   @example
-      #     '*.txt'
-      rule(:data_name) {
-        squote >>
-        (backslash >> any | squote.absent? >> any).repeat.as(:data_name) >>
-        squote
-      }
-
-      # @!attribute [r] package_name
-      #   +package_name+ matches package name.
-      #   @return [Parslet::Atoms::Entity] +package_name+ atom
-      #   @example
-      #     &Main
-      rule(:package_name) {
-        ampersand >>
-        identifier.repeat(1).as(:package_name)
-      }
-
-      # @!attribute [r] rule_name
-      #   +rule_name+ matches rule name.
-      #   @return [Parslet::Atoms::Entity] +rule_name+ atom
-      #   @example
-      #     Main
-      rule(:rule_name) {
-        identifier.as(:rule_name)
-      }
-
-      # @!attribute [r] parameters
-      #   +parameters+ matches parameters table.
-      #   @return [Parslet::Atoms::Entity] +parameters+ atom
-      #   @example
-      #     {abc: "a"}
-      #   @example
-      #     {a: 1, b: 2, c: 3}
-      rule(:parameters) {
-        lbrace >>
-        ( pad? >>
-          ( parameters_elements.maybe.as(:parameters) |
-            syntax_error("it should be parameter key", :identifier)
-          ) >>
-          pad? >>
-          (rbrace | syntax_error("it should be parameters end.", :parameters_end))
-        )
-      }
-
-      # @!attribute [r] parameters_elements
-      #   +parameters_elements+ matches elements of parameters.
-      #   @return [Parslet::Atoms::Entity] +parameters_elements+ atom
-      #   @example
-      #     a: 1, b: 2, c: 3
-      rule(:parameters_elements) {
-        ( parameters_element >>
-          parameters_elements_rest.repeat
-        )
-      }
-
-      # @api private
-      MSG_MISSING_COLON =
-        "Parameter elements should be 'key:value' form, but colon is missing."
-
-      # @api private
-      MSG_MISSING_VALUE =
-        "it should be parameter value."
-
-      # @!attribute [r] parameters_element
-      #   +parameters_element+ matches each element of parameters.
-      #   @return [Parslet::Atoms::Entity] +parameters_element+ atom
-      #   @example
-      #     a: 1
-      #   @example
-      #     b: 2
-      #   @example
-      #     c: 3
-      rule(:parameters_element) {
-        ( identifier.as(:key) >>
-          pad? >>
-          (colon | syntax_error(MSG_MISSING_COLON, :colon)) >>
-          pad? >>
-          (expr.as(:value) | syntax_error(MSG_MISSING_VALUE, :expr))
-        ).as(:parameters_element)
-      }
-
-      # @!attribute [r] parameters_elements_rest
-      #   +parameters_elements_rest+ matches elements rest of parameters.
-      #   @return [Parslet::Atoms::Entity] +parameters_elements_rest+ atom
-      #   @example
-      #     , a: 1
-      rule(:parameters_elements_rest) {
-        pad? >>
-        comma >>
-        pad? >>
-        ( parameters_element |
-          syntax_error("it should be parameter key", :identifier)
-        )
-      }
-
-      # @!attribute [r] ticket
-      # +ticket+ matches ticket object.
-      #
-      # @return [Parslet::Atoms::Entity] +ticket+ atom
-      # @example
-      #   &Main
-      rule(:ticket) {
-        less_than >>
-        space? >>
-        identifier.as(:ticket) >>
-        space? >>
-        greater_than
-      }
-    end
-  end
-end

data/lib/pione/parser/rule-definition-parser.rb

@@ -1,158 +0,0 @@
-module Pione
-  module Parser
-    # RuleDefinitionParser is a set of parser atom for defining rule.
-    module RuleDefinitionParser
-      include Parslet
-      include SyntaxError
-      include CommonParser
-      include LiteralParser
-      include ExprParser
-      include FlowElementParser
-      include BlockParser
-
-      # @!attribute [r] rule_definition
-      #   @return [Parslet::Atoms::Entity] rule definition
-      #   @example
-      #     Rule Main
-      #       input '*.txt'
-      #       ...
-      #     Flow
-      #       rule SubRule
-      #       ...
-      #     End
-      rule(:rule_definition) {
-        ( space? >>
-          rule_header >>
-          rule_conditions >>
-          block.as(:block)
-        ).as(:rule_definition)
-      }
-
-      # @!attribute [r] rule_header
-      #   @return [Parslet::Atoms::Entity] rule header
-      #   @example
-      #     Rule Main
-      rule(:rule_header) {
-        ( keyword_Rule >>
-          space >>
-          ( rule_name | syntax_error("it should be rule name", :rule_name)) >>
-          line_end
-        ).as(:rule_header)
-      }
-
-      # @!attribute [r] rule_conditions
-      #   @return [Parslet::Atoms::Entity] rule condition list
-      rule(:rule_conditions) {
-        rule_condition.repeat.as(:rule_conditions)
-      }
-
-      # @!attribute [r] rule_condition
-      #   @return [Parslet::Atoms::Entity] rule condition
-      #   @example
-      #     # input condition
-      #     input '*.in'
-      #   @example
-      #     # output condition
-      #     output '*.out'
-      #   @example
-      #     # param line
-      #     param $VAR := "abc"
-      #   @example
-      #     # feature condition
-      #     feature *
-      rule(:rule_condition) {
-        input_line |
-        output_line |
-        param_line |
-        feature_line |
-        constraint_line |
-        annotation_line
-      }
-
-      #
-      # rule conditions
-      #
-
-      # @!attribute [r] input_line
-      #   @return [Parslet::Atoms::Entity] input line
-      #   @example
-      #     input '*.in'
-      rule(:input_line) {
-        ( space? >>
-          keyword_input >>
-          space >>
-          ( expr.as(:expr) |
-            syntax_error("it should be data_expr", :data_expr)
-          ) >>
-          line_end
-        ).as(:input_line)
-      }
-
-      # @!attribute [r] output_line
-      #   @return [Parslet::Atoms::Entity] output line
-      #   @example
-      #     output '*.out'
-      rule(:output_line) {
-        ( space? >>
-          keyword_output >>
-          space >>
-          ( expr.as(:expr) |
-            syntax_error("it should be data_expr", :data_expr)
-          ) >>
-          line_end
-        ).as(:output_line)
-      }
-
-      # @!attribute [r] param_line
-      #   @return [Parslet::Atoms::Entity] parameter line
-      #   @example
-      #     param $VAR := "abc"
-      rule(:param_line) {
-        ( space? >>
-          ((keyword_basic | keyword_advanced).as(:param_type) >> space).maybe >>
-          keyword_param >>
-          space >>
-          ( expr.as(:expr) |
-            syntax_error("it should be expr", :expr)
-          ).as(:param_expr) >>
-          line_end
-        ).as(:param_line)
-      }
-
-      # @!attribute [r] feature_line
-      #   @return [Parslet::Atoms::Entity] feature line
-      #   @example
-      #     feature *
-      rule(:feature_line) {
-        ( space? >>
-          keyword_feature >>
-          space >>
-          ( expr.as(:expr) |
-            syntax_error("it should be feature_expr", :feature_expr)
-          ) >>
-          line_end
-        ).as(:feature_line)
-      }
-
-      rule(:constraint_line) {
-        ( space? >>
-          keyword_constraint >>
-          space? >>
-          ( expr.as(:expr) |
-            syntax_error("it should be expr", :expr)
-          ) >>
-          line_end
-        ).as(:constraint_line)
-      }
-
-      rule(:annotation_line) {
-        ( space? >>
-          atmark >>
-          space? >>
-          ( expr.as(:expr) | syntax_error("it should be expr", :expr)) >>
-          line_end
-        ).as(:annotation_line)
-      }
-    end
-  end
-end