pione 0.1.2 → 0.1.3

data/lib/pione/log/xes-log.rb

@@ -0,0 +1,105 @@
+module Pione
+  module Log
+    # XESLog is a class for XES formatted log.
+    class XESLog < ProcessLogFormatter
+      set_format_name :xes
+
+      # Format as a XML document.
+      #
+      # @return [String]
+      #   result string
+      def format(trace_filters=[])
+        filter = Proc.new {|trace| trace_filters.empty? or trace_filters.any?{|filter| filter.call(trace)}}
+        StringIO.new.tap do |out|
+          XES::Document.new.tap do |doc|
+            doc.log = XES::Log.default.tap do |log|
+              log.concept_name = "PIONE process log"
+              log.traces += [format_agent_activity + format_rule_process + format_task_process].flatten.select(&filter)
+              log.traces.flatten!
+            end
+            if doc.formattable?
+              doc.format.write(out, 2)
+              return out.string
+            else
+              raise ProcessLogFormatError.new("not formattable: %s" % doc.inspect)
+            end
+          end
+        end
+      end
+
+      private
+
+      # Format agent activity records.
+      #
+      # @return [Array<XES::Trace>]
+      def format_agent_activity
+        @bundles.map do |bundle|
+          bundle.agent_activity_log.group_by(:agent_uuid).map do |agent_uuid, records|
+            XES::Trace.new.tap do |trace|
+              trace.attributes << XES.string("pione:traceType", "agent_activity")
+              trace.identity_id = agent_uuid
+              trace.events = records.sort{|a, b| a.timestamp <=> b.timestamp}.map do |record|
+                XES::Event.new.tap do |event|
+                  event.concept_name = record.state
+                  event.org_resource = record.agent_type
+                  event.time_timestamp = record.timestamp
+                  event.lifecycle_transition = record.transition
+                end
+              end
+            end
+          end.flatten
+        end
+      end
+
+      # Format rule process records.
+      #
+      # @return [Array<XES::Trace>]
+      def format_rule_process
+        @bundles.map do |bundle|
+          XES::Trace.new.tap do |trace|
+            trace.concept_name = "rule_process %s" % Util.generate_uuid
+            trace.attributes << XES.string("pione:traceType", "rule_process")
+            trace.events = bundle.rule_process_log.records.map do |record|
+              XES::Event.new.tap do |event|
+                # standard attributes
+                event.concept_name = record.name
+                event.org_resource = record.caller
+                event.time_timestamp = record.timestamp
+                event.lifecycle_transition = record.transition
+
+                # pione extension attributes
+                event.attributes << XES.string("pione:ruleType", record.rule_type)
+              end
+            end
+          end
+        end
+      end
+
+      # Format task process records.
+      #
+      # @return [Array<XES::Trace>]
+      def format_task_process
+        @bundles.map do |bundle|
+          XES::Trace.new.tap do |trace|
+            trace.concept_name = "task process %s" % Util.generate_uuid
+            trace.attributes << XES.string("pione:traceType", "task_process")
+            trace.events = bundle.task_process_log.records.map do |record|
+              XES::Event.new.tap do |event|
+                # standard attributes
+                event.concept_name = record.name
+                # event.org_resource = record.caller
+                event.time_timestamp = record.timestamp
+                event.lifecycle_transition = record.transition
+
+                # pione extension attributes
+                event.attributes << XES.string("pione:ruleType", record.rule_type)
+                event.attributes << XES.string("pione:inputs", record.inputs)
+                event.attributes << XES.string("pione:parameters", record.parameters)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/model/assignment.rb

@@ -1,95 +1,103 @@
-module Pione::Model
-  # Assignment represents a value assignment for variable.
-  # @example
-  #   # assigning a string
-  #   $X := "a"
-  #   # => Assignment.new(Variable.new('X'), PioneString.new('a'))
-  # @example
-  #   # assigning a variable value
-  #   $X := $Y
-  #   # => Assignment.new(Variable.new('X'), Variable.new('Y'))
-  class Assignment < BasicModel
-    set_pione_model_type TypeAssignment
+module Pione
+  module Model
+    # Assignment represents a value assignment for variable.
+    #
+    # @example
+    #   # assigning a string
+    #   $X := "a"
+    #   # => Assignment.new(Variable.new('X'), PioneString.new('a'))
+    # @example
+    #   # assigning a variable value
+    #   $X := $Y
+    #   # => Assignment.new(Variable.new('X'), Variable.new('Y'))
+    class Assignment < BasicModel
+      set_pione_model_type TypeAssignment
 
