pione 0.4.2 → 0.5.0.alpha.1

data/lib/pione/package/package-handler.rb

@@ -106,14 +106,18 @@ module Pione
       # Load parent packages from package database. Parent packages should be
       # recorded in the database, or Package::NotFound error is raised.
       def load_parent_package(env, name, editor, tag)
-        if digest = Global.package_database.find(name, editor, tag)
-          parent_location = PackageCache.directory_cache(digest)
-          handler = PackageHandler.new(parent_location, digest: digest)
-          handler.eval(env)
-          return env.current_package_id
-        else
-          raise NotFound.new(name, editor, tag)
+        db = Database::load(Global.package_database_location)
+
+        if record = db.find(name, editor, tag)
+          if digest = record.digest
+            parent_location = PackageCache.directory_cache(digest)
+            handler = PackageHandler.new(parent_location, digest: digest)
+            _env = handler.eval(env)
+            return _env.current_package_id
+          end
         end
+
+        raise NotFound.new(name, editor, tag)
       end
     end
   end

data/lib/pione/package/package-info.rb

@@ -41,11 +41,11 @@ module Pione
         data["PackageName"] = name
         data["Editor"] = editor if editor
         data["Tag"] = tag if tag
-        data["Parents"] = parents
-        data["Documents"] = documents
-        data["Scenarios"] = scenarios
-        data["Bins"] = bins
-        data["Etcs"] = etcs
+        data["Parents"] = parents.sort
+        data["Documents"] = documents.sort
+        data["Scenarios"] = scenarios.sort
+        data["Bins"] = bins.sort
+        data["Etcs"] = etcs.sort
         data.to_json(*args)
       end
     end
@@ -64,12 +64,18 @@ module Pione
         new(args)
       end
 
-      def to_json
+      def <=>(other)
+        (name <=> other.name).tap {|x| return x unless x == 0}
+        (editor <=> other.editor).tap {|x| return x unless x == 0}
+        (tag <=> other.tag).tap {|x| return x unless x == 0}
+      end
+
+      def to_json(*args)
         data = {}
         data["PackageName"] = name
         data["Editor"] = editor if editor
         data["Tag"] = tag if tag
-        data.to_json
+        data.to_json(*args)
       end
     end
   end

data/lib/pione/package/package-scanner.rb

@@ -50,7 +50,7 @@ module Pione
         location.entries.each_with_object([]) do |entry, paths|
           if entry.file?
             # PIONE document has extension ".pione"
-            if /^[^.].+.pione$/.match(entry.basename)
+            if /^[^.].*.pione$/.match(entry.basename)
               # document path should be relative
               paths << entry.path.relative_path_from(@package_location.path).to_s
             end

data/lib/pione/package/scenario-info.rb

@@ -26,8 +26,8 @@ module Pione
         data = Hash.new
         data["ScenarioName"] = name
         data["ParamSet"] = textual_param_sets
-        data["Inputs"] = inputs
-        data["Outputs"] = outputs
+        data["Inputs"] = inputs.sort
+        data["Outputs"] = outputs.sort
         data.to_json(*args)
       end
     end

data/lib/pione/pnml.rb

@@ -3,11 +3,15 @@ module Pione
   module PNML; end
 end
 
+require 'pione/pnml/pnml-exception'
+
 #
 # language model
 #
 
+require 'pione/pnml/parser'
 require 'pione/pnml/pnml-model'  # source models
+require 'pione/pnml/label-extractor'
 require 'pione/pnml/pione-model' # target models
 
 #
@@ -24,12 +28,14 @@ require 'pione/pnml/output-decomposition-complement'
 require 'pione/pnml/output-synchronization-complement'
 require 'pione/pnml/io-expansion'
 require 'pione/pnml/invalid-arc-elimination'
+require 'pione/pnml/ticket-instantiation'
 
 #
 # utility
 #
 
 require 'pione/pnml/annotation-extractor'
+require 'pione/pnml/declaration-extractor'
 require 'pione/pnml/reader'
 require 'pione/pnml/compiler'
 

data/lib/pione/pnml/compiler.rb

