pione 0.3.0 → 0.3.1

data/lib/pione/rule-engine/engine-exception.rb

@@ -16,6 +16,17 @@ module Pione
       end
     end
 
+    class ActionError < StandardError
+      def initialize(digest, report)
+        @digest = digest
+        @report = report
+      end
+
+      def message
+        "Action rule %s has errored:\n%s" % [@digest, @report]
+      end
+    end
+
     class InvalidOutputError < RuleExecutionError
       def initialize(handler, outputs)
         super(handler)

data/lib/pione/rule-engine/flow-handler.rb

@@ -171,6 +171,7 @@ module Pione
       def initialize(handler)
         super(handler)
         @data_finder = DataFinder.new(tuple_space_server, domain_id)
+        @finished = [] # finished tuple cache
       end
 
       # Apply input data to rules.
@@ -178,9 +179,12 @@ module Pione
         # start message
         user_message_begin("Rule Application: %s" % digest, 1)
 
-        # rule application loop
-        while tasks = find_tasks(rules) do
-          distribute_tasks(tasks)
+        # with profile
+        Util::Profiler.profile(Util::RuleApplicationProfileReport.new(digest)) do
+          # rule application loop
+          while tasks = find_tasks(rules) do
+            distribute_tasks(tasks)
+          end
         end
 
         # end message
@@ -337,9 +341,9 @@ module Pione
           # setup output variables
           var_o = Lang::Variable.new("O")
           task.env.variable_set(Lang::Variable.new("OUTPUT"), var_o)
-          o = find_output_variables(task, inputs, Lang::KeyedSequence.new)
-          task.env.variable_set(var_o, o)
-          param_set = param_set.set(table: param_set.table.merge({"O" => o}))
+          kseq = find_output_variables(task, Lang::KeyedSequence.new)
+          task.env.variable_set(var_o, kseq)
+          param_set = param_set.set(table: param_set.table.merge({"O" => kseq}))
 
           return task.set(order: order, env: env, param_set: param_set)
         else
@@ -347,17 +351,17 @@ module Pione
         end
       end
 
-      def find_output_variables(task, inputs, o)
-        _o = o
+      def find_output_variables(task, kseq)
+        _kseq = kseq
         task.rule_condition.outputs.each_with_index do |condition, i|
           begin
             data = condition.eval(task.env)
-            _o = o.put(Lang::IntegerSequence.of(i+1), data)
+            _kseq = _kseq.put(Lang::IntegerSequence.of(i+1), data)
           rescue Lang::UnboundError
             next
           end
         end
-        return _o
+        return _kseq
       end
 
       # Distribute tasks.
@@ -410,7 +414,12 @@ module Pione
       def need_to_publish_task?(task, tuple)
         # reuse task finished result if order is weak update
         if task.order == :weak
-          if read!(TupleSpace::FinishedTuple.new(domain: task.domain_id, status: :succeeded))
+          template = TupleSpace::FinishedTuple.new(domain: task.domain_id, status: :succeeded)
+          if @finished.include?(template)
+            return false
+          end
+          if finished = read!(template)
+            @finished << finished
             return false
           end
         end

data/lib/pione/system.rb

@@ -5,10 +5,10 @@ end
 
 require 'pione/system/object'
 require 'pione/system/common'
-require 'pione/system/config'
 require 'pione/system/init'
 require 'pione/system/file-cache'
 require 'pione/system/domain-info'
+require 'pione/system/status'
 
 # export some classes to the name space of Pione
 Pione.module_exec {const_set(:PioneObject, Pione::System::PioneObject)}

data/lib/pione/system/file-cache.rb

@@ -135,7 +135,7 @@ module Pione
         def get(location)
           # cache if record doesn't exist
           unless @table.has_key?(location)
-            cache_location = Location[Temppath.create(basedir: @tmpdir)]
+            cache_location = Location[Global.file_cache_path_generator.create]
             location.turn(cache_location)
             @table[location] = cache_location
           end

data/lib/pione/system/init.rb

@@ -5,27 +5,25 @@ module Pione
         # turn on "abort on exception" mode
         Thread.abort_on_exception = true
 
-        # load configration file
-        System::Config.load(Global.config_path)
+        # load configration file for global system
+        Global::Config.load(Global.config_path)
 
         # make temporary directories
-        unless Global.temporary_directory_root.exist?
-          Global.temporary_directory_root.mkdir(0777)
-        end
         unless Global.temporary_directory.exist?
-          Global.temporary_directory.mkdir(0700)
-        end
-        unless Global.working_directory_root.exist?
-          Global.working_directory_root.mkdir(0777)
+          Global.temporary_directory.mkdir(0777)
         end
