pione 0.1.3 → 0.1.4

data/lib/pione/model/rule.rb

@@ -2,65 +2,40 @@ module Pione
   module Model
     # RuleCondition represents rule condition.
     class RuleCondition < BasicModel
-      # the value of attribute inputs
-      #
       # @return [Array<DataExpr, Array<DataExpr>>]
-      #   rule inputs condition
+      #   input data condition
       attr_reader :inputs
 
-      # the value of attribute outputs
-      #
       # @return [Array<DataExpr, Array<DataExpr>>]
-      #   rule outputs condition
+      #   output data condition
       attr_reader :outputs
 
-      # the value of attribute params
-      #
-      # @return [Parameters]
-      #   rule parameters table
-      attr_reader :params
-
-      # the value of attribute features
-      #
-      # @return [Feature]
-      #   rule feature condition
-      attr_reader :features
-
-      # 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
+      forward_as_key! :@condition, :params, :features, :constraints, :input_ticket_expr, :output_ticket_expr
 
       # Create a rule condition.
       #
-      # @param inputs [Array<DataExpr, Array<DataExpr>>]
-      #   rule inputs
-      # @param outputs [Array<DataExpr, Array<DataExpr>>]
-      #   rule outputs
-      # @param params [Parameters]
+      # @param inputs [Array<DataExpr>]
+      #   input conditions
+      # @param outputs [Array<DataExpr>]
+      #   output conditions
+      # @param condition [Hash]
+      # @option condition [Parameters] params
       #   rule parameters
-      # @param features [Feature]
+      # @option condition [Feature] features
       #   rule 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)
+      # @option condition [TicketExpr] input_ticket_expr
+      #   input ticket
+      # @option condition [TicketExpr] output_ticket_expr
+      #   output ticket
+      def initialize(inputs, outputs, condition={})
         @inputs = inputs
         @outputs = outputs
-        @params = params
-        @features = features
-        @input_ticket_expr = input_ticket_expr
-        @output_ticket_expr = output_ticket_expr
+        @condition = {}
+        @condition[:params] = condition[:params] || Parameters.empty
+        @condition[:features] = condition[:features] || Feature.empty
+        @condition[:constraints] = condition[:constraints] || Constraints.empty
+        @condition[:input_ticket_expr] = condition[:input_ticket_expr] || TicketExprSequence.empty
+        @condition[:output_ticket_expr] = condition[:output_ticket_expr] || TicketExprSequence.empty
         super()
       end
 
@@ -69,81 +44,90 @@ module Pione
       # @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?,
-          @input_tickets.any? {|ticket| ticket.include_variable?},
-          @output_tickets.any? {|ticket| ticket.include_variable?}
-        ].any?
+        return true if @inputs.any? {|input| input.include_variable?}
+        return true if @outputs.any? {|output| output.include_variable?}
+        return true if @condition.any? {|key, val| val.include_variable?}
+        return false
+      end
+
+      def to_hash
+        @condition.merge(inputs: @inputs, outputs: @outputs)
       end
 
       # @api private
       def ==(other)
-        return false unless @inputs == other.inputs
-        return false unless @outputs == other.outputs
-        return false unless @params == other.params
-        return false unless @features == other.features
-        return true
+        to_hash == other.to_hash
       end
       alias :eql? :"=="
 
       # @api private
       def hash
-        @inputs.hash + @outputs.hash + @params.hash + @features.hash
+        @inputs.hash + @outputs.hash + @condition.hash
       end
     end
 
     # Rule is a class for PIONE rule model.
     class Rule < BasicModel
-      extend Forwardable
+      class << self
+        attr_reader :rule_type
+        attr_reader :handler_class
+
+        # Declare rule type of the class.
+        #
+        # @param rule_type [Symbol]
+        #   rule type
+        # @return [void]
+        def set_rule_type(rule_type)
+          @rule_type = rule_type
+        end
 
-      # Returns rule type.
-      def self.rule_type
-        @rule_type
+        # Declare rule handler class of the class.
+        #
+        # @param handler_class [Class]
+        #   handler class
+        # @return [void]
+        def set_handler_class(handler_class)
+          @handler_class = handler_class
+        end
       end
 
-      # Return the value of attribute expr.
-      #
-      # @return [Array<DataExpr, Array<DataExpr>>]
-      #   rule inputs condition
-      attr_reader :expr
+      # @return [RuleExpr]
+      #   rule expression
+      attr_reader :rule_expr
 
+      # @return [RuleCondition]
+      #   rule condition
       attr_reader :condition
+
+      # @return [Object]
+      #   rule body
       attr_reader :body
 
-      forward! :@condition, :inputs, :outputs, :params, :features
+      forward! :@condition, :inputs, :outputs, :params, :features, :constraints
       forward! :@condition, :input_ticket_expr, :output_ticket_expr
