pione 0.1.1 → 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. data/History.txt +9 -2
  2. data/Rakefile +1 -1
  3. data/example/Fib/Fib.pione +5 -5
  4. data/example/SequentialProcess/SequentialProcess.pione +69 -0
  5. data/lib/pione.rb +7 -11
  6. data/lib/pione/agent/input-generator.rb +3 -2
  7. data/lib/pione/agent/task-worker.rb +6 -3
  8. data/lib/pione/agent/trivial-routine-worker.rb +6 -5
  9. data/lib/pione/command/basic-command.rb +7 -1
  10. data/lib/pione/command/child-process.rb +5 -1
  11. data/lib/pione/command/front-owner-command.rb +15 -4
  12. data/lib/pione/command/pione-client.rb +16 -9
  13. data/lib/pione/command/pione-syntax-checker.rb +45 -30
  14. data/lib/pione/command/pione-task-worker.rb +22 -13
  15. data/lib/pione/command/pione-tuple-space-provider.rb +4 -2
  16. data/lib/pione/command/pione-tuple-space-receiver.rb +10 -5
  17. data/lib/pione/front/task-worker-owner.rb +1 -0
  18. data/lib/pione/model/basic-model.rb +3 -0
  19. data/lib/pione/model/block.rb +2 -1
  20. data/lib/pione/model/call-rule.rb +10 -0
  21. data/lib/pione/model/feature-expr.rb +143 -54
  22. data/lib/pione/model/float.rb +0 -1
  23. data/lib/pione/model/rule-expr.rb +132 -7
  24. data/lib/pione/model/rule.rb +53 -17
  25. data/lib/pione/model/ticket-expr.rb +124 -0
  26. data/lib/pione/parser/expr-parser.rb +75 -38
  27. data/lib/pione/parser/literal-parser.rb +14 -0
  28. data/lib/pione/parser/parslet-extension.rb +143 -0
  29. data/lib/pione/rule-handler/flow-handler.rb +33 -3
  30. data/lib/pione/system/global.rb +10 -3
  31. data/lib/pione/transformer.rb +24 -0
  32. data/lib/pione/transformer/block-transformer.rb +6 -5
  33. data/lib/pione/transformer/document-transformer.rb +5 -10
  34. data/lib/pione/transformer/expr-transformer.rb +56 -30
  35. data/lib/pione/transformer/feature-expr-transformer.rb +9 -5
  36. data/lib/pione/transformer/flow-element-transformer.rb +21 -23
  37. data/lib/pione/transformer/literal-transformer.rb +39 -35
  38. data/lib/pione/transformer/rule-definition-transformer.rb +8 -6
  39. data/lib/pione/transformer/transformer-module.rb +7 -5
  40. data/lib/pione/tuple/ticket-tuple.rb +8 -0
  41. data/lib/pione/util/{message.rb → console-message.rb} +54 -26
  42. data/lib/pione/version.rb +1 -1
  43. data/pione.gemspec +2 -1
  44. data/test/model/spec_feature-expr.rb +18 -3
  45. data/test/model/spec_feature-expr.yml +28 -16
  46. data/test/model/spec_ticket-expr.rb +67 -0
  47. data/test/parser/spec_expr-parser.yml +74 -25
  48. data/test/parser/spec_literal-parser.yml +11 -0
  49. data/test/test-util.rb +1 -1
  50. data/test/transformer/spec_expr-transformer.rb +27 -54
  51. data/test/transformer/spec_literal-transformer.rb +6 -0
  52. metadata +29 -7
  53. data/lib/pione/parser/syntax-error.rb +0 -61
@@ -0,0 +1,24 @@
1
+ require 'pione/transformer/transformer-module'
2
+ require 'pione/transformer/literal-transformer'
3
+ require 'pione/transformer/feature-expr-transformer'
4
+ require 'pione/transformer/expr-transformer'
5
+ require 'pione/transformer/flow-element-transformer'
6
+ require 'pione/transformer/block-transformer'
7
+ require 'pione/transformer/rule-definition-transformer'
8
+ require 'pione/transformer/document-transformer'
9
+
10
+ module Pione
11
+ # Transformer is a name space for PIONE document transformers and provides
12
+ # utilities.
13
+ module Transformer
14
+ # Transform by applying DocumentTransformer.
15
+ #
16
+ # @param syntax_tree [Hash]
17
+ # target syntax tree
18
+ # @return [Object]
19
+ # transformed object
20
+ def self.document(syntax_tree)
21
+ DocumentTransformer.new.apply(syntax_tree)
22
+ end
23
+ end
24
+ end
@@ -1,21 +1,22 @@
1
1
  module Pione
