pione 0.1.2 → 0.1.3

data/lib/pione/model/boolean.rb

@@ -1,138 +1,149 @@
-module Pione::Model
-  # PioneBoolean representes truth value in PIONE system.
-  class PioneBoolean < BasicModel
-    set_pione_model_type TypeBoolean
-
-    # Returns the value in ruby.
-    attr_reader :value
-
-    class << self
-      # Returns true value in PIONE system.
-      # @return [PioneBoolean]
-      #   true value
-      def true
-        new(true)
+module Pione
+  module Model
+    # PioneBoolean representes truth value in PIONE system.
+    class PioneBoolean < BasicModel
+      set_pione_model_type TypeBoolean
+
+      # Returns the value in ruby.
+      attr_reader :value
+
+      class << self
+        # Return true value in PIONE system.
+        #
+        # @return [PioneBoolean]
+        #   true value
+        def true
+          new(true)
+        end
+
+        # Return false value in PIONE system.
+        #
+        # @return [PioneBoolean]
+        #   false value
+        def false
+          new(false)
+        end
+
+        # Return inverse value of it.
+        #
+        # @param boolean [Boolean]
+        #   target value
+        # @return [PioneBoolean]
+        #   true if the param is false, or false
+        def not(boolean)
+          new(not(boolean.value))
+        end
+
+        # Return true value if arguments include true value.
+        #
+        # @param args [Array<PioneBoolean>]
+        # @return [PioneBoolean]
+        #   true value if arguments include true value
+        def or(*args)
+          new(args.any?{|arg| arg.true?})
+        end
+
+        # Return true value if all arguments has true value.
+        #
+        # @param args [Array<PioneBoolean>]
+        # @return [PioneBoolean]
+        #   true value if all arguments has true value
+        def and(*args)
+          new(args.all?{|arg| arg.true?})
+        end
       end
 
-      # Returns false value in PIONE system.
-      # @return [PioneBoolean]
-      #   false value
-      def false
-        new(false)
+      # Create a value.
+      #
+      # @param value [Boolean]
+      #   true or false
+      def initialize(value)
+        @value = value
+        super()
       end
 
-      # Returns inverse value of it.
-      # @param [Boolean] boolean
-      #   target value
-      # @return [PioneBoolean]
-      #   true if the param is false, or false
-      def not(boolean)
-        new(not(boolean.value))
+      # @api private
+      def task_id_string
+        "Boolean<#{@value}>"
       end
 
-      # Returns true value if arguments include true value.
-      # @param [Array<PioneBoolean>] args
-      # @return [PioneBoolean]
-      #   true value if arguments include true value
-      def or(*args)
-        new(args.any?{|arg| arg.true?})
+      # @api private
+      def textize
+        @value.to_s
       end
 
-      # Returns true value if all arguments has true value.
-      # @param [Array<PioneBoolean>] args
-      # @return [PioneBoolean]
-      #   true value if all arguments has true value
-      def and(*args)
-        new(args.all?{|arg| arg.true?})
+      # Return true if the value is true.
+      #
+      # @return [Boolean]
+      #   true if the value is true
+      def true?
+        @value == true
       end
-    end
-
-    # Creates a value.
-    # @param [Boolean] value
-    #   true or false
-    def initialize(value)
-      @value = value
-      super()
-    end
-
-    # @api private
-    def task_id_string
-      "Boolean<#{@value}>"
-    end
-
-    # @api private
-    def textize
-      @value.to_s
-    end
 
-    # Returns true if the value is true.
-    # @return [Boolean]
-    #   true if the value is true
-    def true?
-      @value == true
-    end
-
-    # Returns true if the value is false.
-    # @return [Boolean]
-    #   true if the value is false
-    def false?
-      @value == false
-    end
+      # Return true if the value is false.
+      #
+      # @return [Boolean]
+      #   true if the value is false
+      def false?
+        @value == false
+      end
 
-    # Returns ruby's boolean value.
-    # @return [Boolean]
-    #   ruby's boolean value
-    def to_ruby
-      return @value
-    end
+      # Return ruby's boolean value.
+      #
+      # @return [Boolean]
+      #   ruby's boolean value
+      def to_ruby
+        return @value
+      end
 
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @value == other.value
-    end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @value == other.value
+      end
 
-    alias :eql? :==
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @value.hash
-    end
+      # @api private
+      def hash
+        @value.hash
+      end
 
-    #
-    # pione methods
-    #
+      #
+      # pione methods
+      #
 
-    define_pione_method("==", [TypeBoolean], TypeBoolean) do |rec, other|
-      PioneBoolean.new(rec.value == other.value)
-    end
+      define_pione_method("==", [TypeBoolean], TypeBoolean) do |rec, other|
+        PioneBoolean.new(rec.value == other.value)
+      end
 