@@ -13,6 +13,9 @@ module Pione
 
       def initialize(net, option={})
         @net = net
+        @net_name = option[:flow_rule_name] || "Main"
+        @env = option[:env] || Lang::Environment.new
+
         @option = option
         @net_rewriter = NetRewriter.new do |rules|
           rules << IsolatedElementElimination
@@ -24,6 +27,7 @@ module Pione
           rules << InputParallelizationComplement
           rules << OutputDecompositionComplement
           rules << OutputSynchronizationComplement
+          rules << TicketInstantiation
         end
         @actions = []
       end
@@ -32,13 +36,19 @@ module Pione
       def compile
         # annotations
         annotations = AnnotationExtractor.new(@net, @option).extract
+        declarations = DeclarationExtractor.new(@env, @net).extract
 
         # apply net rewriting rules
-        @net_rewriter.rewrite(@net)
+        @net_rewriter.rewrite(@net, @env)
 
         # build rules
-        rules, flow_elements = build_constituent_rule_definitions
-        definition_main = build_flow_rule_definition(@option[:flow_rule_name] || "Main", flow_elements)
+        rules, flow_elements = ConstituentRuleBuilder.new(@net, @net_name, @env).build()
+        definition_main = FlowRuleBuilder.new(@net, @net_name, @env).build(
+          flow_elements,
+          declarations.params,
+          declarations.features,
+          declarations.variable_bindings
+        )
 
         # merge literate actions
         rules.each do |rule|
@@ -50,131 +60,296 @@ module Pione
         end
 
         # textize
-        [*annotations, "", definition_main.textize, *rules.map {|rule| rule.textize}].join("\n")
+        sections = []
+        if annotations and annotations.size > 0
+          sections << annotations << ""
+        end
+        sections << definition_main.textize
+        rules.each {|rule| sections << rule.textize}
+        return sections.join("\n")
+      end
+    end
+
+    # ConstituentRuleBuilder builds constituent rule definitions.
+    class ConstituentRuleBuilder
+      # @param net [PNML::Net]
+      #   net
+      # @param net_name [String]
+      #   name of the net
+      # @param env [Lang::Environment]
+      #   language environment
+      def initialize(net, net_name, env)
+        @net = net
+        @net_name = net_name
+        @env = env
+      end
+
+      # Build a consituent rule definitions by transitions in the net.
+      #
+      # @return [Array(Array<RuleDefinition>,Array)]
+      def build
+        definition = build_rule_definition_table()
+
+        # save all inner rules
+        rules = definition.values.compact
+        flow_elements = definition.values.compact
+
+        # conditional branch
+        @net.transitions.each do |transition|
+          inputs = @net.find_all_places_by_target_id(transition.id).select do |place|
+            Perspective.data_place?(place, @env)
+          end.map {|input| InputData.new(input)}
+
+          if Perspective.if_transition?(@env, transition)
+            flow_elements << create_if_branch(transition, definition, inputs, flow_elements)
+          elsif Perspective.case_transition?(@env, transition)
+            flow_elements << create_case_branch(transition, definition, inputs, flow_elements)
+          end
+        end
+
+        return [rules, flow_elements]
       end
 
       private
 
-      # Build constituent rule definitions by transitions in the net.
-      def build_constituent_rule_definitions
-        definition = @net.transitions.each_with_object({}) do |transition, table|
-          if Perspective.rule?(transition)
-            type = Perspective.flow_rule?(transition) ? :flow : :action
-            rule = RuleDefinition.new(transition.name, type)
-
-            # inputs
-            @net.find_all_places_by_target_id(transition.id).each do |place|
-              if Perspective.file?(place)
-                rule.inputs << Perspective.normalize_data_name(place.name)
-              end
-            end
+      # Build rule definition table.
+      #
+      # @return [Hash{String=>RuleDefinition}]
+      #   relatioin table between transition ID and rule definition
+      def build_rule_definition_table
+        return @net.transitions.each_with_object({}) do |transition, table|
+          if Perspective.rule_transition?(@env, transition)
+            type = :action
+            rule_name = LabelExtractor.extract_rule_expr(transition.name)
+            is_external = Perspective.external_rule_transition?(@env, transition)
+            rule = RuleDefinition.new(rule_name, type, is_external, @net_name, table.size)
 
