pione 0.2.2 → 0.3.0

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

@@ -0,0 +1,86 @@
+module Pione
+  module Lang
+    # PackageExpr is an referential expression of PIONE package.
+    class PackageExpr < Piece
+      piece_type_name "PackageExpr"
+      member :name
+      member :tag
+      member :editor
+      member :package_id
+      member :parent_ids
+      member :param, default: ParameterSetSequence.new
+
+      def eval(env)
+        # get package id
+        if _package_id = package_id ? package_id : env.find_package_id_by_package_name(name)
+          # get definition
+          definition = env.package_get(set(package_id: _package_id))
+          # update package expression
+          attr = {}
+          attr[:package_id] = definition.package_id
+          attr[:parent_ids] = definition.parent_ids
+          attr[:param] = param.eval(env)
+          return set(attr)
+        else
+          return self
+        end
+      end
+    end
+
+    class PackageExprSequence < OrdinalSequence
+      pione_type TypePackageExpr
+      piece_class PackageExpr
+    end
+
+    #
+    # pione methods
+    #
+    TypePackageExpr.instance_eval do
+      # Set the editor name.
+      define_pione_method("editor", [TypeString], TypePackageExpr) do |env, rec, name|
+        rec.map {|piece| piece.set(editor: name)}
+      end
+
+      # Set the tag name.
+      define_pione_method("tag", [TypeString], TypePackageExpr) do |env, rec, name|
+        rec.map {|piece| piece.set(tag: name)}
+      end
+
+      # Set the state.
+      define_pione_method("state", [TypeString], TypePackageExpr) do |env, rec, name|
+        rec.map {|piece| piece.set(state: name)}
+      end
+
+      define_pione_method("param", [], TypeParameterSet) do |env, rec|
+        rec.fold(ParameterSetSequence.new) do |seq, rec_piece|
+          seq.set(pieces: seq.pieces + rec_piece.param.pieces)
+        end
+      end
+
+      define_pione_method("param", [TypeParameterSet], TypePackageExpr) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          _param = rec_piece.param
+          if _param.pieces.empty?
+            rec_piece.set(param: other)
+          else
+            rec_piece.set(param: _param.map {|param_piece| param_piece.set(table: param_piece.table.merge(other_piece.table))})
+          end
+        end
+      end
+
+      # Assign the package id to the variable.
+      define_deferred_pione_method("var", [TypeVariable], TypeVariable) do |env, rec, var|
+        var.set(package_id: rec.pieces.first.package_id)
+      end
+
+      # Assign the package id to the rule expression.
+      define_pione_method("rule", [TypeRuleExpr], TypeRuleExpr) do |env, rec, rule|
+        RuleExprSequence.map2(rec, rule) {|rec_piece, rule_piece| rule_piece.set(package_id: rec_piece.package_id)}
+      end
+
+      define_pione_method("Parent", [], TypePackageExpr) do |env, rec|
+        rec.set_annotation_type("Parent")
+      end
+    end
+  end
+end

data/lib/pione/lang/parameters.rb