-    define_pione_method("!=", [TypeBoolean], TypeBoolean) do |rec, other|
-      PioneBoolean.not(rec.call_pione_method("==", other))
-    end
+      define_pione_method("!=", [TypeBoolean], TypeBoolean) do |rec, other|
+        PioneBoolean.not(rec.call_pione_method("==", other))
+      end
 
-    define_pione_method("&&", [TypeBoolean], TypeBoolean) do |rec, other|
-      PioneBoolean.new(rec.value && other.value)
-    end
+      define_pione_method("&&", [TypeBoolean], TypeBoolean) do |rec, other|
+        PioneBoolean.new(rec.value && other.value)
+      end
 
-    define_pione_method("||", [TypeBoolean], TypeBoolean) do |rec, other|
-      PioneBoolean.new(rec.value || other.value)
-    end
+      define_pione_method("||", [TypeBoolean], TypeBoolean) do |rec, other|
+        PioneBoolean.new(rec.value || other.value)
+      end
 
-    define_pione_method("and", [TypeBoolean], TypeBoolean) do |rec, other|
-      rec.call_pione_method("&&", other)
-    end
+      define_pione_method("and", [TypeBoolean], TypeBoolean) do |rec, other|
+        rec.call_pione_method("&&", other)
+      end
 
-    define_pione_method("or", [TypeBoolean], TypeBoolean) do |rec, other|
-      rec.call_pione_method("||", other)
-    end
+      define_pione_method("or", [TypeBoolean], TypeBoolean) do |rec, other|
+        rec.call_pione_method("||", other)
+      end
 
-    define_pione_method("as_string", [], TypeString) do |rec|
-      PioneString.new(rec.value.to_s)
-    end
+      define_pione_method("as_string", [], TypeString) do |rec|
+        PioneString.new(rec.value.to_s)
+      end
 
-    define_pione_method("not", [], TypeBoolean) do |rec|
-      PioneBoolean.not(rec)
+      define_pione_method("not", [], TypeBoolean) do |rec|
+        PioneBoolean.not(rec)
+      end
     end
   end
 end

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

@@ -1,79 +1,86 @@
-module Pione::Model
-  # CallRule represents the application of a rule.
-  # @example
-  #   # simple rule calling:
-  #   rule r1
-  #   #=> CallRule.new(RuleExpr.new('r1'))
-  # @example
-  #   # with absolute path:
-  #   rule /abc:a
-  #   #=> CallRule.new(RuleExpr.new('/abc:a'))
-  # @example
-  #   # with variable:
-  #   rule $X
-  #   #=> CallRule.new(Variable.new('X'))
-  class CallRule < BasicModel
-    attr_reader :expr
+module Pione
+  module Model
+    # CallRule represents the application of a rule.
+    #
+    # @example
+    #   # simple rule calling:
+    #   rule r1
+    #   #=> CallRule.new(RuleExpr.new('r1'))
+    # @example
+    #   # with absolute path:
+    #   rule /abc:a
+    #   #=> CallRule.new(RuleExpr.new('/abc:a'))
+    # @example
+    #   # with variable:
+    #   rule $X
+    #   #=> CallRule.new(Variable.new('X'))
+    class CallRule < BasicModel
+      attr_reader :expr
 
-    # Creates a callee rule.
-    # @param [BasicModel] expr
-    #   callee rule
-    def initialize(expr)
-      @expr = expr
-      super()
-    end
+      # Create a callee rule.
+      #
+      # @param expr [BasicModel]
+      #   callee rule
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
 
-    # Returns a rule path string with expanding variables.
-    # @return [String]
-    #   rule path(package name and rule name)
-    def rule_path
-      if @expr.include_variable?
-        raise UnboundVariableError.new(@expr)
+      # Return a rule path string with expanding variables.
+      #
+      # @return [String]
+      #   rule path(package name and rule name)
+      def rule_path
+        if @expr.include_variable?
+          raise UnboundVariableError.new(@expr)
+        end
+        @expr.rule_path
       end
-      @expr.rule_path
-    end
 
-    # Returns true if the expression has variables.
-    # @return [Boolean]
-    #   true if the expression has variables
-    def include_variable?
-      @expr.include_variable?
-    end
+      # Return true if the expression has variables.
+      #
+      # @return [Boolean]
+      #   true if the expression has variables
+      def include_variable?
+        @expr.include_variable?
+      end
 
-    # Evaluates the expression.
-    # @param [VariableTable] vtable
-    #   variable table for evaluation
-    # @return [BasicModel]
-    #   evaluation result
-    def eval(vtable)
-      self.class.new(@expr.eval(vtable))
-    end
+      # Evaluate the expression.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        self.class.new(@expr.eval(vtable))
+      end
 