-            @net.find_all_places_by_source_id(transition.id).each do |place|
-              # outputs
-              if Perspective.file?(place)
-                rule.outputs << Perspective.normalize_data_name(place.name)
-              end
+            # setup rule conditions
+            rule.inputs = find_inputs(transition)
+            rule.outputs = find_outputs(transition)
+            rule.params = find_params(transition)
+            rule.constraints = find_constraints(transition)
+            rule.source_tickets = find_source_tickets(transition)
+            rule.target_tickets = find_target_tickets(transition)
+            rule.features = find_features(transition)
+
+            table[transition.id] = rule
+          end
+        end
+      end
 
-              # params
-              if Perspective.param?(place)
-                rule.params << Param.new(place.name, nil)
+      # Find inputs from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array<InputData>]
+      #   rule inputs
+      def find_inputs(transition)
+        @net.find_all_places_by_target_id(transition.id).each_with_object([]) do |place, inputs|
+          begin
+            # consideration for constraint nodes
+            prev_transition = @net.find_transition_by_target_id(place.id)
+            if Perspective.constraint_transition?(@env, prev_transition)
+              @net.find_all_places_by_target_id(prev_transition.id).each do |_place|
+                if Perspective.data_place?(_place, @env)
+                  inputs << InputData.new(_place)
+                end
+              end
+            else
+              if Perspective.data_place?(place, @env)
+                inputs << InputData.new(place)
               end
             end
-
-            table[transition.id] = rule
+          rescue AmbiguousNetQueryResult
+            # ignore
           end
         end
+      end
 
-        # save all inner rules
-        rules = definition.values.select{|rule_def| rule_def.action?}.compact
-        flow_elements = definition.values.compact
+      # Find outputs from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array]
+      #   rule outputs
+      def find_outputs(transition)
+        @net.find_all_places_by_source_id(transition.id).each_with_object([]) do |place, outputs|
+          if Perspective.data_place?(@env, place)
+            outputs << OutputData.new(place)
+          end
+        end
+      end
 
-        # conditional branch
-        @net.transitions.each do |transition|
-          places = @net.find_all_places_by_target_id(transition.id)
-          input_places = places.select {|place| Perspective.file?(place)}
-          inputs = input_places.map {|input| Perspective.normalize_data_name(input.name)}
-
-          case Perspective.normalize_data_name(transition.name)
-          when "if"
-            # if-branch
-            condition = @net.find_place_by_source_id(transition.id)
-
-            keywords = @net.find_all_transitions_by_source_id(condition.id)
-            key_then = keywords.find{|key| Perspective.compact(key.name) == "then"}
-            key_else = keywords.find{|key| Perspective.compact(key.name) == "else"}
-
-            branch = ConditionalBranch.new(:if, condition.name)
-
-            find_next_rules(key_then).each do |transition|
-              rule = definition[transition.id]
-              rule.inputs += inputs
-              flow_elements.delete(rule)
-              branch.table[:then] << rule
+      # Find parameters from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array<Param>]
+      #   rule parameters
+      def find_params(transition)
+        @net.find_all_places_by_target_id(transition.id).each_with_object([]) do |place, params|
+          if Perspective.param_place?(@env, place)
+            prev_transitions = @net.find_all_transitions_by_target_id(place.id)
+            keyword_transitions = prev_transitions.select{|t| Perspective.keyword_transition?(t)}
+            if keyword_transitions.empty?
+              params << Param.new(place)
             end
+          end
+        end
+      end
 
-            find_next_rules(key_else).each do |transition|
-              rule = definition[transition.id]
-              rule.inputs += inputs
-              flow_elements.delete(rule)
-              branch.table[:else] << rule
-            end
+      # Find constraints from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array<Constraint>]
+      #   rule constraints
+      def find_constraints(transition)
+        @net.find_all_places_by_target_id(transition.id).each_with_object([]) do |place, constraints|
+          prev_transitions = @net.find_all_transitions_by_target_id(place.id)
+          constraint_transitions = prev_transitions.select{|t| Perspective.constraint_transition?(@env, t)}
 
