pione 0.4.2 → 0.5.0.alpha.1

data/lib/pione/pnml/declaration-extractor.rb

@@ -0,0 +1,90 @@
+module Pione
+  module PNML
+    # DeclarationExtractor extracts declarations from net.
+    class DeclarationExtractor
+      def initialize(env, net, option={})
+        @env = env
+        @net = net
+        @declarations = ExtractedDeclarations.new
+      end
+
+      def extract
+        extract_params
+        extract_variable_bindings
+        extract_features
+
+        return @declarations
+      end
+
+      private
+
+      # Extract net parameters.
+      def extract_params
+        @net.transitions.each_with_object([]) do |transition, sentences|
+          if Perspective.param_transition?(@env, transition)
+            # evaluate the sentence for updating language environment
+            Perspective.eval_param_sentence(@env, transition)
+            @declarations.add_param(transition.name)
+          end
+        end
+      end
+
+      # Extract net variable bindings.
+      def extract_variable_bindings
+        @net.transitions.each do |transition|
+          if Perspective.variable_binding_transition?(@env, transition)
+            @declarations.add_variable_binding(transition.name)
+          end
+        end
+      end
+
+      # Extract net features.
+      def extract_features
+        @net.transitions.each_with_object([]) do |transition, sentences|
+          if Perspective.feature_transition?(@env, transition)
+            @declarations.add_feature(transition.name)
+          end
+        end
+      end
+    end
+
+    # ExtractedDeclarations is a store of declarations.
+    class ExtractedDeclarations
+      attr_reader :params
+      attr_reader :variable_bindings
+      attr_reader :features
+
+      def initialize
+        @params = []
+        @variable_bindings = []
+        @features = []
+      end
+
+      # Add the parameter.
+      #
+      # @param param [String]
+      #   a string of parameter
+      def add_param(param)
+        @params << Perspective.normalize_declaration(param)
+      end
+
+      # Add the variable binding.
+      #
+      # @param variable_binding [String]
+      #   a string of variable binding
+      def add_variable_binding(variable_binding)
+        @variable_bindings <<
+          Perspective.normalize_declaration(variable_binding)
+      end
+
+      # Add the feature.
+      #
+      # @param variable_binding [String]
+      #   a string of feature
+      def add_feature(feature)
+        @features <<
+          Perspective.normalize_declaration(feature)
+      end
+    end
+  end
+end

data/lib/pione/pnml/input-merge-complement.rb

@@ -16,7 +16,6 @@ module Pione
     #     'p2' --> empty transition --+--> 'p1' or 'p2' or 'p3' -> A
     #                                 |
     #     'p3' --> empty transition --+
-    #
     module InputMergeComplement
       # Find subjects(source transitions and target palce) of this rule from the
       # net. The conditions are followings:
@@ -28,19 +27,21 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [Array]
       #   source transitions and target place
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.places.each do |place|
-          # target place should have no names
-          next unless place.empty_name?
+          # target place should be empty
+          next unless Perspective.empty_place?(env, place)
 
           # collect transitions
           transitions = net.find_all_transitions_by_target_id(place.id).select do |transition|
             arcs = net.find_all_arcs_by_target_id(transition.id)
             if arcs.size == 1
               _place = net.find_place(arcs.first.source_id)
-              transition.empty_name? and Perspective.file?(_place)
+              Perspective.empty_transition?(env, transition) and Perspective.data_place?(env, _place)
             end
           end
 
@@ -59,19 +60,24 @@ module Pione
       #   rewriting target net
       # @param subjects [Array]
       #   source transitions and target place
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         transitions, place = subjects
 
+        source_places = transitions.map do |transition|
+          net.find_all_places_by_target_id(transition.id)
+        end.flatten
+
         # build a new name