-    # Return a set of call-rules that the rule expression are expanded.
-    #
-    # @return [Set<CallRule>]
-    #   a set of call-rules
-    def to_set
-      @expr.to_set.map do |expr|
-        self.class.new(expr)
+      # Return a set of call-rules that the rule expression are expanded.
+      #
+      # @return [Set<CallRule>]
+      #   a set of call-rules
+      def to_set
+        @expr.to_set.map do |expr|
+          self.class.new(expr)
+        end
       end
-    end
 
-    # @api private
-    def textize
-      "call_rule(%s)" % [@expr.textize]
-    end
+      # @api private
+      def textize
+        "call_rule(%s)" % [@expr.textize]
+      end
 
-    # @api private
-    def ==(other)
-      @expr == other.expr
-    end
+      # @api private
+      def ==(other)
+        @expr == other.expr
+      end
 
-    alias :eql? :==
+      alias :eql? :"=="
 
-    # @api private
-    def hash
-      @expr.hash
+      # @api private
+      def hash
+        @expr.hash
+      end
     end
   end
 end

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

@@ -1,360 +1,666 @@
-module Pione::Model
+module Pione
+  module Model
+    # DataExpr is a class for data name expressions of rule input and output.
+    #
+    # @example
+    #   # complete name
+    #   DataExpr.new("test.txt")
+    # @example
+    #   # incomplete name
+    #   DataExpr.new("*.txt")
+    class DataExpr < BasicModel
+
+      # separator symbol for all modifier
+      SEPARATOR = ':'
+
+      # DataExpr::Compiler is a regexp compiler for data expression.
+      module Compiler
+        TABLE = {}
+
+        # Define a string matcher.
+        def self.define_matcher(matcher, replace)
+          TABLE[Regexp.escape(matcher)] = replace
+        end
+
+        # Asterisk symbol is multi-characters matcher(empty string is not matched).
+        define_matcher('*', '(.+)')
+
+        # Question symbol is single character matcher(empty string is not matched).
+        define_matcher('?', '(.)')
+
+        # Compiles data name into regular expression.
+        #
+        # @param name [String]
+        #   data name
+        def compile(name)
+          return name unless name.kind_of?(String)
+
+          s = "^#{Regexp.escape(name)}$"
+          TABLE.keys.each {|key| s.gsub!(key, TABLE)}
+          s.gsub!(/\\\[(!|\\\^)?(.*)\\\]/){"[#{'^' if $1}#{$2.gsub('\-','-')}]"}
+          s.gsub!(/\\{(.*)\\}/){"(#{$1.split(',').join('|')})"}
+          Regexp.new(s)
+        end
+        module_function :compile
+      end
 
-  # DataExpr is a class for data name expressions of rule input and output.
-  # @example
-  #   # complete name
-  #   DataExpr.new("test.txt")
-  # @example
-  #   # incomplete name
-  #   DataExpr.new("*.txt")
-  class DataExpr < BasicModel
+      class << self
+        alias :orig_new :new
+
+        # Create a data expression. If the name includes separators, create DataExprOr instance.
+        def new(*args)
+          # check OR expression
+          name = args.first
+          if self == DataExpr and name.include?(SEPARATOR)
+            name.split(SEPARATOR).map do |single_name|
+              orig_new(single_name, *args.drop(1))
+            end.tap {|exprs| return DataExprOr.new(exprs)}
+          end
+
+          # other cases
+          return orig_new(*args)
+        end
+
+        # Create a named expression.
+        #
+        # @param name [String]
+        #   data name
+        def [](name)
+          new(name)
+        end
+
+        # Create a name expression with 'each' modifier.
+        #
+        # @param name [String]
+        #   data name
+        def each(name)
+          new(name, modifier: :each)
+        end
+
+        # Create a name expression with 'all' modifier.
+        #
+        # @param name [String]
+        #   data name
+        def all(name)
+          new(name, modifier: :all)
+        end
+
+        # Create a new data name for stdout ouput.
+        #
+        # @param name [String]
+        #   data name
+        # @return [DataExpr]
+        #   data expression for stdout
+        def stdout(name)
+          new(name, modifier: :each, mode: :stdout)
+        end
+
+        # Create a new data name for stderr output.
+        #
+        # @param name [String]
+        #   data name
+        # @return [DataExpr]
+        #   data expression for stderr
+        def stderr(name)
+          new(name, modifier: :each, mode: :stderr)
+        end
+
+        # Return convertion prcedure for enumerable.
+        #
+        # @return [Proc]
+        #   +Proc+ object that returns data expression with name
+        def to_proc
+          Proc.new{|name| name.kind_of?(self) ? name : self.new(name)}
+        end
+      end
 
