pione 0.1.4 → 0.2.0

data/lib/pione/model/integer.rb

@@ -2,48 +2,14 @@ module Pione
   module Model
     # PioneInteger represents integer value in PIONE system.
     class PioneInteger < Value
-      # @api private
-      def task_id_string
-        "Integer<#{@value}>"
-      end
-
       # @api private
       def textize
         @value.to_s
       end
 
-      # Return the ruby's value.
-      #
-      # @return [Integer]
-      #   ruby's value
-      def to_ruby
-        return @value
-      end
-
       def to_seq
         IntegerSequence.new([self])
       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
-
-      # @api private
-      def inspect
-        "#<PioneInteger %s>" % @value
-      end
-
-      # @api private
-      alias :to_s :inspect
     end
 
     class IntegerSequence < OrdinalSequence
@@ -53,95 +19,95 @@ module Pione
     end
 
     TypeInteger.instance_eval do
-      define_pione_method(">", [TypeInteger], TypeBoolean) do |rec, other|
+      define_pione_method(">", [TypeInteger], TypeBoolean) do |vtable, rec, other|
         sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
           rec_elt.value > other_elt.value
         end
       end
 
-      define_pione_method(">=", [TypeInteger], TypeBoolean) do |rec, other|
+      define_pione_method(">=", [TypeInteger], TypeBoolean) do |vtable, rec, other|
         BooleanSequence.new(
-          [PioneBoolean.new(rec.call_pione_method(">", other).value || rec.call_pione_method("==", other).value)]
+          [PioneBoolean.new(rec.call_pione_method(vtable, ">", other).value || rec.call_pione_method(vtable, "==", other).value)]
         )
       end
 
-      define_pione_method("<", [TypeInteger], TypeBoolean) do |rec, other|
+      define_pione_method("<", [TypeInteger], TypeBoolean) do |vtable, rec, other|
         sequential_map2(TypeBoolean, rec, other) do |rec_elt, other_elt|
           rec_elt.value < other_elt.value
         end
       end
 
-      define_pione_method("<=", [TypeInteger], TypeBoolean) do |rec, other|
+      define_pione_method("<=", [TypeInteger], TypeBoolean) do |vtable, rec, other|
         BooleanSequence.new(
           [PioneBoolean.new(
-              rec.call_pione_method("<", other).value ||
-              rec.call_pione_method("==", other).value
+              rec.call_pione_method(vtable, "<", other).value ||
+              rec.call_pione_method(vtable, "==", other).value
           )]
         )
       end
 
-      define_pione_method("+", [TypeInteger], TypeInteger) do |rec, other|
+      define_pione_method("+", [TypeInteger], TypeInteger) do |vtable, rec, other|
         sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
           rec_elt.value + other_elt.value
         end
       end
 
-      define_pione_method("-", [TypeInteger], TypeInteger) do |rec, other|
+      define_pione_method("-", [TypeInteger], TypeInteger) do |vtable, rec, other|
         sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
           rec_elt.value - other_elt.value
         end
       end
 
-      define_pione_method("*", [TypeInteger], TypeInteger) do |rec, other|
+      define_pione_method("*", [TypeInteger], TypeInteger) do |vtable, rec, other|
         sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
           rec_elt.value * other_elt.value
         end
       end
 
-      define_pione_method("%", [TypeInteger], TypeInteger) do |rec, other|
+      define_pione_method("%", [TypeInteger], TypeInteger) do |vtable, rec, other|
         # TODO: zero division error
         sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
           rec_elt.value % other_elt.value
         end
       end
 
-      define_pione_method("/", [TypeInteger], TypeInteger) do |rec, other|
+      define_pione_method("/", [TypeInteger], TypeInteger) do |vtable, rec, other|
         # TODO: zero division error
         sequential_map2(TypeInteger, rec, other) do |rec_elt, other_elt|
           rec_elt.value / other_elt.value
         end
       end
 
-      define_pione_method("as_string", [], TypeString) do |rec|
+      define_pione_method("as_string", [], TypeString) do |vtable, rec|
         sequential_map1(TypeString, rec) {|elt| elt.value.to_s}
       end
 
-      define_pione_method("as_integer", [], TypeInteger) do |rec|
+      define_pione_method("as_integer", [], TypeInteger) do |vtable, rec|
         rec
       end
 