-    # Returns the variable part of assignment.
-    attr_reader :variable
+      # Return the variable part of assignment.
+      attr_reader :variable
 
-    # Returns the expression part of assignment.
-    attr_reader :expr
+      # Return the expression part of assignment.
+      attr_reader :expr
 
-    # Creates an assignment.
-    # @param [Variable] variable
-    #   variable part of assignment
-    # @param [BasicModel] expr
-    #   expression part of assignment
-    def initialize(variable, expr)
-      check_argument_type(variable, Variable)
-      check_argument_type(expr, BasicModel)
-      @variable = variable
-      @expr = expr
-      super()
-    end
+      # Create an assignment.
+      #
+      # @param variable [Variable]
+      #   variable part of assignment
+      # @param expr [BasicModel]
+      #   expression part of assignment
+      def initialize(variable, expr)
+        check_argument_type(variable, Variable)
+        check_argument_type(expr, BasicModel)
+        @variable = variable
+        @expr = expr
+        super()
+      end
 
-    # Evaluates the assignment. This method updates the variable table with the
-    # variable and expression. The expression is pushed into the table directory
-    # as it is because of lazy evaluation.
-    # @param [VariableTable] vtable
-    #   variable table for evaluation
-    # @return [BasicModel]
-    #   self
-    def eval(vtable)
-      vtable.set(@variable, @expr)
-    end
+      # Evaluate the assignment. This method updates the variable table with the
+      # variable and expression. The expression is pushed into the table directory
+      # as it is because of lazy evaluation.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   self
+      def eval(vtable)
+        vtable.set(@variable, @expr)
+      end
 
-    # Set truth of toplevel assignment.
-    def set_toplevel(b)
-      @variable.set_toplevel(b)
-    end
-
-    # Set truth of user parameter.
-    def set_user_param(b)
-      @variable.set_user_param(b)
-    end
+      # Set truth of toplevel assignment.
+      def set_toplevel(b)
+        @variable.set_toplevel(b)
+      end
 
-    # Returns true if the assignment is defined in toplevel.
-    # @return [Boolean]
-    #   true if the assignment is defined in toplevel
-    def toplevel?
-      @variable.toplevel?
-    end
+      # Set truth of user parameter.
+      def set_user_param(b)
+        @variable.set_user_param(b)
+      end
 
-    # Returns false because assignment form is complex(pair of variable and
-    # expression).
-    # @return [Boolean]
-    #   false
-    def atomic?
-      false
-    end
+      # Return true if the assignment is defined in toplevel.
+      #
+      # @return [Boolean]
+      #   true if the assignment is defined in toplevel
+      def toplevel?
+        @variable.toplevel?
+      end
 
-    # Returns true if the expression part of assignment includes variable.
-    # @return [Boolean]
-    #   true if the expression part of assignment includes variable
-    def include_variable?
-      @expr.include_variable?
-    end
+      # Return false because assignment form is complex(pair of variable and
+      # expression).
+      #
+      # @return [Boolean]
+      #   false
+      def atomic?
+        false
+      end
 
-    # @api private
-    def textize
-      "%s:=%s" % [@variable.textize, @expr.textize]
-    end
+      # Return true if the expression part of assignment includes variable.
+      #
+      # @return [Boolean]
+      #   true if the expression part of assignment includes variable
+      def include_variable?
+        @expr.include_variable?
+      end
 
-    # Returns true if other is a variable object which name is same as myself.
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @variable == other.variable && @expr == other.expr
-    end
+      # @api private
+      def textize
+        "%s:=%s" % [@variable.textize, @expr.textize]
+      end
 
