pione 0.1.1 → 0.1.2

data/lib/pione/transformer.rb

@@ -0,0 +1,24 @@
+require 'pione/transformer/transformer-module'
+require 'pione/transformer/literal-transformer'
+require 'pione/transformer/feature-expr-transformer'
+require 'pione/transformer/expr-transformer'
+require 'pione/transformer/flow-element-transformer'
+require 'pione/transformer/block-transformer'
+require 'pione/transformer/rule-definition-transformer'
+require 'pione/transformer/document-transformer'
+
+module Pione
+  # Transformer is a name space for PIONE document transformers and provides
+  # utilities.
+  module Transformer
+    # Transform by applying DocumentTransformer.
+    #
+    # @param syntax_tree [Hash]
+    #   target syntax tree
+    # @return [Object]
+    #   transformed object
+    def self.document(syntax_tree)
+      DocumentTransformer.new.apply(syntax_tree)
+    end
+  end
+end

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

@@ -1,21 +1,22 @@
 module Pione
   module Transformer
+    # BlockTransformer is a transformer for syntax tree of blocks.
     module BlockTransformer
       include TransformerModule
 
-      # flow_block:
+      # Transform +:flow_block+ as Model::FlowBlock.
       rule(:flow_block => sequence(:elements)) {
         FlowBlock.new(*elements)
       }
 
-      # action_block:
+      # Transform +:action_block+ as Model::ActionBlock.
       rule(:action_block =>
         { :key => simple(:keyword_Action),
           :content => simple(:content) }
       ) {
-        line_and_column = keyword_Action.line_and_column
-        ActionBlock.new(content) do
-          set_line_and_column(line_and_column)
+        val = content.str
+        ActionBlock.new(val).tap do |x|
+          x.set_line_and_column(keyword_Action.line_and_column)
         end
       }
     end

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

@@ -1,5 +1,6 @@
 module Pione
   module Transformer
+    # DocumentTransformer is a transformer for syntax tree of document.
     class DocumentTransformer < Parslet::Transform
       include LiteralTransformer
       include FeatureExprTransformer
@@ -8,30 +9,24 @@ module Pione
       include BlockTransformer
       include RuleDefinitionTransformer
 
+      # @param package_name [String]
+      #   package name of the document
       def initialize(package_name="main")
         super()
         @current_package_name = package_name
         Thread.current[:current_package_name] = @current_package_name
       end
 
-      def apply(*args)
-        res = super
-        return res
-      end
-
       def check_model_type(data, type)
         data.pione_model_type == type
       end
 
-      #
-      # statement
-      #
-
+      # Transform +:param_block+ as Naming::ParamBlock.
       rule(:param_block => sequence(:assignment_list)) {
         Naming.ParamBlock(assignment_list)
       }
 
-      # package
+      # Transform +:package+ as Naming::Package.
       rule(:package => subtree(:tree)) {
         @current_package = Naming.Package(tree[:package_name].to_s)
       }

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

@@ -1,62 +1,74 @@
 module Pione
   module Transformer
-    MessageArgument = Struct.new(:name, :parameters)
-    ParametersElement = Struct.new(:key, :value)
-
+    # ExprTransformer is a transformer for syntax tree of expressions.
     module ExprTransformer
       include TransformerModule
 
-      # expr_operator_application
+      # Transform +:expr_operator_application+ as Model::BinaryOperator.
       rule(:expr_operator_application =>
            { :left => simple(:left),
              :operator => simple(:operator),
              :right => simple(:right) }) {
-        Model::BinaryOperator.new(operator, left, right)
+        Model::BinaryOperator.new(operator.to_s, left, right)
       }
 
-      # expr
+      # Extract the content of +:expr+.
       rule(:expr => simple(:obj)) { obj }
 
