pione 0.1.3 → 0.1.4

data/lib/pione/model/parameters.rb

@@ -1,7 +1,10 @@
 module Pione
   module Model
     # Parameters is a PIONE mode class for parameters.
-    class Parameters < BasicModel
+    class Parameters < Callable
+      set_pione_model_type TypeParameters
+      include Enumerable
+
       # InvalidParameter is raised when you specify invalid parameter.
       class InvalidParameter < TypeError
         # Create a error.
@@ -59,7 +62,6 @@ module Pione
       end
 
       attr_reader :data
-      set_pione_model_type TypeParameters
 
       # Create a parameters object.
       #
@@ -158,7 +160,7 @@ module Pione
       # @return [Parameters]
       #   new parameters with the parameter
       def set_safety(name, value)
-        if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
+        if not(@data.has_key?(name)) or @data[name].void?
           set(name, value)
         end
       end
@@ -171,7 +173,7 @@ module Pione
       #   value
       # @return [void]
       def set_safety!(name, value)
-        if not(@data.has_key?(name)) or @data[name].kind_of?(UndefinedValue)
+        if not(@data.has_key?(name)) or @data[name].void?
           set!(name, value)
         end
       end
@@ -208,7 +210,7 @@ module Pione
         when Parameters
           self.class.new(@data.merge(other.data))
         when Variable
-          self.class.new(@data.merge({other => UndefinedValue.new}))
+          self.class.new(@data.merge({other => Sequence.void}))
         when Assignment
           self.class.new(@data.merge({other.variable => other.expr}))
         else
@@ -226,7 +228,7 @@ module Pione
         when Parameters
           @data.merge!(other.data)
         when Variable
-          @data.merge!({other => UndefinedValue.new})
+          @data.merge!({other => Sequence.void})
         when Assignment
           @data.merge!({other.variable => other.expr})
         else
@@ -250,6 +252,47 @@ module Pione
         @data.keys.sort
       end
 
+      # Expand parameter value sequences.
+      #
+      # @yield [Parameters]
+      #   sequences expanded parameters
+      # @return [void]
+      def each
+        array = @data.map do |k, v|
+          [k, (v.respond_to?(:each) and v.each?) ? v.each : v]
+        end
+        find_atomic_parameters_rec(array, Hamster.hash) do |table|
+          yield Parameters.new(table.reduce(Hash.new){|h, k, v| h[k] = v; h})
+        end
+      end
+
+      # Find atomic parameters recursively.
+      #
+      # @param array [Array]
+      #   key and value associated list
+      # @param table [Hamster::Hash]
+      #   immutable hash table
+      # @param b [Proc]
+      #   the process executes when atomic parameters found
+      # @return [void]
+      def find_atomic_parameters_rec(array, table, &b)
+        if array.empty?
+          b.call(table)
+        else
+          key, enum = array.first
+          tail = array.drop(1)
+          loop do
+            if enum.kind_of?(Enumerator)
+              find_atomic_parameters_rec(tail, table.put(key, enum.next), &b)
+            else
+              find_atomic_parameters_rec(tail, table.put(key, enum), &b)
+              raise StopIteration
+            end
+          end
+          enum.rewind if enum.kind_of?(Enumerator)
+        end
+      end
+
       # @api private
       def string_form
         "{" + @data.map{|k,v| "#{k}: #{v}"}.join(", ") + "}"
@@ -274,6 +317,11 @@ module Pione
       end
     end
 
+    # class ParametersSequence < Sequence
+    #   set_pione_model_type TypeParameters
+    #   set_element_class Parameters
+    # end
+
     TypeParameters.instance_eval do
       define_pione_method('==', [TypeParameters], TypeBoolean) do |rec, other|
         PioneBoolean.new(rec.data == other.data)
@@ -283,17 +331,17 @@ module Pione
         PioneBoolean.not(rec.call_pione_method("==", other))
       end
 
-      define_pione_method("[]", [TypeString], TypeAny) do |rec, name|
+      define_pione_method("[]", [TypeString], TypeSequence) do |rec, name|
         rec.get(Variable.new(name.value))
       end
 