@@ -0,0 +1,121 @@
+module Pione
+  module Lang
+    # ParameterSet is a piece class for set of actual parameters.
+    class ParameterSet < Piece
+      include Enumerable
+      member :table, default: lambda { Hash.new }
+
+      forward! Proc.new{table}, :each, :keys, :[]
+
+      # Evaluate the object with variable table.
+      def eval(env)
+        set(table: Hash[*table.map{|key, val| [key, val.eval(env)]}.flatten(1)])
+      end
+
+      # Merge values of the other parameter set.
+      def merge(other)
+        set(table: table.merge(other.table))
+      end
+
+      def filter(names)
+        set(table: table.reject{|key, _| names.include?(key)})
+      end
+
+      # Merge default values of the rule condition.
+      def merge_default_values(rule_condition)
+        tbl = Hash.new
+
+        rule_condition.param_definition.each do |key, param_definition|
+          unless keys.include?(key)
+            tbl[key] = param_definition.value
+          end
+        end
+
+        set(table: table.merge(tbl))
+      end
+
+      def textize
+        "{" + table.keys.sort.map{|k| "%s:%s" % [k, table[k].textize]}.join(", ") + "}"
+      end
+
+      # Expand parameter value sequences.
+      def expand
+        if block_given?
+          array = table.map do |k, v|
+            [k, (v.respond_to?(:each) and v.distribution == :each) ? v.each : v]
+          end
+          find_atomic_composites(array, Hash.new) do |t|
+            yield set(table: t.inject(Hash.new){|h, (k, v)| h.merge(k => v)})
+          end
+        else
+          Enumerator.new(self, :expand)
+        end
+      end
+
+      # Find atomic parameters recursively.
+      def find_atomic_composites(array, table, &b)
+        # end recursion
+        return b.call(table) if array.empty?
+
+        # find atomic composites
+        key, enum = array.first
+        tail = array.drop(1)
+        loop do
+          if enum.kind_of?(Enumerator)
+            find_atomic_composites(tail, table.merge(key => enum.next), &b)
+          else
+            find_atomic_composites(tail, table.merge(key => enum), &b)
+            raise StopIteration
+          end
+        end
+        enum.rewind if enum.kind_of?(Enumerator)
+      end
+
+      def to_json(*args)
+        table.to_json(*args)
+      end
+
+      def ==(other)
+        return false unless other.kind_of?(self.class)
+        table == other.table
+      end
+      alias :eql? :"=="
+    end
+
+    class ParameterSetSequence < OrdinalSequence
+      pione_type TypeParameterSet
+      piece_class ParameterSet
+
+      def each
+        if block_given?
+          pieces.each {|piece| piece.each {|pset| yield set(pieces: [pset])}}
+        else
+          Enumerator.new(self, :each)
+        end
+      end
+
+      def merge(other)
+        if pieces.empty?
+          set(pieces: other.pieces)
+        else
+          map2(other) do |rec_piece, other_piece|
+            rec_piece.set(table: rec_piece.table.merge(other_piece.table))
+          end
+        end
+      end
+    end
+
+    TypeParameterSet.instance_eval do
+      # Compound parameters.
+      define_deferred_pione_method("+", [TypeParameterSet], TypeParameterSet) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.set(table: rec_piece.table.merge(other_piece.table))
+        end
+      end
+
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        StringSequece.of(rec.textize)
+      end
+    end
+  end
+end

data/lib/pione/lang/piece.rb

@@ -0,0 +1,42 @@
+module Pione
+  module Lang
+    # Piece is a base class for all elements of sequence. You cannot write it
+    # directly in PIONE language because pieces are not included in expressions.
+    class Piece < StructX
+      include Util::Positionable
+      immutable true
+
+      # Declare the type name of piece.
+      def self.piece_type_name(name=nil)
+        name ? @piece_type_name = name : @piece_type_name
+      end
+
+      forward :class, :piece_type_name
+
+      def eval(env)
+        return self
+      end
+
+      # Convert to text string.
+      def textize
+        args = to_h.map do |key, val|
+          "%s=%s" % [key, val.kind_of?(Piece) ? val.textize : val.to_s]
+        end.join(", ")
+        "#%s{%s}" % [piece_type_name, args]
+      end
+    end
+
+    # SimplePiece is a piece of sequence that has single value elements.
+    class SimplePiece < Piece
+      member :value
+
+      def textize
+        "#%s{value=%s}" % [piece_type_name, value.textize]
+      end
+
+      def inspect
+        "#%s{value=%s}" % [piece_type_name, value.to_s]
+      end
+    end
+  end
+end

data/lib/pione/{model → lang}/pione-method.rb

@@ -1,5 +1,5 @@
 module Pione
-  module Model
+  module Lang
     # MethodInterfaceError is a exception for method interface mismatching.
     class MethodInterfaceError < StandardError
       attr_reader :kind
@@ -30,37 +30,23 @@ module Pione
     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
+    class PioneMethod < StructX
+      member :method_type
+      member :name
+      member :inputs
+      member :output
+      member :body
 
       # Call the method with recevier and arguemnts.