-    # separator symbol for all modifier
-    SEPARATOR = ':'
+      set_pione_model_type TypeDataExpr
+
+      attr_reader :name
+      alias :core :name
+      forward_as_key! :@data, :modifier, :mode, :exceptions, :update_criteria
+
+      # Create a data expression.
+      #
+      # @param name [String]
+      #   data expression name
+      # @param opts [Hash]
+      #   options of the expression
+      # @option opts [Symbol] :modifier
+      #   :all or :each
+      # @option opts [Symbol] :mode
+      #   nil, :stdout, or :stderr
+      # @option opts [Array<DataExpr>] :exceptions
+      #   exceptional expressions
+      # @option opts [Boolean] :update_criteria
+      #   the flag whether the data disregards update criterias
+      def initialize(name, data={})
+        unless name.kind_of? String or name.kind_of? Regexp
+          raise ArgumentError.new(name)
+        end
+
+        @name = name
+        @data = Hash.new
+        @data[:modifier] = data[:modifier] || :each
+        @data[:mode] = data[:mode]
+        @data[:exceptions] = data[:exceptions] || []
+        @data[:update_criteria] = data[:update_criteria] || :care
+
+        super()
+      end
 
-    # DataExpr::Compiler is a regexp compiler for data expression.
-    module Compiler
-      TABLE = {}
+      # Return new data expression with each modifier.
+      #
+      # @return [DataExpr]
+      #   new data expression with each modifier
+      def each
+        return self.class.new(@name, @data.merge(modifier: :each))
+      end
 
-      # Define a string matcher.
-      def self.define_matcher(matcher, replace)
-        TABLE[Regexp.escape(matcher)] = replace
+      # Return new data expression with all modifier.
+      #
+      # @return [DataExpr]
+      #   new data expression with all modifier
+      def all
+        return self.class.new(@name, @data.merge(modifier: :all))
       end
 
-      # Asterisk symbol is multi-characters matcher(empty string is matched).
-      define_matcher('*', '(.*)')
+      # Return new data expression with stdout mode.
+      #
+      # @return [DataExpr]
+      #   new data expression with stdout mode
+      def stdout
+        return self.class.new(@name, @data.merge(mode: :stdout))
+      end
 
-      # Question symbol is single character matcher(empty string is not matched).
-      define_matcher('?', '(.)')
+      # Return new data expression with stderr mode.
+      #
+      # @return [DataExpr]
+      #   new data expression with stderr mode
+      def stderr
+        return self.class.new(@name, @data.merge(mode: :stderr))
+      end
 
-      # Compiles data name into regular expression.
-      def compile(name)
-        return name unless name.kind_of?(String)
+      # Return new data expression with disregarding update-criteria.
+      #
+      # @return [DataExpr]
+      #    new data expression with disregarding update-criteria
+      def neglect
+        return self.class.new(@name, @data.merge(update_criteria: :neglect))
+      end
 
-        s = "^#{Regexp.escape(name)}$"
-        TABLE.keys.each {|key| s.gsub!(key, TABLE)}
-        s.gsub!(/\\\[(!|\\\^)?(.*)\\\]/){"[#{'^' if $1}#{$2.gsub('\-','-')}]"}
-        s.gsub!(/\\{(.*)\\}/){"(#{$1.split(',').join('|')})"}
-        Regexp.new(s)
+      # Return new data expression with regarding update-criteria.
+      #
+      # @return [DataExpr]
+      #    new data expression with regarding update-criteria
+      def care
+        return self.class.new(@name, @data.merge(update_criteria: :care))
       end
-      module_function :compile
-    end
 
-    # This module implements DataExpr singleton methods.
-    module SingletonMethod
-      # Create a named expression.
-      # @param [String] name
-      #   data expression
-      def [](name)
-        new(name)
+      # Evaluate the data expression.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        new_exceptions = exceptions.map {|exc| exc.eval(vtable)}
+        self.class.new(vtable.expand(name), @data.merge(exceptions: new_exceptions))
       end
 
-      # Create a name expression with 'each' modifier.
-      def each(name)
-        new(name, :each)
+      # Return true if the name includes variables.
+      #
+      # @return [Boolean]
+      #   true if the name includes variables
+      def include_variable?
+        VariableTable.check_include_variable(name)
       end
 
-      # Create a name expression with 'all' modifier.
-      def all(name)
-        new(name, :all)
+      # @api private
+      def task_id_string
+        "DataExpr<#{name},#{modifier},[%s]>" % [
+          exceptions.map{|exc| exc.task_id_string}.join(",")
+        ]
       end
 
-      # Creates a new data name for stdout ouput.
-      # @param [String] name
-      #   data name
-      # @return [DataExpr]
-      #   data expression for stdout
-      def stdout(name)
-        new(name, :each, :stdout)
+      # @api private
+      def textize
+        "data_expr(\"#{name}\",:#{modifier},[%s])" % [
+          exceptions.map{|exc| exc.textize}.join(",")
+        ]
       end
 