-        new_name = transitions.map do |transition|
-          arcs = net.find_all_arcs_by_target_id(transition.id)
-          _place = net.find_place(arcs.first.source_id)
-          Perspective.normalize_data_name(_place.name)
+        new_name = source_places.map do |source_place|
+          LabelExtractor.extract_data_expr(source_place.name)
         end.sort.join(" or ")
 
         # update the place name
-        place.name = "%s%s" % [Perspective.modifier(place.name), new_name]
+        modifier = Perspective.data_modifier(env, place) || ""
+        place.name = modifier + new_name
       end
     end
   end

data/lib/pione/pnml/input-parallelization-complement.rb

@@ -29,22 +29,24 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [Array]
       #   input place and target places
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.transitions.each do |transition|
           # source transition should have no names
-          next unless transition.empty_name?
+          next unless Perspective.empty_transition?(env, transition)
 
           # transition should have only one named input
           input_places = net.find_all_places_by_target_id(transition.id)
-          unless input_places.size == 1 and Perspective.file?(input_places.first)
+          unless input_places.size == 1 and Perspective.data_place?(env, input_places.first)
             next
           end
 
           # collect places
           output_places = net.find_all_places_by_source_id(transition.id)
-          next unless output_places.all? {|output_place| output_place.empty_name?}
+          next unless output_places.all? {|output_place| Perspective.empty_place?(env, output_place)}
 
           # there should be more than 2 places
           next unless output_places.size > 1
@@ -61,13 +63,15 @@ module Pione
       #   rewriting target net
       # @param subjects [Array]
       #   input place and target places
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         input_place, target_places = subjects
 
         # rewrite names of target places
         target_places.each do |place|
-          place.name = Perspective.normalize_data_name(input_place.name)
+          place.name = LabelExtractor.extract_data_expr(input_place.name)
         end
       end
     end

data/lib/pione/pnml/input-reduction.rb

@@ -17,15 +17,15 @@ module Pione
       # - There is an empty source transition.
       # - There is an empty target place. It is an input of named transition.
       # - There is an arc that connects the source and the target.
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.transitions.each do |rule|
           # rule has its name
-          next unless Perspective.named?(rule)
+          next if Perspective.empty?(env, rule)
 
           # find source places
           net.find_all_places_by_target_id(rule.id).each do |place|
             # the source place has empty name
-            next unless Perspective.empty?(place)
+            next unless Perspective.empty?(env, place)
 
             # find transtions that generates the source place
             transitions = net.find_all_transitions_by_target_id(place.id)
@@ -37,7 +37,7 @@ module Pione
               # the transition is connected to only one place at target side
               if net.find_all_places_by_source_id(transition.id).size == 1
                 # the transition has empty name
-                if Perspective.empty?(transition)
+                if Perspective.empty?(env, transition)
                   return [transition, place, net.find_arc(transition.id, place.id)]
                 end
               end
@@ -54,7 +54,7 @@ module Pione
       # - Remove the subject transition.
       # - Remove the subject and related arcs.
       # - Connect discontinuous nodes by new arcs.
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         transition, place, arc = subjects
 
         # remove subjects from the net

data/lib/pione/pnml/invalid-arc-elimination.rb

@@ -8,7 +8,7 @@ module Pione
       # - There is a arc.
       # - It should connect source place and target transition, or source
       #   transition and target place.
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.arcs.each do |arc|
           source_transition = net.find_transition(arc.source_id)
           source_place = net.find_place(arc.source_id)
@@ -30,7 +30,7 @@ module Pione
       end
 
       # Rewrite the net by eliminating isolated node.
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         arc = subjects.first
 
         # eliminate

data/lib/pione/pnml/io-expansion.rb

@@ -20,22 +20,24 @@ module Pione
       #
       # @param net [PNML::Net]
       #   rewriting target net
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [Array]
       #   sandwiched place and target side arcs
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         net.transitions.each do |transition|
           # transition should be a rule
-          next unless Perspective.rule?(transition)
+          next unless Perspective.rule_transition?(env, transition)
 
           net.find_all_places_by_source_id(transition.id).each do |place|
             # place should be a file
