pione 0.1.2 → 0.1.3

data/lib/pione/model/string.rb

@@ -1,108 +1,119 @@
-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])
+module Pione
+  module Model
+    # PioneString is a string value in PIONE system.
+    class PioneString < BasicModel
+      set_pione_model_type TypeString
+      attr_reader :value
+
+      # Create a string with the value.
+      #
+      # @param value [String]
+      #   string value
+      def initialize(value)
+        @value = value
+        super()
+      end
+
+      # Evaluate the object with the variable table.
+      #
+      # @param vtable [VariableTable]
+      #   variable table for evaluation
+      # @return [BasicModel]
+      #   evaluation result
+      def eval(vtable)
+        self.class.new(vtable.expand(@value))
+      end
+
+      # Return 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
+
+      # Return 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("as_data_expr", [], TypeDataExpr) do |rec|
+        DataExpr.new(rec.value)
+      end
+
+      define_pione_method("substring",
+        [TypeInteger, TypeInteger],
+        TypeString) do |rec, nth, len|
+        PioneString.new(rec.value[nth.value, len.value])
+      end
     end
   end
 end
 
 # String extention for PIONE system.
 class String
-  # Returns PIONE's value.
+  # Return PIONE's value.
+  #
   # @return [PioneString]
   #   PIONE's value
   def to_pione

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

@@ -1,315 +1,344 @@
-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
+module Pione
+  module Model
+    # UnboundVariableError represents an unknown variable reference.
+    class UnboundVariableError < StandardError
+      attr_reader :variable
+
+      # Create 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
+      # @api private
+      def message
+        "Refferred unbound variable '%s' in the context." % @variable.name
+      end
     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
+    # 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
+
+      # Create an error.
+      #
+      # @param variable [Variable]
+      #   double bound variable
+      # @param new_value [BasicModel]
+      #   new value
+      # @param old_value [BasicModel]
+      #   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
+      # @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
-  end
 
-  # VariableTable represents variable tables for rule context.
-  class VariableTable < BasicModel
-    set_pione_model_type TypeVariableTable
+    # 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
+      # Return empty variable table.
+      #
+      # @return [VariableTable]
+      #   empty variable table
+      def self.empty
+        new
+      end
 
-    # Returns the variable table as hash.
-    # @return [Hash{Variable => BasicModel}]
-    #   hash form of the variable table
-    def to_hash
-      @table
-    end
+      # Create a vairable table.
+      #
+      # @param table [Hash{Variable => BasicModel}]
+      #   initial values for the variable table
+      def initialize(table={})
+        @table = table.to_hash.dup
+        super()
+      end
 
-    # Returns the parameters form.
-    # @return [Parameters]
-    #   parameters form of the variable table
-    def to_params
-      Parameters.new(to_hash)
-    end
+      # Return the variable table as hash.
+      #
+      # @return [Hash{Variable => BasicModel}]
+      #   hash form of the variable table
+      def to_hash
+        @table
+      end
 
-    # Returns true if the table is empty.
-    # @return [Boolean]
-    #   true if the table is empty
-    def empty?
-      @table.empty?
-    end
+      # Return the parameters form.
+      #
+      # @return [Parameters]
+      #   parameters form of the variable table
+      def to_params
+        Parameters.new(to_hash)
+      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
+      # Return true if the table is empty.
+      #
+      # @return [Boolean]
+      #   true if the table is empty
+      def empty?
+        @table.empty?
       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)
+      # Gets the variable value and evaluates the value if the value is not
+      # atomic.
+      #
+      # @param var [Variable]
+      #   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
-      @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
+      # Set a new variable. This method raises an exception when the variable has
+      # its value already.
+      #
+      # @param variable [Variable]
+      #   table key
+      # @param new_value [BasicModel]
+      #   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
-      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
+
+      # Set a variable. This method overrides old variable value.
+      #
+      # @param variable [Variable]
+      #   table key
+      # @param new_value [BasicModel]
+      #   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
-    end
 
-    # Returns key variables of the table.
-    # @return [Array<Variable>]
-    #   variable as table keys
-    def variables
-      @table.keys
-    end
+      # Expand variables in the string.
+      #
+      # @param str [String]
+      #   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
 
-    # 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?
+      # Return key variables of the table.
+      #
+      # @return [Array<Variable>]
+      #   variable as table keys
+      def variables
+        @table.keys
       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)
+      # Return true if the string includes variables.
+      #
+      # @param str [String]
+      #   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
-    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)
+      # Return 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
-    end
-
-    # @api private
-    def ==(other)
-      return false unless other.kind_of?(self.class)
-      @table == other.to_hash
-    end
 
-    alias :eql? :"=="
+      # Make input auto-variables.
+      #
+      # @param input_exprs [Array<DataExpr>]
+      #   input expressions
+      # @param input_tuples [Array<Expr>]
+      #   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
 
-    # @api private
-    def hash
-      @table.hash
-    end
+      # Make output auto-variables.
+      #
+      # @param output_exprs [Array<DataExpr>]
+      #   output expressions
+      # @param output_tuples [Array<DataExpr>]
+      #   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
 
-    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)
+      # @api private
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        @table == other.to_hash
       end
-    end
+      alias :eql? :"=="
 
-    # 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]))
+      # @api private
+      def hash
+        @table.hash
       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
+      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, index)
+        when :each
+          make_io_auto_variables_by_each(prefix, expr, data, index)
+        end
+      end
 
-      # variable
-      var = Variable.new(prefix)
+      # 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.location.uri.to_s)
+        elt.match = PioneList.new(*md.map{|d| PioneString.new(d)})
 
-      # setup rule-io list
-      list = get(var)
-      list = RuleIOList.new unless list
-      io_list = RuleIOList.new()
+        # update the list
+        set!(var, list.add(elt))
 
-      # 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)
+        # set special variable if index equals 1
+        if prefix == 'I' && index == 1
+          set(Variable.new("*"), PioneString.new(md[1]))
+        end
       end
 
-      # update
-      set!(var, list.add(io_list))
-    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, index)
+        # 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()
+
+        asterisk = []
+
+        # convert each tuples
+        tuples.each do |tuple, i|
+          asterisk << expr.match(tuple.name).to_a[1]
+
+          elt = RuleIOElement.new(PioneString.new(tuple.name))
+          elt.uri = PioneString.new(tuple.location.uri.to_s)
+          elt.match = PioneList.new(
+            *expr.match(tuple.name).to_a.map{|m| PioneString.new(m)}
+          )
+          io_list.add!(elt)
+        end
 
-    #
-    # pione methods
-    #
+        # set special variable if index equals 1
+        if prefix == 'I' && index == 1
+          set(Variable.new("*"), PioneString.new(asterisk.join(":")))
+        end
 
-    define_pione_method("get", [TypeString], TypeAny) do |name|
-      get(Variable.new(name.value))
-    end
+        # update
+        set!(var, list.add(io_list))
+      end
+
+      #
+      # pione methods
+      #
 
-    define_pione_method("keys", [], TypeList.new(TypeString)) do
-      PioneList.new(@table.keys.map{|var| PioneString.new(var.name)})
+      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
 end