-      # Creates a new data name for stderr output.
-      # @param [String] name
-      #   data name
+      # Return true if the name has 'all' modifier.
+      #
+      # @return [Boolean]
+      #   true if the name has 'all' modifier
+      def all?
+        modifier == :all
+      end
+
+      # Return true if the name has 'each' modifier.
+      #
+      # @return [Boolean]
+      #   true if the name has 'each' modifier
+      def each?
+        modifier == :each
+      end
+
+      # Return true if the data content is in stdout.
+      #
+      # @return [Boolean]
+      #   true if the data content is in stdout
+      def stdout?
+        mode == :stdout
+      end
+
+      # Return true if the data content is in stderr.
+      #
+      # @return [Boolean]
+      #   true if the data content is in stderr
+      def stderr?
+        mode == :stderr
+      end
+
+      # Return true if the data disregards update criteria.
+      #
+      # @return [Boolean]
+      #   true if the data disregards update criteria
+      def neglect?
+        update_criteria == :neglect
+      end
+
+      # Return true if the data regards update criteria.
+      #
+      # @return [Boolean]
+      #   true if the data regards update criteria
+      def care?
+        update_criteria == :care
+      end
+
+      # Create new data expression with appending the exception.
+      #
+      # @param exc [DataExpr, String]
+      #   data name for exceptions
       # @return [DataExpr]
-      #   data expression for stderr
-      def stderr(name)
-        new(name, :each, :stderr)
+      #   new data name with the exception
+      def except(exc)
+        new_exceptions = exceptions + [exc.kind_of?(DataExpr) ? exc : DataExpr.new(exc)]
+        return self.class.new(core, @data.merge(exceptions: new_exceptions))
       end
 
-      # Returns convertion prcedure for enumerable.
-      # @return [Proc]
-      #   +Proc+ object that returns data expression with name
-      def to_proc
-        Proc.new{|name| name.kind_of?(self) ? name : self.new(name)}
+      # Return matched data if the name is matched with the expression.
+      #
+      # @param other [String]
+      #   data name string
+      # @return [MatchedData]
+      #   matched data
+      def match(other)
+        # check exceptions
+        return false if match_exceptions(other)
+        # match test
+        return compile_to_regexp(name).match(other)
       end
-    end
 
-    extend SingletonMethod
+      # Return if the expression accepts nonexistence of corresponding data.
+      #
+      # @return [Boolean]
+      #   false because data expression needs corresponding data
+      def accept_nonexistence?
+        false
+      end
 
-    set_pione_model_type TypeDataExpr
+      # Select from name list matched with the expression.
+      #
+      # @param [Array<String>] names
+      #   name list
+      def select(*names)
+        names.flatten.select {|name| match(name) }
+      end
 
-    attr_reader :name
-    attr_reader :modifier
-    attr_reader :mode
-    attr_reader :exceptions
+      # Generate concrete name string by arguments.
+      #
+      # @example
+      #   DataExpr["test-*.rb"].generate(1)
+      #   # => "test-1.rb"
+      def generate(*args)
+        name = @name.clone
+        while name =~ /(\*|\?)/ and not(args.empty?)
+          val = args.shift.to_s
+          name.sub!(/(\*|\?)/){$1 == "*" ? val : val[0]}
+        end
+        return name
+      end
 
-    # Creates a data expression.
-    # @param [String] name
-    #   data expression name
-    # @param [Symbol] modifier
-    #   :all or :each
-    # @param [Symbol] mode
-    #   nil, :stdout, or :stderr
-    def initialize(name, modifier = :each, mode = nil, exceptions = [])
-      unless name.kind_of? String or name.kind_of? Regexp
-        raise ArgumentError.new(name)
+      # Create OR relation data expression. Self and the other element have the
+      # same attributes.
+      #
+      # @example
+      #   expr = DataExpr.new("A") | DataExpr.new("B")
+      #   expr.match("A") # => true
+      #   expr.match("B") # => true
+      #   expr.match("C") # => false
+      # @example
+      #   DataExpr.all("A") | DataExpr.each("B")
+      #   # => raise ArgumentError
+      def |(other)
+        raise ArgumentError.new(other) unless other.kind_of?(DataExpr)
+        return DataExprOr.new([self, other])
       end
 
-      @name = name
-      @modifier = modifier
-      @mode = mode
-      @exceptions = exceptions
+      # @api private
+      def to_s
+        "#<#<#{self.class.name}> name='#{name}' data=#{@data.inspect}>"
+      end
 
-      super()
-    end
+      # Return true if name, modifier, mode, and exceptions are the same.
+      #
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        return false unless name == other.name
+        return false unless modifier == other.modifier
+        return false unless mode == other.mode
+        return false unless exceptions.sort == other.exceptions.sort
+        return true
+      end
+      alias :eql? :"=="
 
-    # Returns new data expression with each modifier.
-    # @return [DataExpr]
-    #   new data expression with each modifier
-    def each
-      return self.class.new(@name, :each, @mode, @exceptions)
-    end
+      # @api private
+      def hash
+        [name, modifier, mode, exceptions].join("\000").hash
+      end
 