2
2
  module Transformer
3
+ # BlockTransformer is a transformer for syntax tree of blocks.
3
4
  module BlockTransformer
4
5
  include TransformerModule
5
6
 
6
- # flow_block:
7
+ # Transform +:flow_block+ as Model::FlowBlock.
7
8
  rule(:flow_block => sequence(:elements)) {
8
9
  FlowBlock.new(*elements)
9
10
  }
10
11
 
11
- # action_block:
12
+ # Transform +:action_block+ as Model::ActionBlock.
12
13
  rule(:action_block =>
13
14
  { :key => simple(:keyword_Action),
14
15
  :content => simple(:content) }
15
16
  ) {
16
- line_and_column = keyword_Action.line_and_column
17
- ActionBlock.new(content) do
18
- set_line_and_column(line_and_column)
17
+ val = content.str
18
+ ActionBlock.new(val).tap do |x|
19
+ x.set_line_and_column(keyword_Action.line_and_column)
19
20
  end
20
21
  }
21
22
  end
@@ -1,5 +1,6 @@
1
1
  module Pione
2
2
  module Transformer
3
+ # DocumentTransformer is a transformer for syntax tree of document.
3
4
  class DocumentTransformer < Parslet::Transform
4
5
  include LiteralTransformer
5
6
  include FeatureExprTransformer
@@ -8,30 +9,24 @@ module Pione
8
9
  include BlockTransformer
9
10
  include RuleDefinitionTransformer
10
11
 
12
+ # @param package_name [String]
13
+ # package name of the document
11
14
  def initialize(package_name="main")
12
15
  super()
13
16
  @current_package_name = package_name
14
17
  Thread.current[:current_package_name] = @current_package_name
15
18
  end
16
19
 
17
- def apply(*args)
18
- res = super
19
- return res
20
- end
21
-
22
20
  def check_model_type(data, type)
23
21
  data.pione_model_type == type
24
22
  end
25
23
 
26
- #
27
- # statement
28
- #
29
-
24
+ # Transform +:param_block+ as Naming::ParamBlock.
30
25
  rule(:param_block => sequence(:assignment_list)) {
31
26
  Naming.ParamBlock(assignment_list)
32
27
  }
33
28
 
34
- # package
29
+ # Transform +:package+ as Naming::Package.
35
30
  rule(:package => subtree(:tree)) {
36
31
  @current_package = Naming.Package(tree[:package_name].to_s)
37
32
  }
@@ -1,62 +1,74 @@
1
1
  module Pione
2
2
  module Transformer
3
- MessageArgument = Struct.new(:name, :parameters)
4
- ParametersElement = Struct.new(:key, :value)
5
-
3
+ # ExprTransformer is a transformer for syntax tree of expressions.
6
4
  module ExprTransformer
7
5
  include TransformerModule
8
6
 
9
- # expr_operator_application
7
+ # Transform +:expr_operator_application+ as Model::BinaryOperator.
10
8
  rule(:expr_operator_application =>
11
9
  { :left => simple(:left),
12
10
  :operator => simple(:operator),
13
11
  :right => simple(:right) }) {
14
- Model::BinaryOperator.new(operator, left, right)
12
+ Model::BinaryOperator.new(operator.to_s, left, right)
15
13
  }
16
14
 
17
- # expr
15
+ # Extract the content of +:expr+.
18
16
  rule(:expr => simple(:obj)) { obj }
19
17
 
20
- # receiver
18
+ # Transform receiver and messages as Model::Message.
21
19
  rule({ :receiver => simple(:receiver),
22
20
  :messages => sequence(:messages) }) {
23
- obj = receiver
24
- messages.each do |msg|
25
- obj = Model::Message.new(msg.name, obj, *msg.parameters)
21
+ messages.inject(receiver) do |rec, msg|
22
+ Model::Message.new(msg.name, rec, *msg.parameters)
23
+ end
24
+ }
25
+
26
+ # Transform receiver and reverse message as Model::Message.
27
+ rule({ :receiver => simple(:receiver),
28
+ :reverse_messages => sequence(:messages) }) {
29
+ messages.reverse.inject(receiver) do |obj, msg|
30
+ Model::Message.new(msg.name, obj, *msg.parameters)
26
31
  end
27
- obj
28
32
  }
33
+
34
+ # Transform receiver and indexes as Model::Message.
29
35
  rule({ :receiver => simple(:receiver),
30
36
  :indexes => sequence(:indexes) }) {
31
- obj = receiver
32
- indexes.each do |msg|
33
- obj = Model::Message.new("[]", obj, *msg.parameters)
37
+ indexes.inject(receiver) do |rec, msg|
38
+ Model::Message.new("[]", rec, *msg.parameters)
34
39
  end
35
- obj
36
40
  }
