pione 0.1.0

data/lib/pione/model/block.rb

@@ -0,0 +1,233 @@
+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
+
+    # @api private
+    def textize
+      "action_block(\"#{@content}\")"
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @content == other.content
+    end
+
+    alias :eql? :==
+
+    # @api private
+    def hash
+      @content.hash
+    end
+  end
+
+  # 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
+    end
+
+    # Evaluates each elements and return it.
+    # @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)
+        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
+    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
+
+    alias :eql? :==
+
+    # @api private
+    def hash
+      @elements.hash
+    end
+  end
+
+  # 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
+    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
+      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
+
+    # @api private
+    def textize
+      "conditional_block(%s,{%s})" % [
+        @condition.textize,
+        @blocks.map{|val, block| "%s=>%s" % [val,block]}.join(",")
+      ]
+    end
+
+    # @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
+    end
+  end
+end

data/lib/pione/model/boolean.rb

@@ -0,0 +1,138 @@
+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)
+      end
+
+      # Returns false value in PIONE system.
+      # @return [PioneBoolean]
+      #   false value
+      def false
+        new(false)
+      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))
+      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?})
+      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?})
+      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
+
+    # Returns 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
+
+    alias :eql? :==
+
+    # @api private
+    def hash
+      @value.hash
+    end
+
+    #
+    # 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.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("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("as_string", [], TypeString) do |rec|
+      PioneString.new(rec.value.to_s)
+    end
+
+    define_pione_method("not", [], TypeBoolean) do |rec|
+      PioneBoolean.not(rec)
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+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
+
+    # Creates a callee rule.
+    # @param [BasicModel] expr
+    #   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)
+      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
+
+    # Evaluates the expression.
+    # @param [VariableTable] vtable
+    #   variable table for evaluation
+    # @return [BasicModel]
+    #   evaluation result
+    def eval(vtable)
+      self.class.new(@expr.eval(vtable))
+    end
+
+    # @api private
+    def textize
+      "call_rule(%s)" % [@expr.textize]
+    end
+
+    # @api private
+    def ==(other)
+      @expr == other.expr
+    end
+
+    alias :eql? :==
+
+    # @api private
+    def hash
+      @expr.hash
+    end
+  end
+end

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

@@ -0,0 +1,360 @@
+module Pione::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 matched).
+      define_matcher('*', '(.*)')
+
+      # Question symbol is single character matcher(empty string is not matched).
+      define_matcher('?', '(.)')
+
+      # Compiles data name into regular expression.
+      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
+
+    # This module implements DataExpr singleton methods.
+    module SingletonMethod
+      # Create a named expression.
+      # @param [String] name
+      #   data expression
+      def [](name)
+        new(name)
+      end
+
+      # Create a name expression with 'each' modifier.
+      def each(name)
+        new(name, :each)
+      end
+
+      # Create a name expression with 'all' modifier.
+      def all(name)
+        new(name, :all)
+      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)
+      end
+
+      # Creates a new data name for stderr output.
+      # @param [String] name
+      #   data name
+      # @return [DataExpr]
+      #   data expression for stderr
+      def stderr(name)
+        new(name, :each, :stderr)
+      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)}
+      end
+    end
+
+    extend SingletonMethod
+
+    set_pione_model_type TypeDataExpr
+
+    attr_reader :name
+    attr_reader :modifier
+    attr_reader :mode
+    attr_reader :exceptions
+
+    # 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)
+      end
+
+      @name = name
+      @modifier = modifier
+      @mode = mode
+      @exceptions = exceptions
+
+      super()
+    end
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # Returns true if the name includes variables.
+    # @return [Boolean]
+    #   true if the name includes variables
+    def include_variable?
+      VariableTable.check_include_variable(@name)
+    end
+
+    # @api private
+    def task_id_string
+      "DataExpr<#{@name},#{@modifier},[%s]>" % [
+        @exceptions.map{|exc| exc.task_id_string}.join(",")
+      ]
+    end
+
+    # @api private
+    def textize
+      "data_expr(\"#{@name}\",:#{@modifier},[%s])" % [
+        @exceptions.map{|exc| exc.textize}.join(",")
+      ]
+    end
+
+    # 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
+
+    # Returns true if the data content is in stderr.
+    # @return [Boolean]
+    #   true if the data content is in stderr
+    def stderr?
+      @mode == :stderr
+    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
+
+    # 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
+
+    # Selects from name list matched with the expression.
+    # @param [Array<String>] names
+    #   name list
+    def select(*names)
+      names.flatten.select {|name| match(name) }
+    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
+
+    # 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
+
+    # @api private
+    def to_s
+      "#<#<#{self.class.name}> #{@name}>"
+    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
+
+    alias eql? ==
+
+    # @api private
+    def hash
+      [@name, @modifier, @mode, @exceptions].join("\000").hash
+    end
+
+    # Same as Regexp#=~ but return 0 if it matched.
+    def =~(other)
+      match(other) ? 0 : nil
+    end
+
+    # Pattern match.
+    # @api private
+    def ===(other)
+      match(other) ? true : false
+    end
+
+    private
+
+    # @api private
+    def compile_to_regexp(name)
+      Compiler.compile(name)
+    end
+
+    # Returns true if the name matchs exceptions.
+    # @api private
+    def match_exceptions(name)
+      not(@exceptions.select{|ex| ex.match(name)}.empty?)
+    end
+  end
+
+  # 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 match(name)
+      @left.match(name) or @right.match(name)
+    end
+  end
+
+  TypeDataExpr.instance_eval do
+    define_pione_method("==", [TypeDataExpr], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec == other)
+    end
+
+    define_pione_method("!=", [TypeDataExpr], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("all", [], TypeDataExpr) do |rec|
+      rec.all
+    end
+
+    define_pione_method("each", [], TypeDataExpr) do |rec|
+      rec.each
+    end
+
+    define_pione_method("except", [TypeDataExpr], TypeDataExpr) do |rec, target|
+      rec.except(target)
+    end
+
+    define_pione_method("stdout", [], TypeDataExpr) do |rec|
+      rec.stdout
+    end
+
+    define_pione_method("stderr", [], TypeDataExpr) do |rec|
+      rec.stderr
+    end
+  end
+end