-    # Returns new data expression with all modifier.
-    # @return [DataExpr]
-    #   new data expression with all modifier
-    def all
-      return self.class.new(@name, :all, @mode, @exceptions)
-    end
+      # Same as Regexp#=~ but return 0 if it matched.
+      def =~(other)
+        match(other) ? 0 : nil
+      end
 
-    # Returns new data expression with stdout mode.
-    # @return [DataExpr]
-    #   new data expression with stdout mode
-    def stdout
-      return self.class.new(@name, @modifier, :stdout, @exceptions)
-    end
+      # Pattern match.
+      #
+      # @api private
+      def ===(other)
+        match(other) ? true : false
+      end
 
-    # Returns new data expression with stderr mode.
-    # @return [DataExpr]
-    #   new data expression with stderr mode
-    def stderr
-      return self.class.new(@name, @modifier, :stderr, @exceptions)
-    end
+      private
 
-    # Evaluates the data expression.
-    # @param [VariableTable] vtable
-    #   variable table for evaluation
-    # @return [BasicModel]
-    #   evaluation result
-    def eval(vtable)
-      exceptions = @exceptions.map {|exc| exc.eval(vtable)}
-      self.class.new(vtable.expand(name), @modifier, @mode, exceptions)
-    end
+      # @api private
+      def compile_to_regexp(name)
+        Compiler.compile(name)
+      end
 
-    # Returns true if the name includes variables.
-    # @return [Boolean]
-    #   true if the name includes variables
-    def include_variable?
-      VariableTable.check_include_variable(@name)
+      # Return true if the name matchs exceptions.
+      #
+      # @api private
+      def match_exceptions(name)
+        not(exceptions.select{|ex| ex.match(name)}.empty?)
+      end
     end
 
-    # @api private
-    def task_id_string
-      "DataExpr<#{@name},#{@modifier},[%s]>" % [
-        @exceptions.map{|exc| exc.task_id_string}.join(",")
-      ]
-    end
+    class DataExprNull < DataExpr
+      include Singleton
 
-    # @api private
-    def textize
-      "data_expr(\"#{@name}\",:#{@modifier},[%s])" % [
-        @exceptions.map{|exc| exc.textize}.join(",")
-      ]
-    end
+      # null returns itself for property change methods
+      def return_self
+        self
+      end
+      alias :all :return_self
+      alias :each :return_self
+      alias :stdout :return_self
+      alias :stderr :return_self
+      alias :neglect :return_self
+      alias :care :return_self
+
+      def initialize
+        @data = {}
+      end
 
-    # Return true if the name has 'all' modifier.
-    # @return [Boolean]
-    #   true if the name has 'all' modifier
-    def all?
-      @modifier == :all
-    end
+      def accept_nonexistence?
+        true
+      end
 
-    # Return true if the name has 'each' modifier.
-    # @return [Boolean]
-    #   true if the name has 'each' modifier
-    def each?
-      @modifier == :each
-    end
+      def match(name)
+        nil
+      end
 
-    # Return true if the data content is in stdout.
-    # @return [Boolean]
-    #   true if the data content is in stdout
-    def stdout?
-      @mode == :stdout
-    end
+      # Evaluate the data expression. The result is myself.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   self
+      def eval(vtable)
+        self
+      end
 
-    # Returns true if the data content is in stderr.
-    # @return [Boolean]
-    #   true if the data content is in stderr
-    def stderr?
-      @mode == :stderr
-    end
+      def textize
+        "data_expr(null)"
+      end
 
-    # Creates new data expression with a exception name.
-    # @param [DataExpr, String] name
-    #   data name for exceptions
-    # @return [DataExpr]
-    #   new data name with the exception
-    def except(name)
-      exceptions =
-        @exceptions.clone + [name.kind_of?(DataExpr) ? name : DataExpr.new(name)]
-      return self.class.new(@name, @modifier, @mode, exceptions)
-    end
+      # @api private
+      def to_s
+        "#<#<#{self.class.name}>>"
+      end
 