-            flow_elements << branch
-          when "case"
-            expr = @net.find_place_by_source_id(transition.id)
+          case constraint_transitions.size
+          when 0
+            # ignore
+          when 1
+            if Perspective.expr_place?(place)
+              constraints << Constraint.new(place.name)
+            else
+              # the place should be constraint expression
+              raise CompilerError.should_be_constraint_expr(place)
+            end
+          else
+            # multiple constraint keywords found
+            raise CompilerError.multiple_constraint_keywords(transition.name)
+          end
+        end
+      end
 
-            keywords = @net.find_all_transtions_by_source_id(expr.id)
-            keys_when = keywords.select{|key| Perspective.compact(key.name) == "then"}
-            key_else = keywords.find{|key| Perspective.compact(key.name) == "else"}
+      # Find source tickets from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array<Ticket>]
+      #   tickets
+      def find_source_tickets(transition)
+        @net.find_all_places_by_target_id(transition.id).each_with_object([]) do |place, tickets|
+          if Perspective.ticket_place?(place, @env)
+            tickets << Ticket.new(place)
+          end
+        end
+      end
 
-            branch = ConditionalBranch.new(:case, expr.name)
+      # Find target tickets from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array<Ticket>]
+      #   tickets
+      def find_target_tickets(transition)
+        @net.find_all_places_by_source_id(transition.id).each_with_object([]) do |place, tickets|
+          if Perspective.ticket_place?(place, @env)
+            tickets << Ticket.new(place.name)
+          end
+        end
+      end
 
-            keys_when.each do |key|
-              find_next_rules(key).each do |transition|
-                rule = definition[transition.id]
-                rule.inputs += inputs
-                flow_elements.delete(rule)
-                branch.table[key.name] << rule
-              end
+      # Find features from net.
+      #
+      # @param transition [Transition]
+      #   base transition
+      # @return [Array<Feature>]
+      #   features
+      def find_features(transition)
+        @net.find_all_places_by_target_id(transition.id).each_with_object([]) do |place, features|
+          if Perspective.feature_place?(place, @env)
+            keyword_transitions = @net.find_all_transitions_by_target_id(place.id).select do |t|
+              Perspective.keyword_transition?(t)
             end
-
-            find_next_rules(key_else).each do |transition|
-              rule = definition[transition.id]
-              rule.inputs += inputs
-              flow_elements.delete(rule)
-              branch.table[:else] << rule
+            if keyword_transitions.empty?
+              features << Feature.new(place.name)
             end
-
-            flow_elements << branch
           end
         end
+      end
 
-        return [rules, flow_elements]
+      # Create a if-branch from the transiton.
+      #
+      # @param transition [PNML::Transition]
+      #   base transition
+      # @return [ConditionalBranch]
+      #   conditional branch
+      def create_if_branch(transition, definition, inputs, flow_elements)
+        condition = @net.find_place_by_source_id(transition.id)
+
+        nodes = @net.find_all_transitions_by_source_id(condition.id)
+        key_then = nodes.find{|node| Perspective.then_transition?(node)}
+        key_else = nodes.find{|node| Perspective.else_transition?(node)}
+
+        branch = ConditionalBranch.new(:if, condition.name)
+
+        find_next_rules(key_then).each do |transition|
+          rule = definition[transition.id]
+          rule.inputs += inputs
+          flow_elements.delete(rule)
+          branch.table[:then] << rule
+        end
+
+        find_next_rules(key_else).each do |transition|
+          rule = definition[transition.id]
+          rule.inputs += inputs
+          flow_elements.delete(rule)
+          branch.table[:else] << rule
+        end
+
+        return branch
       end
 
-      # Make a main rule.
-      def build_flow_rule_definition(name, flow_elements)
-        inputs = @net.places.select {|place| Perspective.file?(place) and Perspective.net_input?(place)}
-        inputs = inputs.map {|input| Perspective.normalize_data_name(input.name)}
+      # Create a case-branch from the transiton.
+      #
+      # @param transition [PNML::Transition]
+      #   base transition
+      # @return [ConditionalBranch]
+      #   conditional branch
+      def create_case_branch(transition, definition, inputs, flow_elements)
+        expr = @net.find_place_by_source_id(transition.id)
 
