pione 0.1.0

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

@@ -0,0 +1,105 @@
+module Pione
+  module Parser
+    # FeatureExprParser is a set of parser atoms for feature expressions.
+    module FeatureExprParser
+      include Parslet
+      include SyntaxError
+      include CommonParser
+      include LiteralParser
+
+      # @!attribute [r] atomic_feature
+      #   +atomic_feature+ matches all atomic features.
+      #   @return [Parslet::Atoms::Entity] +atomic_feature+ atom
+      #   @example
+      #     # requisite feature
+      #     +X
+      #   @example
+      #     # blocking feature
+      #     -X
+      #   @example
+      #     # preferred feature
+      #     ?X
+      #   @example
+      #     # possible feature
+      #     ^X
+      #   @example
+      #     # restrictive feature
+      #     !X
+      #   @example
+      #     # empty feature
+      #     *
+      #   @example
+      #     # boundless feature
+      #     @
+      rule(:atomic_feature) {
+        ( (plus.as(:operator) >> identifier.as(:symbol)) |
+          (minus.as(:operator) >> identifier.as(:symbol)) |
+          (question.as(:operator) >> identifier.as(:symbol)) |
+          (hat.as(:operator) >> identifier.as(:symbol)) |
+          (exclamation.as(:operator) >> identifier.as(:symbol)) |
+          (asterisk.as(:symbol)) |
+          (atmark.as(:symbol))
+         ).as(:atomic_feature)
+      }
+
+      # @!attribute [r] feature_expr
+      #   +feature_expr+ matches all features.
+      #   @return [Parslet::Atoms::Entity] +feature_expr+ atom
+      #   @example
+      #     # atomic feature
+      #     +X
+      #   @example
+      #     # feature conjunction
+      #     +X & +Y
+      #   @example
+      #     # feature disjunction
+      #     +X | +Y
+      rule(:feature_expr) {
+        (feature_conjunction |
+         feature_disjunction |
+         feature_element).as(:feature_expr)
+      }
+
+      # @!attribute [r] feature_element
+      #   +feature_element+ matches all features.
+      #   @return [Parslet::Atoms::Entity] +feature_element+ atom
+      #   @example
+      #     +X
+      #   @example
+      #     # feature with parethese
+      #     (+X)
+      rule(:feature_element) {
+        atomic_feature |
+        lparen >> feature_expr >> rparen
+      }
+
+      # @!attribute [r] feature_conjunction
+      #   +feature_conjunction+ matches feature conjunction.
+      #   @return [Parslet::Atoms::Entity] +feature_conjunction+ atom
+      #   @example
+      #     +X & +Y
+      rule(:feature_conjunction) {
+        (feature_element.as(:left) >>
+         space? >>
+         ampersand >>
+         space? >>
+         feature_expr.as(:right)
+         ).as(:feature_conjunction)
+      }
+
+      # @!attribute [r] feature_disjunction
+      #   +feature_disjunction+ matches feature disjunction.
+      #   @return [Parslet::Atoms::Entity] +feature_disjunction+ atom
+      #   @example
+      #     +X | +Y
+      rule(:feature_disjunction) {
+        (feature_element.as(:left) >>
+         space? >>
+         vbar >>
+         space? >>
+         feature_expr.as(:right)
+         ).as(:feature_disjunction)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,181 @@
+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
+        ).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) >>
+        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

@@ -0,0 +1,182 @@
+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)
+        )
+      }
+    end
+  end
+end