-        unless Global.working_directory.exist?
-          Global.working_directory.mkdir(0700)
-        end
-        unless Global.file_cache_directory_root.exist?
-          Global.file_cache_directory_root.mkdir(0777)
+
+        # setup default temporary path generator
+        Temppath.update_basedir(Global.my_temporary_directory + "others_%s" % Util::UUID.generate)
+
+        # make file cache directory
+        unless Global.file_cache_directory.exist?
+          Global.file_cache_directory.mkdir(0777)
         end
+
+        # make my file cache directory
         unless Global.file_cache_directory.exist?
-          Global.file_cache_directory.mkdir(0700)
+          Global.file_cache_directory.mkdir(0777)
         end
       end
     end

data/lib/pione/system/status.rb

@@ -0,0 +1,30 @@
+module Pione
+  module System
+    class Status
+      class << self
+        def success
+          new(:success)
+        end
+
+        def error(exception)
+          new(:error, exception)
+        end
+      end
+
+      attr_reader :exception
+
+      def initialize(status, exception=nil)
+        @status = status
+        @exception = exception
+      end
+
+      def success?
+        @status == :success
+      end
+
+      def error?
+        @status == :error
+      end
+    end
+  end
+end

data/lib/pione/system/system-exception.rb

@@ -1,29 +1,5 @@
 module Pione
   module System
     class SystemException < StandardError; end
-
-    # This exception class is raised when configuration file is in invalid format.
-    class InvalidConfigFile < SystemException
-      # config file path
-      attr_reader :path
-
-      def initialize(path)
-        @path = path
-      end
-
-      def message
-        "invalid format configuration file: %s" % @path
-      end
-    end
-
-    class UnconfigurableVariableError < SystemException
-      def initialize(name)
-        @name = name
-      end
-
-      def message
-        "global variable \"%s\" is unconfigurable." % @name
-      end
-    end
   end
 end

data/lib/pione/test-helper.rb

@@ -15,7 +15,14 @@ module Pione
       @scope_id = (@scope_id || 0) + 1
       mod = Module.new
       const_set("MODULE%s" % @scope_id, mod)
-      mod.instance_eval(&b)
+      mod.send(:define_method, :this) do
+        mod
+      end
+      mod.module_eval(&b)
+    end
+
+    def self.scope_of(mod)
+      eval(mod.name.split("::").reverse.drop(1).reverse.join("::"))
     end
   end
 end

data/lib/pione/test-helper/command-helper.rb

@@ -1,16 +1,21 @@
 module Pione
   module TestHelper
+    # CommandResult is a result of command execution. This has result status,
+    # stdout, stdin, and etc, so you can analyze and check it.
     class CommandResult < StructX
       member :exception
       member :stdout
       member :stderr
 
+      # Return true if the command succeeded.
       def success?
         exception.kind_of?(SystemExit) and exception.success?
       end
 
+      # Print the command result report.
       def report
         unless success?
+          puts "[FAIL]"
           puts "ERROR: %s" % exception.message
           exception.backtrace.each do |line|
             puts "TRACE: %s" % line
@@ -23,40 +28,62 @@ module Pione
             puts "STDERR:"
             puts stderr.string[0..100]
           end
+        else
+          puts "[SUCCESS]"
         end
       end
     end
 
+    # This module helps tests of command execution.
     module Command
       class << self
-        def execute(&b)
+        # Run the action with expectation command execution succeeds.
+        def succeed(*options, &b)
+          res = execute(options, &b)
+          res.should.success
+          return res
+        end
+
+        # Run the action with expectation command execution fails.
+        def fail(*options, &b)
+          res = execute(options, &b)
+          res.should.not.success
+          return res
+        end
+
+        private
+
+        # Run the command execution action.
+        def execute(options, &b)
           # initialize exit status
           Global.exit_status = true
 
           # make result
           res = CommandResult.new(stdout: StringIO.new("", "w"), stderr: StringIO.new("", "w"))
-          $stdout = res.stdout
-          $stderr = res.stderr
+
+          # setup stdout and stderr
+          $stdout = res.stdout unless options.include?(:show) or options.include?(:show_stdout)
+          $stderr = res.stderr unless options.include?(:show) or options.include?(:show_stderr)
+
+          # run the action
           begin
             b.call
           rescue Object => e
-            res.exception = e
+            unless options.include?(:show_exception)
+              res.exception = e
+            else
+              raise
+            end
           end
+
+          # revert stdout and stderr
           $stdout = STDOUT
           $stderr = STDERR
-          return res
-        end
 
-        def succeed(&b)
-          res = execute(&b)
-          res.report
-          res.should.success
-          return res
-        end
+          if options.include?(:report)
+            res.report
+          end
 
-        def fail(&b)
-          res = execute(&b)
-          res.should.not.success
           return res
         end
       end

data/lib/pione/util.rb

@@ -23,4 +23,5 @@ require 'pione/util/positionable'            # source position handler
 require 'pione/util/embeded-expr-expander'   # expand text embeded PIONE expression
 require 'pione/util/free-thread-generator'   # generate threads free from thread group
 require 'pione/util/parslet-extension'       # parslet extension