-    alias :eql? :"=="
+      # Return true if other is a variable object which name is same as myself.
+      #
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @variable == other.variable && @expr == other.expr
+      end
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @variable.hash + @expr.hash
+      # @api private
+      def hash
+        @variable.hash + @expr.hash
+      end
     end
   end
 end

data/lib/pione/model/binary-operator.rb

@@ -1,80 +1,86 @@
-module Pione::Model
+module Pione
+  module Model
+    # BinaryOperator represents applications between Pione model objects.
+    #
+    # @example
+    #   1 + 1
+    # @example
+    #   true == false
+    # @example
+    #   $X * $Y
+    class BinaryOperator < BasicModel
+      attr_reader :symbol
+      attr_reader :left
+      attr_reader :right
 
-  # BinaryOperator represents applications between Pione model objects.
-  # @example
-  #   1 + 1
-  # @example
-  #   true == false
-  # @example
-  #   $X * $Y
-  class BinaryOperator < BasicModel
-    attr_reader :symbol
-    attr_reader :left
-    attr_reader :right
+      # Create a binary operator.
+      #
+      # @param symbol [String]
+      #   operator's symbol
+      # @param left [BasicModel]
+      #   left operand
+      # @param right [BasicModel]
+      #   right operand
+      def initialize(symbol, left, right)
+        @symbol = symbol
+        @left = left
+        @right = right
+        super()
+      end
 
-    # Create a binary operator.
-    # @param [String] symbol
-    #   operator's symbol
-    # @param [BasicModel] left
-    #   left operand
-    # @param [BasicModel] right
-    #   right operand
-    def initialize(symbol, left, right)
-      @symbol = symbol
-      @left = left
-      @right = right
-      super()
-    end
-
-    # Returns false because Message has complex form.
-    # @return [Boolean]
-    #   false
-    def atomic?
-      false
-    end
+      # Return false because Message has complex form.
+      #
+      # @return [Boolean]
+      #   false
+      def atomic?
+        false
+      end
 
-    # Returns true if the left or right expression includes variable.
-    # @return [Boolean]
-    #    true if the left or right expression includes variable
-    def include_variable?
-      @left.include_variable? or @right.include_variable?
-    end
+      # Return true if the left or right expression includes variable.
+      #
+      # @return [Boolean]
+      #    true if the left or right expression includes variable
+      def include_variable?
+        @left.include_variable? or @right.include_variable?
+      end
 
-    # @api private
-    def pione_model_type
-      @left.pione_model_type.method_interface[@symbol].output
-    end
+      # @api private
+      def pione_model_type
+        @left.pione_model_type.method_interface[@symbol].output
+      end
 
-    # Evaluates the application expression and returns application result.
-    # @param [VariableTable] vtable
-    #   variable table for the evaluation
-    # @return [BasicModel]
-    #   evaluation result object
-    def eval(vtable)
-      left = @left.eval(vtable)
-      right = @right.eval(vtable)
-      left.call_pione_method(@symbol, right)
-    end
+      # Evaluate the application expression and returns application result.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for the evaluation
+      # @return [BasicModel]
+      #   evaluation result object
+      def eval(vtable)
+        left = @left.eval(vtable)
+        right = @right.eval(vtable)
+        left.call_pione_method(@symbol, right)
+      end
 
-    # @api private
-    def textize
-      "%s%s%s" % [@left.textize, @symbol.to_s, @right.textize]
-    end
+      # @api private
+      def textize
+        "%s%s%s" % [@left.textize, @symbol.to_s, @right.textize]
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      return false unless @symbol == other.symbol
-      return false unless @left == other.left
-      return false unless @right == other.right
-      return true
-    end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        return false unless @symbol == other.symbol
+        return false unless @left == other.left
+        return false unless @right == other.right
+        return true
+      end
 
-    alias :eql? :"=="
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @symbol.hash + @left.hash + @right.hash
+      # @api private
+      def hash
+        @symbol.hash + @left.hash + @right.hash
+      end
     end
   end
 end

data/lib/pione/model/block.rb