-      forward :class, :rule_type
+      forward! :class, :rule_type, :handler_class
+      forward! :@rule_expr, :rule_path
 
       # Create a rule.
       #
-      # @param expr [RuleExpr]
+      # @param rule_expr [RuleExpr]
       #   rule expression
       # @param condition [RuleCondition]
       #   rule condition
       # @param [Block] body
       #   rule body block
-      def initialize(expr, condition, body)
-        @expr = expr
+      def initialize(rule_expr, condition, body)
+        @rule_expr = rule_expr
         @condition = condition
         @body = body
       end
 
-      # Return the rule path.
-      #
-      # @return [String]
-      #   rule path
-      def rule_path
-        @expr.rule_path
-      end
-
       # Return true if expression, condition, or body include variables.
       #
       # @return [Boolean]
       #   true if expression, condition, or body include variables
       def include_variable?
-        return true if @expr.include_variable?
+        return true if @rule_expr.include_variable?
         return true if @condition.include_variable?
         return true if @body.include_variable?
         return false
@@ -169,7 +153,7 @@ module Pione
       #
       # @param ts_server [TupleSpaceServer]
       #   tuple space server
-      # @param inputs [Array<Data, Array<Data>>]
+      # @param inputs [Array<DataTuple, Array<DataTuple>>]
       #   input tuples
       # @param params [Parameters]
       #   rule parameters
@@ -181,17 +165,10 @@ module Pione
         handler_class.new(ts_server, self, inputs, params, call_stack, opts)
       end
 
-      # Return a rule handler class.
-      #
-      # @api private
-      def handler_class
-        raise NotImplementedError
-      end
-
       # @api private
       def ==(other)
         return false unless other.kind_of?(self.class)
-        return false unless @expr == other.expr
+        return false unless @rule_expr == other.rule_expr
         return false unless @condition == other.condition
         return false unless @body == other.body
         return true
@@ -201,39 +178,42 @@ module Pione
 
       # @api private
       def hash
-        @expr.hash + @condition.hash + @body.hash
+        @rule_expr.hash + @condition.hash + @body.hash
       end
     end
 
-    # ActionRule is a rule writing action.
+    # ActionRule is a rule that have some actions. This rule makes data
+    # processing.
     class ActionRule < Rule
-      @rule_type = :action
-
-      # @api private
-      def handler_class
-        RuleHandler::ActionHandler
-      end
+      set_rule_type :action
+      set_handler_class RuleHandler::ActionHandler
     end
 
-    # FlowRule represents a flow structured rule. This rule is consisted by flow
-    # elements and executes elements actions.
+    # FlowRule is a rule that have flow elements. This rule makes flows of PIONE
+    # processing.
     class FlowRule < Rule
-      @rule_type = :flow
+      set_rule_type :flow
+      set_handler_class RuleHandler::FlowHandler
+    end
 
-      # @api private
-      def handler_class
-        RuleHandler::FlowHandler
-      end
+    # EmptyRule is a rule that have no body. This rule is useful when you need
+    # no flows and no actions.
+    class EmptyRule < Rule
+      set_rule_type :action
+      set_handler_class RuleHandler::EmptyHandler
     end
 
-    # RootRule is a hidden toplevel flow rule like the following:
+    # RootRule is a hidden toplevel rule. This rule has same flow as the follow:
     #   Rule Root
     #     input  '*'.all
     #     output '*'.all.except('{$INPUT[1]}')
     #   Flow
     #     rule &main:Main
     #   End
-    class RootRule < FlowRule
+    class RootRule < Rule
+      set_rule_type :flow
+      set_handler_class RuleHandler::RootHandler
+
       INPUT_DOMAIN = 'input'
 
       # root domain has no digest and no package
@@ -250,56 +230,45 @@ module Pione
       def initialize(main, params=Parameters.empty)
         @main = main
         @params = params
-        condition = make_condition
         super(
-          RuleExpr.new(Package.new("root"), "Root", Parameters.empty, TicketExpr.empty, TicketExpr.empty),
-          condition,
-          FlowBlock.new(CallRule.new(@main.expr.set_params(@params)))
+          RuleExpr.new(Package.new("root"), "Root"),
+          RuleCondition.new(@main.inputs, @main.outputs),
+          FlowBlock.new(CallRule.new(@main.rule_expr.set_params(@params)))
         )
         @domain = ROOT_DOMAIN
       end
 
       # @api private
       def make_handler(ts_server)
+        # build parameter
+        params = @main.params.merge(@params)
+
+        # find inputs
         finder = DataFinder.new(ts_server, INPUT_DOMAIN)
-        results = finder.find(:input, inputs, @params.as_variable_table)
+        results = finder.find(:input, inputs, params.as_variable_table)
         if results.empty? and not(@main.inputs.empty?)
           return nil
         end
         inputs = @main.inputs.empty? ? [] : results.first.combination