-      # receiver
+      # Transform receiver and messages as Model::Message.
       rule({ :receiver => simple(:receiver),
              :messages => sequence(:messages) }) {
-        obj = receiver
-        messages.each do |msg|
-          obj = Model::Message.new(msg.name, obj, *msg.parameters)
+        messages.inject(receiver) do |rec, msg|
+          Model::Message.new(msg.name, rec, *msg.parameters)
+        end
+      }
+
+      # Transform receiver and reverse message as Model::Message.
+      rule({ :receiver => simple(:receiver),
+             :reverse_messages => sequence(:messages) }) {
+        messages.reverse.inject(receiver) do |obj, msg|
+          Model::Message.new(msg.name, obj, *msg.parameters)
         end
-        obj
       }
+
+      # Transform receiver and indexes as Model::Message.
       rule({ :receiver => simple(:receiver),
              :indexes => sequence(:indexes) }) {
-        obj = receiver
-        indexes.each do |msg|
-          obj = Model::Message.new("[]", obj, *msg.parameters)
+        indexes.inject(receiver) do |rec, msg|
+          Model::Message.new("[]", rec, *msg.parameters)
         end
-        obj
       }
 
-      # message
+      # Transform +:message+ with no parameters as OpenStruct.
       rule(:message => {:message_name => simple(:name)}) {
-        MessageArgument.new(name)
+        OpenStruct.new(name: name)
       }
+
+      # Transform +:message+ with no parameters as OpenStruct.
       rule(:message =>
-           { :message_name => simple(:name),
-             :message_parameters => sequence(:parameters) }) {
-        MessageArgument.new(name, parameters)
+        { :message_name => simple(:name),
+          :message_parameters => nil }) {
+        OpenStruct.new(name: name)
       }
+
+      # Transform +:message+ with parameters as OpenStruct.
       rule(:message =>
-           { :message_name => simple(:name),
-             :message_parameters => nil }) {
-        MessageArgument.new(name)
+        { :message_name => simple(:name),
+          :message_parameters => sequence(:parameters) }) {
+        OpenStruct.new(name, parameters)
       }
+
+      # Transform +:message+ with parameters as OpenStruct.
       rule(:message =>
-           { :message_name => simple(:name),
-             :message_parameters => simple(:arg) }) {
-        MessageArgument.new(name, arg)
+        { :message_name => simple(:name),
+          :message_parameters => simple(:arg) }) {
+        OpenStruct.new(name: name, parameters: arg)
       }
 
-      # rule_expr
+      # Extract the content of +:rule_expr+.
       rule(:rule_expr => simple(:rule)) { rule }