-      define_pione_method("get", [TypeString], TypeAny) do |rec, name|
+      define_pione_method("get", [TypeString], TypeSequence) do |rec, name|
         rec.get(Variable.new(name.value))
       end
 
       define_pione_method(
         "set",
-        [TypeString, TypeAny],
+        [TypeString, TypeSequence],
         TypeParameters
       ) do |rec, name, val|
         rec.set(Variable.new(name.value), val)
@@ -306,6 +354,10 @@ module Pione
       define_pione_method("as_string", [], TypeString) do |rec|
         PioneString.new(rec.string_form)
       end
+
+      define_pione_method("str", [], TypeString) do |rec|
+        rec.call_pione_method("as_string")
+      end
     end
   end
 end

data/lib/pione/model/pione-method.rb

@@ -0,0 +1,146 @@
+module Pione
+  module Model
+    # MethodInterfaceError is a exception for method interface mismatching.
+    class MethodInterfaceError < StandardError
+      attr_reader :kind
+      attr_reader :name
+      attr_reader :types
+      attr_reader :values
+
+      # @param kind [Symbol]
+      #   :input or :output
+      # @param name [String]
+      #   method name
+      # @param types [Array<Type>]
+      #   expected types
+      # @param values [Array<BasicModel>]
+      #   values
+      def initialize(kind, name, types, values)
+        @kind = kind
+        @name = name
+        @types = types
+        @values = values
+      end
+
+      def message
+        types = @types.map{|type| type}.join(" -> ")
+        values = @values.map{|value| value.inspect}.join(" -> ")
+        '"%s" expected %s but got %s' % [@name, types, values]
+      end
+    end
+
+    # PioneMethod is a class represents method in PIONE system.
+    class PioneMethod < Pione::PioneObject
+      attr_reader :name
+      attr_reader :inputs
+      attr_reader :output
+      attr_reader :body
+
+      # @param name [String]
+      #   method name
+      # @param inputs [Array<Type>]
+      #   input types
+      # @param output [Type]
+      #   ouutput types
+      def initialize(name, inputs, output, body)
+        @name = name
+        @inputs = inputs
+        @output = output
+        @body = body
+      end
+
+      # Call the method with recevier and arguemnts.
+      #
+      # @param receiver [BasicModel]
+      #   receiver object
+      # @param args [Array<BasicModel>]
+      #   arguments
+      # @return [BasicModel]
+      #   the result
+      def call(receiver, *args)
+        output = receiver.pione_model_type.instance_exec(receiver, *args, &@body)
+        validate_output(receiver, output)
+        return output
+      end
+
+      # Validate inputs data types for the method.
+      #
+      # @param receiver_type [Type]
+      #   receiver type
+      # @param args [Array<Object>]
+      #   arguments
+      # @return [Boolean]
+      #   true if input data are valid
+      def validate_inputs(receiver, *args)
+        # check size
+        return false unless @inputs.size == args.size
+
+        # check type
+        @inputs.each_with_index do |input, i|
+          input = get_type(input, receiver)
+          unless input.match(args[i])
+            return false
+          end
+        end
+        return true
+      end
+
+      # Validate output data type for the method.
+      #
+      # @param receiver_type [Type]
+      #   recevier type
+      # @param value [BasicModel]
+      #   output value
+      # @return [void]
+      def validate_output(receiver, value)
+        output = get_type(@output, receiver)
+        unless output.match(value)
+          raise MethodInterfaceError.new(:output, @name, [output], [value])
+        end
+      end
+
+      # Get the input types of receiver.
+      #
+      # @param receiver [Callable]
+      #   receiver
+      # @return [Type]
+      #   input types
+      def get_input_types(receiver)
+        @inputs.map{|input| get_type(input, receiver)}
+      end
+
+      # Get the output type of receiver.
+      #
+      # @param receiver [Callable]
+      #   receiver
+      # @return [Type]
+      #   output type
+      def get_output_type(receiver)
+        get_type(@output, receiver)
+      end
+
+      private
+
+      # Get a type object.
+      #
+      # @param type [Type, Symbol]
+      #   type object or special type symbol
+      # @param receiver [BasicModel]
+      #   receiver
+      # @return [Type]
+      #   type
+      def get_type(type, receiver)
+        case type
+        when :index_type
+          receiver.index_type
+        when :element_type
+          receiver.element_type
+        when :receiver_type
+          receiver.pione_model_type
+        else
+          type
+        end
+      end
+    end
+  end
+end

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

