pione 0.1.0

data/lib/pione/model/float.rb

@@ -0,0 +1,107 @@
+module Pione::Model
+  # PioneFloat represents float values in PIONE system.
+  class PioneFloat < BasicModel
+    set_pione_model_type TypeFloat
+
+    attr_reader :value
+
+    # Creates a float value in PIONE system.
+    # @param [Float] value
+    #    value in ruby
+    def initialize(value)
+      @value = value
+      super()
+    end
+
+    # @api private
+    def textize
+      "#PioneFloat{%s}" % @value
+      # @value.to_s
+    end
+
+    # Returns ruby's value.
+    # @return [Float]
+    #   ruby's value
+    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
+
+  TypeFloat.instance_eval do
+    # Returns true if the other equals self.
+    # @return [PioneBoolean]
+    #   true if the other equals self
+    define_pione_method("==", [TypeFloat], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value == other.value)
+    end
+
+    define_pione_method("!=", [TypeFloat], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method(">", [TypeFloat], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value > other.value)
+    end
+
+    define_pione_method(">=", [TypeFloat], TypeBoolean) do |rec, other|
+      PioneBoolean.or(rec.call_pione_method(">", other),
+                      rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("<", [TypeFloat], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value < other.value)
+    end
+
+    define_pione_method("<=", [TypeFloat], TypeBoolean) do |rec, other|
+      PioneBoolean.or(rec.call_pione_method("<", other),
+                      rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("+", [TypeFloat], TypeFloat) do |rec, other|
+      PioneFloat.new(rec.value + other.value)
+    end
+
+    define_pione_method("-", [TypeFloat], TypeFloat) do |rec, other|
+      PioneFloat.new(rec.value - other.value)
+    end
+
+    define_pione_method("*", [TypeFloat], TypeFloat) do |rec, other|
+      PioneFloat.new(rec.value * other.value)
+    end
+
+    define_pione_method("%", [TypeFloat], TypeFloat) do |rec, other|
+      # TODO: zero division error
+      PioneFloat.new(rec.value % other.value)
+    end
+
+    define_pione_method("/", [TypeFloat], TypeFloat) do |rec, other|
+      # TODO: zero division error
+      PioneFloat.new(rec.value / other.value)
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      PioneString.new(rec.value.to_s)
+    end
+
+    define_pione_method("as_int", [], TypeInteger) do |rec|
+      PioneInteger.new(rec.value.to_i)
+    end
+
+    define_pione_method("as_float", [], TypeFloat) do |rec|
+      rec
+    end
+  end
+end

data/lib/pione/model/integer.rb

@@ -0,0 +1,140 @@
+module Pione::Model
+  # PioneInteger represents integer value in PIONE system.
+  class PioneInteger < BasicModel
+    set_pione_model_type TypeInteger
+
+    attr_reader :value
+
+    # Creates a integer value in PIONE system.
+    # @param [Integer] value
+    #   value in ruby
+    def initialize(value)
+      @value = value
+      super()
+    end
+
+    # @api private
+    def task_id_string
+      "Integer<#{@value}>"
+    end
+
+    # @api private
+    def textize
+      @value.to_s
+    end
+
+    # Returns the ruby's value.
+    # @return [Integer]
+    #   ruby's value
+    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
+
+    # @api private
+    def inspect
+      "#<Pione::Model::PioneInteger @value=%s>" % @value.inspect
+    end
+
+    # @api private
+    alias :to_s :inspect
+  end
+
+  TypeInteger.instance_eval do
+    define_pione_method("==", [TypeInteger], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value == other.value)
+    end
+
+    define_pione_method("!=", [TypeInteger], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method(">", [TypeInteger], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value > other.value)
+    end
+
+    define_pione_method(">=", [TypeInteger], TypeBoolean) do |rec, other|
+      PioneBoolean.or(rec.call_pione_method(">", other),
+                      rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("<", [TypeInteger], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.value < other.value)
+    end
+
+    define_pione_method("<=", [TypeInteger], TypeBoolean) do |rec, other|
+      PioneBoolean.or(rec.call_pione_method("<", other),
+                      rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("+", [TypeInteger], TypeInteger) do |rec, other|
+      PioneInteger.new(rec.value + other.value)
+    end
+
+    define_pione_method("-", [TypeInteger], TypeInteger) do |rec, other|
+      PioneInteger.new(rec.value - other.value)
+    end
+
+    define_pione_method("*", [TypeInteger], TypeInteger) do |rec, other|
+      PioneInteger.new(rec.value * other.value)
+    end
+
+    define_pione_method("%", [TypeInteger], TypeInteger) do |rec, other|
+      # TODO: zero division error
+      PioneInteger.new(rec.value % other.value)
+    end
+
+    define_pione_method("/", [TypeInteger], TypeInteger) do |rec, other|
+      # TODO: zero division error
+      PioneInteger.new(rec.value / other.value)
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      PioneString.new(rec.value.to_s)
+    end
+
+    define_pione_method("as_int", [], TypeInteger) do |rec|
+      rec
+    end
+
+    define_pione_method("as_float", [], TypeFloat) do |rec|
+      PioneFloat.new(rec.value.to_f)
+    end
+
+    define_pione_method("next", [], TypeInteger) do |rec|
+      PioneInteger.new(rec.value.next)
+    end
+
+    define_pione_method("prev", [], TypeInteger) do |rec|
+      PioneInteger.new(rec.value.pred)
+    end
+
+    define_pione_method("even?", [], TypeBoolean) do |rec|
+      PioneBoolean.new(rec.value.even?)
+    end
+
+    define_pione_method("odd?", [], TypeBoolean) do |rec|
+      PioneBoolean.new(rec.value.odd?)
+    end
+  end
+end
+
+# Integer extention for PIONE.
+class Integer
+  # Returns the PIONE's value.
+  def to_pione
+    PioneInteger.new(self)
+  end
+end

data/lib/pione/model/list.rb

@@ -0,0 +1,104 @@
+module Pione::Model
+  # PioneList is a list that include same type elements.
+  class PioneList < BasicModel
+    extend Forwardable
+
+    set_pione_model_type TypeList[TypeAny]
+
+    attr_reader :values
+    def_delegators :@values, :[], :size, :empty?
+
+    # Creates a list with elements.
+    # @param [Array] elts
+    #   elements
+    def initialize(*elts)
+      unless elts.empty?
+        if elts.find{|val| not(val.kind_of?(BasicModel))}
+          raise ArgumentError.new(elts)
+        end
+        unless elts.map{|val| val.pione_model_type}.uniq.size == 1
+          raise ArgumentError.new(elts)
+        end
+      end
+      @values = elts
+    end
+
+    # Returns pione model type corresponding to the elements.
+    # @return [TypeList]
+    #   the type
+    def pione_model_type
+      type = @values.empty? ? TypeAny : @values.first.pione_model_type
+      TypeList.new(type)
+    end
+
+    # Returns new list which appended the element.
+    # @param [BasicModel] elt
+    #   the element object
+    # @return [PioneList]
+    #   new list with the element
+    def add(elt)
+      unless elt.kind_of?(BasicModel)
+        raise ArgumentError.new(elt)
+      end
+      unless pione_model_type == elt.pione_model_type
+        raise ArgumentError.new(elt)
+      end
+      self.class.new(@values + [elt])
+    end
+
+
+    # @api private
+    def textize
+      "[%s]" % @values.map{|val| val.textize}.join(",")
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @values == other.values
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @value.hash
+    end
+
+    #
+    # pione method
+    #
+
+    define_pione_method("==", [TypeList[TypeAny]], TypeBoolean) do |rec, other|
+      PioneBoolean.new(rec.values == other.values)
+    end
+
+    define_pione_method("!=", [TypeList[TypeAny]], TypeBoolean) do |rec, other|
+      PioneBoolean.not(rec.call_pione_method("==", other))
+    end
+
+    define_pione_method("+", [TypeList[TypeAny]], TypeList[TypeAny]) do |rec, other|
+      PioneList.new(rec.values + other.values)
+    end
+
+    define_pione_method("-", [TypeList[TypeAny]], TypeList[TypeAny]) do |rec, other|
+      PioneList.new(rec.values - other.values)
+    end
+
+    define_pione_method("*", [TypeList[TypeAny]], TypeList[TypeAny]) do |rec, other|
+      PioneList.new(rec.values * other.values)
+    end
+
+    define_pione_method("empty?", [], TypeBoolean) do |rec|
+      PioneBoolean.new(rec.empty?)
+    end
+
+    define_pione_method("[]", [TypeInteger], TypeAny) do |rec, i|
+      rec.values[i.value]
+    end
+
+    define_pione_method("as_string", [], TypeString) do |rec|
+      PioneString.new(rec.values.to_s)
+    end
+  end
+end

data/lib/pione/model/message.rb

@@ -0,0 +1,80 @@
+module Pione::Model
+  # Message represents method callers for PIONE model objects.
+  # @example
+  #   1.as_string()
+  # @example
+  #   '*.txt'.except('a*')
+  class Message < BasicModel
+    attr_reader :name
+    attr_reader :receiver
+    attr_reader :arguments
+
+    # Creates a message.
+    # @param [String] name
+    #   message name
+    # @param [BasicModel] receiver
+    #   message receiver
+    # @param [BasicModel] arguments
+    #   message arguments
+    def initialize(name, receiver, *arguments)
+      @name = name
+      @receiver = receiver.to_pione
+      @arguments = arguments.map{|arg| arg.to_pione}
+      super()
+    end
+
+    # Returns false because Message is a complex form.
+    # @return [Boolean]
+    #   false
+    def atomic?
+      false
+    end
+
+    # Returns PIONE model type of the message result according to type
+    # interface.
+    # @return [Symbol]
+    #   PIONE model type
+    def pione_model_type
+      @receiver.pione_model_type.method_interface[@name.to_s].output
+    end
+
+    # Evaluates the application expression and returns application result.
+    # @param [VariableTable] vtable variable table for the evaluation
+    # @return [BasicModel]
+    #   evaluation result
+    def eval(vtable)
+      receiver = @receiver.eval(vtable)
+      arguments = @arguments.map{|arg| arg.eval(vtable)}
+      receiver.call_pione_method(@name, *arguments)
+    end
+
+    # Returns true if the receiver or arguments include variables.
+    # @return [Boolean]
+    #   true if the receiver or arguments include variables
+    def include_variable?
+      @receiver.include_variable? or @arguments.any?{|arg| arg.include_variable?}
+    end
+
+    # @api private
+    def textize
+      args = [@name, @receiver.textize, @arguments.textize]
+      "message(\"%s\",%s,[%s])" % args
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      return false unless @name == other.name
+      return false unless @receiver == other.receiver
+      return false unless @arguments == other.arguments
+      return true
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @name.hash + @receiver.hash + @arguments.hash
+    end
+  end
+end

data/lib/pione/model/package.rb

@@ -0,0 +1,48 @@
+module Pione::Model
+  # Package is a PIONE model class for rule package.
+  class Package < BasicModel
+    attr_reader :name
+    set_pione_model_type TypePackage
+
+    # Creates a package with name.
+    # @param [String] name
+    #   package name
+    def initialize(name)
+      @name = name
+      super()
+    end
+
+    # @api private
+    def task_id_string
+      "Package<#{@name}>"
+    end
+
+    # @api private
+    def textize
+      "package(\"%s\")" % [@name]
+    end
+
+    # Return a rule path.
+    # @param [RuleExpr] other
+    #   rule expression
+    # @return [String]
+    #   rule path string
+    def +(other)
+      raise ArgumentError.new(other) unless other.kind_of?(RuleExpr)
+      "#{@name}:#{other.name}"
+    end
+
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @name == other.name
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @value.hash
+    end
+  end
+end