+
+      # Extract the content of +:rule_expr+ and set the package.
       rule(:rule_expr => {
           :package => simple(:package),
           :expr => simple(:expr)
@@ -64,25 +76,39 @@ module Pione
         expr.set_package(package)
       }
 
-      # parameters
+      # Transform +:parameters+ as emtpy parameters.
       rule(:parameters => nil) { Parameters.new({}) }
+
+      # Transform +:parameters+ as emtpy parameters.
       rule(:parameters => simple(:elt)) {
         Parameters.new({elt.key => elt.value})
       }
+
+      # Transform +:parameters+ as parameters.
       rule(:parameters => sequence(:list)) {
         elts = Hash[*list.map{|elt| [elt.key, elt.value]}.flatten(1)]
         Parameters.new(elts)
       }
 
+      # Transform +:parameters_element+ as key and value pair.
       rule(:parameters_element => {
           :key => simple(:key),
           :value => simple(:value)
         }) {
-        ParametersElement.new(Variable.new(key.to_s), value)
+        var = Variable.new(key.str).tap do |x|
+          x.set_line_and_column(key.line_and_column)
+        end
+        OpenStruct.new(key: var, value: value)
       }
 
+      # Transform +:index+ as name and parameters structure.
       rule(:index => sequence(:args)) {
-        MessageArgument.new("[]", args)
+        OpenStruct.new(name: "[]", parameters: args)
+      }
+
+      # Transform +:postpositional_parameters+ as parameters structure.
+      rule(:postpositional_parameters => simple(:parameters)) {
+        OpenStruct.new(name: "params", parameters: parameters)
       }
     end
   end

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

@@ -1,10 +1,12 @@
 module Pione
   module Transformer
+    # FeatureExprTransformer is a transformer for syntax tree of feature
+    # expressions.
     module FeatureExprTransformer
       include TransformerModule
 
-      # feature_name
-      # convert into plain string
+      # Transform +:feature_name+ as feature expression model corresponding to
+      # the operator.
       rule(:atomic_feature =>
            { :operator => simple(:operator),
              :symbol => simple(:symbol) }
@@ -22,6 +24,8 @@ module Pione
           Feature::RestrictiveExpr.new(symbol.str)
         end
       end
+
+      # Transform +:atomic_feature+ as empty feature or boundless feature.
       rule(:atomic_feature => {:symbol => simple(:symbol)}) {
         case symbol
         when "*"
@@ -31,12 +35,12 @@ module Pione
         end
       }
 
-      # feature expr
+      # Extract the content of +:feature_expr+.
       rule(:feature_expr => simple(:expr)) do
         expr
       end
 
-      # feature conjunction
+      # Transform +:feature conjunction+ as Feature::AndExpr.
       rule(:feature_conjunction => {
              :left => simple(:left),
              :right => simple(:right)
@@ -44,7 +48,7 @@ module Pione
         Feature::AndExpr.new(left, right)
       end
 
-      # feature disjunction
+      # Transform +:feature_disjunction+ as Feature::OrExpr.
       rule(:feature_disjunction => {
              :left => simple(:left),
              :right => simple(:right)

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

@@ -1,37 +1,37 @@
 module Pione
   module Transformer
+    # FlowElementTransformer is a transformer for syntax tree of flow elements.
     module FlowElementTransformer
       include TransformerModule
 
-      # flow_elements returns just elements sequence
+      # Extract the content of +:flow_elements+.
       rule(:flow_elements => sequence(:elements)) {
         elements
       }
 
-      # call_rule
+      # Transform +:call_rule: as Model::CallRule.
       rule(:call_rule => subtree(:rule_expr)) {
         TypeRuleExpr.check(rule_expr)
         CallRule.new(rule_expr)
       }
 
-      # if_block
+      # Trasnform +:if_block+ as Model::ConditionalBlock.
       rule(:if_block =>
            { :condition => simple(:condition),
              :if_true_elements => sequence(:if_true),
              :if_else_block => simple(:if_false)
            }) {
-        block = { PioneBoolean.true => FlowBlock.new(*if_true) }
+        block = { Model::PioneBoolean.true => Model::FlowBlock.new(*if_true) }
         block[:else] = if_false if if_false
-        ConditionalBlock.new(condition, block)
+        Model::ConditionalBlock.new(condition, block)
       }
 
-      # else_block
-      rule(:else_block =>
-           { :elements => sequence(:elements) }) {
-        FlowBlock.new(*elements)
+      # Transform +:else_block+ as Model::FlowBlock.
+      rule(:else_block => {:elements => sequence(:elements)}) {
+        Model::FlowBlock.new(*elements)
       }
 
-      # case_block
+      # Transform +:case_block+ as Model::ConditionalBlock.
       rule(:case_block =>
         { :condition => simple(:condition),
           :when_blocks => sequence(:when_blocks),
@@ -41,26 +41,24 @@ module Pione
           block[when_block.value] = when_block.body
         end
         block[:else] = else_block if else_block
-        ConditionalBlock.new(condition, block)
+        Model::ConditionalBlock.new(condition, block)
       }
 
-      WhenBlock = Struct.new(:value, :body)
-
-      # when_block
+      # Transform +:when_block+ as Model::WhenBlock.
       rule(:when_block =>
         { :value => simple(:value),
-        :elements => sequence(:elements) }
+          :elements => sequence(:elements) }
       ) {
-        WhenBlock.new(value, FlowBlock.new(*elements))
+        OpenStruct.new(value: value, body: Model::FlowBlock.new(*elements))
       }
 
-    # assignment
-    rule(:assignment =>
-      { :symbol => simple(:symbol),
-        :value => simple(:value) }
-    ) {
-      Assignment.new(symbol, value)
-    }
+    # Transform +:assignment+ as Model::Assignment.
+      rule(:assignment =>
+        { :symbol => simple(:symbol),
+          :value => simple(:value) }
+      ) {
+        Model::Assignment.new(symbol, value)
+      }
     end
   end
 end

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

@@ -1,73 +1,77 @@
 module Pione
   module Transformer
+    # LiteralTransformer is a transformer for syntax tree of literals.
     module LiteralTransformer
       include TransformerModule
 
-      # boolean
+      # Tranform +:boolean+ as Model::PioneBoolean.
       rule(:boolean => simple(:s)) do
-        line_and_column = s.line_and_column
         val = (s == "true")
-        Model::PioneBoolean.new(val) do
-          set_line_and_column(line_and_column)
+        Model::PioneBoolean.new(val).tap do |x|
+          x.set_line_and_column(s.line_and_column)
         end
       end
 
-      # string
+      # Transform +:string+ as Model::PioneString.
       rule(:string => simple(:s)) do
-        line_and_column = s.line_and_column
-        Model::PioneString.new(s.str.gsub(/\\(.)/){$1}) do
-          set_line_and_column(line_and_column)
+        # convert backslash notations
+        val = s.str.gsub(/\\(.)/){$1}
+        Model::PioneString.new(val).tap do |x|
+          x.set_line_and_column(s.line_and_column)
         end
       end
 
-      # integer
+      # Transform +:integer+ as Model::PioneInteger.
       rule(:integer => simple(:i)) do
-        line_and_column = i.line_and_column
-        Model::PioneInteger.new(i.to_i) do
-          set_line_and_column(line_and_column)
+        Model::PioneInteger.new(i.to_i).tap do |x|
+          x.set_line_and_column(i.line_and_column)
         end
       end
 
-      # float
+      # Transform +:float+ as Model::PioneFloat.
       rule(:float => simple(:f)) do
-        line_and_column = f.line_and_column
-        Model::PioneFloat.new(f.to_f) do
-          set_line_and_column(line_and_column)
+        Model::PioneFloat.new(f.to_f).tap do |x|
+          x.set_line_and_column(f.line_and_column)
         end
       end
 
-      # variable
-      rule(:variable => simple(:v)) do
-        line_and_column = v.line_and_column
-        Model::Variable.new(v) do
-          set_line_and_column(line_and_column)
+      # Transform +:variable+ as Model::Variable.
+      rule(:variable => simple(:var)) do
+        Model::Variable.new(var.str).tap do |x|
+          x.set_line_and_column(var.line_and_column)
         end
       end
 
-      # data_name
-      # escape characters are substituted
+      # Transform +:data_name+ as Model::DataExpr.
       rule(:data_name => simple(:name)) do
-        line_and_column = name.line_and_column
-        Model::DataExpr.new(name.str.gsub(/\\(.)/) {$1}) do
-          set_line_and_column(line_and_column)
+        # convert backslash notations
+        val = name.str.gsub(/\\(.)/){$1}
+        Model::DataExpr.new(val).tap do |x|
+          x.set_line_and_column(name.line_and_column)
         end
       end
 
-      # package_name
+      # Transform +:package_name+ as Model::Package.
       rule(:package_name => simple(:name)) do
-        line_and_column = name.line_and_column
-        Model::Package.new(name) do
-          set_line_and_column(line_and_column)
+        val = name.str
+        Model::Package.new(val).tap do |x|
+          x.set_line_and_column(name.line_and_column)
         end
       end
 
-      # rule_name
+      # Transform +:rule_name+ as Model::RuleExpr.
       rule(:rule_name => simple(:name)) do
+        package = Package.new(Thread.current[:current_package_name])
+        val = name.str
+        RuleExpr.new(package, val, Parameters.empty, TicketExpr.empty, TicketExpr.empty).tap do |x|
+          x.set_line_and_column(name.line_and_column)
+        end
+      end
+
+      # ticket
+      rule(:ticket => simple(:name)) do
         line_and_column = name.line_and_column
-        RuleExpr.new(
-          Package.new(Thread.current[:current_package_name]),
-          name
-        ) do
+        TicketExpr.new([name.to_s]) do
           set_line_and_column(line_and_column)
         end
       end