pione 0.1.0

data/lib/pione/model/rule.rb

@@ -0,0 +1,294 @@
+module Pione::Model
+  # RuleCondition represents rule condition.
+  class RuleCondition < BasicModel
+    # Returns the value of attribute inputs.
+    # @return [Array<DataExpr, Array<DataExpr>>]
+    #   rule inputs condition
+    attr_reader :inputs
+
+    # Returns the value of attribute outputs.
+    # @return [Array<DataExpr, Array<DataExpr>>]
+    #  rule outputs condition
+    attr_reader :outputs
+
+    # Returns the value of attribute params.
+    # @return [Parameters]
+    #   rule parameters table
+    attr_reader :params
+
+    # Returns the value of attribute features.
+    # @return [Feature]
+    #   rule feature condition
+    attr_reader :features
+
+    # Creates a rule condition.
+    # @param [Array<DataExpr, Array<DataExpr>>] inputs
+    #   rule inputs
+    # @param [Array<DataExpr, Array<DataExpr>>] outputs
+    #   rule outputs
+    # @param [Parameters] params
+    #   rule parameters
+    # @param [Feature] features
+    #   rule features
+    def initialize(inputs, outputs, params, features)
+      check_argument_type(params, Parameters)
+      check_argument_type(features, Feature::Expr)
+      @inputs = inputs
+      @outputs = outputs
+      @params = params
+      @features = features
+      super()
+    end
+
+    # Returns true if the condition includes variable.
+    # @return [Boolean]
+    #   true if the condition includes variable, or false
+    def include_variable?
+      [ @inputs.any? {|input| input.include_variable?},
+        @outputs.any? {|output| output.include_variable?},
+        @params.include_variable?,
+        @features.include_variable?
+      ].any?
+    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
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @inputs.hash + @outputs.hash + @params.hash + @features.hash
+    end
+  end
+
+  # Rule is a class for PIONE rule model.
+  class Rule < BasicModel
+    extend Forwardable
+
+    # Returns rule type.
+    def self.rule_type
+      @rule_type
+    end
+
+    # Returns the value of attribute expr.
+    # @return [Array<DataExpr, Array<DataExpr>>]
+    #   rule inputs condition
+    attr_reader :expr
+
+    attr_reader :condition
+    attr_reader :body
+
+    def_delegators :@condition, :inputs, :outputs, :params, :features
+
+    # Creates a rule.
+    # @param [RuleExpr] expr
+    #   rule expression
+    # @param [RuleCondition] condition
+    #   rule condition
+    # @param [Block] body
+    #   rule body block
+    def initialize(expr, condition, body)
+      @expr = expr
+      @condition = condition
+      @body = body
+    end
+
+    # Returns the rule path.
+    # @return [String]
+    #   rule path
+    def rule_path
+      @expr.rule_path
+    end
+
+    # Returns 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 @condition.include_variable?
+      return true if @body.include_variable?
+      return false
+    end
+
+    # Returns true if this is a kind of action rule.
+    # @return [Boolean]
+    #   true if this is a kind of action rule, or false
+    def action?
+      self.class.rule_type == :action
+    end
+
+    # Returns true if this is a kind of flow rule.
+    # @return [Boolean]
+    #   true if this is a kind of flow rule, or false
+    def flow?
+      self.class.rule_type == :flow
+    end
+
+    # Makes a task handler object for the rule.
+    # @param [TupleSpaceServer] ts_server
+    #   tuple space server
+    # @param [Array<Data, Array<Data>>] inputs
+    #   input tuples
+    # @param [Parameters] params
+    #   rule parameters
+    # @param [Array<String>] call_stack
+    #   call stack
+    # @return [RuleHandler]
+    #   rule handler object
+    def make_handler(ts_server, inputs, params, call_stack, opts={})
+      handler_class.new(ts_server, self, inputs, params, call_stack, opts)
+    end
+
+    # Returns 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 @condition == other.condition
+      return false unless @body == other.body
+      return true
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @expr.hash + @condition.hash + @body.hash
+    end
+  end
+
+  # ActionRule is a rule writing action.
+  class ActionRule < Rule
+    @rule_type = :action
+
+    # @api private
+    def handler_class
+      RuleHandler::ActionHandler
+    end
+  end
+
+  # FlowRule represents a flow structured rule. This rule is consisted by flow
+  # elements and executes elements actions.
+  class FlowRule < Rule
+    @rule_type = :flow
+
+    # @api private
+    def handler_class
+      RuleHandler::FlowHandler
+    end
+  end
+
+  # RootRule is a hidden toplevel flow rule like the following:
+  #   Rule Root
+  #     input  '*'.all
+  #     output '*'.all.except('{$INPUT[1]}')
+  #   Flow
+  #     rule &main:Main
+  #   End
+  class RootRule < FlowRule
+    INPUT_DOMAIN = 'input'
+
+    # root domain has no digest and no package
+    ROOT_DOMAIN = 'root'
+
+    attr_reader :main
+
+    # Makes a rule.
+    def initialize(main, params=Parameters.empty)
+      @main = main
+      @params = params
+      condition = make_condition
+      super(
+        RuleExpr.new(Package.new("root"), "Root"),
+        condition,
+        FlowBlock.new(CallRule.new(@main.expr.set_params(@params)))
+      )
+      @domain = ROOT_DOMAIN
+    end
+
+    # @api private
+    def make_handler(ts_server)
+      finder = DataFinder.new(ts_server, INPUT_DOMAIN)
+      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
+      handler_class.new(
+        ts_server,
+        self,
+        inputs,
+        @params,
+        [],
+        {:domain => @domain}
+      )
+    end
+
+    private
+
+    # @api private
+    def make_condition
+      RuleCondition.new(
+        @main.inputs,
+        @main.outputs,
+        Parameters.empty,
+        Feature.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
+    # Creates a system rule model.
+    # @param [String] name
+    #   rule name
+    # @param [Proc] b
+    #   rule process
+    def initialize(name, &b)
+      expr = RuleExpr.new(Package.new('system'), name)
+      condition = make_condition
+      super(expr, condition, b)
+    end
+
+    private
+
+    # @api private
+    def make_condition
+      inputs = [DataExpr.new('*')]
+      RuleCondition.new(inputs, [], Parameters.empty, Feature::EmptyFeature.new)
+    end
+
+    # @api private
+    def handler_class
+      RuleHandler::SystemHandler
+    end
+  end
+
+  # &System:Terminate rule
+  SYSTEM_TERMINATE = SystemRule.new('Terminate') do |tuple_space_server|
+    user_message "!!!!!!!!!!!!!!!!!"
+    user_message "!!! Terminate !!!"
+    user_message "!!!!!!!!!!!!!!!!!"
+    tuple_space_server.write(Tuple[:command].new("terminate"))
+  end
+
+  SYSTEM_RULES = [ SYSTEM_TERMINATE ]
+end

data/lib/pione/model/string.rb

@@ -0,0 +1,111 @@
+module Pione::Model
+  # PioneString is a string value in PIONE system.
+  class PioneString < BasicModel
+    set_pione_model_type TypeString
+    attr_reader :value
+
+    # Creates a string with the value.
+    # @param [String] value
+    #   string value
+    def initialize(value)
+      @value = value
+      super()
+    end
+
+    # Evaluates the object with the variable table.
+    # @param [VariableTable] vtable
+    #   variable table for evaluation
+    # @return [BasicModel]
+    #   evaluation result
+    def eval(vtable)
+      self.class.new(vtable.expand(@value))
+    end
+
+    # Returns true if the value includes variables.
+    # @return [Boolean]
+    #   true if the value includes variables
+    def include_variable?
+      VariableTable.check_include_variable(@value)
+    end
+
+    # @api private
+    def task_id_string
+      "String<#{@value}>"
+    end
+
+    # @api private
+    def textize
+      "\"%s\"" % [@value]
+    end
+
+    # Returns ruby's value.
+    # @return [String]
+    #   the value in ruby
+    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
+  end
+
+  TypeString.instance_eval do
+    define_pione_method("==", [TypeString], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value == other.value)
+    end
+
+    define_pione_method("!=", [TypeString], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("+", [TypeString], TypeString) do |rec, other|
+      PioneString.new(rec.value + other.value)
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      rec
+    end
+
+    define_pione_method("as_int", [], TypeInteger) do |rec|
+      PioneInteger.new(rec.value.to_i)
+    end
+
+    define_pione_method("as_float", [], TypeFloat) do |rec|
+      PioneFloat.new(rec.value.to_f)
+    end
+
+    define_pione_method("length", [], TypeInteger) do |rec|
+      PioneInteger.new(rec.value.size)
+    end
+
+    define_pione_method("include?", [TypeString], TypeBoolean) do |rec, str|
+      PioneBoolean.new(rec.value.include?(str.value))
+    end
+
+    define_pione_method("substring",
+                        [TypeInteger, TypeInteger],
+                        TypeString) do |rec, nth, len|
+      PioneString.new(rec.value[nth.value, len.value])
+    end
+  end
+end
+
+# String extention for PIONE system.
+class String
+  # Returns PIONE's value.
+  # @return [PioneString]
+  #   PIONE's value
+  def to_pione
+    PioneString.new(self)
+  end
+end

data/lib/pione/model/undefined-value.rb

@@ -0,0 +1,24 @@
+module Pione
+  module Model
+    class UndefinedValue < BasicModel
+      set_pione_model_type TypeUndefinedValue
+
+      def ==(other)
+        return other.kind_of?(UndefinedValue)
+      end
+
+      alias :eql? :"=="
+
+      def hash
+        0
+      end
+
+      #
+      # pione model method
+      #
+      define_pione_method("as_string", [], TypeString) do |rec|
+        PioneString.new("undefined")
+      end
+    end
+  end
+end

data/lib/pione/model/variable-table.rb

@@ -0,0 +1,315 @@
+module Pione::Model
+  # UnboundVariableError represents an unknown variable reference.
+  class UnboundVariableError < StandardError
+    attr_reader :variable
+
+    # Creates an error.
+    # @param [Variable] variable
+    #   unbound variable
+    def initialize(variable)
+      @variable = variable
+    end
+
+    # @api private
+    def message
+      "Refferred unbound variable '%s' in the context." % @variable.name
+    end
+  end
+
+  # VariableBindingError represents an error that you try to bind different value
+  # to a variable.
+  class VariableBindingError < StandardError
+    attr_reader :variable
+    attr_reader :new_value
+    attr_reader :old_value
+
+    # Creates an error.
+    # @param [Variable] variable
+    #   double bound variable
+    # @param [BasicModel] new_value
+    #   new value
+    # @param [BasicModel] old_value
+    #   old value
+    def initialize(variable, new_value, old_value)
+      @variable = variable
+      @new_value = new_value
+      @old_value = old_value
+    end
+
+    # @api private
+    def message
+      args = [
+        @new_value.textize,
+        @variable.name,
+        @old_value.textize,
+        @variable.line,
+        @variable.column
+      ]
+      message = [
+        "Try to bind the value '%s' as variable %s, ",
+        "but already bound the value '%s'",
+        "(line: %s, column: %s)"
+      ] % args
+    end
+  end
+
+  # VariableTable represents variable tables for rule context.
+  class VariableTable < BasicModel
+    set_pione_model_type TypeVariableTable
+
+    # Returns empty variable table.
+    # @return [VariableTable]
+    #   empty variable table
+    def self.empty
+      new
+    end
+
+    # Creates a vairable table.
+    # @param [Hash{Variable => BasicModel}] table
+    #   initial values for the variable table
+    def initialize(table={})
+      @table = table.to_hash.dup
+      super()
+    end
+
+    # Returns the variable table as hash.
+    # @return [Hash{Variable => BasicModel}]
+    #   hash form of the variable table
+    def to_hash
+      @table
+    end
+
+    # Returns the parameters form.
+    # @return [Parameters]
+    #   parameters form of the variable table
+    def to_params
+      Parameters.new(to_hash)
+    end
+
+    # Returns true if the table is empty.
+    # @return [Boolean]
+    #   true if the table is empty
+    def empty?
+      @table.empty?
+    end
+
+    # Gets the variable value and evaluates the value if the value is not
+    # atomic.
+    # @param [Variable] var
+    #   table key to get the value
+    # @return [BasicModel]
+    #   the value
+    def get(var)
+      check_argument_type(var, Variable)
+      val = @table[var]
+      case val
+      when Variable
+        next_val = get(val)
+        return next_val.nil? ? val : next_val
+      when BasicModel
+        return not(val.atomic?) ? val.eval(self) : val
+      end
+      return val
+    end
+
+    # Sets a new variable. This method raises an exception when the variable has
+    # its value already.
+    # @param [Variable] variable
+    #   table key
+    # @param [BasicModel] new_value
+    #   new value
+    # @return [VariableTable]
+    #   new variable table
+    def set(variable, new_value)
+      check_argument_type(variable, Variable)
+      check_argument_type(new_value, BasicModel)
+      if old_value = @table[variable]
+        unless old_value.kind_of?(UndefinedValue) or new_value == old_value
+          raise VariableBindingError.new(variable, new_value, old_value)
+        end
+      end
+      @table[variable] = new_value
+    end
+
+    # Sets a variable. This method overrides old variable value.
+    # @param [Variable] variable
+    #   table key
+    # @param [BasicModel] new_value
+    #   new value
+    # @return [void]
+    def set!(variable, new_value)
+      check_argument_type(variable, Variable)
+      check_argument_type(new_value, BasicModel)
+      @table[variable] = new_value
+    end
+
+    # Expands variables in the string.
+    # @param [String] str
+    #   string
+    # @return [String]
+    #   expanded string
+    def expand(str)
+      variables = to_hash
+      new_str = str.to_s.gsub(/\{(\$.+?)\}/) do
+        expr = DocumentTransformer.new.apply(DocumentParser.new.expr.parse($1))
+        expr.eval(self).call_pione_method("as_string").to_ruby
+      end
+      new_str.gsub(/\<\?\s*(.+?)\s*\?\>/) do
+        expr = DocumentTransformer.new.apply(DocumentParser.new.expr.parse($1))
+        expr.eval(self).call_pione_method("as_string").to_ruby
+      end
+    end
+
+    # Returns key variables of the table.
+    # @return [Array<Variable>]
+    #   variable as table keys
+    def variables
+      @table.keys
+    end
+
+    # FIXME
+    # Returns true if the string includes variables.
+    # @param [String] str
+    #   target string
+    # @return [Boolean]
+    #   true if the string includes variables
+    def self.check_include_variable(str)
+      str = str.to_s
+      return true if /\{\$(.+?)\}/.match(str)
+      str.gsub(/\<\?\s*(.+?)\s*\?\>/) do
+        expr = Transformer.new.apply(Parser.new.expr.parse($1))
+        return true if expr.include_variable?
+      end
+      return false
+    end
+
+    # Returns true if table's values include variables.
+    # @return [Boolean]
+    #   true if table's values include variables
+    def include_variable?
+      # FIXME
+      @table.values.any?{|val| val.include_variable?}
+    end
+
+    # Makes input auto-variables.
+    # @param [Array<DataExpr>] input_exprs
+    #   input expressions
+    # @param [Array<Expr>] input_tuples
+    #   input tuples
+    # @return [void]
+    def make_input_auto_variables(input_exprs, input_tuples)
+      set(Variable.new("INPUT"), Variable.new("I"))
+      input_exprs.each_with_index do |expr, index|
+        make_io_auto_variables(:input, expr, input_tuples[index], index+1)
+      end
+    end
+
+    # Makes output auto-variables.
+    # @param [Array<DataExpr>] output_exprs
+    #   output expressions
+    # @param [Array<DataExpr>] output_tuples
+    #   output tuples
+    # @return [void]
+    def make_output_auto_variables(output_exprs, output_tuples)
+      set(Variable.new("OUTPUT"), Variable.new("O"))
+      output_exprs.each_with_index do |expr, index|
+        make_io_auto_variables(:output, expr, output_tuples[index], index+1)
+      end
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @table == other.to_hash
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @table.hash
+    end
+
+    private
+
+    # Make input or output auto variables.
+    # @api private
+    def make_io_auto_variables(type, expr, data, index)
+      expr = expr.eval(self)
+      prefix = (type == :input ? "I" : "O")
+      case expr.modifier
+      when :all
+        make_io_auto_variables_by_all(type, prefix, expr, data)
+      when :each
+        make_io_auto_variables_by_each(prefix, expr, data, index)
+      end
+    end
+
+    # Make input or output auto variables for 'exist' modified data name
+    # expression.
+    # @api private
+    def make_io_auto_variables_by_each(prefix, expr, tuple, index)
+      return if tuple.nil?
+      # variable
+      var = Variable.new(prefix)
+      # matched data
+      md = expr.match(tuple.name).to_a
+
+      # setup rule-io list
+      list = get(var)
+      list = RuleIOList.new unless list
+      elt = RuleIOElement.new(PioneString.new(tuple.name))
+      elt.uri = PioneString.new(tuple.uri)
+      elt.match = PioneList.new(*md.map{|d| PioneString.new(d)})
+
+      # update the list
+      set!(var, list.add(elt))
+
+      # set special variable if index equals 1
+      if prefix == 'I' && index == 1
+        set(Variable.new("*"), PioneString.new(md[1]))
+      end
+    end
+
+    # Make input or output auto variables for 'all' modified data name
+    # expression.
+    # @api private
+    def make_io_auto_variables_by_all(type, prefix, expr, tuples)
+      # FIXME: output
+      return if type == :output
+
+      # variable
+      var = Variable.new(prefix)
+
+      # setup rule-io list
+      list = get(var)
+      list = RuleIOList.new unless list
+      io_list = RuleIOList.new()
+
+      # convert each tuples
+      tuples.each do |tuple, i|
+        elt = RuleIOElement.new(PioneString.new(tuple.name))
+        elt.uri = PioneString.new(tuple.uri)
+        elt.match = PioneList.new(
+          *expr.match(tuple.name).to_a.map{|m| PioneString.new(m)}
+        )
+        io_list.add!(elt)
+      end
+
+      # update
+      set!(var, list.add(io_list))
+    end
+
+    #
+    # pione methods
+    #
+
+    define_pione_method("get", [TypeString], TypeAny) do |name|
+      get(Variable.new(name.value))
+    end
+
+    define_pione_method("keys", [], TypeList.new(TypeString)) do
+      PioneList.new(@table.keys.map{|var| PioneString.new(var.name)})
+    end
+  end
+end