@@ -1,14 +1,22 @@
 module Pione
   module Model
     # Rule representation in the flow element context.
-    class RuleExpr < BasicModel
+    class RuleExpr < Callable
       set_pione_model_type TypeRuleExpr
 
+      # @return [String]
+      #   package name
       attr_reader :package
+
+      # @return [String]
+      #   rule name
       attr_reader :name
-      attr_reader :params
-      attr_reader :input_ticket_expr
-      attr_reader :output_ticket_expr
+
+      # @return [Hash]
+      #   attributes of the rule expression
+      attr_reader :attributes
+
+      forward_as_key! :@attributes, :params, :input_ticket_expr, :output_ticket_expr
 
       # Create a rule expression.
       #
@@ -16,18 +24,21 @@ module Pione
       #   package name
       # @param name [String]
       #   rule name
-      # @param params [Parameters]
-      #   parameters
-      # @param input_ticket_expr [TicketExpr]
+      # @param attributes [Hash]
+      #   attributes of the expression
+      # @option attributes [Model::Parameters] :params
+      #   rule parameters
+      # @option attributes [Model::TicketExpr] :input_ticket_expr
       #   input ticket condition
-      # @param output_ticket_expr [TicketExpr]
+      # @option attributes [Model::TicketExpr] :output_ticket_expr
       #   output ticket condition
-      def initialize(package, name, params, input_ticket_expr, output_ticket_expr)
+      def initialize(package, name, attributes={})
         @package = package
         @name = name
-        @params = params
-        @input_ticket_expr = input_ticket_expr
-        @output_ticket_expr = output_ticket_expr
+        @attributes = {}
+        @attributes[:params] = attributes[:params] || Model::Parameters.empty
+        @attributes[:input_ticket_expr] = attributes[:input_ticket_expr] || Model::TicketExprSequence.empty
+        @attributes[:output_ticket_expr] = attributes[:output_ticket_expr] || Model::TicketExprSequence.empty
         super()
       end
 
@@ -63,7 +74,8 @@ module Pione
       # @return [RuleExpr]
       #   new rule expression
       def add_input_ticket_expr(ticket_expr)
-        return self.class.new(@package, @name, @params, @input_ticket_expr + ticket_expr, @output_ticket_expr)
+        new_attributes = @attributes.merge(input_ticket_expr: @attributes[:input_ticket_expr].concat(ticket_expr))
+        return self.class.new(@package, @name, new_attributes)
       end
 
       # Create a new rule expression with adding the ticket expression as output
@@ -74,7 +86,8 @@ module Pione
       # @return [RuleExpr]
       #   new rule expression
       def add_output_ticket_expr(ticket_expr)
-        return self.class.new(@package, @name, @params, @input_ticket_expr, @output_ticket_expr + ticket_expr)
+        new_attributes = @attributes.merge(output_ticket_expr: @attributes[:output_ticket_expr].concat(ticket_expr))
+        return self.class.new(@package, @name, new_attributes)
       end
 
       # Sets a package name and returns a new expression.
@@ -84,7 +97,7 @@ module Pione
       # @return [RuleExpr]
       #   new rule expression with the package name
       def set_package(package)
-        return self.class.new(package, @name, @params, @input_ticket_expr, @output_ticket_expr)
+        return self.class.new(package, @name, @attributes)
       end
 
       # Set parameters and returns a new expression.
@@ -94,23 +107,19 @@ module Pione
       # @return [RuleExpr]
       #   new rule expression with the parameters
       def set_params(params)