-      define_pione_method("as_float", [], TypeFloat) do |rec|
+      define_pione_method("as_float", [], TypeFloat) do |vtable, rec|
         sequential_map1(TypeFloat, rec) {|elt| elt.value.to_f}
       end
 
-      define_pione_method("next", [], TypeInteger) do |rec|
+      define_pione_method("next", [], TypeInteger) do |vtable, rec|
         sequential_map1(TypeInteger, rec) {|elt| elt.value.next}
       end
 
-      define_pione_method("prev", [], TypeInteger) do |rec|
+      define_pione_method("prev", [], TypeInteger) do |vtable, rec|
         sequential_map1(TypeInteger, rec) {|elt| elt.value.pred}
       end
 
-      define_pione_method("even?", [], TypeBoolean) do |rec|
+      define_pione_method("even?", [], TypeBoolean) do |vtable, rec|
         sequential_pred1(rec) {|elt| elt.value.even?}
       end
 
-      define_pione_method("odd?", [], TypeBoolean) do |rec|
+      define_pione_method("odd?", [], TypeBoolean) do |vtable, rec|
         sequential_pred1(rec) {|elt| elt.value.odd?}
       end
 
       # upto : *integer -> *integer
-      define_pione_method("upto", [TypeInteger], TypeInteger) do |rec, max|
+      define_pione_method("upto", [TypeInteger], TypeInteger) do |vtable, rec, max|
         sequential_fold2(TypeInteger, rec, max) do |seq, rec_elt, max_elt|
           if rec_elt.value < max_elt.value
             rec_elt.value.upto(max_elt.value).inject(seq) do |_seq, i|
@@ -153,8 +119,8 @@ module Pione
         end
       end
 
-      # downto : *integer -> *integer
-      define_pione_method("downto", [TypeInteger], TypeInteger) do |rec, min|
+      # downto : integer -> integer
+      define_pione_method("downto", [TypeInteger], TypeInteger) do |vtable, rec, min|
         sequential_fold2(TypeInteger, rec, min) do |seq, rec_elt, min_elt|
           if rec_elt.value > min_elt.value
             rec_elt.value.downto(min_elt.value).inject(seq) do |_seq, i|
@@ -165,6 +131,28 @@ module Pione
           end
         end
       end
+
+      # max : integer
+      define_pione_method("max", [], TypeInteger) do |vtable, rec|
+        fold1(IntegerSequence.empty, rec) do |seq, elt|
+          if seq.elements.size == 0 or seq.elements.first.value < elt.value
+            elt.to_seq
+          else
+            seq
+          end
+        end
+      end
+
+      # min : integer
+      define_pione_method("min", [], TypeInteger) do |vtable, rec|
+        fold1(IntegerSequence.empty, rec) do |seq, elt|
+          if seq.elements.size == 0 or seq.elements.first.value > elt.value
+            elt.to_seq
+          else
+            seq
+          end
+        end
+      end
     end
   end
 end

data/lib/pione/model/keyed-sequence.rb

@@ -51,7 +51,7 @@ module Pione
         end
       end
 
-      # Concatenate another sequence.
+      # Concatenate the sequence and another one.
       #
       # @param other [Sequence]
       #   other sequence
@@ -123,21 +123,28 @@ module Pione
     end
 
     TypeKeyedSequence.instance_eval do
-      define_pione_method("keys", [], :index_type) do |rec|
+      # keys : index_type
+      define_pione_method("keys", [], :index_type) do |vtable, rec|
         keys = rec.elements.keys
         rec.ordinal_sequence_of_element(keys.first).new(keys)
       end
 
-      define_pione_method("values", [], :element_type) do |rec|
+      # values : element_type
+      define_pione_method("values", [], :element_type) do |vtable, rec|
         vals = rec.elements.values.flatten
         rec.ordinal_sequence_of_element(vals.first).new(vals)
       end
 
-      define_pione_method("[]", [:index_type], :element_type) do |rec, index|
+      # [] : index_type -> element_type
+      define_pione_method("[]", [:index_type], :element_type) do |vtable, rec, index|
         index.elements.map do |index_elt|
           rec.elements[index_elt]
         end.flatten.tap{|x| break rec.ordinal_sequence_of_element(x.first).new(x, rec.attribute)}
       end
