pione 0.1.3 → 0.1.4

data/lib/pione/model/string.rb

@@ -1,19 +1,7 @@
 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
-
+    class PioneString < Value
       # Evaluate the object with the variable table.
       #
       # @param vtable [VariableTable]
@@ -32,6 +20,14 @@ module Pione
         VariableTable.check_include_variable(@value)
       end
 
+      # Return a sequence that contains self.
+      #
+      # @return [StringSequence]
+      #   a sequence
+      def to_seq
+        StringSequence.new([self])
+      end
+
       # @api private
       def task_id_string
         "String<#{@value}>"
@@ -62,49 +58,99 @@ module Pione
       def hash
         @value.hash
       end
+
+      def inspect
+        '#<PioneString "%s">' % @value
+      end
     end
 
-    TypeString.instance_eval do
-      define_pione_method("==", [TypeString], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.value == other.value)
+    class StringSequence < OrdinalSequence
+      set_pione_model_type TypeString
+      set_element_class PioneString
+      set_shortname "StrSeq"
+
+      def value
+        @value ||= @elements.map{|elt| elt.value}.join
       end
 
-      define_pione_method("!=", [TypeString], TypeBoolean) do |rec, other|
-        PioneBoolean.not(rec.call_pione_method("==", other))
+      def set_annotation_type(type)
+        self.class.new(@elements, @attribute.merge(annotation_type: type))
       end
+    end
 
+    TypeString.instance_eval do
       define_pione_method("+", [TypeString], TypeString) do |rec, other|
-        PioneString.new(rec.value + other.value)
+        raise Model::AttributeError.new(other.attribute) unless rec.attribute == other.attribute
+        rec.elements.map do |rec_elt|
+          other.elements.map do |other_elt|
+            PioneString.new(rec_elt.value + other_elt.value)
+          end
+        end.flatten.tap {|x| break StringSequence.new(x, rec.attribute)}
       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)
+      define_pione_method("as_integer", [], TypeInteger) do |rec|
+        sequential_map1(TypeInteger, rec) do |elt|
+          elt.value.to_i
+        end
       end
 
       define_pione_method("as_float", [], TypeFloat) do |rec|
-        PioneFloat.new(rec.value.to_f)
+        sequential_map1(TypeFloat, rec) do |elt|
+          elt.value.to_f
+        end
       end
 
-      define_pione_method("length", [], TypeInteger) do |rec|
-        PioneInteger.new(rec.value.size)
+      define_pione_method("as_data_expr", [], TypeDataExpr) do |rec|
+        # FIXME
+        DataExpr.new(rec.elements.map{|elt| elt.value}.join(":")).to_seq
       end
 
-      define_pione_method("include?", [TypeString], TypeBoolean) do |rec, str|
-        PioneBoolean.new(rec.value.include?(str.value))
+      define_pione_method("count", [], TypeInteger) do |rec|
+        sequential_map1(TypeInteger, rec) do |elt|
+          elt.value.size
+        end
       end
 
-      define_pione_method("as_data_expr", [], TypeDataExpr) do |rec|
-        DataExpr.new(rec.value)
+      define_pione_method("include?", [TypeString], TypeBoolean) do |rec, target|
+        sequential_map2(TypeBoolean, rec, target) do |rec_elt, target_elt|
+          rec_elt.value.include?(target_elt.value)
+        end
       end
 
       define_pione_method("substring",
         [TypeInteger, TypeInteger],
         TypeString) do |rec, nth, len|