-      #
-      # @param receiver [BasicModel]
-      #   receiver object
-      # @param args [Array<BasicModel>]
-      #   arguments
-      # @return [BasicModel]
-      #   the result
-      def call(vtable, receiver, *args)
-        output = receiver.pione_model_type.instance_exec(vtable, receiver, *args, &@body)
-        validate_output(receiver, output)
-        return output
+      def call(env, receiver, args)
+        _output = receiver.pione_type.instance_exec(env, receiver, *args, &body)
+        if _output.nil?
+          p self
+          p receiver
+          p args
+        end
+        validate_output(receiver, _output)
+        return _output
       end
 
       # Validate inputs data types for the method.
@@ -71,13 +57,13 @@ module Pione
       #   arguments
       # @return [Boolean]
       #   true if input data are valid
-      def validate_inputs(receiver, *args)
+      def validate_inputs(rec, args)
         # check size
-        return false unless @inputs.size == args.size
+        return false unless inputs.size == args.size
 
         # check type
-        @inputs.each_with_index do |input, i|
-          input = get_type(input, receiver)
+        inputs.each_with_index do |input, i|
+          input = get_type(input, rec)
           unless input.match(args[i])
             return false
           end
@@ -86,49 +72,26 @@ module Pione
       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])
+        _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)}
+        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)
+        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
@@ -136,7 +99,7 @@ module Pione
         when :element_type
           receiver.element_type
         when :receiver_type
-          receiver.pione_model_type
+          receiver.pione_type
         else
           type
         end

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

@@ -0,0 +1,70 @@
+module Pione
+  module Lang
+    # RuleExpr is a referential expression of rule definition that consists of
+    # rule name and pakcage id.
+    class RuleExpr < Piece
+      piece_type_name "RuleExpr"
+      member :name
+      member :package_id
+      member :param_sets, default: ParameterSetSequence.of(ParameterSet.new)
+      member :input_tickets, default: TicketExprSequence.new
+      member :output_tickets, default: TicketExprSequence.new
+    end
+
+    # RuleExprSequence is a ordinal sequence of rule expressions.
+    class RuleExprSequence < OrdinalSequence
+      pione_type TypeRuleExpr
+      piece_class RuleExpr
+    end
+
+    TypeRuleExpr.instance_eval do
+      # Set parameters.
+      define_pione_method("param", [TypeParameterSet], TypeRuleExpr) do |env, rec, param|
+        # evaluate arguments
+        _param = param.eval(env)
+
+        # update pieces with new parameters
+        rec.map {|piece| piece.set(param_sets: _param)}
+      end
+
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        StringSequence.map(rec) {|piece| piece.textize}
+      end
+
+      define_pione_method("input_tickets", [], TypeTicketExpr) do |env, rec|
+        tickets = rec.pieces.map {|piece| piece.input_tickets}
+        tickets.inject {|res, t| res + t}
+      end
+
+      define_pione_method("output_tickets", [], TypeTicketExpr) do |env, rec|
+        tickets = rec.pieces.map {|piece| piece.output_tickets}
+        tickets.inject {|res, t| res + t}
+      end
+
+      # Update ticket condition of receiver by the ticket.
+      define_pione_method("==>", [TypeTicketExpr], TypeRuleExpr) do |env, rec, tickets|
+        # setup ticket conditions
+        rec.map do |piece|
+          piece.set(output_tickets: piece.output_tickets + tickets)
+        end
+      end
+
+      # Update ticket condtion of receiver and other by anonymous ticket.
+      define_pione_method(">>>", [TypeRuleExpr], TypeRuleExpr) do |env, rec, other|
+        # create an anonymous ticket
+        tickets = TicketExprSequence.of(Util::UUID.generate)
+
+        # setup ticket conditions
+        left = rec.map do |rec_piece|
+          rec_piece.set(output_tickets: rec_piece.output_tickets + tickets)
+        end
+        right = other.map do |other_piece|
+          other_piece.set(input_tickets: other_piece.input_tickets + tickets)
+        end
+
+        # concat sequence
+        left + right
+      end
+    end
+  end
+end