-        return self.class.new(@package, @name, params, @input_ticket_expr, @output_ticket_expr)
+        new_attributes = @attributes.merge(params: params)
+        return self.class.new(@package, @name, new_attributes)
       end
 
       # Evaluate the object with the variable table.
       #
       # @param vtable [VariableTable]
       #   variable table for evaluation
-      # @return [BasicModel]
+      # @return [RuleExpr]
       #   evaluation result
       def eval(vtable)
-        return self.class.new(
-          @package.eval(vtable),
-          @name,
-          @params.eval(vtable),
-          @input_ticket_expr.eval(vtable),
-          @output_ticket_expr.eval(vtable)
-        )
+        new_attributes = Hash[@attributes.map{|key, val| [key, val.eval(vtable)]}]
+        return self.class.new(@package.eval(vtable), @name, new_attributes)
       end
 
       # Return true if the package or parameters include variables.
@@ -118,11 +127,7 @@ module Pione
       # @return [Boolean]
       #   true if the package or parameters include variables
       def include_variable?
-        [ @package.include_variable?,
-          @params.include_variable?,
-          @input_ticket_expr.include_variable?,
-          @output_ticket_expr.include_variable?
-        ].any?
+        @package.include_variable? or @attributes.values.any?{|val| val.include_variable?}
       end
 
       # @api private
@@ -130,14 +135,14 @@ module Pione
         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 false unless @attributes == other.attributes
         return true
       end
       alias :eql? :"=="
 
       # @api private
       def hash
-        @package.hash + @name.hash + @params.hash
+        @package.hash + @name.hash + @attributes.hash
       end
 
       # Return a set that contains self as a single element.
@@ -215,16 +220,17 @@ module Pione
       end
     end
 
+    class RuleExprSequence < Sequence
+      set_pione_model_type TypeRuleExpr
+    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))
+          rec.params == other.params
+        ).to_seq
       end
 
       define_pione_method("params", [TypeParameters], TypeRuleExpr) do |rec, params|
@@ -232,7 +238,7 @@ module Pione
       end
 
       define_pione_method("as_string", [], TypeString) do |rec|
-        PioneString.new(rec.name)
+        PioneString.new(rec.name).to_seq
       end
 
       define_pione_method("==>", [TypeTicketExpr], TypeRuleExpr) do |rec, ticket_expr|
@@ -240,7 +246,7 @@ module Pione
       end
 
       define_pione_method(">>>", [TypeRuleExpr], TypeRuleExpr) do |rec, other|
-        ticket_expr = TicketExpr.new([rec.path])
+        ticket_expr = TicketExpr.new(rec.path).to_seq
         left = rec.add_output_ticket_expr(ticket_expr)
         right = other.add_input_ticket_expr(ticket_expr)
         CompositionalRuleExpr.new(left, right)

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

@@ -64,13 +64,17 @@ module Pione
         rec.call_pione_method("match")
       end
 
-      define_pione_method("[]", [TypeInteger], TypeAny) do |rec, i|
-        rec.match[i.value-1]
+      define_pione_method("[]", [TypeInteger], TypeSequence) do |rec, i|
+        rec.match[i.value]
       end
 
       define_pione_method("as_string", [], TypeString) do |rec|
         rec.name
       end
+
+      define_pione_method("str", [], TypeString) do |rec|
+        rec.call_pione_method("as_string")
+      end
     end
 
     # RuleIOList is a input or output list for RuleIOElement.
@@ -146,7 +150,7 @@ module Pione
         PioneBoolean.not(rec.call_pione_method("==", other))
       end
 
-      define_pione_method("[]", [TypeInteger], TypeAny) do |rec, i|
+      define_pione_method("[]", [TypeInteger], TypeSequence) do |rec, i|
         rec.elements[i.value-1]
       end
 
@@ -165,6 +169,10 @@ module Pione
           }.join(DataExpr::SEPARATOR)
         )
       end
+
+      define_pione_method("str", [], TypeString) do |rec|
+        rec.call_pione_method("as_string")
+      end
     end
   end
 end