-        PioneString.new(rec.value[nth.value, len.value])
+        sequential_map2(TypeString, nth, len) do |nth_elt, len_elt|
+          rec.value[nth_elt.value-1, len_elt.value]
+        end
+      end
+
+      # insert : (pos : integer) -> (other : string) -> string
+      define_pione_method("insert", [TypeInteger, TypeString], TypeString) do |rec, pos, other|
+        sequential_map3(TypeString, rec, pos, other) do |rec_elt, pos_elt, other_elt|
+          rec_elt.value.clone.insert(pos_elt.value-1, other_elt.value)
+        end
+      end
+
+      # join : string
+      define_pione_method("join", [], TypeString) do |rec|
+        rec.call_pione_method("join", PioneString.new(rec.separator).to_seq)
+      end
+
+      # join : (sep : string) -> string
+      define_pione_method("join", [TypeString], TypeString) do |rec, sep|
+        sequential_map1(TypeString, sep) do |sep_elt|
+          rec.elements.map{|elt| elt.value}.join(sep_elt.value)
+        end
+      end
+
+      # author : string
+      define_pione_method("author", [], TypeString) do |rec|
+        rec.set_annotation_type(:author)
       end
     end
   end

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

@@ -14,9 +14,7 @@ module Pione
     #   End
     # @example TicketExpr represents a set
     #   TicketExpr.new("T1") + TicketExpr.new("T2") #=> TicketExpr.new(["T1", "T2"])
-    class TicketExpr < BasicModel
-      set_pione_model_type TypeTicketExpr
-
+    class TicketExpr < Element
       class << self
         # Return an emtpy ticket expression. Empty ticket expression has no
         # ticket conditions.
@@ -26,25 +24,15 @@ module Pione
       end
 
       # ticket names
-      attr_reader :names
+      attr_reader :name
+      alias :value :name
 
       # Create a ticket expression with names.
       #
       # @param names [Set, Array]
       #   ticket names
-      #
-      # @example
-      #   TicketExpr.new(["T1", "T2"])
-      # @example
-      #   TicketExpr.new(Set.new(["T1", "T2"]))
-      def initialize(names)
-        @names = Set.new(names)
-        super()
-      end
-
-      # Return true if the ticket expression is empty.
-      def empty?
-        @names.empty?
+      def initialize(name)
+        @name = name
       end
 
       # Evaluate the object with the variable table.
@@ -89,33 +77,33 @@ module Pione
       # @api private
       def ==(other)
         return false unless other.kind_of?(self.class)
-        @names == other.names
+        @name == other.name
       end
       alias :eql? :"=="
 
       # @api private
       def hash
-        @names.hash
+        @name.hash
       end
     end
 
-    TypeTicketExpr.instance_eval do
-      define_pione_method("==", [TypeTicketExpr], TypeBoolean) do |rec, other|
-        PioneBoolean.new(rec.names == other.names)
-      end
+    class TicketExprSequence < OrdinalSequence
+      set_pione_model_type TypeTicketExpr
+      set_element_class TicketExpr
+      set_shortname "TSeq"
 
-      define_pione_method("!=", [TypeTicketExpr], TypeBoolean) do |rec, other|
-        PioneBoolean.not(rec.call_pione_method("==", other))
+      def names
+        @elements.map do |elt|
+          elt.name
+        end
       end
+    end
 
+    TypeTicketExpr.instance_eval do
       define_pione_method("==>", [TypeRuleExpr], TypeRuleExpr) do |rec, other|
         other.add_input_ticket_expr(rec)
       end
 
-      define_pione_method("+", [TypeTicketExpr], TypeTicketExpr) do |rec, other|
-        rec + other
-      end
-
       define_pione_method("as_string", [], TypeString) do |rec|
         rec.textize
       end

data/lib/pione/model/type.rb