-            next unless Perspective.file?(place)
+            next unless Perspective.data_place?(env, place)
 
             # collect target side arcs
             all_target_arcs = net.find_all_arcs_by_source_id(place.id)
             target_arcs = all_target_arcs.select do |arc|
               transition = net.find_transition(arc.target_id)
-              transition and Perspective.rule?(transition)
+              transition and Perspective.rule_transition?(env, transition)
             end
             next unless target_arcs.size > 0
 
@@ -57,8 +59,10 @@ module Pione
       #   rewriting target net
       # @param subjects [Array]
       #   sandwiched place and target side arcs
+      # @param env [Lang::Environment]
+      #   language environment
       # @return [void]
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         place, target_arcs = subjects
 
         # remove arcs

data/lib/pione/pnml/isolated-element-elimination.rb

@@ -7,7 +7,7 @@ module Pione
       #
       # - There is a place or transition.
       # - It has no arcs.
-      def self.find_subjects(net)
+      def self.find_subjects(net, env)
         (net.places + net.transitions).each do |node|
           input_arcs = net.find_all_arcs_by_source_id(node.id)
           output_arcs = net.find_all_arcs_by_target_id(node.id)
@@ -20,7 +20,7 @@ module Pione
       end
 
       # Rewrite the net by eliminating isolated node.
-      def self.rewrite(net, subjects)
+      def self.rewrite(net, subjects, env)
         subjects.each do |node|
           # eliminate the node
           net.transitions.delete(node)

data/lib/pione/pnml/label-extractor.rb