37
41
 
38
- # message
42
+ # Transform +:message+ with no parameters as OpenStruct.
39
43
  rule(:message => {:message_name => simple(:name)}) {
40
- MessageArgument.new(name)
44
+ OpenStruct.new(name: name)
41
45
  }
46
+
47
+ # Transform +:message+ with no parameters as OpenStruct.
42
48
  rule(:message =>
43
- { :message_name => simple(:name),
44
- :message_parameters => sequence(:parameters) }) {
45
- MessageArgument.new(name, parameters)
49
+ { :message_name => simple(:name),
50
+ :message_parameters => nil }) {
51
+ OpenStruct.new(name: name)
46
52
  }
53
+
54
+ # Transform +:message+ with parameters as OpenStruct.
47
55
  rule(:message =>
48
- { :message_name => simple(:name),
49
- :message_parameters => nil }) {
50
- MessageArgument.new(name)
56
+ { :message_name => simple(:name),
57
+ :message_parameters => sequence(:parameters) }) {
58
+ OpenStruct.new(name, parameters)
51
59
  }
60
+
61
+ # Transform +:message+ with parameters as OpenStruct.
52
62
  rule(:message =>
53
- { :message_name => simple(:name),
54
- :message_parameters => simple(:arg) }) {
55
- MessageArgument.new(name, arg)
63
+ { :message_name => simple(:name),
64
+ :message_parameters => simple(:arg) }) {
65
+ OpenStruct.new(name: name, parameters: arg)
56
66
  }
57
67
 
58
- # rule_expr
68
+ # Extract the content of +:rule_expr+.
59
69
  rule(:rule_expr => simple(:rule)) { rule }
