pione 0.4.2 → 0.5.0.alpha.1

data/lib/pione/command/pione-package.rb

@@ -17,6 +17,7 @@ module Pione
       require 'pione/command/pione-package-build'
       require 'pione/command/pione-package-show'
       require 'pione/command/pione-package-update'
+      require 'pione/command/pione-package-remove'
     end
 
     PioneCommand.define_subcommand("package", PionePackage)

data/lib/pione/command/spawner.rb

@@ -23,9 +23,14 @@ module Pione
         # keep to watch child process
         @thread = Process.detach(@pid)
 
+        # fail to spawn if the monitor thread is nil
+        unless @thread
+          return self
+        end
+
         # find child front while child process is alive
         Timeout.timeout(10) do
-          while @thread and @thread.alive? do
+          while @thread.alive? do
             # find front and save its uri and pid
             if child_front = find_child_front(@pid)
               @child_front = child_front
@@ -36,8 +41,12 @@ module Pione
             end
           end
 
-          # when process is dead, raise an error
-          raise SpawnError.new(@model[:scenario_name], @name, @argv, "child process is dead")
+          # error if the process has failed
+          unless not(@thread.alive?) and @thread.value.success?
+            raise SpawnError.child_process_is_dead(@model[:scenario_name], @name, @argv)
+          end
+
+          return self
         end
       rescue Timeout::Error
         raise SpawnError.new(@model[:scenario_name], @name, @argv, "timed out")

data/lib/pione/lang/boolean.rb

@@ -7,7 +7,7 @@ module Pione
 
     # BooleanSequence is a class for sequences of boolean.
     class BooleanSequence < OrdinalSequence
-      pione_type TypeBoolean
+      set_pione_type TypeBoolean
       piece_class PioneBoolean
 
       def value

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

@@ -154,13 +154,15 @@ module Pione
       rule(:number!) { number.or_error("it should be number") }
 
       # +space+ matches sequences of space character, tab, or comment.
-      rule(:space) { (match("[ \t]") | comment).repeat(1) }
+      rule(:space_char) {match("[ \t]")}
+      rule(:space) { (space_char | comment).repeat(1) }
 
       # +space?+ matches +space+ or empty.
       rule(:space?) { space.maybe }
 
       # +pad+ matches sequences of space character, tab, newline, or comment.
-      rule(:pad) { (match("[ \t\n]") | comment).repeat(1) }
+      rule(:pad_char) {match("[ \t\n]")}
+      rule(:pad) { (pad_char | comment).repeat(1) }
 
       # +pad?+ matches +pad+ or empty.
       rule(:pad?) { pad.maybe }
@@ -194,7 +196,7 @@ module Pione
 
       # Create an atom that matches a line with the content.
       def line(content)
-        space? >> content >> line_end
+        space? >> content >> line_end.as(:tail)
       end
     end
   end

data/lib/pione/lang/context-parser.rb

@@ -16,8 +16,14 @@ module Pione
       # +param_context+ matches parameter block contexts.
       rule(:param_context) {structural_context.as(:param_context)}
 
-      # +rule_condition_context+ matches rule condition contexts.
-      rule(:rule_condition_context) {structural_context.as(:rule_condition_context)}
+      # +flow_rule_condition_context+ matches flow rule condition contexts.
+      rule(:flow_rule_condition_context) {structural_context.as(:flow_rule_condition_context)}
+
+      # +action_rule_condition_context+ matches action rule condition contexts.
+      rule(:action_rule_condition_context) {structural_context.as(:action_rule_condition_context)}
+
+      # +empty_rule_condition_context+ matches empty rule condition contexts.
+      rule(:empty_rule_condition_context) {structural_context.as(:empty_rule_condition_context)}
 
       # +flow_context+ matches flow contexts.
       rule(:flow_context) {structural_context.as(:flow_context)}

data/lib/pione/lang/context-transformer.rb

@@ -14,9 +14,19 @@ module Pione
         Lang::ParamContext.new(elements)
       }
 