-        outputs = @net.places.select {|place| Perspective.file?(place) and Perspective.net_output?(place)}
-        outputs = outputs.map {|output| Perspective.normalize_data_name(output.name)}
+        nodes = @net.find_all_transitions_by_source_id(expr.id)
+        keys_when = nodes.select{|node| Perspective.when_transition?(node)}
+        key_else = nodes.find{|node| Perspective.else_transition?(node)}
 
-        option = {
-          :inputs => inputs,
-          :outputs => outputs,
-          :params => @net.places.select {|place| Perspective.param?(place) and Perspective.net_input?},
-          :flow_elements => flow_elements,
-        }
+        branch = ConditionalBranch.new(:case, expr.name)
 
-        RuleDefinition.new(name, :flow, option)
+        keys_when.each do |key|
+          find_next_rules(key).each do |transition|
+            rule = definition[transition.id]
+            rule.inputs += inputs
+            flow_elements.delete(rule)
+            conditional_value_place = @net.find_place_by_source_id(key.id)
+            branch.table[conditional_value_place.name] << rule
+          end
+        end
+
+        if key_else
+          find_next_rules(key_else).each do |transition|
+            rule = definition[transition.id]
+            rule.inputs += inputs
+            flow_elements.delete(rule)
+            branch.table[:else] << rule
+          end
+        end
+
+        return branch
       end
 
+      # Find next rules.
+      #
+      # @param base_rule [PNML::Transition]
+      #   base transition
       def find_next_rules(base_rule)
         @net.find_all_places_by_source_id(base_rule.id).each_with_object([]) do |place, res|
           @net.find_all_transitions_by_source_id(place.id).each do |transition|
-            if Perspective.rule?(transition)
+            if Perspective.rule_transition?(transition)
               res << transition
             else
               find_next_rules(transition)
@@ -183,5 +358,64 @@ module Pione
         end
       end
     end
+
+    # FlowRuleBuilder builds a flow rule definition for PNML net.
+    class FlowRuleBuilder
+      # @param net [PNML::Net]
+      #   PNML net
+      # @param net_name [String]
+      #   name of the net
+      # @param env [Lang::Environment]
+      #   language environment
+      def initialize(net, net_name, env)
+        @net = net
+        @net_name = net_name
+        @env = env
+      end
+
+      # Build a flow rule definition for PNML net.
+      #
+      # @param flow_elements [Array]
+      #   flow elements
+      # @return [RuleDefinition]
+      #   a flow rule definition for PNML net
+      def build(flow_elements, params, features, variable_bindings)
+        inputs = @net.places.select {|place| Perspective.net_input_data_place?(place, @env)}
+        inputs = inputs.map {|input| InputData.new(input)}
+
+        outputs = @net.places.select {|place| Perspective.net_output_data_place?(place, @env)}
+        outputs = outputs.map {|output| OutputData.new(output)}
+
+        option = {
+          :inputs => inputs,
+          :outputs => outputs,
+          :params => params,
+          :features => features,
+          :variable_bindings => variable_bindings,
+          :flow_elements => flow_elements
+        }
+
+        RuleDefinition.new(@net_name, :flow, false, @net_name, 0, option)
+      end
+    end
+
+    # CompilerError represents compiler errors.
+    class CompilerError < StandardError
+      # Raise an exception for the case of invalid constraint expression.
+      #
+      # @param node [Node]
+      #   node that has invalid constraint expression
+      def self.should_be_constraint_expr(node)
+        new('The node "%s" should be a PIONE expression because of constraint keyword.' % node.name)
+      end
+
+      # Raise an exception for the case multiple constraint keywords found.
+      #
+      # @param rule_name [String]
+      #   rule name
+      def self.multiple_constraint_keywords(rule_name)
+        new('Cannot connect multiple constraint nodes with rule "%s".' % rule_name)
+      end
+    end
   end
 end