pione 0.1.1 → 0.1.2

data/lib/pione/model/float.rb

@@ -16,7 +16,6 @@ module Pione::Model
     # @api private
     def textize
       "#PioneFloat{%s}" % @value
-      # @value.to_s
     end
 
     # Returns ruby's value.

data/lib/pione/model/rule-expr.rb

@@ -6,15 +6,27 @@ module Pione::Model
     attr_reader :package
     attr_reader :name
     attr_reader :params
+    attr_reader :input_ticket_expr
+    attr_reader :output_ticket_expr
 
     # Create a rule expression.
-    # @param [String] package pione package name
-    # @param [String] name rule name
-    # @param [Parameters] params parameters
-    def initialize(package, name, params=Parameters.empty)
+    #
+    # @param package [String]
+    #   package name
+    # @param name [String]
+    #   rule name
+    # @param params [Parameters]
+    #   parameters
+    # @param input_ticket_expr [TicketExpr]
+    #   input ticket condition
+    # @param output_ticket_expr [TicketExpr]
+    #   output ticket condition
+    def initialize(package, name, params, input_ticket_expr, output_ticket_expr)
       @package = package
       @name = name
       @params = params
+      @input_ticket_expr = input_ticket_expr
+      @output_ticket_expr = output_ticket_expr
       super()
     end
 
@@ -41,6 +53,28 @@ module Pione::Model
       "rule_expr(%s,\"%s\")" % [@package.textize, @name]
     end
 
+    # Create a new rule expression with adding the ticket expression as input
+    # condition.
+    #
+    # @param ticket_expr [TicketExpr]
+    #   ticket expression as additional input condition
+    # @return [RuleExpr]
+    #   new rule expression
+    def add_input_ticket_expr(ticket_expr)
+      return self.class.new(@package, @name, @params, @input_ticket_expr + ticket_expr, @output_ticket_expr)
+    end
+
+    # Create a new rule expression with adding the ticket expression as output
+    # condition.
+    #
+    # @param ticket_expr [TicketExpr]
+    #   ticket expression as additional output condition
+    # @return [RuleExpr]
+    #   new rule expression
+    def add_output_ticket_expr(ticket_expr)
+      return self.class.new(@package, @name, @params, @input_ticket_expr, @output_ticket_expr + ticket_expr)
+    end
+
     # Sets a package name and returns a new expression.
     # @param [String] package
     #   package name
@@ -56,7 +90,7 @@ module Pione::Model
     # @return [RuleExpr]
     #   new rule expression with the parameters
     def set_params(params)
-      return self.class.new(@package, @name, params)
+      return self.class.new(@package, @name, params, @input_ticket_expr, @output_ticket_expr)
     end
 
     # Evaluates the object with the variable table.
@@ -68,7 +102,9 @@ module Pione::Model
       return self.class.new(
         @package.eval(vtable),
         @name,
-        @params.eval(vtable)
+        @params.eval(vtable),
+        @input_ticket_expr.eval(vtable),
+        @output_ticket_expr.eval(vtable)
       )
     end
 
@@ -76,7 +112,11 @@ module Pione::Model
     # @return [Boolean]
     #   true if the package or parameters include variables
     def include_variable?
-      @package.include_variable? or @params.include_variable?
+      [ @package.include_variable?,
+        @params.include_variable?,
+        @input_ticket_expr.include_variable?,
+        @output_ticket_expr.include_variable?
+      ].any?
     end
 
     # @api private
@@ -95,6 +135,80 @@ module Pione::Model
     def hash
       @package.hash + @name.hash + @params.hash
     end
+
+    # Return a set that contains self as a single element.
+    #
+    # @return [Set<RuleExpr>]
+    #   a set that contains self
+    def to_set
+      Set.new([self])
+    end
+  end
+
+  class CompositionalRuleExpr < RuleExpr
+    # Create a new compositional rule expression. This consists from left and
+    # right child expressions.
+    #
+    # @param left [RuleExpr]
+    #   left expression
+    # @param right [RuleExpr]
+    #   right expression
+    def initialize(left, right)
+      @left = left
+      @right = right
+    end
+
+    # Create a new compositioanl rule expression with adding the ticket
+    # expression as input condition of left expression.
+    #
+    # @param ticket_expr [TicketExpr]
+    #   ticket expression as additional input condition
+    # @return [CompositionalRuleExpr]
+    #   new rule expression
+    def add_input_ticket_expr(ticket_expr)
+      return self.class.new(@left.add_input_ticket_expr(ticket_expr), @right)
+    end
+
+    # Create a new compositional rule expression with adding the ticket
+    # expression as output condition of right expression.
+    #
+    # @param ticket_expr [TicketExpr]
+    #   ticket expression as additional output condition
+    # @return [CompositionalRuleExpr]
+    #   new rule expression
+    def add_output_ticket_expr(ticket_expr)
+      return self.class.new(@left, @right.add_output_ticket_expr(ticket_expr))
+    end
+
+    # Evaluates left and right expressions with the variable table.
+    #
+    # @param [VariableTable] vtable
+    #   variable table for evaluation
+    # @return [CompositionalRuleExpr]
+    #   evaluation result
+    def eval(vtable)
+      return self.class.new(@left.eval(vtable), @right.eval(vtable))
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      return to_set == other.to_set
+    end
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @left.hash + @right.hash
+    end
+
+    # Return a set that contains all rule expressions of left and right.
+    #
+    # @return [Set<RuleExpr>]
+    #   a set that contains all rule expressions of left and right
+    def to_set
+      @left.to_set + @right.to_set
+    end
   end
 
   TypeRuleExpr.instance_eval do