-      # Transform +rule_condition_context+ into Lang::RuleConditionContext.
-      rule(:rule_condition_context => sequence(:elements)) {
-        Lang::RuleConditionContext.new(elements)
+      # Transform +flow_rule_condition_context+ into Lang::FlowRuleConditionContext.
+      rule(:flow_rule_condition_context => sequence(:elements)) {
+        Lang::FlowRuleConditionContext.new(elements)
+      }
+
+      # Transform +action_rule_condition_context+ into Lang::ActionRuleConditionContext.
+      rule(:action_rule_condition_context => sequence(:elements)) {
+        Lang::ActionRuleConditionContext.new(elements)
+      }
+
+      # Transform +empty_rule_condition_context+ into Lang::EmptyRuleConditionContext.
+      rule(:empty_rule_condition_context => sequence(:elements)) {
+        Lang::EmptyRuleConditionContext.new(elements)
       }
 
       # Transform +flow_context+ into Lang::FlowContext.

data/lib/pione/lang/context.rb

@@ -169,12 +169,30 @@ module Pione
 
       # Evaluate the rule condition context. Return a new definition of rule condition.
       def eval(env)
-        RuleCondition.new.tap do |definition|
-          env.temp(current_definition: definition) {|_env| super(_env)}
+        create_condition.tap do |condition|
+          env.temp(current_definition: condition) {|_env| super(_env)}
         end
       end
     end
 
+    class FlowRuleConditionContext < RuleConditionContext
+      def create_condition
+        RuleCondition.new(type: :flow)
+      end
+    end
+
+    class ActionRuleConditionContext < RuleConditionContext
+      def create_condition
+        RuleCondition.new(type: :action)
+      end
+    end
+
+    class EmptyRuleConditionContext < RuleConditionContext
+      def create_condition
+        RuleCondition.new(type: :empty)
+      end
+    end
+
     # FlowContext is a context for flow rule body.
     class FlowContext < StructuralContext
       accept VariableBindingDeclaration

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

@@ -87,7 +87,7 @@ module Pione
     end
 
     class DataExprSequence < OrdinalSequence
-      pione_type TypeDataExpr
+      set_pione_type TypeDataExpr
       piece_class DataExpr
 
       member :output_mode, :default => :file, :values => [:file, :stdout, :stderr]

data/lib/pione/lang/declaration-parser.rb

@@ -73,10 +73,24 @@ module Pione
       # +param_sentence+ matches parameter declarations.
       rule(:param_sentence) {
         type = (keyword_basic | keyword_advanced).as(:type)
+
+        line(((type >> pad).maybe >> keyword_param.as(:declarator) >> pad >> param_expr).as(:param_sentence))
+      }
+
+      # +param_expr+ matches a parameter expression.
+      rule(:param_expr) {
         with_default = expr.as(:expr1) >> padded?(binding_operator) >> expr!.as(:expr2)
         without_default = expr.as(:expr1)
 
-        line(((type >> pad).maybe >> keyword_param.as(:declarator) >> pad >> (with_default | without_default)).as(:param_sentence))
+        with_default | without_default
+      }
+
+      # +param_expr+ natches a parameter expression with variable explicitly.
+      rule(:strict_param_expr) {
+        with_default = variable.as(:expr1) >> padded?(binding_operator) >> expr!.as(:expr2)
+        without_default = variable.as(:expr1)
+
+        with_default | without_default
       }
 
       # +rule_binding_sentence+ matches rule binding declarations.
@@ -144,21 +158,21 @@ module Pione
 
       # +flow_rule_block+ matches flow rule declarations.
       rule(:flow_rule_block) {
-        ( rule_header >> rule_condition_context.as(:context1) >>
+        ( rule_header >> flow_rule_condition_context.as(:context1) >>
           line(keyword_Flow) >> flow_context.as(:context2) >> rule_footer!
         ).as(:flow_rule_block)
       }
 
       # +action_rule_block+ matches action rule declarations.
       rule(:action_rule_block) {
-        ( rule_header >> rule_condition_context.as(:context1) >>
+        ( rule_header >> action_rule_condition_context.as(:context1) >>
           line(keyword_Action) >> action_context.as(:context2) >> rule_footer!
         ).as(:action_rule_block)
       }
 
       # +empty_rule_block+ matches empty rule declarations.
       rule(:empty_rule_block) {
-        (rule_header >> rule_condition_context.as(:context) >> rule_footer!).as(:empty_rule_block)
+        (rule_header >> empty_rule_condition_context.as(:context) >> rule_footer!).as(:empty_rule_block)
       }
 
       # +rule_header+ matches rule headers.

data/lib/pione/lang/declaration-transformer.rb

@@ -25,7 +25,7 @@ module Pione
       }
 
       # Transform +param_sentence+ into +Lang::ParamDeclaration+.
-      rule(:param_sentence => subtree(:tree)) {
+      rule(:param_sentence => subtree(:tree), :tail => simple(:tail_message)) {
         type = (tree[:type] || "basic").to_sym
 
         Lang::ParamDeclaration.new(type, tree[:expr1], tree[:expr2]).tap do |declaration|

data/lib/pione/lang/declaration.rb

@@ -265,7 +265,9 @@ module Pione
       end
     end
 
-    class FlowRuleDeclaration < Declaration
+    class RuleDeclaration < Declaration; end
+
+    class FlowRuleDeclaration < RuleDeclaration
       member :expr                   # rule name
       member :rule_condition_context # rule condition context
       member :flow_context           # flow context
@@ -285,7 +287,7 @@ module Pione
       end
     end
 
-    class ActionRuleDeclaration < Declaration
+    class ActionRuleDeclaration < RuleDeclaration
       member :expr              # rule name
       member :condition_context # rule condition context
       member :action_context    # action context
@@ -305,7 +307,7 @@ module Pione
       end
     end
 
-    class EmptyRuleDeclaration < Declaration
+    class EmptyRuleDeclaration < RuleDeclaration
       member :expr              # rule name
       member :condition_context # rule condition context
 

data/lib/pione/lang/definition.rb

@@ -2,6 +2,7 @@ module Pione
   module Lang
     # RuleCondition is a storage of rule conditions.
     class RuleCondition < StructX
+      member :type
       member :inputs, default: lambda { Array.new }
       member :outputs, default: lambda { Array.new }
       member :features, default: lambda { Array.new }

data/lib/pione/lang/environment.rb

@@ -231,6 +231,35 @@ module Pione
         rule_table.get!(self, setup_package_id(ref))
       end
 
+      # Return name of entrance rule.
+      #
+      # @param package_id [String]
+      #   pakcage id
+      # @return [String]
+      #   name of entrance rule
+      def entrance_rule_name(package_id=current_package_id)
+        # find main rule name from annotations
+        annotations = package_get(Lang::PackageExpr.new(package_id: package_id)).annotations
+        annotations.each do |annotation|
+          if annotation.annotation_type == "Entrance"
+            return annotation.pieces.first.name
+          end
+        end
+
+        # default name
+        return "Main"
+      end
+
+      # Return entrance rule.
+      #
+      # @param package_id [String]
+      #   pakcage id
+      # @return [RuleDeclaration]
+      #   entrance rule
+      def entrance_rule(package_id=current_package_id)
+        rule_get!(Lang::RuleExpr.new(entrance_rule_name(package_id)))
+      end
+
       # Get the expression of the reference.
       def rule_get_value(ref)
         if val = rule_table.get_value(self, setup_package_id(ref))
@@ -335,17 +364,23 @@ module Pione
         set(current_package_id: package_id, current_definition: definition)
       end
 
+      # Make a root rule definition.
+      #
+      # @param main_param_set [ParameterSet]
+      #   main parameter set
+      # @return [RuleDefinition]
+      #  root rule definition
       def make_root_rule(main_param_set)
         # put variable of parameter set for main rule
         variable_set(Variable.new("MAIN_PARAM_SET"), ParameterSetSequence.of(main_param_set))
 
         # make root rule
-        Package::Document.parse(<<-PIONE, current_package_id, nil, nil, "*System*").eval(self)
+        Package::Document.parse(<<-PIONE % entrance_rule_name, current_package_id, nil, nil, "*System*").eval(self)
            Rule Root
              input '*'.all or null
              output '*'.all
            Flow
-             rule Main.param($MAIN_PARAM_SET)
+             rule %s.param($MAIN_PARAM_SET)
            End
         PIONE
         rule_get(RuleExpr.new("Root"))

data/lib/pione/lang/expr.rb

@@ -6,21 +6,19 @@ module Pione
       immutable true
 
       class << self
-        attr_reader :pione_type
-
         # Set pione model type of the model.
-        def pione_type(type=nil)
-          if type
-            @pione_type = type
-            Type.table[type.name][:sequence_class] = self
-          else
-            @pione_type
-          end
+        def pione_type(env=nil)
+          @pione_type
+        end
+
+        def set_pione_type(type)
+          @pione_type = type
+          Type.table[type.name][:sequence_class] = self
         end
 
         def inherited(subclass)
           if @pione_type
-            subclass.pione_type(@pione_type)
+            subclass.set_pione_type(@pione_type)
           end
         end
       end
@@ -54,7 +52,7 @@ module Pione
         # check arguments
         raise ArgumentError.new(args) unless args.is_a?(Array)
 
-        if pione_method = pione_type.find_method(env, name, self, args)
+        if pione_method = pione_type(env).find_method(env, name, self, args)
           # evaluate arguments if the method type is immediate
           if pione_method.method_type == :immediate
             args = args.map {|arg| arg.eval(env)}
@@ -62,7 +60,7 @@ module Pione
           # call it
           pione_method.call(env, self, args)
         else
-          raise MethodNotFound.new(name, self, args)
+          raise MethodNotFound.new(env, name, self, args)
         end
       end
     end

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

@@ -157,7 +157,7 @@ module Pione
 
     # FeatureSequence represents disjunction of feature pieces.
     class FeatureSequence < OrdinalSequence
-      pione_type TypeFeature
+      set_pione_type TypeFeature
       piece_class EmptyFeature
       piece_class AlmightyFeature
       piece_class PossibleFeature

data/lib/pione/lang/float.rb

@@ -6,7 +6,7 @@ module Pione
     end
 
     class FloatSequence < OrdinalSequence
-      pione_type TypeFloat
+      set_pione_type TypeFloat
       piece_class PioneFloat
 
       def value

data/lib/pione/lang/integer.rb

@@ -7,7 +7,7 @@ module Pione
 
     # IntegerSequence is a sequence of PIONE integer.
     class IntegerSequence < OrdinalSequence
-      pione_type TypeInteger
+      set_pione_type TypeInteger
       piece_class PioneInteger
 
       def textize

data/lib/pione/lang/keyed-sequence.rb

@@ -2,7 +2,7 @@ module Pione
   module Lang
     # KeyedSequence is a sequence that have key and value pairs.
     class KeyedSequence < Sequence
-      pione_type TypeKeyedSequence
+      set_pione_type TypeKeyedSequence
 
       member :pieces, default: {}
       member :piece_type
@@ -43,12 +43,12 @@ module Pione
         end
       end
 
-      def index_type
-        pieces.keys.first.pione_type
+      def index_type(env)
+        pieces.keys.first.pione_type(env)
       end
 
-      def element_type
-        pieces.values.first.pione_type
+      def element_type(env)
+        pieces.values.first.pione_type(env)
       end
 
       def eval(env)

data/lib/pione/lang/lang-exception.rb

@@ -156,15 +156,16 @@ module Pione
 
     # LangTypeError represents type mismatch error in PIONE language.
     class LangTypeError < StandardError
-      def initialize(obj, type)
+      def initialize(obj, type, env)
         @obj = obj
         @type = type
+        @env = env
       end
 
       def message
         args = [
           @type.name,
-          @obj.pione_type.name,
+          @obj.pione_type(env).name,
           @obj.line,
           @obj.column
         ]
@@ -179,21 +180,24 @@ module Pione
       attr_reader :arguments
 
       # Creates an exception.
+      # @param env [Environment]
+      #   language environment
       # @param name [String]
       #   method name
       # @param receiver [Callable]
       #   method reciever
       # @param arguments [Array<Callable>]
       #   method arguments
-      def initialize(name, receiver, arguments)
+      def initialize(env, name, receiver, arguments)
+        @env = env
         @name = name
         @receiver = receiver
         @arguments = arguments
       end
 
       def message
-        rec_type = @receiver.pione_type
-        arg_types = @arguments.map{|arg| arg.pione_type}.join(" -> ")
+        rec_type = @receiver.pione_type(@env)
+        arg_types = @arguments.map{|arg| arg.pione_type(@env)}.join(" -> ")
         "PIONE method \"%s\" is not found: %s. %s" % [@name, rec_type, arg_types]
       end
     end