@@ -0,0 +1,242 @@
+module Pione
+  module Model
+    # Type is a class for type expression of PIONE model objects.
+    class Type < System::PioneObject
+      @table = Hamster.hash
+
+      class << self
+        def put(name, value)
+          @table = @table.put(name, value)
+        end
+
+        def get(name)
+          @table.get(name)
+        end
+      end
+
+      attr_reader :name
+      attr_reader :parent_type
+      attr_reader :pione_method
+
+      # Create a type for PIONE model object.
+      #
+      # @param name [Symbol]
+      #   type name
+      # @param parent_type [Type]
+      #   parent type
+      def initialize(name, parent_type=nil)
+        @name = name
+        @parent_type = parent_type
+        @pione_method = Hamster.hash
+        Type.put(name, self)
+      end
+
+      # Return true if the type or the pione model object matches.
+      #
+      # @param [BasicModel] target
+      #   matching test target
+      # @return [Boolean]
+      #   true if it matches, or false
+      def match(target)
+        target_type = target.pione_model_type
+        while target_type do
+          return true if self == target_type
+          target_type = target_type.parent_type
+        end
+        return false
+      end
+
+      # Find named method.
+      #
+      # @param name [String]
+      #   method name
+      # @param rec [Callable]
+      #   receiver
+      # @param args [Array<BasicModel>]
+      #   arguments
+      # @return [void]
+      def find_method(name, rec, *args)
+        name = name.to_s
+        if @pione_method.has_key?(name)
+          @pione_method[name].each do |pione_method|
+            if pione_method.validate_inputs(rec, *args)
+              return pione_method
+            end
+          end
+        else
+          return @parent_type ? @parent_type.find_method(name, rec, *args) : nil
+        end
+      end
+
+      # Define PIONE model object methods.
+      #
+      # @param name [Symbol]
+      #   method name
+      # @param inputs [Array<Type>]
+      #   input types of the method
+      # @param output [Type]
+      #   output type of the method
+      # @param [Proc] b
+      # @return [void]
+      def define_pione_method(name, inputs, output, &b)
+        name = name.to_s
+        method = PioneMethod.new(name, inputs, output, b)
+        list = @pione_method.fetch(name, Hamster.list)
+        @pione_method = @pione_method.put(name, list.cons(method))
+      end
+
+      # Return true if the data has the type.
+      #
+      # @return [void]
+      def check(data)
+        unless match(data)
+          raise PioneModelTypeError.new(data, self)
+        end
+      end
+
+      def type_to_class(type)
+        case type
+        when TypeString
+          StringSequence
+        when TypeInteger
+          IntegerSequence
+        when TypeFloat
+          FloatSequence
+        when TypeBoolean
+          BooleanSequence
+        when TypeDataExpr
+          DataExprSequence
+        when TypeTicketExpr
+          TicketExprSequence
+        end
+      end
+
+      def map1(seq, &b)
+        seq_class = type_to_class(self)
+        seq_class.new(seq.elements.map{|elt| b.call(elt)}, seq.attribute)
+      end
+
+      def map2(seq1, seq2, &b)
+        seq_class = type_to_class(self)
+        seq1.elements.map do |elt1|
+          seq2.elements.map do |elt2|
+            b.call(elt1, elt2)
+          end
+        end.flatten.tap {|x| break seq_class.new(x, seq1.attribute)}
+      end
+
+      def sequential_map1(type, seq1, &b)
+        seq_class = type_to_class(type)
+        seq1.elements.map do |elt1|
+          seq_class.element_class.new(b.call(elt1))
+        end.tap {|x| break seq_class.new(x, seq1.attribute)}
+      end
+
+      def sequential_map2(type, seq1, seq2, &b)
+        seq_class = type_to_class(type)
+        seq1.elements.map do |elt1|
+          seq2.elements.map do |elt2|
+            seq_class.element_class.new(b.call(elt1, elt2))
+          end
+        end.flatten.tap {|x| break seq_class.new(x, seq1.attribute)}
+      end
+
+      def sequential_map3(type, seq1, seq2, seq3, &b)
+        seq_class = type_to_class(type)
+        seq1.elements.map do |elt1|
+          seq2.elements.map do |elt2|
+            seq3.elements.map do |elt3|
+              seq_class.element_class.new(b.call(elt1, elt2, elt3))
+            end
+          end
+        end.flatten.tap {|x| break seq_class.new(x, seq1.attribute)}
+      end
+
+      def sequential_fold1(type, seq1, &b)
+        seq_class = type_to_class(type)
+        seq1.elements.inject(seq_class.new([], seq1.attribute)) do |obj, elt1|
+          b.call(elt1, obj)
+        end
+      end
+
+      def sequential_fold2(type, seq1, seq2, &b)
+        seq_class = type_to_class(type)
+        seq1.elements.inject(seq_class.new([], seq1.attribute)) do |obj1, elt1|
+          seq2.elements.inject(obj1) do |obj2, elt2|
+            b.call(obj2, elt1, elt2)
+          end
+        end
+      end
+
+      def sequential_pred1(seq1, &b)
+        method1 = seq1.every? ? :all? : :any?
+        seq1.elements.send(method1) do |elt1|
+          PioneBoolean.new(b.call(elt1))
+        end.tap {|x| break BooleanSequence.new(x)}
+      end
+
+      def sequential_pred2(seq1, seq2, &b)
+        method1 = seq1.every? ? :all? : :any?
+        method2 = seq2.every? ? :all? : :any?
+        seq1.elements.send(method1) do |elt1|
+          seq2.elements.send(method2) do |elt2|
+            b.call(elt1, elt2)
+          end
+        end.tap {|x| break BooleanSequence.new([PioneBoolean.new(x)])}
+      end
+
+      def to_s
+        "#<Type %s>" % @name
+      end
+    end
+
+    # TypeSequence is a type for sequence of something.
+    TypeSequence = Type.new("sequence")
+
+    # TypeOrdinalSequence is a type for integer indexed sequence.
+    TypeOrdinalSequence = Type.new("ordinal-sequence", TypeSequence)
+
+    # TypeKeyedSequence is a type for something indexed sequence.
+    TypeKeyedSequence = Type.new("keyed-sequence", TypeSequence)
+
+    # TypeBoolean is a type for integer indexed boolean sequence.
+    TypeBoolean = Type.new("boolean", TypeOrdinalSequence)
+
+    # TypeInteger is a type for integer indexed integer sequence.
+    TypeInteger = Type.new("integer", TypeOrdinalSequence)
+
+    # TypeFloat is a type for float
+    TypeFloat = Type.new("float", TypeOrdinalSequence)
+
+    # string type for PIONE system
+    TypeString = Type.new("string", TypeOrdinalSequence)
+
+    # data expression type for PIONE system
+    TypeDataExpr = Type.new("data-expr", TypeOrdinalSequence)
+
+    # feature type for PIONE system
+    TypeFeature = Type.new("feature", TypeOrdinalSequence)
+
+    # rule expression type for PIONE system
+    TypeRuleExpr = Type.new("rule-expr", TypeOrdinalSequence)
+
+    # parameters type for PIONE system
+    TypeParameters = Type.new("parameters", TypeOrdinalSequence)
+
+    # assignment type for PIONE system
+    TypeAssignment = Type.new("assignment", TypeOrdinalSequence)
+
+    # variable table type for PIONE system
+    TypeVariableTable = Type.new("variable-table", TypeOrdinalSequence)
+
+    # package type for PIONE system
+    TypePackage = Type.new("package", TypeOrdinalSequence)
+
+    # ticket expression type
+    TypeTicketExpr = Type.new("ticket-expr", TypeOrdinalSequence)
+
+    def TypeSequence.match(other)
+      true
+    end
+  end
+end

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