+
+        # make handler
         handler_class.new(
           ts_server,
           self,
           inputs,
-          @params,
+          params,
           [],
           {:domain => @domain}
         )
       end
-
-      private
-
-      # @api private
-      def make_condition
-        RuleCondition.new(
-          @main.inputs,
-          @main.outputs,
-          Parameters.empty,
-          Feature.empty,
-          TicketExpr.empty,
-          TicketExpr.empty
-        )
-      end
-
-      # @api private
-      def handler_class
-        RuleHandler::RootHandler
-      end
     end
 
     # SystemRule represents built-in rule definition. System rules belong to
     # 'system' package.
-    class SystemRule < ActionRule
+    class SystemRule < Rule
+      set_rule_type :action
+      set_handler_class RuleHandler::SystemHandler
+
       # Create a system rule model.
       #
       # @param name [String]
@@ -307,29 +276,10 @@ module Pione
       # @param [Proc] b
       #   rule process
       def initialize(name, &b)
-        expr = RuleExpr.new(
-          Package.new('system'),
-          name,
-          Parameters.empty,
-          TicketExpr.empty,
-          TicketExpr.empty
-        )
-        condition = make_condition
+        expr = RuleExpr.new(Package.new('system'), name)
+        condition = RuleCondition.new([DataExpr.new('*').to_seq.set_all], [])
         super(expr, condition, b)
       end
-
-      private
-
-      # @api private
-      def make_condition
-        inputs = [DataExpr.new('*')]
-        RuleCondition.new(inputs, [], Parameters.empty, Feature::EmptyFeature.new, TicketExpr.empty, TicketExpr.empty)
-      end
-
-      # @api private
-      def handler_class
-        RuleHandler::SystemHandler
-      end
     end
 
     # &System:Terminate rule

data/lib/pione/model/sequence.rb