-    # Returns matched data if the name is matched with the expression.
-    # @param [String] other
-    #   data name string
-    def match(other)
-      # check exceptions
-      return false if match_exceptions(other)
-      # match test
-      md = nil
-      @name.split(SEPARATOR).each do |name|
-        break if md = compile_to_regexp(name).match(other)
-      end
-      return md
-    end
+      # @api private
+      def ==(other)
+        self.class == other.class
+      end
+      alias :eql? :"=="
+    end
+
+    # DataExprOr represents or-relation of data expressions. Expressions have
+    # same properties about modifier and mode.
+    class DataExprOr < DataExpr
+      attr_reader :elements
+      alias :core :elements
+
+      forward! Proc.new{find_not_null_element}, :modifier, :mode, :update_criteria
+
+      # @param elements [Array<DataExpr>]
+      #   elements that have OR relation
+      # @param data [Hash]
+      #   options of the expression
+      # @option opts [Array<DataExpr>] :exceptions
+      #   exceptional expressions
+      def initialize(elements, data={})
+        @elements = elements
+        @data = {}
+        @data[:exceptions] = data[:exceptions] || []
+
+        # check whether all elements have same modifier
+        unless elements.all?{|elt| modifier == elt.modifier or elt.kind_of?(DataExprNull)}
+          raise ArgumentError.new(elements)
+        end
+
+        # check whether all elements have same mode
+        unless elements.all?{|elt| mode == elt.mode or elt.kind_of?(DataExprNull)}
+          raise ArmguentError.new(elements)
+        end
+
+        # check whether all elements have same mode
+        unless elements.all?{|elt| update_criteria == elt.update_criteria or elt.kind_of?(DataExprNull)}
+          raise ArmguentError.new(elements)
+        end
+      end
 
-    # Selects from name list matched with the expression.
-    # @param [Array<String>] names
-    #   name list
-    def select(*names)
-      names.flatten.select {|name| match(name) }
-    end
+      # Match if the name is matched one of elements.
+      #
+      # @param name [String]
+      #   data name
+      # @return [MatchedData,nil]
+      #   the matchde data, or nil
+      def match(name)
+        # check exceptions
+        return false if match_exceptions(name)
+        # check to match the expression
+        @elements.each do |element|
+          if md = element.match(name)
+            return md
+          end
+        end.tap {return nil}
+      end
 
-    # Generates concrete name string by arguments.
-    # @example
-    #   DataExpr["test-*.rb"].generate(1)
-    #   # => "test-1.rb"
-    def generate(*args)
-      name = @name.clone
-      while name =~ /(\*|\?)/ and not(args.empty?)
-        val = args.shift.to_s
-        name.sub!(/(\*|\?)/){$1 == "*" ? val : val[0]}
-      end
-      return name
-    end
+      # Return true if at least one element accepts nonexistence.
+      #
+      # @return [Boolean]
+      #   true if at least one element accepts nonexistence
+      def accept_nonexistence?
+        @elements.any?{|element| element.accept_nonexistence?}
+      end
 
-    # Create OR relation data expression. Self and the other element have the
-    # same attributes.
-    # @example
-    #   expr = DataExpr.new("A") | DataExpr.new("B")
-    #   expr.match("A") # => true
-    #   expr.match("B") # => true
-    #   expr.match("C") # => false
-    # @example
-    #   DataExpr.all("A") | DataExpr.each("B")
-    #   # => raise ArgumentError
-    def |(other)
-      raise ArgumentError.new(other) unless other.kind_of?(DataExpr)
-      return DataExprOr.new(self, other)
-    end
+      # Return a new instance that has elements with "all" modifier.
+      #
+      # @return [DataExprOr]
+      #   a new instance that has elements with "all" modifier
+      def all
+        self.class.new(@elements.map{|elt| elt.all}, @data)
+      end
 
-    # @api private
-    def to_s
-      "#<#<#{self.class.name}> #{@name}>"
-    end
+      # Return a new instance that has elements with "each" modifier.
+      #
+      # @return [DataExprOr]
+      #   a new instance that has elements with "each" modifier
+      def each
+        self.class.new(@elements.map{|elt| elt.each}, @data)
+      end
 
-    # Returns true if name, modifier, mode, and exceptions are the same.
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      return false unless @name == other.name
-      return false unless @modifier == other.modifier
-      return false unless @mode == other.mode
-      return false unless @exceptions.sort == other.exceptions.sort
-      return true
-    end
+      # Return a new instance that has elements with stdout mode.
+      #
+      # @return [DataExprOr]
+      #   a new instance that has elements with stdout mode
+      def stdout
+        self.class.new(@elements.map{|elt| elt.stdout}, @data)
+      end
 
-    alias eql? ==
+      # Return a new instance that has elements with stderr mode.
+      #
+      # @return [DataExprOr]
+      #   a new instance that has elements with stderr mode
+      def stderr
+        self.class.new(@elements.map{|elt| elt.stderr}, @data)
+      end
 
-    # @api private
-    def hash
-      [@name, @modifier, @mode, @exceptions].join("\000").hash
-    end
+      # Return a new instance that has elements with neglecting update criteria.
+      #
+      # @return [DataExprOr]
+      #   a new instance that has elements with neglecting update criteria
+      def neglect
+        self.class.new(@elements.map{|elt| elt.neglect}, @data)
+      end
 
-    # Same as Regexp#=~ but return 0 if it matched.
-    def =~(other)
-      match(other) ? 0 : nil
-    end
+      # Return a new instance that has elements with caring update criteria.
+      #
+      # @return [DataExprOr]
+      #   a new instance that has elements with caring update criteria
+      def care
+        self.class.new(@elements.map{|elt| elt.care}, @data)
+      end
 