+
+      define_pione_method("textize", [], TypeString) do |vtable, rec|
+        rec.call_pione_method(vtable, "values").call_pione_method(vtable, "textize")
+      end
     end
   end
 end

data/lib/pione/model/message.rb

@@ -21,8 +21,8 @@ module Pione
       #   message arguments
       def initialize(name, receiver, *arguments)
         @name = name
-        @receiver = receiver.to_pione
-        @arguments = arguments.map{|arg| arg.to_pione}
+        @receiver = receiver
+        @arguments = arguments
         super()
       end
 
@@ -42,7 +42,7 @@ module Pione
         if pione_method = @receiver.pione_model_type.find_method(@name, @receiver, *@arguments)
           pione_method.get_output_type(@receiver)
         else
-          raise MethodNotFound.new(@name.to_s, self)
+          raise MethodNotFound.new(@name.to_s, @receiver, *@arguments)
         end
       end
 
@@ -55,7 +55,7 @@ module Pione
       def eval(vtable)
         receiver = @receiver.eval(vtable)
         arguments = @arguments.map{|arg| arg.eval(vtable)}
-        receiver.call_pione_method(@name, *arguments)
+        receiver.call_pione_method(vtable, @name, *arguments)
       end
 
       # Return true if the receiver or arguments include variables.

data/lib/pione/model/ordinal-sequence.rb

@@ -14,49 +14,47 @@ module Pione
     end
 
     TypeOrdinalSequence.instance_eval do
-      define_pione_method("==", [:receiver_type], TypeBoolean) do |rec, other|
+      define_pione_method("==", [:receiver_type], TypeBoolean) do |vtable, rec, other|
         if rec.elements.size == other.elements.size
           rec.elements.size.times.all? do |i|
-            rec.elements[i].value == other.elements[i].value
+            rec.elements[i] == other.elements[i]
           end.tap {|x| break BooleanSequence.new([PioneBoolean.new(x)])}
         else
           BooleanSequence.new([PioneBoolean.new(false)])
         end
       end
 
-      define_pione_method("nth", [TypeInteger], :receiver_type) do |rec, index|
-        map1(index) do |elt|
-          elt.value == 0 ? rec : rec.elements[elt.value-1]
-        end
+      define_pione_method("nth", [TypeInteger], :receiver_type) do |vtable, rec, index|
+        map1(index) {|elt| elt.value == 0 ? rec : rec.elements[elt.value-1]}
       end
 
-      define_pione_method("[]", [:index_type], :receiver_type) do |rec, index|
-        rec.call_pione_method("nth", index)
+      define_pione_method("[]", [:index_type], :receiver_type) do |vtable, rec, index|
+        rec.call_pione_method(vtable, "nth", index)
       end
 
-      define_pione_method("reverse", [], :receiver_type) do |rec|
+      define_pione_method("reverse", [], :receiver_type) do |vtable, rec|
         rec.class.new(rec.elements.reverse, rec.attribute)
       end
 
-      define_pione_method("head", [], :receiver_type) do |rec|
+      define_pione_method("head", [], :receiver_type) do |vtable, rec|
         rec.class.new([rec.elements[0]], rec.attribute)
       end
 
-      define_pione_method("tail", [], :receiver_type) do |rec|
+      define_pione_method("tail", [], :receiver_type) do |vtable, rec|
         # NOTE: #tail should fail when the sequence length is less than 1
         rec.class.new(rec.elements[1..-1], rec.attribute)
       end
 
-      define_pione_method("last", [], :receiver_type) do |rec|
+      define_pione_method("last", [], :receiver_type) do |vtable, rec|
         rec.class.new([rec.elements[-1]], rec.attribute)
       end
 
-      define_pione_method("init", [], :receiver_type) do |rec|
+      define_pione_method("init", [], :receiver_type) do |vtable, rec|
         # NOTE: #init should fail when the sequence length is less than 1
         rec.class.new(rec.elements[0..-2], rec.attribute)
       end
 
-      define_pione_method("type", [], TypeString) do |rec|
+      define_pione_method("type", [], TypeString) do |vtable, rec|
         case rec
         when StringSequence
           "string"

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