@@ -58,8 +58,6 @@ module Pione
 
     # VariableTable represents variable tables for rule context.
     class VariableTable < BasicModel
-      set_pione_model_type TypeVariableTable
-
       # Return empty variable table.
       #
       # @return [VariableTable]
@@ -134,7 +132,7 @@ module Pione
         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
+          unless old_value.void? or new_value == old_value
             raise VariableBindingError.new(variable, new_value, old_value)
           end
         end
@@ -164,11 +162,11 @@ module Pione
         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
+          expr.eval(self).call_pione_method("textize").first.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
+          expr.eval(self).call_pione_method("textize").first.value
         end
       end
 
@@ -246,15 +244,13 @@ module Pione
         @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
+        case expr.distribution
         when :all
           make_io_auto_variables_by_all(type, prefix, expr, data, index)
         when :each
@@ -262,37 +258,52 @@ module Pione
         end
       end
 
-      # Make input or output auto variables for 'exist' modified data name
-      # expression.
+      # Make input/output auto variables by data expression with each
+      # distribution.
       #
-      # @api private
+      # @param prefix [String]
+      #   "I" or "O"
+      # @param expr [DataExpr]
+      #   data expression
+      # @param tuple [DataTuple]
+      #   data tuple
+      # @param index [Integer]
+      #   index number of the input/output
+      # @return [void]
       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
