pione 0.3.2 → 0.4.0

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

@@ -0,0 +1,23 @@
+module Pione
+  module PNML
+    # `AmbiguousNetQueryResult` is an exception that raised when reuslt of net
+    # query is ambigous unexpectedly.
+    class AmbiguousNetQueryResult < StandardError
+      # @param name [String]
+      #   net query method name
+      # @param query [Object]
+      #   the query
+      # @param result [Object]
+      #   the result
+      def initialize(name, query, result)
+        @name = name
+        @query = query
+        @result = result
+      end
+
+      def message
+        "The result of net query(%s, %s) is ambiguous: %s" % [@name, @query.inspect, @result.inspect]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,368 @@
+module Pione
+  module PNML
+    # `Net` represents a net in PNML. PIONE handles PT-nets only, so this is
+    # consisted by places, transitions, and arcs.
+    class Net < StructX
+      # all places in the net
+      member :places, :default => lambda{ Array.new }
+
+      # all transitions in the net
+      member :transitions, :default => lambda{ Array.new }
+
+      # all arcs in the net
+      member :arcs, :default => lambda{ Array.new }
+
+      # Generate a new PNML's ID.
+      def generate_id
+        Util::UUID.generate
+      end
+
+      # Return true if the net is valid. The criterion of validness is that all
+      # arcs connect places and transitions.
+      #
+      # @return [Boolean]
+      #   true if the net is valid
+      def valid?
+        arcs.each do |arc|
+          source_transition = find_transition(arc.source_id)
+          source_place = find_place(arc.source_id)
+          target_transition = find_transition(arc.target_id)
+          target_place = find_place(arc.target_id)
+
+          # arc from transition to place
+          cond1 = not(source_transition.nil?) && not(target_place.nil?)
+
+          # arc from place to transition
+          cond2 = not(source_place.nil?) && not(target_transition.nil?)
+
+          unless cond1 or cond2
+            return false
+          end
+        end
+
+        return true
+      end
+
+      # Find the arc that connects from the source ID to the target ID. If no
+      # arcs found, return `nil`.
+      #
+      # @param source_id [String]
+      #   source ID
+      # @param target_id [String]
+      #   target ID
+      # @return [PNML::Arc]
+      #   the arc, or `nil`
+      def find_arc(source_id, target_id)
+        _arcs = arcs.select {|arc| arc.source_id == source_id and arc.target_id == target_id}
+
+        # the result shouldn't be ambiguous
+        if _arcs.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, place_id, _transitions)
+        end
+
+        return _arcs.first
+      end
+
+      # Find all arcs by the source ID.
+      #
+      # @param source_id [String]
+      #   source ID
+      # @return [Array<Arc>]
+      #   result arcs
+      def find_all_arcs_by_source_id(source_id)
+        arcs.select {|arc| arc.source_id == source_id}
+      end
+
+      # Find all arcs by the target ID.
+      #
+      # @param target_id [String]
+      #   target ID
+      # @return [Array<Arc>]
+      #   result arcs
+      def find_all_arcs_by_target_id(target_id)
+        arcs.select {|arc| arc.target_id == target_id}
+      end
+
+      # Return all arcs which have the direction from transtion to place.
+      #
+      # @return [Array<PNML::Arc>]
+      #   arcs
+      def tp_arcs
+        arcs.select {|arc| arc.from_transition_to_place?}
+      end
+
+      # Return all arcs which have the direction from place to transition.
+      #
+      # @return [Array<PNML::Arc>]
+      #   arcs
+      def pt_arcs
+        arcs.select {|arc| arc.from_place_to_transition?}
+      end
+
+      # Find a transition by ID.
+      #
+      # @param id [String]
+      #   transition ID
+      # @return [Transition]
+      #   transition
+      def find_transition(id)
+        transitions.find {|transition| transition.id == id}
+      end
+
+      # Find a transition by the name.
+      #
+      # @param name [String]
+      #   the transition name
+      # @return [Transition]
+      #   a transition, or nil
+      def find_transition_by_name(name)
+        _transitions = transitions.select {|transition| transition.name == name}
+
+        # the result shouldn't be ambiguous
+        if _transitions.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, place_id, _transitions)
+        end
+
+        return _transitions.first
+      end
+
+      # Find all transitions by the name.
+      #
+      # @param name [String]
+      #   transition's name
+      # @return [Array<Transition>]
+      #   transitions
+      def find_all_transitions_by_name(name)
+        transitions.select {|transition| transition.name == name}
+      end
+
+      # Find a transition by the source place ID.
+      #
+      # @param place_id [String]
+      #   place ID
+      # @return [Array<Transition>]
+      #   result transitions
+      def find_transition_by_source_id(place_id)
+        _arcs = arcs.select {|arc| arc.source_id == place_id}
+        _transitions = _arcs.map do |arc|
+          transitions.find {|transition| transition.id == arc.target_id}
+        end.compact.uniq
+
+        # the result shouldn't be ambiguous
+        if _transitions.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, place_id, _transitions)
+        end
+
+        return _transitions.first
+      end
+
+      # Find all transitions by the source place ID.
+      #
+      # @param place_id [String]
+      #   place ID
+      # @return [Array<Transition>]
+      #   result transitions
+      def find_all_transitions_by_source_id(place_id)
+        _arcs = arcs.select {|arc| arc.source_id == place_id}
+        _transitions = _arcs.map do |arc|
+          transitions.find {|transition| transition.id == arc.target_id}
+        end
+        return _transitions.compact.uniq
+      end
+
+      # Find a transition by the target place ID.
+      #
+      # @param place_id [String]
+      #   place ID
+      # @return [Array<Transition>]
+      #   result transitions
+      def find_transition_by_target_id(target_id)
+        _arcs = arcs.select {|arc| arc.target_id == target_id}
+        _transitions = _arcs.map do |arc|
+          transitions.find {|transition| transition.id == arc.source_id}
+        end.compact.uniq
+
+        # the result shouldn't be ambiguous
+        if _transitions.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, place_id, _transitions)
+        end
+
+        return _transitions.first
+      end
+
+      # Find all transitions by the target place ID.
+      #
+      # @param place_id [String]
+      #   place ID
+      # @return [Array<Transition>]
+      #   result transitions
+      def find_all_transitions_by_target_id(target_id)
+        _arcs = arcs.select {|arc| arc.target_id == target_id}
+        _transitions = _arcs.map do |arc|
+          transitions.find {|transition| transition.id == arc.source_id}
+        end
+        return _transitions.compact.uniq
+      end
+
+      # Find a place by ID.
+      #
+      # @param id [String]
+      #   the place ID
+      # @return [Place]
+      #   place
+      def find_place(id)
+        places.find {|place| place.id == id}
+      end
+
+      # Find a place by the name.
+      #
+      # @param name [String]
+      #   the place name
+      # @return [Place]
+      #   a place, or nil
+      def find_place_by_name(name)
+        _places = places.select {|place| place.name == name}
+
+        # the result shouldn't be ambiguous
+        if _places.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, name, _places)
+        end
+
+        return _places.first
+      end
+
+      # Find places by the name.
+      #
+      # @param name [String]
+      #   place name
+      # @return [Array<Place>]
+      #   places
+      def find_all_places_by_name(name)
+        places.select {|place| place.name == name}
+      end
+
+      # Find a place by the source transition ID.
+      #
+      # @param transition_id [String]
+      #   transition ID
+      # @return [Array<Transition>]
+      #   a result place
+      def find_place_by_source_id(transition_id)
+        _arcs = arcs.select {|arc| arc.source_id == transition_id}
+        _places = _arcs.map do |arc|
+          places.find {|place| place.id == arc.target_id}
+        end.compact.uniq
+
+        # the result shouldn't be ambiguous
+        if _places.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, name, _places)
+        end
+
+        return _places.first
+      end
+
+      # Find all places by the source transition ID.
+      #
+      # @param transition_id [String]
+      #   transition ID
+      # @return [Array<Transition>]
+      #   result places
+      def find_all_places_by_source_id(transition_id)
+        _arcs = arcs.select {|arc| arc.source_id == transition_id}
+        _places = _arcs.map do |arc|
+          places.find {|place| place.id == arc.target_id}
+        end
+        return _places.compact.uniq
+      end
+
+      # Find a place by the target transition ID.
+      #
+      # @param transition_id [String]
+      #   transition ID
+      # @return [Array<Transition>]
+      #   result places
+      def find_place_by_target_id(transition_id)
+        _arcs = arcs.select {|arc| arc.target_id == transition_id}
+        _places = _arcs.map do |arc|
+          places.find {|place| place.id == arc.source_id}
+        end.compact.uniq
+
+        # the result shouldn't be ambiguous
+        if _places.size > 1
+          raise AmbiguousNetQueryResult.new(__method__, name, _places)
+        end
+
+        return _places.first
+      end
+
+      # Find all places by the target transition ID.
+      #
+      # @param transition_id [String]
+      #   transition ID
+      # @return [Array<Transition>]
+      #   result places
+      def find_all_places_by_target_id(transition_id)
+        _arcs = arcs.select {|arc| arc.target_id == transition_id}
+        _places = _arcs.map do |arc|
+          places.find {|place| place.id == arc.source_id}
+        end
+        return _places.compact.uniq
+      end
+    end
+
+    # `Node` is a meta class for `Place` and `Transition`.
+    class Node < StructX
+      # Eliminate comments from the string. This implementation is temporary, we
+      # should fix this.
+      def eliminate_comment(str)
+        # FIXME
+        str.sub(/#.*$/, "")
+      end
+
+      # Return true if the name is empty.
+      def empty_name?
+        name.nil? or /^\s*[<>]?\s*$/.match(eliminate_comment(name))
+      end
+
+      def inspect
+        "#<%s id=%s name=%s>" % [self.class.name, id.inspect, name.inspect]
+      end
+    end
+
+    # `Place` is a class represents places in PT-net.
+    class Place < Node
+      member :net
+      member :id
+      member :name
+    end
+
+    # `Transition` is a class represents transitions in PT-net.
+    class Transition < Node
+      member :net
+      member :id
+      member :name
+    end
+
+    # `Arc` is a class represents arcs in PT-net.
+    class Arc < StructX
+      member :net
+      member :id
+      member :source_id
+      member :target_id
+
+      # Return true if the arc has the direction from transition to place.
+      def from_transition_to_place?
+        net.transitions.any? {|t| t.id == source_id} and net.places.any? {|p| p.id == target_id}
+      end
+
+      # Return true if the arc has the direction from place to transition.
+      def from_place_to_transition?
+        net.places.any? {|p| p.id == source_id} and net.transitions.any? {|t| t.id == target_id}
+      end
+
+      def inspect
+        "#<Pione::PNML::Arc id=%s source_id=%s target_id=%s>" % [id.inspect, source_id.inspect, target_id.inspect]
+      end
+    end
+  end
+end

data/lib/pione/pnml/reader.rb

@@ -0,0 +1,51 @@
+module Pione
+  module PNML
+    class Reader
+      # Read a PNML file at the location and return `PNML::Net`.
+      #
+      # @param location [Location::DataLocation]
+      #   PNML file's location
+      def self.read(location)
+        new(location.read).read
+      end
+
+      def initialize(src)
+        @doc = REXML::Document.new(src)
+      end
+
+      def read
+        Net.new.tap do |net|
+          net.transitions = find_transitions(@doc, net)
+          net.places = find_places(@doc, net)
+          net.arcs = find_arcs(@doc, net)
+        end
+      end
+
+      # Find all transtions in the document.
+      def find_transitions(doc, net)
+        REXML::XPath.match(doc, "/pnml/net/transition").map do |elt|
+          id = elt.attribute("id").value
+          name = REXML::XPath.first(elt, "name/text").texts.map{|text| text.value}.join("")
+          Transition.new(net, id, name)
+        end
+      end
+
+      def find_places(doc, net)
+        REXML::XPath.match(doc, "/pnml/net/place").map do |elt|
+          id = elt.attribute("id").value
+          name = REXML::XPath.first(elt, "name/text").texts.map{|text| text.value}.join("")
+          Place.new(net, id, name)
+        end
+      end
+
+      def find_arcs(doc, net)
+        REXML::XPath.match(doc, "/pnml/net/arc").map do |elt|
+          id = elt.attribute("id").value
+          source_id = elt.attribute("source").value # source place(data) id
+          target_id = elt.attribute("target").value # target transition(rule) id
+          Arc.new(net, id, source_id, target_id)
+        end
+      end
+    end
+  end
+end

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

@@ -78,6 +78,8 @@ module Pione
       # Write the action into a shell script.
       def write_shell_script(&b)
         file = @working_directory + "__pione-action__.sh"
+        content = @rule_definition.action_context.eval(@env).content
+        sh = Util::EmbededExprExpander.expand(@env, content)
 
         # write the action
         if @dry_run
@@ -85,9 +87,8 @@ module Pione
             file.create("touch %s" % output.eval(@env).name)
           end
         else
-          # apply offside rule
-          content = @rule_definition.action_context.eval(@env).content
-          file.create(Util::EmbededExprExpander.expand(@env, content))
+          file.create(sh)
+
           # chmod 700
           if @working_directory.scheme == "local"
             FileUtils.chmod(0700, file.path)
@@ -95,8 +96,7 @@ module Pione
         end
 
         # message
-        lines = @rule_definition.action_context.eval(@env).content.split("\n")
-        user_message(["-"*60, lines, "-"*60].flatten, 0, "SH")
+        user_message(["-"*60, sh.split("\n"), "-"*60].flatten, 0, "SH")
 
         return b.call(file.path)
       end
@@ -117,7 +117,7 @@ module Pione
 
         # the case the script has errored
         unless $?.success?
-          raise ActionError.new(digest, (@working_directory + err).read)
+          raise ActionError.new(self, digest, (@working_directory + err).read)
         end
 
         # delete .stdout file if it is empty
@@ -177,6 +177,8 @@ module Pione
           src = @working_directory + output.name
           dest = output.location
           System::FileCache.put(src, dest)
+          # copy the data to the caller's domain in file server
+          src.copy(dest)
         end
       end