@@ -116,5 +230,16 @@ module Pione::Model
     define_pione_method("as_string", [], TypeString) do |rec|
       PioneString.new(rec.name)
     end
+
+    define_pione_method("==>", [TypeTicketExpr], TypeRuleExpr) do |rec, ticket_expr|
+      rec.add_output_ticket_expr(ticket_expr)
+    end
+
+    define_pione_method(">>>", [TypeRuleExpr], TypeRuleExpr) do |rec, other|
+      ticket_expr = TicketExpr.new([rec.path])
+      left = rec.add_output_ticket_expr(ticket_expr)
+      right = other.add_input_ticket_expr(ticket_expr)
+      CompositionalRuleExpr.new(left, right)
+    end
   end
 end

data/lib/pione/model/rule.rb

@@ -1,53 +1,79 @@
 module Pione::Model
   # RuleCondition represents rule condition.
   class RuleCondition < BasicModel
-    # Returns the value of attribute inputs.
+    # the value of attribute inputs
+    #
     # @return [Array<DataExpr, Array<DataExpr>>]
     #   rule inputs condition
     attr_reader :inputs
 
-    # Returns the value of attribute outputs.
+    # the value of attribute outputs
+    #
     # @return [Array<DataExpr, Array<DataExpr>>]
-    #  rule outputs condition
+    #   rule outputs condition
     attr_reader :outputs
 
-    # Returns the value of attribute params.
+    # the value of attribute params
+    #
     # @return [Parameters]
     #   rule parameters table
     attr_reader :params
 
-    # Returns the value of attribute features.
+    # the value of attribute features
+    #
     # @return [Feature]
     #   rule feature condition
     attr_reader :features
 
-    # Creates a rule condition.
-    # @param [Array<DataExpr, Array<DataExpr>>] inputs
+    # input ticket expression
+    #
+    # @return [TicketExpr]
+    #    input ticket expression
+    attr_reader :input_ticket_expr
+
+    # output ticket expression
+    #
+    # @return [TicketExpr]
+    #    output ticket
+    attr_reader :output_ticket_expr
+
+    # Create a rule condition.
+    #
+    # @param inputs [Array<DataExpr, Array<DataExpr>>]
     #   rule inputs
-    # @param [Array<DataExpr, Array<DataExpr>>] outputs
+    # @param outputs [Array<DataExpr, Array<DataExpr>>]
     #   rule outputs
-    # @param [Parameters] params
+    # @param params [Parameters]
     #   rule parameters
-    # @param [Feature] features
+    # @param features [Feature]
     #   rule features
-    def initialize(inputs, outputs, params, features)
+    # @param input_ticket_expr [TicketExpr]
+    #   input ticket expression
+    # @param output_ticket_expr [TicketExpr]
+    #   output ticket expression
+    def initialize(inputs, outputs, params, features, input_ticket_expr, output_ticket_expr)
       check_argument_type(params, Parameters)
       check_argument_type(features, Feature::Expr)
       @inputs = inputs
       @outputs = outputs
       @params = params
       @features = features
+      @input_ticket_expr = input_ticket_expr
+      @output_ticket_expr = output_ticket_expr
       super()
     end
 
-    # Returns true if the condition includes variable.
+    # Return true if the condition includes variable.
+    #
     # @return [Boolean]
     #   true if the condition includes variable, or false
     def include_variable?
       [ @inputs.any? {|input| input.include_variable?},
         @outputs.any? {|output| output.include_variable?},
         @params.include_variable?,
-        @features.include_variable?
+        @features.include_variable?,
+        @input_tickets.any? {|ticket| ticket.include_variable?},
+        @output_tickets.any? {|ticket| ticket.include_variable?}
       ].any?
     end
 
@@ -60,6 +86,7 @@ module Pione::Model
       return true
     end
 
+    # @api private
     alias :eql? :"=="
 
     # @api private
@@ -86,6 +113,7 @@ module Pione::Model
     attr_reader :body
 
     def_delegators :@condition, :inputs, :outputs, :params, :features