@@ -0,0 +1,53 @@
+module Pione
+  module Model
+    # PackageExpr is an expression of PIONE package.
+    class PackageExpr < Element
+      attr_reader :name
+
+      # Create a package with name.
+      #
+      # @param name [String]
+      #   package name
+      def initialize(name)
+        @name = name
+        super()
+      end
+
+      # @api private
+      def textize
+        "package-expr(\"%s\")" % [@name]
+      end
+
+      # Return a rule path.
+      #
+      # @param other [RuleExpr]
+      #   rule expression
+      # @return [String]
+      #   rule path string
+      def +(other)
+        raise ArgumentError.new(other) unless other.kind_of?(RuleExpr)
+        "#{@name}:#{other.name}"
+      end
+    end
+
+    class PackageExprSequence < Sequence
+      set_pione_model_type TypePackageExpr
+      set_element_class PackageExpr
+    end
+
+    TypePackageExpr.instance_eval do
+      define_pione_method("bin", [], TypeString) do |vtable, rec|
+        base = Location[vtable.get(Variable.new("__BASE__")).value]
+        bin = base + "package" + rec.elements.first.name + "bin"
+        working_directory = Location[vtable.get(Variable.new("__WORKING_DIRECTORY__")).first.value]
+        bin.entries.each do |entry|
+          path = working_directory + "bin" + entry.basename
+          unless path.exist?
+            entry.copy(working_directory + "bin" + entry.basename)
+          end
+        end
+        PioneString.new((working_directory + "bin").path).to_seq
+      end
+    end
+  end
+end

data/lib/pione/model/parameters.rb

@@ -99,7 +99,8 @@ module Pione
 
       # @api private
       def textize
-        "{" + @data.map{|k,v| "%s:%s" % [k.textize[1..-1], v.textize]}.join(", ") + "}"
+        # "{" + @data.map{|k,v| "%s:%s" % [k.textize[1..-1], v.textize]}.join(", ") + "}"
+        "{" + @data.map.sort.map{|k,v| "%s:%s" % [k.textize[1..-1], v.textize]}.join(", ") + "}"
       end
 
       # Return value of parameter name.
@@ -323,19 +324,19 @@ module Pione
     # end
 
     TypeParameters.instance_eval do
-      define_pione_method('==', [TypeParameters], TypeBoolean) do |rec, other|
+      define_pione_method('==', [TypeParameters], TypeBoolean) do |vtable, rec, other|
         PioneBoolean.new(rec.data == other.data)
       end
 
-      define_pione_method("!=", [TypeParameters], TypeBoolean) do |rec, other|
-        PioneBoolean.not(rec.call_pione_method("==", other))
+      define_pione_method("!=", [TypeParameters], TypeBoolean) do |vtable, rec, other|
+        PioneBoolean.not(rec.call_pione_method(vtable, "==", other))
       end
 
-      define_pione_method("[]", [TypeString], TypeSequence) do |rec, name|
+      define_pione_method("[]", [TypeString], TypeSequence) do |vtable, rec, name|
         rec.get(Variable.new(name.value))
       end
 
-      define_pione_method("get", [TypeString], TypeSequence) do |rec, name|
+      define_pione_method("get", [TypeString], TypeSequence) do |vtable, rec, name|
         rec.get(Variable.new(name.value))
       end
 
@@ -343,20 +344,20 @@ module Pione
         "set",
         [TypeString, TypeSequence],
         TypeParameters
-      ) do |rec, name, val|
+      ) do |vtable, rec, name, val|
         rec.set(Variable.new(name.value), val)
       end
 
-      define_pione_method("empty?", [], TypeBoolean) do |rec|
+      define_pione_method("empty?", [], TypeBoolean) do |vtable, rec|
         PioneBoolean.new(rec.empty?)
       end
 
-      define_pione_method("as_string", [], TypeString) do |rec|
+      define_pione_method("as_string", [], TypeString) do |vtable, rec|
         PioneString.new(rec.string_form)
       end
 
-      define_pione_method("str", [], TypeString) do |rec|
-        rec.call_pione_method("as_string")
+      define_pione_method("str", [], TypeString) do |vtable, rec|
+        rec.call_pione_method(vtable, "as_string")
       end
     end
   end