@@ -0,0 +1,258 @@
+module Pione
+  module PNML
+    # LabelExtractor extracts PIONE string from node label.
+    module LabelExtractor
+      class << self
+        # Extract a rule expression.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   rule expression without modifier and comment
+        def extract_rule_expr(label)
+          extract_string(label, :rule_transition, :expr)
+        end
+
+        # Extract a data expression.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   data expression without modifier and comment
+        def extract_data_expr(label)
+          extract_string(label, :data_place, :expr)
+        end
+
+        # Extract a param set.
+        #
+        # @param name [String]
+        #   node label
+        # @return [String]
+        #   parameter set string without modifier and comment
+        def extract_param_set(label)
+          extract_string(label, :expr_place, :expr)
+        end
+
+        # Extract a ticket.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   ticket string without modifier and comment
+        def extract_ticket(label)
+          extract_string(label, :expr_place, :expr)
+        end
+
+        # Extract a feature.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   feature string without modifier and comment
+        def extract_feature(label)
+          extract_string(label, :expr_place, :expr)
+        end
+
+        # Extract a param sentence.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   data expression without modifier and comment
+        def extract_param_sentence(label)
+          extract_string(label, :param_sentence, :param_sentence)
+        end
+
+        # Extract a feature sentence.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   feature sentence string without modifier and comment
+        def extract_feature_sentence(label)
+          extract_string(label, :feature_sentence, :feature_sentence)
+        end
+
+        # Extract a variable binding sentence.
+        #
+        # @param label [String]
+        #   node label
+        # @return [String]
+        #   variable binding sentence string without modifier and comment
+        def extract_variable_binding(label)
+          extract_string(label, :variable_binding_sentence, :variable_binding_sentence)
+        end
+
+        # Extract priority.
+        #
+        # @param label [String]
+        #   node label
+        # @return [Integer]
+        #   priority
+        def extract_priority(label)
+          matched = Parser.new.data_priority.parse(label)
+          return matched[:priority].to_i
+        rescue Parslet::ParseFailed
+          return nil
+        end
+
+        # Extract key and value pairs from parameter set string.
+        #
+        # @param label [String]
+        #   node label
+        # @return [Hash]
+        #   key and value pairs
+        def extract_data_from_param_set(label)
+          param_set = LabelExtractor.extract_param_set(label)
+
+          parsed = Parser.new.expr_place.parse(param_set)
+          tail_offset = parsed[:tail] ? parsed[:tail].offset : label.size
+
+          keys = []
+          values = []
+
+          found = find_all_by_tree_names(parsed, [:key, :value, :separator, :footer])
+          found.each_with_index do |item, index|
+            if index % 3 == 0
+              keys << item.to_s
+            end
+
+            if index % 3 == 1
+              offset = find_head_character_position(item)
+              separator_offset = found[index + 1] ? found[index + 1].offset : tail_offset
+              values << label[offset, separator_offset - offset]
+            end
+          end
+
+          return Hash[keys.zip(values)]
+        end
+
+        # Extract key and value pairs from parameter set string.
+        #
+        # @param label [String]
+        #   node label
+        # @return [Hash]
+        #   key and value pairs
+        def extract_data_from_param_sentence(label)
+          param_sentence = LabelExtractor.extract_param_sentence(label)
+          parsed = Parser.new.param_sentence.parse(param_sentence)
+
+          # variable
+          var = parsed[:param_sentence][:expr1][:expr][:variable][:name].to_s
+
+          # value
+          expr2 = parsed[:param_sentence][:expr2]
+          expr2_offset = find_head_character_position(expr2)
+          tail_offset = offset_of(parsed[:tail]) || label.size
+          value = label[expr2_offset, tail_offset - expr2_offset]
+
+          return {var => value}
+        end
+
+        private
+
+        # Extract the string of expression.
+        #
+        # @param label [String]
+        #   node label
+        # @param paser_name [Symbol]
+        #   parser name
+        # @param tree_name [Symbol]
+        #   tree name
+        # @return [String]
+        #   expression without modifier and comment
+        def extract_string(label, parser_name, tree_name)
+          return nil if label.nil?
+
+          parsed = Parser.new.send(parser_name).parse(label)
+          offset = find_head_character_position(parsed[tree_name])
+          tail_offset = offset_of(find_parsed_element(parsed, :tail)) || label.size
+          return label[offset, tail_offset - offset]
+        end
+
+        # Find position of head character of parsed tree.
+        #
+        # @param parsed [Hash]
+        #   parsed tree
+        # @return [Integer]
+        #   position of head character or nil
+        def find_head_character_position(parsed)
+          return nil if parsed.nil?
+
+          pos = nil
+          parsed.values.each do |value|
+            if value.kind_of?(Hash)
+              if _pos = find_head_character_position(value)
+                if pos.nil? or pos > _pos
+                  pos = _pos
+                end
+              end
+            else
+              if value.kind_of?(Parslet::Slice) and (pos.nil? or pos > value.offset)
+                pos = value.offset
+              end
+            end
+          end
+          return pos
+        end
+
+        def offset_of(value)
+          if value.kind_of?(Parslet::Slice)
+            value.offset
+          end
+        end
+
+        # Find a parsed element by the name.
+        #
+        # @param parsed [Hash]
+        #   parsed tree
+        # @param name [Symbol]
+        #   element name
+        # @return [Object]
+        #   parsed element
+        def find_parsed_element(parsed, name)
+          return nil if parsed.nil?
+
+          parsed.each do |key, value|
+            if key == name
+              return value
+            else
+              if value.kind_of?(Hash)
+                if elt = find_parsed_element(value, name)
+                  return elt
+                end
+              end
+            end
+          end
+
+          return nil
+        end
+
+        def find_all_by_tree_names(parsed, names)
+          list = []
+          return list if parsed.nil?
+
+          parsed.each do |key, value|
+            if names.include?(key)
+              list << value
+            else
+              if value.kind_of?(Hash)
+                list += find_all_by_tree_names(value, names)
+              end
+
+              if value.kind_of?(Array)
+                value.each do |elt|
+                  if elt.kind_of?(Hash)
+                    list += find_all_by_tree_names(elt, names)
+                  end
+                end
+              end
+            end
+          end
+
+          return list
+        end
+      end
+    end
+  end
+end