-    # Pattern match.
-    # @api private
-    def ===(other)
-      match(other) ? true : false
-    end
+      # Evaluate the data expression. This evaluates all elements of the expression.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        new_elements = @elements.map {|elt| elt.eval(vtable)}
+        new_exceptions = exceptions.map {|exc| exc.eval(vtable)}
+        self.class.new(new_elements, @data.merge(exceptions: new_exceptions))
+      end
 
-    private
+      def textize
+        "data_expr_or(%s)" % @elements.map{|elt| elt.textize}.join(", ")
+      end
 
-    # @api private
-    def compile_to_regexp(name)
-      Compiler.compile(name)
-    end
+      # @api private
+      def to_s
+        "#<#<#{self.class.name}> #{@elements} #{@data}>"
+      end
 
-    # Returns true if the name matchs exceptions.
-    # @api private
-    def match_exceptions(name)
-      not(@exceptions.select{|ex| ex.match(name)}.empty?)
-    end
-  end
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        (@elements - other.elements).empty?
+      end
+      alias :eql? :"=="
 
-  # DataExprOr represents or-relation of data expressions.
-  class DataExprOr < DataExpr
-    extend Forwardable
-    def_delegator :@left, :modifier
-    def_delegator :@left, :mode
-
-    def initialize(left, right)
-      raise ArgumentError.new([left, right]) unless left.modifier == right.modifier
-      raise ArmguentError.new([left, right]) unless left.mode == right.mode
-      @left = left
-      @right = right
-    end
+      # @api private
+      def hash
+        @elements.hash
+      end
 
-    # @api private
-    def match(name)
-      @left.match(name) or @right.match(name)
-    end
-  end
+      private
 
-  TypeDataExpr.instance_eval do
-    define_pione_method("==", [TypeDataExpr], TypeBoolean) do |rec, other|
-      PioneBoolean.new(rec == other)
+      def find_not_null_element
+        @elements.find{|elt| not(elt.kind_of?(DataExprNull))}
+      end
     end
 
-    define_pione_method("!=", [TypeDataExpr], TypeBoolean) do |rec, other|
-      PioneBoolean.not(rec.call_pione_method("==", other))
-    end
+    TypeDataExpr.instance_eval do
+      define_pione_method("==", [TypeDataExpr], TypeBoolean) do |rec, other|
+        PioneBoolean.new(rec == other)
+      end
 
-    define_pione_method("all", [], TypeDataExpr) do |rec|
-      rec.all
-    end
+      define_pione_method("!=", [TypeDataExpr], TypeBoolean) do |rec, other|
+        PioneBoolean.not(rec.call_pione_method("==", other))
+      end
 
-    define_pione_method("each", [], TypeDataExpr) do |rec|
-      rec.each
-    end
+      define_pione_method("all", [], TypeDataExpr) do |rec|
+        rec.all
+      end
 
-    define_pione_method("except", [TypeDataExpr], TypeDataExpr) do |rec, target|
-      rec.except(target)
-    end
+      define_pione_method("each", [], TypeDataExpr) do |rec|
+        rec.each
+      end
 
-    define_pione_method("stdout", [], TypeDataExpr) do |rec|
-      rec.stdout
-    end
+      define_pione_method("except", [TypeDataExpr], TypeDataExpr) do |rec, target|
+        rec.except(target)
+      end
 
-    define_pione_method("stderr", [], TypeDataExpr) do |rec|
-      rec.stderr
+      define_pione_method("stdout", [], TypeDataExpr) do |rec|
+        rec.stdout
+      end
+
+      define_pione_method("stderr", [], TypeDataExpr) do |rec|
+        rec.stderr
+      end
+
+      define_pione_method("neglect", [], TypeDataExpr) do |rec|
+        rec.neglect
+      end
+
+      define_pione_method("care", [], TypeDataExpr) do |rec|
+        rec.care
+      end
+
+      define_pione_method("or", [TypeDataExpr], TypeDataExpr) do |rec, other|
+        DataExprOr.new([rec, other])
+      end
+
+      define_pione_method("join", [TypeString], TypeString) do |rec, connective|
+        PioneString.new(rec.elements.map{|elt| elt.name}.join(connective.to_ruby))
+      end
+
+      define_pione_method("match?", [TypeString], TypeBoolean) do |rec, name|
+        if rec.match(name.value)
+          PioneBoolean.true
+        else
+          PioneBoolean.false
+        end
+      end
+
+      define_pione_method("as_string", [], TypeString) do |rec|
+        case rec
+        when DataExprNull
+          PioneString.new("")
+        when DataExprOr
+          PioneString.new(rec.elements.map{|elt| elt.name}.join(DataExpr::SEPARATOR))
+        when DataExpr
+          PioneString.new(rec.name)
+        end
+      end
     end
   end
 end