@@ -1,234 +1,245 @@
-module Pione::Model
-  # ActionBlock represents content script of action.
-  # @example
-  #   Action
-  #     echo "abc"
-  #   End
-  #   #=> ActionBlock.new("  echo \"abc\"")
-  class ActionBlock < BasicModel
-    attr_reader :content
-
-    # Creates a action block.
-    # @param [String] content
-    #   action content of shell script
-    def initialize(content)
-      @content = content
-      super()
-    end
-
-    # Evaluates the object.
-    # @param [VariableTable] vtable
-    #   variable table for evaluation
-    # @return [BasicModel]
-    #   evaluation result
-    def eval(vtable)
-      self.class.new(vtable.expand(@content))
-    end
-
-    # Returns true if the content includes variables.
-    # @return [Boolean]
-    #   true if the content includes variables
-    def include_variable?
-      return VariableTable.check_include_variable(@content)
-    end
+module Pione
+  module Model
+    # ActionBlock represents content script of action.
+    #
+    # @example
+    #   Action
+    #     echo "abc"
+    #   End
+    #   #=> ActionBlock.new("  echo \"abc\"")
+    class ActionBlock < BasicModel
+      attr_reader :content
+
+      # Create an action block.
+      #
+      # @param content [String]
+      #   action content of shell script
+      def initialize(content)
+        @content = content
+        super()
+      end
 
-    # @api private
-    def textize
-      "action_block(\"#{@content}\")"
-    end
+      # Evaluate the block. Variables of the content is expanded by the variable
+      # table.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        self.class.new(vtable.expand(@content))
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @content == other.content
-    end
+      # Return true if the content includes variables.
+      #
+      # @return [Boolean]
+      #   true if the content includes variables
+      def include_variable?
+        return VariableTable.check_include_variable(@content)
+      end
 
-    alias :eql? :==
+      # @api private
+      def textize
+        "action_block(\"#{@content}\")"
+      end
 
-    # @api private
-    def hash
-      @content.hash
-    end
-  end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @content == other.content
+      end
+      alias :eql? :"=="
 
-  # FlowBlock represents flow element sequence.
-  # @example
-  #   Flow
-  #     rule Test1
-  #     rule Test2
-  #     rule Test3
-  #   End
-  #   #=> Block.new([ CallRule.new('Test1'),
-  #                   CallRule.new('Test2'),
-  #                   CallRule.new('Test3') ])
-  class FlowBlock < BasicModel
-    attr_reader :elements
-
-    # Create a flow block.
-    # @param [Array<BasicModel>] elements
-    #   flow elements
-    def initialize(*elements)
-      unless elements.all? {|elt| elt.kind_of?(BasicModel)}
-        raise ArgumentError.new(elements)
-      end
-      @elements = elements
+      # @api private
+      def hash
+        @content.hash
+      end
     end
 
-    # Evaluate each elements and return it.
+    # FlowBlock represents flow element sequence.
     #
-    # @param [VariableTable] vtable
-    #   variable table for evaluation
-    # @return [BasicModel]
-    #   evaluation result
-    def eval(vtable)
-      assignments = @elements.select{|elt| elt.kind_of?(Assignment)}
-      conditional_blocks = @elements.select{|elt| elt.kind_of?(ConditionalBlock)}
-      call_rules = @elements.select{|elt| elt.kind_of?(CallRule)}
-
-      if not(assignments.empty?)
-        assignments.each do |assignment|
-          assignment.eval(vtable)
+    # @example
+    #   Flow
+    #     rule Test1
+    #     rule Test2
+    #     rule Test3
+    #   End
+    #   #=> Block.new([ CallRule.new('Test1'),
+    #                   CallRule.new('Test2'),
+    #                   CallRule.new('Test3') ])
+    class FlowBlock < BasicModel
+      attr_reader :elements
+
+      # Create a flow block.
+      #
+      # @param elements [Array<BasicModel>]
+      #   flow elements
+      def initialize(*elements)
+        unless elements.all? {|elt| elt.kind_of?(BasicModel)}
+          raise ArgumentError.new(elements)
         end