+        md = expr.first.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 data expression sequence
+        seq = get(var) || KeyedSequence.empty
+        data_expr = DataExpr.new(tuple.name, location: tuple.location, matched_data: md)
 
-        # update the list
-        set!(var, list.add(elt))
+        # update variable table
+        set!(var, seq.put(PioneInteger.new(index), data_expr))
 
-        # set special variable if index equals 1
+        # set the special variable if index is 1
         if prefix == 'I' && index == 1
-          set(Variable.new("*"), PioneString.new(md[1]))
+          set(Variable.new("*"), StringSequence.new([PioneString.new(md[1])], separator: DataExpr::SEPARATOR))
         end
       end
 
-      # Make input or output auto variables for 'all' modified data name
-      # expression.
+      # Make input/output auto variables by data expression with all
+      # distribution.
       #
-      # @api private
+      # @param prefix [String]
+      #   "I" or "O"
+      # @param expr [DataExpr]
+      #   data expression
+      # @param tuple [DataTuple]
+      #   data tuple
+      # @param index [Integer]
+      #   index number of the input/output
+      # @return [void]
       def make_io_auto_variables_by_all(type, prefix, expr, tuples, index)
         # FIXME: output
         return if type == :output
@@ -300,44 +311,32 @@ module Pione
         # variable
         var = Variable.new(prefix)
 
-        # setup rule-io list
-        list = get(var)
-        list = RuleIOList.new unless list
-        io_list = RuleIOList.new()
+        # setup data expression sequence(this is $I/$O)
+        seq = get(var) || KeyedSequence.empty(separator: DataExpr::SEPARATOR)
 
         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)
+        matched_seq = tuples.inject(seq) do |_seq, tuple|
+          # matched data
+          md = expr.first.match(tuple.name).to_a
+          asterisk << md[1]
+
+          # make a date expression
+          data_expr = DataExpr.new(tuple.name, location: tuple.location, matched_data: md)
+
+          # put it with index
+          _seq.put(PioneInteger.new(index), data_expr)
         end
 
         # set special variable if index equals 1
         if prefix == 'I' && index == 1
-          set(Variable.new("*"), PioneString.new(asterisk.join(":")))
+          strs = asterisk.map{|str| PioneString.new(str)}
+          set(Variable.new("*"), StringSequence.new(strs, separator: DataExpr::SEPARATOR))
         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)})
+        # update sequence
+        set!(var, matched_seq)
       end
     end
   end

data/lib/pione/model/variable.rb

@@ -2,9 +2,8 @@ module Pione
   module Model
     # Variable represent variable name objects. A variable object can evaluates
     # its value with the variable table.
-    class Variable < BasicModel
-      set_pione_model_type TypeAny
-
+    class Variable < Callable
+      set_pione_model_type TypeSequence
       attr_reader :name
 
       # true if the variable is user parameter
@@ -95,9 +94,14 @@ module Pione
 
       # @api private
       def inspect
-        "#<Pione::Model::Variable @name=%s>" % @name.inspect
+        "#<Variable %s>" % @name.inspect
       end
       alias :to_s :inspect
     end
+
+    # class VariableSequence < Sequence
+    #   set_pione_model_type TypeSequence
+    #   set_element_class Variable
+    # end
   end
 end