pione 0.1.0

data/lib/pione/model/parameters.rb

@@ -0,0 +1,282 @@
+module Pione::Model
+  # Parameters is a PIONE mode class for parameters.
+  class Parameters < BasicModel
+    # InvalidParameter is raised when you specify invalid parameter.
+    class InvalidParameter < TypeError
+      # Creates a error.
+      # @param [Object] key
+      #   specified key
+      def initialize(key)
+        @key = key
+      end
+
+      # @api private
+      def message
+        "invalid parameter key: %s" % [@key.inspect]
+      end
+    end
+
+    # InvalidArgument is raised when you specify invalid argument.
+    class InvalidArgument < TypeError
+      # Creates a error.
+      # @param [Object] val
+      #   specified value
+      def initialize(val)
+        @val = val
+      end
+
+      # @api private
+      def message
+        "invalid argument value: %s" % [@val.inspect]
+      end
+    end
+
+    class << self
+      # Creates a empty parameters object.
+      # @return [Parameters]
+      #   empty parameters
+      def empty
+        self.new({})
+      end
+
+      # Merges arguments' parameters.
+      # @param [Array<Parameters>] list
+      #   merge target elements
+      # @return [Parameters]
+      #   merged result
+      def merge(*list)
+        new_params = empty
+        list.each do |params|
+          new_params = new_params.merge(params)
+        end
+        return new_params
+      end
+    end
+
+    attr_reader :data
+    set_pione_model_type TypeParameters
+
+    # Creates a parameters object.
+    # @param [Hash{Variable => BasicModel}] data
+    #   parameters data table
+    def initialize(data)
+      raise TypeError.new(data) unless data.kind_of?(Hash)
+      data.each do |key, val|
+        raise InvalidParameter.new(key) unless key.kind_of?(Variable)
+        raise InvalidArgument.new(val) unless val.kind_of?(BasicModel)
+      end
+      @data = data
+      super()
+    end
+
+    # Evaluates the object with variable table.
+    # @param [VariableTable] vtable
+    #   variable tabale for evaluation
+    # @return [BasicModel]
+    #   evaluated result
+    def eval(vtable)
+      return self.class.empty if empty?
+      data = @data.map{|key, val| [key, val.eval(vtable)]}.flatten(1)
+      self.class.new(Hash[*data])
+    end
+
+    # Returns true if parameters include variables.
+    # @return [Boolean]
+    #   true if parameters include variables
+    def include_variable?
+      @data.any? {|_, val| val.include_variable?}
+    end
+
+    # @api private
+    def textize
+      "{" + @data.map{|k,v| "%s:%s" % [k.textize[1..-1], v.textize]}.join(", ") + "}"
+    end
+
+    # Returns value of parameter name.
+    # @param [String] name
+    #   parameter name to get the value
+    # @return [BasicModel]
+    #   the value
+    def [](name)
+      @data[Variable.new(name)]
+    end
+
+    # Returns the value corresponding to the parameter name. Raises an error
+    # when the parameter name is kind of a variable.
+    # @param [Variable] name
+    #   variable to get the value
+    # @return [BasicModel]
+    #   the value
+    def get(name)
+      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+      @data[name]
+    end
+
+    # Adds the parameter value and return new parameters.
+    # @param [Variable] name
+    # @param [BasicModel] value
+    # @return [Parameters]
+    #   new parameters with the parameter
+    def set(name, value)
+      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+      raise InvalidArgument.new(value) unless value.kind_of?(BasicModel)
+      self.class.new(@data.merge({name => value}))
+    end
+
+    # Adds the parameter value.
+    # @param [Variable] name
+    # @param [BasicModel] value
+    # @return [void]
+    def set!(name, value)
+      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+      raise InvalidArgument.new(value) unless value.kind_of?(BasicModel)
+      @data.merge!({name => value})
+    end
+
+    # Adds the parameter value safety and return new parameters.
+    # @param [Variable] name
+    # @param [BasicModel] value
+    # @return [Parameters]
+    #   new parameters with the parameter
+    def set_safety(name, value)
+      if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
+        set(name, value)
+      end
+    end
+
+    # Adds the parameter value safety.
+    # @param [Variable] name
+    # @param [BasicModel] value
+    # @return [void]
+    def set_safety!(name, value)
+      if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
+        set!(name, value)
+      end
+    end
+
+    # Deletes the parameter by name.
+    # @param [Variable] name
+    #   target's name
+    # @return [Parameters]
+    #   new parameters that deleted the target
+    def delete(name)
+      raise InvalidParameter.new(name) unless name.kind_of?(Variable)
+      new_data = @data.clone
+      new_data.delete(name)
+      self.class.new(new_data)
+    end
+
+    # Returns true if the parameters is empty.
+    # @return [Boolean]
+    #   true if the parameters is empty
+    def empty?
+      @data.empty?
+    end
+
+    # Updates parameters with the argument and return new parameters with it.
+    # @param [BasicModel] other
+    #   merge target
+    # @return [Parameters]
+    #   new parameters that merged the target
+    def merge(other)
+      case other
+      when Parameters
+        self.class.new(@data.merge(other.data))
+      when Variable
+        self.class.new(@data.merge({other => UndefinedValue.new}))
+      when Assignment
+        self.class.new(@data.merge({other.variable => other.expr}))
+      else
+        raise TypeError.new(other)
+      end
+    end
+
+    # Updates parameters with the argument destructively.
+    # @param [BasicModel] other
+    #   merge target
+    # @return [void]
+    def merge!(other)
+      case other
+      when Parameters
+        @data.merge!(other.data)
+      when Variable
+        @data.merge!({other => UndefinedValue.new})
+      when Assignment
+        @data.merge!({other.variable => other.expr})
+      else
+        raise TypeError.new(other)
+      end
+    end
+
+    # Converts into variable table.
+    # @return [VariableTable]
+    #   variable table which values are same as the parameters.
+    def as_variable_table
+      VariableTable.new(@data)
+    end
+
+    # Returns key list.
+    # @return [Array<Variable>]
+    #   parameter key list
+    def keys
+      @data.keys.sort
+    end
+
+    # @api private
+    def string_form
+      "{" + @data.map{|k,v| "#{k}: #{v}"}.join(", ") + "}"
+    end
+
+    # @api private
+    def to_json(*args)
+      @data.to_json(*args)
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @data == other.data
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @data.hash
+    end
+  end
+
+  TypeParameters.instance_eval do
+    define_pione_method('==', [TypeParameters], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.data == other.data)
+    end
+
+    define_pione_method("!=", [TypeParameters], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("[]", [TypeString], TypeAny) do |rec, name|
+      rec.get(Variable.new(name.value))
+    end
+
+    define_pione_method("get", [TypeString], TypeAny) do |rec, name|
+      rec.get(Variable.new(name.value))
+    end
+
+    define_pione_method(
+      "set",
+      [TypeString, TypeAny],
+      TypeParameters
+    ) do |rec, name, val|
+      rec.set(Variable.new(name.value), val)
+    end
+
+    define_pione_method("empty?", [], TypeBoolean) do |rec|
+      PioneBoolean.new(rec.empty?)
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      PioneString.new(rec.string_form)
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Pione::Model
+  # Rule representation in the flow element context.
+  class RuleExpr < BasicModel
+    set_pione_model_type TypeRuleExpr
+
+    attr_reader :package
+    attr_reader :name
+    attr_reader :params
+
+    # Create a rule expression.
+    # @param [String] package pione package name
+    # @param [String] name rule name
+    # @param [Parameters] params parameters
+    def initialize(package, name, params=Parameters.empty)
+      @package = package
+      @name = name
+      @params = params
+      super()
+    end
+
+    # Returns rule path form.
+    # @return [String]
+    #   rule path string
+    def path
+      "&%s:%s" % [@package.name, @name]
+    end
+
+    # FIXME
+    def rule_path
+      raise UnboundVariableError.new(self) if @package.include_variable?
+      "&%s:%s" % [@package.name, @name]
+    end
+
+    # @api private
+    def task_id_string
+      "RuleExpr<%s,#{@name}>" % [@package.task_id_string]
+    end
+
+    # @api private
+    def textize
+      "rule_expr(%s,\"%s\")" % [@package.textize, @name]
+    end
+
+    # Sets a package name and returns a new expression.
+    # @param [String] package
+    #   package name
+    # @return [RuleExpr]
+    #   new rule expression with the package name
+    def set_package(package)
+      return self.class.new(package, @name, @params)
+    end
+
+    # Sets parameters and returns a new expression.
+    # @param [Parameters] params
+    #   parameters
+    # @return [RuleExpr]
+    #   new rule expression with the parameters
+    def set_params(params)
+      return self.class.new(@package, @name, params)
+    end
+
+    # Evaluates the object with the variable table.
+    # @param [VariableTable] vtable
+    #   variable table for evaluation
+    # @return [BasicModel]
+    #   evaluation result
+    def eval(vtable)
+      return self.class.new(
+        @package.eval(vtable),
+        @name,
+        @params.eval(vtable)
+      )
+    end
+
+    # Returns true if the package or parameters include variables.
+    # @return [Boolean]
+    #   true if the package or parameters include variables
+    def include_variable?
+      @package.include_variable? or @params.include_variable?
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      return false unless @package = other.package
+      return false unless @name == other.name
+      return false unless @params == other.params
+      return true
+    end
+
+    # @api private
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @package.hash + @name.hash + @params.hash
+    end
+  end
+
+  TypeRuleExpr.instance_eval do
+    define_pione_method("==", [TypeRuleExpr], TypeBoolean) do |rec, other|
+      PioneBoolean.new(
+        rec.package == other.package &&
+        rec.name == other.name &&
+        rec.params == other.params)
+    end
+
+    define_pione_method("!=", [TypeRuleExpr], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("params", [TypeParameters], TypeRuleExpr) do |rec, params|
+      rec.set_params(params)
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      PioneString.new(rec.name)
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+module Pione::Model
+  # RuleIOElement is a special PIONE model object for matched data name result.
+  class RuleIOElement < BasicModel
+    set_pione_model_type TypeRuleIOElement
+
+    attr_accessor :name
+    attr_accessor :uri
+    attr_accessor :match
+
+    # Creates a element with the name.
+    # @param [PioneString, String] name
+    #   element name
+    def initialize(name)
+      @name = name.kind_of?(PioneString) ? name : PioneString.new(name)
+      @uri = PioneString.new("")
+      @match = PioneList.new()
+    end
+
+    # @api private
+    def textize
+      "rule-io-element(%s,%s,%s)" % [@name.to_ruby, @uri.textize, @match.textize]
+    end
+
+    # @api private
+    def uri=(uri)
+      @uri = uri.to_pione
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @name == other.name && @uri == other.uri && @match == other.match
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @value.hash
+    end
+
+    #
+    # pione method
+    #
+
+    define_pione_method("==", [TypeRuleIOElement], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.values == other.values)
+    end
+
+    define_pione_method("!=", [TypeRuleIOElement], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("uri", [], TypeString) do |rec, other|
+      PioneString.new(rec.uri)
+    end
+
+    define_pione_method("match", [], TypeList.new(TypeString)) do |rec|
+      rec.match
+    end
+
+    define_pione_method("MATCH", [], TypeList.new(TypeString)) do |rec|
+      rec.call_pione_method("match")
+    end
+
+    define_pione_method("[]", [TypeInteger], TypeAny) do |rec, i|
+      rec.match[i.value-1]
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      rec.name
+    end
+  end
+
+  # RuleIOList is a input or output list for RuleIOElement.
+  class RuleIOList < BasicModel
+    extend Forwardable
+
+    set_pione_model_type TypeRuleIOList
+
+    attr_accessor :elements
+    def_delegators :@elements, :[], :size, :length
+
+    # Creates a list object.
+    # @param [Array<RuleIOElement>] elts
+    #   list elements
+    def initialize(elts = [])
+      @elements = elts
+    end
+
+    # Returns new list which appended the element.
+    # @param [RuleIOElement] elt
+    #   target element
+    # @return [RuleIOList]
+    #   new list object that added the element
+    def add(elt)
+      unless elt.kind_of?(RuleIOElement) || elt.kind_of?(self.class)
+        raise ArgumentError.new(elt)
+      end
+      self.class.new(@elements + [elt])
+    end
+
+    # Adds the element to this list.
+    # @param [RuleIOElement] elt
+    #   target element
+    # @return [void]
+    def add!(elt)
+      unless elt.kind_of?(RuleIOElement) || elt.kinf_of?(self.class)
+        raise ArgumentError.new(elt)
+      end
+      @elements << elt
+    end
+
+    # @api private
+    def textize
+      "rule-io-list(%s)" % @elements.map{|elt|
+        elt.textize
+      }.join(DataExpr::SEPARATOR)
+    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
+
+    #
+    # pione method
+    #
+
+    define_pione_method("==", [TypeRuleIOList], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.values == other.values)
+    end
+
+    define_pione_method("!=", [TypeRuleIOList], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("[]", [TypeInteger], TypeAny) do |rec, i|
+      rec.elements[i.value-1]
+    end
+
+    define_pione_method("join", [TypeString], TypeString) do |rec, connective|
+      PioneString.new(
+        rec.elements.map{|elt|
+          elt.call_pione_method("as_string").to_ruby
+        }.join(connective.to_ruby)
+      )
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      PioneString.new(
+        rec.elements.map{|elt|
+          elt.call_pione_method("as_string").to_ruby
+        }.join(DataExpr::SEPARATOR)
+      )
+    end
+  end
+end