-        FlowBlock.new(*(conditional_blocks+call_rules)).eval(vtable)
-      elsif not(conditional_blocks.empty?)
-        exception = nil
-        new_blocks = []
-        next_blocks = []
-        conditional_blocks.each do |block|
-          begin
-            new_blocks << block.eval(vtable)
-          rescue UnboundVariableError => e
-            exception = e
-            next_blocks << block
+        @elements = elements
+      end
+
+      # Evaluate each elements and return it.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        assignments = @elements.select{|elt| elt.kind_of?(Assignment)}
+        conditional_blocks = @elements.select{|elt| elt.kind_of?(ConditionalBlock)}
+        call_rules = @elements.select{|elt| elt.kind_of?(CallRule)}
+
+        if not(assignments.empty?)
+          assignments.each do |assignment|
+            assignment.eval(vtable)
           end
+          FlowBlock.new(*(conditional_blocks+call_rules)).eval(vtable)
+        elsif not(conditional_blocks.empty?)
+          exception = nil
+          new_blocks = []
+          next_blocks = []
+          conditional_blocks.each do |block|
+            begin
+              new_blocks << block.eval(vtable)
+            rescue UnboundVariableError => e
+              exception = e
+              next_blocks << block
+            end
+          end
+          # fail to evaluate conditional blocks
+          if conditional_blocks == next_blocks
+            raise exception
+          end
+          # next
+          elements = new_blocks.inject([]){|elts, block| elts += block.elements}
+          FlowBlock.new(*(elements + next_blocks + call_rules)).eval(vtable)
+        else
+          FlowBlock.new(*call_rules.map{|call_rule| call_rule.eval(vtable)})
         end
-        # fail to evaluate conditional blocks
-        if conditional_blocks == next_blocks
-          raise exception
-        end
-        # next
-        elements = new_blocks.inject([]){|elts, block| elts += block.elements}
-        FlowBlock.new(*(elements + next_blocks + call_rules)).eval(vtable)
-      else
-        FlowBlock.new(*call_rules.map{|call_rule| call_rule.eval(vtable)})
       end
-    end
 
-    # Returns true if the elements include variables.
-    # @return [Boolean]
-    #   true if the elements include variables
-    def include_variable?
-      @elements.any?{|elt| elt.include_variable?}
-    end
-
-    # @api private
-    def textize
-      "flow_block(%s)" % [@elements.map{|elt| elt.textize}.join(",")]
-    end
-
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @elements == other.elements
-    end
+      # Return true if the elements include variables.
+      #
+      # @return [Boolean]
+      #   true if the elements include variables
+      def include_variable?
+        @elements.any?{|elt| elt.include_variable?}
+      end
 
-    alias :eql? :==
+      # @api private
+      def textize
+        "flow_block(%s)" % [@elements.map{|elt| elt.textize}.join(",")]
+      end
 
-    # @api private
-    def hash
-      @elements.hash
-    end
-  end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @elements == other.elements
+      end
+      alias :eql? :"=="
 
-  # ConditionalBlock represents conditional flow applications.
-  # @example
-  #   # if statement
-  #   if $X == "a"
-  #     rule Test1
-  #   else
-  #     rule Test2
-  #   end
-  #   #=> ConditionalBlock.new(
-  #         BinaryOperator::Equals.new(Variable.new('X'), 'a'),
-  #         { true => [CallRule.new('Test1')],
-  #           :else => [CallRule.new('Test2')] })
-  # @example
-  #   # case statement
-  #   case $X
-  #   when "a"
-  #     rule Test1
-  #   when "b"
-  #     rule Test2
-  #   else
-  #     rule Test3
-  #   end
-  #   # => ConditionalBlock.new(
-  #          Variable.new('X'),
-  #          { 'a' => FlowBlock.new(CallRule.new('Test1')),
-  #            'b' => FlowBlock.new(CallRule.new('Test2')),
-  #            :else => FlowBlock.new(CallRule.new('Test3')) })
-  class ConditionalBlock < BasicModel
-    attr_reader :condition
-    attr_reader :blocks
-
-    # Creates a conditional block.
-    # @param [BasicModel] condition
-    #    condition value
-    # @param [Hash{BasicModel => FlowBlock}] blocks
-    #    condition key and block
-    def initialize(condition, blocks={})
-      unless blocks.all?{|key,val|
-          (key.kind_of?(BasicModel) or key == :else) &&
-          val.kind_of?(FlowBlock)
-        }
-        raise ArgumentError.new(blocks)
-      end
-      @condition = condition
-      @blocks = blocks
+      # @api private
+      def hash
+        @elements.hash
+      end
     end
 