+    def_delegators :@condition, :input_ticket_expr, :output_ticket_expr
 
     # Creates a rule.
     # @param [RuleExpr] expr
@@ -211,7 +239,7 @@ module Pione::Model
       @params = params
       condition = make_condition
       super(
-        RuleExpr.new(Package.new("root"), "Root"),
+        RuleExpr.new(Package.new("root"), "Root", Parameters.empty, TicketExpr.empty, TicketExpr.empty),
         condition,
         FlowBlock.new(CallRule.new(@main.expr.set_params(@params)))
       )
@@ -244,7 +272,9 @@ module Pione::Model
         @main.inputs,
         @main.outputs,
         Parameters.empty,
-        Feature.empty
+        Feature.empty,
+        TicketExpr.empty,
+        TicketExpr.empty
       )
     end
 
@@ -263,7 +293,13 @@ module Pione::Model
     # @param [Proc] b
     #   rule process
     def initialize(name, &b)
-      expr = RuleExpr.new(Package.new('system'), name)
+      expr = RuleExpr.new(
+        Package.new('system'),
+        name,
+        Parameters.empty,
+        TicketExpr.empty,
+        TicketExpr.empty
+      )
       condition = make_condition
       super(expr, condition, b)
     end
@@ -273,7 +309,7 @@ module Pione::Model
     # @api private
     def make_condition
       inputs = [DataExpr.new('*')]
-      RuleCondition.new(inputs, [], Parameters.empty, Feature::EmptyFeature.new)
+      RuleCondition.new(inputs, [], Parameters.empty, Feature::EmptyFeature.new, TicketExpr.empty, TicketExpr.empty)
     end
 
     # @api private

data/lib/pione/model/ticket-expr.rb

@@ -0,0 +1,124 @@
+module Pione
+  module Model
+    # TicketExpr is a ticket expression as alternative input or output
+    # conditions of rules for sequential process. An object of this class
+    # represents a set of ticket conditions.
+    #
+    # @example Sequencial process of rule A and B by tickets in PIONE flow rule
+    #   Rule Main
+    #     input '*.in'
+    #     output '*.out'
+    #   Flow
+    #     rule A ==> <T>
+    #     <T> ==> rule B
+    #   End
+    # @example TicketExpr represents a set
+    #   TicketExpr.new("T1") + TicketExpr.new("T2") #=> TicketExpr.new(["T1", "T2"])
+    class TicketExpr < BasicModel
+      set_pione_model_type TypeTicketExpr
+
+      class << self
+        # Return an emtpy ticket expression. Empty ticket expression has no
+        # ticket conditions.
+        def empty
+          self.new(Set.new)
+        end
+      end
+
+      # ticket names
+      attr_reader :names
+
+      # Create a ticket expression with names.
+      #
+      # @param names [Set, Array]
+      #   ticket names
+      #
+      # @example
+      #   TicketExpr.new(["T1", "T2"])
+      # @example
+      #   TicketExpr.new(Set.new(["T1", "T2"]))
+      def initialize(names)
+        @names = Set.new(names)
+        super()
+      end
+
+      # Return true if the ticket expression is empty.
+      def empty?
+        @names.empty?
+      end
+
+      # Evaluate the object with the variable table.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        self
+      end
+
+      # Return true if the value includes variables.
+      #
+      # @return [Boolean]
+      #   true if the value includes variables
+      def include_variable?
+        false
+      end
+
+      # Composite ticket expressions between this and another.
+      #
+      # @param other [TicketExpr]
+      #   another ticket expression
+      # @return [TicketExpr]
+      #   compositional ticket expression
+      def +(other)
+        raise ArgumentError.new(other) unless other.kind_of?(TicketExpr)
+        self == other ? self : TicketExpr.new(@names + other.names)
+      end
+
+      # @api private
+      def task_id_string
+        "TicketExpr<#{@names}>"
+      end
+
+      # @api private
+      def textize
+        "<%s>" % [@names]
+      end
+
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @names == other.names
+      end
+      alias :eql? :"=="
+
+      # @api private
+      def hash
+        @names.hash
+      end
+    end
+
+    TypeTicketExpr.instance_eval do
+      define_pione_method("==", [TypeTicketExpr], TypeBoolean) do |rec, other|
+        PioneBoolean.new(rec.names == other.names)
+      end
+
+      define_pione_method("!=", [TypeTicketExpr], TypeBoolean) do |rec, other|
+        PioneBoolean.not(rec.call_pione_method("==", other))
+      end
+
+      define_pione_method("==>", [TypeRuleExpr], TypeRuleExpr) do |rec, other|
+        other.add_input_ticket_expr(rec)
+      end
+
+      define_pione_method("+", [TypeTicketExpr], TypeTicketExpr) do |rec, other|
+        rec + other
+      end
+
+      define_pione_method("as_string", [], TypeString) do |rec|
+        rec.textize
+      end
+    end
+  end
+end