+require 'pione/util/pnml-compiler'           # toy compiler from PNML to PIONE
 

data/lib/pione/util/embeded-expr-expander.rb

@@ -6,17 +6,11 @@ module Pione
         return nil if str.nil?
 
         # parse and transform
-        tree = Lang::InterpolatorParser.new.parse(str)
-        list = Lang::InterpolatorTransformer.new.apply(tree, {package_name: nil, filename: nil})
-
-        # evaluate and join
-        list.map do |elt|
-          if elt.is_a?(String)
-            elt
-          else
-            elt.eval(env).call_pione_method(env, "textize", []).value
-          end
-        end.join("")
+        str.gsub(/\{(\$.+?)\}|\<\?\s*(.+?)\s*\?>/) do
+          tree = Lang::DocumentParser.new.expr.parse($1 || $2)
+          expr = Lang::DocumentTransformer.new.apply(tree, {package_name: nil, filename: nil})
+          expr.eval(env).call_pione_method(env, "textize", []).value
+        end
       end
     end
   end

data/lib/pione/util/pnml-compiler.rb

@@ -0,0 +1,97 @@
+module Pione
+  module Util
+    class PNMLCompiler
+      def initialize(src)
+        @src = src
+      end
+
+      # Compile PNML file into PIONE document as a string.
+      def compile
+        doc = REXML::Document.new(@src.read)
+        rule_table = make_rule_table(doc)
+        io_table = make_io_table(doc)
+        input_table = make_input_table(doc, rule_table, io_table)
+        output_table = make_output_table(doc, rule_table, io_table)
+        rules = make_flow_rules(rule_table, input_table, output_table)
+        return textize_flow_rules(rules)
+      end
+
+      private
+
+      # Make rule mapping table by collecting transitions and associating with its id and name.
+      def make_rule_table(doc)
+        rule_table = Hash.new
+        REXML::XPath.each(doc, "/pnml/net/transition") do |elt|
+          id = elt.attribute("id").value
+          name = REXML::XPath.first(elt, "name/text").texts.map{|text| text.value}.join("")
+          rule_table[id] = name
+        end
+        return rule_table
+      end
+
+      # Make input and output mapping table by collecting places and associating its id and name.
+      def make_io_table(doc)
+        io_table = Hash.new {|h, k| h[k] = []}
+        REXML::XPath.each(doc, "/pnml/net/place") do |elt|
+          id = elt.attribute("id").value
+          name = REXML::XPath.first(elt, "name/text").texts.map{|text| text.value}.join("")
+          io_table[id] << name
+        end
+        return io_table
+      end
+
+      # Make rule's input table by collecting arcs and associating its source and target.
+      def make_input_table(doc, rule_table, io_table)
+        input_table = Hash.new {|h, k| h[k] = []}
+        REXML::XPath.each(doc, "/pnml/net/arc") do |elt|
+          source = elt.attribute("source").value
+          target = elt.attribute("target").value
+          name = REXML::XPath.first(elt, "inscription/text").texts.map{|text| text.value}.join("")
+          input_table[rule_table[target]] << io_table[source]
+        end
+        return input_table
+      end
+
+      # Make rule's output table by collecting arcs and associating its source and target.
+      def make_output_table(doc, rule_table, io_table)
+        output_table = Hash.new {|h, k| h[k] = []}
+        REXML::XPath.each(doc, "/pnml/net/arc") do |elt|
+          source = elt.attribute("source").value
+          target = elt.attribute("target").value
+          name = REXML::XPath.first(elt, "inscription/text").texts.map{|text| text.value}.join("")
+          output_table[rule_table[source]] << io_table[target]
+        end
+        return output_table
+      end
+
+      # Make flow rules from rule table, input table, and output table.
+      def make_flow_rules(rule_table, input_table, output_table)
+        rules = Array.new
+        rule_table.each do |key, rule_name|
+          inputs = input_table[rule_name]
+          outputs = output_table[rule_name]
+          rules << [rule_name, inputs, outputs]
+        end
+        return rules.sort {|a, b| a.first <=> b.first}
+      end
+
+      FLOW_RULE_TEMPLATE = <<-RULE
+        Rule %s
+          %s
+          %s
+        Action
+          cp {$I[1]} {$O[1]}
+        End
+      RULE
+
+      # Textize flow rules.
+      def textize_flow_rules(rules)
+        rules.map do |rule|
+          inputs = rule[1].map {|name| "input '%s'" % name}.join("\n  ")
+          outputs = rule[2].map {|name| "output '%s'" % name}.join("\n  ")
+          Indentation.cut(FLOW_RULE_TEMPLATE) % [rule[0], inputs, outputs]
+        end.join("\n\n")
+      end
+    end
+  end
+end