-    # Evaluates the condition and returns the flow block.
-    # @param [VariableTable] vtable
-    #   variable table for evaluation
-    # @return [BasicModel]
-    #   evaluation result
-    def eval(vtable)
-      value = @condition.eval(vtable)
-      if block = @blocks.find {|key, _| key == value}
-        return block[1].eval(vtable)
-      elsif block = @blocks[:else]
-        return block.eval(vtable)
-      else
-        return FlowBlock.new
+    # ConditionalBlock represents conditional flow applications.
+    #
+    # @example
+    #   # if statement
+    #   if $X == "a"
+    #     rule Test1
+    #   else
+    #     rule Test2
+    #   end
+    #   #=> ConditionalBlock.new(
+    #         BinaryOperator::Equals.new(Variable.new('X'), 'a'),
+    #         { true => [CallRule.new('Test1')],
+    #           :else => [CallRule.new('Test2')] })
+    # @example
+    #   # case statement
+    #   case $X
+    #   when "a"
+    #     rule Test1
+    #   when "b"
+    #     rule Test2
+    #   else
+    #     rule Test3
+    #   end
+    #   # => ConditionalBlock.new(
+    #          Variable.new('X'),
+    #          { 'a' => FlowBlock.new(CallRule.new('Test1')),
+    #            'b' => FlowBlock.new(CallRule.new('Test2')),
+    #            :else => FlowBlock.new(CallRule.new('Test3')) })
+    class ConditionalBlock < BasicModel
+      attr_reader :condition
+      attr_reader :blocks
+
+      # Create a conditional block.
+      #
+      # @param condition [BasicModel]
+      #   condition value
+      # @param blocks [Hash{BasicModel => FlowBlock}]
+      #   condition key and block
+      def initialize(condition, blocks={})
+        unless blocks.all?{|key,val|
+            (key.kind_of?(BasicModel) or key == :else) &&
+            val.kind_of?(FlowBlock)
+          }
+          raise ArgumentError.new(blocks)
+        end
+        @condition = condition
+        @blocks = blocks
       end
-    end
 
-    # Returns ture if blocks include variables.
-    # @return [Boolean]
-    #   ture if blocks include variables
-    def include_variable?
-      @blocks.values.any?{|block| block.include_variable?}
-    end
+      # Evaluate the condition and returns the flow block.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        value = @condition.eval(vtable)
+        if block = @blocks.find {|key, _| key == value}
+          return block[1].eval(vtable)
+        elsif block = @blocks[:else]
+          return block.eval(vtable)
+        else
+          return FlowBlock.new
+        end
+      end
 
-    # @api private
-    def textize
-      "conditional_block(%s,{%s})" % [
-        @condition.textize,
-        @blocks.map{|val, block| "%s=>%s" % [val,block]}.join(",")
-      ]
-    end
+      # Return ture if blocks include variables.
+      #
+      # @return [Boolean]
+      #   ture if blocks include variables
+      def include_variable?
+        @blocks.values.any?{|block| block.include_variable?}
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @condition == other.condition && @blocks == other.blocks
-    end
+      # @api private
+      def textize
+        "conditional_block(%s,{%s})" % [
+          @condition.textize,
+          @blocks.map{|val, block| "%s=>%s" % [val,block]}.join(",")
+        ]
+      end
 
-    alias :eql? :==
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @condition == other.condition && @blocks == other.blocks
+      end
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @condition.hash + @blocks.hash
+      # @api private
+      def hash
+        @condition.hash + @blocks.hash
+      end
     end
   end
 end