70
+
71
+ # Extract the content of +:rule_expr+ and set the package.
60
72
  rule(:rule_expr => {
61
73
  :package => simple(:package),
62
74
  :expr => simple(:expr)
@@ -64,25 +76,39 @@ module Pione
64
76
  expr.set_package(package)
65
77
  }
66
78
 
67
- # parameters
79
+ # Transform +:parameters+ as emtpy parameters.
68
80
  rule(:parameters => nil) { Parameters.new({}) }
81
+
82
+ # Transform +:parameters+ as emtpy parameters.
69
83
  rule(:parameters => simple(:elt)) {
70
84
  Parameters.new({elt.key => elt.value})
71
85
  }
86
+
87
+ # Transform +:parameters+ as parameters.
72
88
  rule(:parameters => sequence(:list)) {
73
89
  elts = Hash[*list.map{|elt| [elt.key, elt.value]}.flatten(1)]
74
90
  Parameters.new(elts)
75
91
  }
76
92
 
93
+ # Transform +:parameters_element+ as key and value pair.
77
94
  rule(:parameters_element => {
78
95
  :key => simple(:key),
79
96
  :value => simple(:value)
80
97
  }) {
81
- ParametersElement.new(Variable.new(key.to_s), value)
98
+ var = Variable.new(key.str).tap do |x|
99
+ x.set_line_and_column(key.line_and_column)
100
+ end
101
+ OpenStruct.new(key: var, value: value)
82
102
  }
83
103
 
104
+ # Transform +:index+ as name and parameters structure.
84
105
  rule(:index => sequence(:args)) {
85
- MessageArgument.new("[]", args)
106
+ OpenStruct.new(name: "[]", parameters: args)
107
+ }
108
+
109
+ # Transform +:postpositional_parameters+ as parameters structure.
110
+ rule(:postpositional_parameters => simple(:parameters)) {
111
+ OpenStruct.new(name: "params", parameters: parameters)
86
112
  }
87
113
  end
88
114
  end
@@ -1,10 +1,12 @@
1
1
  module Pione
2
2
  module Transformer
3
+ # FeatureExprTransformer is a transformer for syntax tree of feature
4
+ # expressions.
3
5
  module FeatureExprTransformer
4
6
  include TransformerModule
5
7
 
6
- # feature_name
7
- # convert into plain string
8
+ # Transform +:feature_name+ as feature expression model corresponding to
9
+ # the operator.
8
10
  rule(:atomic_feature =>
9
11
  { :operator => simple(:operator),
10
12
  :symbol => simple(:symbol) }
@@ -22,6 +24,8 @@ module Pione
22
24
  Feature::RestrictiveExpr.new(symbol.str)
23
25
  end
24
26
  end
27
+
28
+ # Transform +:atomic_feature+ as empty feature or boundless feature.
25
29
  rule(:atomic_feature => {:symbol => simple(:symbol)}) {
26
30
  case symbol
27
31
  when "*"
@@ -31,12 +35,12 @@ module Pione
31
35
  end
32
36
  }
33
37
 
34
- # feature expr
38
+ # Extract the content of +:feature_expr+.
35
39
  rule(:feature_expr => simple(:expr)) do
36
40
  expr
37
41
  end
38
42
 
39
- # feature conjunction
43
+ # Transform +:feature conjunction+ as Feature::AndExpr.
40
44
  rule(:feature_conjunction => {
41
45
  :left => simple(:left),
42
46
  :right => simple(:right)
@@ -44,7 +48,7 @@ module Pione
44
48
  Feature::AndExpr.new(left, right)
45
49
  end
46
50
 
47
- # feature disjunction
51
+ # Transform +:feature_disjunction+ as Feature::OrExpr.
48
52
  rule(:feature_disjunction => {
49
53
  :left => simple(:left),
50
54
  :right => simple(:right)
@@ -1,37 +1,37 @@
1
1
  module Pione
2
2
  module Transformer
3
+ # FlowElementTransformer is a transformer for syntax tree of flow elements.
3
4
  module FlowElementTransformer
4
5
  include TransformerModule
5
6
 
6
- # flow_elements returns just elements sequence
7
+ # Extract the content of +:flow_elements+.
7
8
  rule(:flow_elements => sequence(:elements)) {
8
9
  elements
9
10
  }
10
11
 
11
- # call_rule
12
+ # Transform +:call_rule: as Model::CallRule.
12
13
  rule(:call_rule => subtree(:rule_expr)) {
13
14
  TypeRuleExpr.check(rule_expr)
14
15
  CallRule.new(rule_expr)
15
16
  }
16
17
 
17
- # if_block
18
+ # Trasnform +:if_block+ as Model::ConditionalBlock.
18
19
  rule(:if_block =>
19
20
  { :condition => simple(:condition),
20
21
  :if_true_elements => sequence(:if_true),
21
22
  :if_else_block => simple(:if_false)
22
23
  }) {
23
- block = { PioneBoolean.true => FlowBlock.new(*if_true) }
24
+ block = { Model::PioneBoolean.true => Model::FlowBlock.new(*if_true) }
24
25
  block[:else] = if_false if if_false
25
- ConditionalBlock.new(condition, block)
26
+ Model::ConditionalBlock.new(condition, block)
26
27
  }
27
28
 
28
- # else_block
29
- rule(:else_block =>
30
- { :elements => sequence(:elements) }) {
31
- FlowBlock.new(*elements)
29
+ # Transform +:else_block+ as Model::FlowBlock.
30
+ rule(:else_block => {:elements => sequence(:elements)}) {
31
+ Model::FlowBlock.new(*elements)
32
32
  }
33
33
 
34
- # case_block
34
+ # Transform +:case_block+ as Model::ConditionalBlock.
35
35
  rule(:case_block =>
36
36
  { :condition => simple(:condition),
37
37
  :when_blocks => sequence(:when_blocks),
@@ -41,26 +41,24 @@ module Pione
41
41
  block[when_block.value] = when_block.body
42
42
  end
43
43
  block[:else] = else_block if else_block
44
- ConditionalBlock.new(condition, block)
44
+ Model::ConditionalBlock.new(condition, block)
45
45
  }
46
46
 
47
- WhenBlock = Struct.new(:value, :body)
48
-
49
- # when_block
47
+ # Transform +:when_block+ as Model::WhenBlock.
50
48
  rule(:when_block =>
51
49
  { :value => simple(:value),
52
- :elements => sequence(:elements) }
50
+ :elements => sequence(:elements) }
53
51
  ) {
54
- WhenBlock.new(value, FlowBlock.new(*elements))
52
+ OpenStruct.new(value: value, body: Model::FlowBlock.new(*elements))
55
53
  }
56
54
 
57
- # assignment
58
- rule(:assignment =>
59
- { :symbol => simple(:symbol),
60
- :value => simple(:value) }
61
- ) {
62
- Assignment.new(symbol, value)
63
- }
55
+ # Transform +:assignment+ as Model::Assignment.
56
+ rule(:assignment =>
57
+ { :symbol => simple(:symbol),
58
+ :value => simple(:value) }
59
+ ) {
60
+ Model::Assignment.new(symbol, value)
61
+ }
64
62
  end
65
63
  end
66
64
  end
@@ -1,73 +1,77 @@
1
1
  module Pione
2
2
  module Transformer
3
+ # LiteralTransformer is a transformer for syntax tree of literals.
3
4
  module LiteralTransformer
4
5
  include TransformerModule
5
6
 
6
- # boolean
7
+ # Tranform +:boolean+ as Model::PioneBoolean.
7
8
  rule(:boolean => simple(:s)) do
8
- line_and_column = s.line_and_column
9
9
  val = (s == "true")
10
- Model::PioneBoolean.new(val) do
11
- set_line_and_column(line_and_column)
10
+ Model::PioneBoolean.new(val).tap do |x|
11
+ x.set_line_and_column(s.line_and_column)
12
12
  end
13
13
  end
14
14
 
15
- # string
15
+ # Transform +:string+ as Model::PioneString.
16
16
  rule(:string => simple(:s)) do
17
- line_and_column = s.line_and_column
18
- Model::PioneString.new(s.str.gsub(/\\(.)/){$1}) do
19
- set_line_and_column(line_and_column)
17
+ # convert backslash notations
18
+ val = s.str.gsub(/\\(.)/){$1}
19
+ Model::PioneString.new(val).tap do |x|
20
+ x.set_line_and_column(s.line_and_column)
20
21
  end
21
22
  end
22
23
 
23
- # integer
24
+ # Transform +:integer+ as Model::PioneInteger.
24
25
  rule(:integer => simple(:i)) do
25
- line_and_column = i.line_and_column
26
- Model::PioneInteger.new(i.to_i) do
27
- set_line_and_column(line_and_column)
26
+ Model::PioneInteger.new(i.to_i).tap do |x|
27
+ x.set_line_and_column(i.line_and_column)
28
28
  end
29
29
  end
30
30
 
31
- # float
31
+ # Transform +:float+ as Model::PioneFloat.
32
32
  rule(:float => simple(:f)) do
33
- line_and_column = f.line_and_column
34
- Model::PioneFloat.new(f.to_f) do
35
- set_line_and_column(line_and_column)
33
+ Model::PioneFloat.new(f.to_f).tap do |x|
34
+ x.set_line_and_column(f.line_and_column)
36
35
  end
37
36
  end
38
37
 
39
- # variable
40
- rule(:variable => simple(:v)) do
41
- line_and_column = v.line_and_column
42
- Model::Variable.new(v) do
43
- set_line_and_column(line_and_column)
38
+ # Transform +:variable+ as Model::Variable.
39
+ rule(:variable => simple(:var)) do
40
+ Model::Variable.new(var.str).tap do |x|
41
+ x.set_line_and_column(var.line_and_column)
44
42
  end
45
43
  end
46
44
 
47
- # data_name
48
- # escape characters are substituted
45
+ # Transform +:data_name+ as Model::DataExpr.
49
46
  rule(:data_name => simple(:name)) do
50
- line_and_column = name.line_and_column
51
- Model::DataExpr.new(name.str.gsub(/\\(.)/) {$1}) do
52
- set_line_and_column(line_and_column)
47
+ # convert backslash notations
48
+ val = name.str.gsub(/\\(.)/){$1}
49
+ Model::DataExpr.new(val).tap do |x|
50
+ x.set_line_and_column(name.line_and_column)
53
51
  end
54
52
  end
55
53
 
56
- # package_name
54
+ # Transform +:package_name+ as Model::Package.
57
55
  rule(:package_name => simple(:name)) do
58
- line_and_column = name.line_and_column
59
- Model::Package.new(name) do
60
- set_line_and_column(line_and_column)
56
+ val = name.str
57
+ Model::Package.new(val).tap do |x|
58
+ x.set_line_and_column(name.line_and_column)
61
59
  end
62
60
  end
63
61
 
64
- # rule_name
62
+ # Transform +:rule_name+ as Model::RuleExpr.
65
63
  rule(:rule_name => simple(:name)) do
64
+ package = Package.new(Thread.current[:current_package_name])
65
+ val = name.str
66
+ RuleExpr.new(package, val, Parameters.empty, TicketExpr.empty, TicketExpr.empty).tap do |x|
67
+ x.set_line_and_column(name.line_and_column)
68
+ end
69
+ end
70
+
71
+ # ticket
72
+ rule(:ticket => simple(:name)) do
66
73
  line_and_column = name.line_and_column
67
- RuleExpr.new(
68
- Package.new(Thread.current[:current_package_name]),
69
- name
70
- ) do
74
+ TicketExpr.new([name.to_s]) do
71
75
  set_line_and_column(line_and_column)
72
76
  end
73
77
  end