@@ -0,0 +1,273 @@
+module Pione
+  module Model
+    # SequenceAttributeError is an exception for attribute mismatching.
+    class SequenceAttributeError < StandardError
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def message
+        "attribute mismatched: %s" % @attribute
+      end
+    end
+
+    # Sequence is a base class for all expressions.
+    class Sequence < Callable
+      include Enumerable
+
+      class << self
+        # Copy sequence attribute to subclass.
+        def inherited(subclass)
+          @sequence_attribute.each do |name, vals|
+            subclass.define_sequence_attribute(name, *vals)
+          end
+          subclass.set_index_type index_type
+        end
+
+        # Define sequence attribute.
+        #
+        # @param name [Symbol]
+        #    attribute name
+        # @param default_value [Symbol]
+        #    default value of the attribute
+        # @param other_values [Array<Symbol>]
+        #    other values of the attribute
+        # @return [void]
+        def define_sequence_attribute(name, default_value, *other_values)
+          @sequence_attribute ||= {}
+          @sequence_attribute[name] = [default_value] + other_values
+
+          define_method(name) do
+            @attribute[name]
+          end
+
+          define_method("set_%s" % name) do |value|
+            self.class.new(@elements, @attribute.merge({name => value}))
+          end
+
+          # define additional methods when values are symbols
+          if default_value.kind_of?(Symbol)
+            ([default_value] + other_values).each do |value|
+              define_method("%s?" % value) do
+                @attribute[name] == value
+              end
+
+              define_method("set_%s" % value) do
+                self.class.new(@elements, @attribute.merge({name => value}))
+              end
+            end
+          end
+        end
+
+        attr_reader :element_class
+        attr_reader :sequence_attribute
+        attr_reader :shortname
+        attr_reader :index_type
+
+        # Set element class.
+        #
+        # @param klass [Class]
+        #   element class
+        # @return [void]
+        def set_element_class(klass)
+          @element_class = klass
+          klass.set_sequence_class(self)
+        end
+
+        # Set the shortname.
+        #
+        # @param name [String]
+        #   shortname
+        # @return [void]
+        def set_shortname(name)
+          @shortname = name
+        end
+
+        # Set the index type.
+        #
+        # @param index_type [Type]
+        #   index type
+        # @return [void]
+        def set_index_type(index_type)
+          @index_type = index_type
+        end
+
+        # Make an empty sequence.
+        def empty(attributes={})
+          new([], attributes)
+        end
+      end
+
+      # Make a void sequence.
+      def Sequence.void
+        Sequence.new([])
+      end
+
+      define_sequence_attribute :distribution, :each, :all
+      forward! :class, :sequence_attribute, :shortname, :index_type
+      forward! :@elements, :first, :[], :empty?
+      attr_reader :elements
+      attr_reader :attribute
+
+      # @param elements [Array]
+      #   sequence elements
+      # @param attribute [Hash]
+      #   sequence attribute
+      def initialize(elements, attribute={})
+        @elements = elements
+        @attribute = Hash.new.merge(attribute)
+
+        # clear unneeded keys
+        (attribute.keys - sequence_attribute.keys).each do |key|
+          @attribute.delete(key)
+        end
+
+        # fill default value
+        sequence_attribute.each do |name, values|
+          @attribute[name] ||= values.first
+        end
+      end
+
+
+      # Return true if the sequence is void.
+      #
+      # @return [Boolean]
+      #   true if the sequence is void
+      def void?
+        self.class == Sequence and empty?
+      end
+
+      # Concatenate another sequence.
+      #
+      # @param other [Sequence]
+      #   other sequence
+      # @return [Sequence]
+      #   a new sequence that have members of self and other
+      def concat(other)
+        raise SequenceAttributeError.new(other) unless @attribute == other.attribute
+        self.class.new(@elements + other.elements, @attribute)
+      end
+
+      # Push the element to the sequecence.
+      #
+      # @param element [Element]
+      #    the element
+      # @return [Sequence]
+      #    a new sequence that have member self and the element.
+      def push(element)
+        self.class.new(@elements + [element], @attribute)
+      end
+
+      # Iterate each elements.
+      #
+      # @return [Enumerator]
+      #   return an enumerator if the block is not given
+      def each
+        if block_given?
+          @elements.each {|e| yield self.class.new([e], @attribute)}
+        else
+          Enumerator.new(self, :each)
+        end
+      end
+
+      def eval(vtable)
+        self.class.new(@elements.map{|elt| elt.eval(vtable)}, @attribute)
+      end
+
+      def include_variable?
+        @elements.any?{|elt| elt.include_variable?}
+      end
+
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        return false unless @elements == other.elements
+        return @attribute == other.attribute
+      end
+      alias :eql? :"=="
+
+      def hash
+        @elements.hash + @attribute.hash
+      end
+
+      def task_id_string
+        "<#{@elements}, #{@attribute}>"
+      end
+
+      def textize
+        "<%s [%s]>" % [shortname, @elements.map{|x| x.textize}.join(",")]
+      end
+
+      def inspect
+        "#<%s %s %s>" % [shortname, @elements, @attribute]
+      end
+    end
+
+    TypeSequence.instance_eval do
+      define_pione_method("!=", [:receiver_type], TypeBoolean) do |rec, other|
+        rec.call_pione_method("==", other).call_pione_method("not")
+      end
+
+      define_pione_method("|", [:receiver_type], :receiver_type) do |rec, other|
+        rec.concat(other)
+      end
+
+      define_pione_method("each", [], :receiver_type) do |rec|
+        rec.set_each
+      end
+
+      define_pione_method("each?", [], TypeBoolean) do |rec|
+        BooleanSequence.new([PioneBoolean.new(rec.each?)])
+      end
+
+      define_pione_method("all", [], :receiver_type) do |rec|
+        rec.set_all
+      end
+
+      define_pione_method("all?", [], TypeBoolean) do |rec|
+        BooleanSequence.new([PioneBoolean.new(rec.all?)])
+      end
+
+      define_pione_method("i", [], TypeInteger) do |rec|
+        rec.call_pione_method("as_integer")
+      end
+
+      define_pione_method("f", [], TypeFloat) do |rec|
+        rec.call_pione_method("as_float")
+      end
+
+      define_pione_method("str", [], TypeString) do |rec|
+        rec.call_pione_method("as_string")
+      end
+
+      define_pione_method("d", [], TypeDataExpr) do |rec|
+        rec.call_pione_method("as_data_expr")
+      end
+
+      define_pione_method("length", [], TypeInteger) do |rec|
+        IntegerSequence.new([PioneInteger.new(rec.elements.size)])
+      end
+
+      define_pione_method("[]", [:index_type], :receiver_type) do |rec, index|
+        rec.call_pione_method("nth", index)
+      end
+
+      define_pione_method("member?", [:receiver_type], TypeBoolean) do |rec, target|
+        sequential_map1(TypeBoolean, target) do |target_elt|
+          rec.elements.map{|elt| elt.value}.include?(target_elt.value)
+        end
+      end
+
+      define_pione_method(":", [TypeSequence], TypeKeyedSequence) do |keys, vals|
+        keys.elements.map do |key_elt|
+          vals.elements.map do |val_elt|
+            KeyedSequence.new(key_elt => [val_elt])
+          end
+        end.flatten.inject(KeyedSequence.new({})){|seq, _seq| seq.concat(_seq)}
+      end
+
+      define_pione_method("textize", [], TypeString) do |rec|
+        rec.call_pione_method("as_string").call_pione_method("join", PioneString.new(rec.separator).to_seq)
+      end
+    end
+  end
+end