orfeas_petri_flow 0.6.0

data/lib/petri_flow/export/json_exporter.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PetriFlow
+  module Export
+    # Exports Petri nets and Colored Petri Nets to JSON format
+    # Provides a clean, human-readable, and API-friendly format
+    class JsonExporter
+      attr_reader :net
+
+      def initialize(net)
+        @net = net
+      end
+
+      # Export to JSON string
+      # @param pretty [Boolean] Whether to format JSON with indentation
+      # @return [String] JSON representation of the net
+      def to_json(pretty: true)
+        hash = to_hash
+        if pretty
+          JSON.pretty_generate(hash)
+        else
+          JSON.generate(hash)
+        end
+      end
+
+      # Export to Ruby hash
+      # @return [Hash] Hash representation of the net
+      def to_hash
+        {
+          meta: meta_info,
+          net: net_structure,
+          colors: color_definitions,
+          places: places_data,
+          transitions: transitions_data,
+          arcs: arcs_data,
+          marking: current_marking,
+          statistics: statistics
+        }
+      end
+
+      # Save to JSON file
+      def save_json(filename, pretty: true)
+        File.write(filename, to_json(pretty: pretty))
+      end
+
+      private
+
+      def colored_net?
+        @net.is_a?(PetriFlow::Colored::ColoredNet)
+      end
+
+      def meta_info
+        {
+          format: 'PetriFlow JSON Export',
+          version: '1.0',
+          exported_at: Time.now.utc.iso8601,
+          net_type: colored_net? ? 'colored_petri_net' : 'petri_net'
+        }
+      end
+
+      def net_structure
+        {
+          name: @net.name,
+          type: colored_net? ? 'ColoredPetriNet' : 'PetriNet',
+          place_count: @net.places.size,
+          transition_count: @net.transitions.size,
+          arc_count: @net.arcs.size
+        }
+      end
+
+      def color_definitions
+        return [] unless colored_net?
+
+        @net.colors.map do |color_name, color|
+          {
+            name: color_name,
+            attributes: color.attributes,
+            has_validator: !color.validator.nil?
+          }
+        end
+      end
+
+      def places_data
+        @net.places.map do |place_id, place|
+          place_hash = {
+            id: place_id,
+            name: place.name,
+            tokens: place.tokens,
+            capacity: place.capacity == Float::INFINITY ? 'infinite' : place.capacity
+          }
+
+          # Add colored net place info
+          if colored_net? && @net.colored_places[place_id]
+            colored_info = @net.colored_places[place_id]
+            place_hash[:color] = colored_info[:color]
+            place_hash[:colored_tokens] = format_colored_tokens(place_id)
+          end
+
+          place_hash
+        end
+      end
+
+      def format_colored_tokens(place_id)
+        return [] unless colored_net?
+
+        tokens = @net.token_pools[place_id] || []
+        tokens.map do |token|
+          {
+            id: token.id,
+            color: token.color,
+            data: token.data,
+            timestamp: token.timestamp
+          }
+        end
+      end
+
+      def transitions_data
+        @net.transitions.map do |trans_id, transition|
+          trans_hash = {
+            id: trans_id,
+            name: transition.name,
+            input_arcs: transition.input_arcs.size,
+            output_arcs: transition.output_arcs.size,
+            enabled: transition.enabled?
+          }
+
+          # Add guard info
+          if transition.guard
+            trans_hash[:guard] = format_guard(transition.guard)
+          end
+
+          trans_hash
+        end
+      end
+
+      def format_guard(guard)
+        if guard.respond_to?(:name) && guard.name
+          {
+            type: 'named_guard',
+            name: guard.name,
+            description: guard.name
+          }
+        elsif guard.respond_to?(:condition)
+          {
+            type: 'guard',
+            description: 'Custom guard condition'
+          }
+        else
+          {
+            type: 'proc',
+            description: 'Lambda/Proc guard'
+          }
+        end
+      end
+
+      def arcs_data
+        @net.arcs.map.with_index do |arc, index|
+          arc_hash = {
+            id: "arc_#{index}",
+            source: {
+              id: arc.source.id,
+              name: arc.source.name,
+              type: arc.source.class.name.split('::').last
+            },
+            target: {
+              id: arc.target.id,
+              name: arc.target.name,
+              type: arc.target.class.name.split('::').last
+            },
+            weight: arc.weight,
+            direction: arc.input_arc? ? 'place_to_transition' : 'transition_to_place'
+          }
+
+          # Add arc expression info
+          if arc.expression
+            arc_hash[:expression] = format_expression(arc.expression)
+          end
+
+          arc_hash
+        end
+      end
+
+      def format_expression(expression)
+        if expression.respond_to?(:name) && expression.name
+          {
+            type: 'named_expression',
+            name: expression.name,
+            description: expression.name
+          }
+        elsif expression.respond_to?(:transformation)
+          {
+            type: 'arc_expression',
+            description: 'Custom arc expression'
+          }
+        else
+          {
+            type: 'proc',
+            description: 'Lambda/Proc expression'
+          }
+        end
+      end
+
+      def current_marking
+        {
+          tokens_by_place: @net.places.transform_values(&:tokens),
+          total_tokens: @net.places.values.sum(&:tokens)
+        }.tap do |marking|
+          if colored_net?
+            marking[:colored_marking] = @net.colored_marking
+          end
+        end
+      end
+
+      def statistics
+        @net.stats.merge({
+          enabled_transitions_list: @net.enabled_transitions.map(&:id),
+          deadlocked: @net.deadlocked?
+        })
+      end
+    end
+  end
+end

data/lib/petri_flow/export/pnml_exporter.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module PetriFlow
+  module Export
+    # Exports Petri nets and Colored Petri Nets to PNML format
+    # PNML (Petri Net Markup Language) is the ISO/IEC 15909 standard
+    class PnmlExporter
+      attr_reader :net
+
+      def initialize(net)
+        @net = net
+      end
+
+      # Export to PNML XML string
+      def to_pnml
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+
+        # Root element
+        pnml = doc.add_element('pnml', {
+          'xmlns' => 'http://www.pnml.org/version-2009/grammar/pnml'
+        })
+
+        # Add net element
+        net_element = pnml.add_element('net', {
+          'id' => net_id,
+          'type' => net_type_url
+        })
+
+        # Add name
+        add_name(net_element, @net.name)
+
+        # Add page (container for net elements)
+        page = net_element.add_element('page', { 'id' => 'page1' })
+
+        # Add places
+        @net.places.each do |place_id, place|
+          add_place(page, place)
+        end
+
+        # Add transitions
+        @net.transitions.each do |trans_id, transition|
+          add_transition(page, transition)
+        end
+
+        # Add arcs
+        @net.arcs.each_with_index do |arc, index|
+          add_arc(page, arc, index)
+        end
+
+        # Add colored net extensions if applicable
+        if colored_net?
+          add_color_declarations(net_element)
+        end
+
+        # Format XML nicely
+        formatter = REXML::Formatters::Pretty.new(2)
+        formatter.compact = true
+        output = String.new
+        formatter.write(doc, output)
+        output
+      end
+
+      # Save to file
+      def save_pnml(filename)
+        File.write(filename, to_pnml)
+      end
+
+      private
+
+      def net_id
+        @net.name.downcase.gsub(/\s+/, '_')
+      end
+
+      def net_type_url
+        if colored_net?
+          'http://www.pnml.org/version-2009/grammar/highlevelnet'
+        else
+          'http://www.pnml.org/version-2009/grammar/ptnet'
+        end
+      end
+
+      def colored_net?
+        @net.is_a?(PetriFlow::Colored::ColoredNet)
+      end
+
+      def add_name(element, name)
+        name_elem = element.add_element('name')
+        text_elem = name_elem.add_element('text')
+        text_elem.text = name
+      end
+
+      def add_place(page, place)
+        place_elem = page.add_element('place', { 'id' => place.id.to_s })
+        add_name(place_elem, place.name)
+
+        # Add initial marking
+        if place.tokens > 0
+          marking_elem = place_elem.add_element('initialMarking')
+          text_elem = marking_elem.add_element('text')
+          text_elem.text = place.tokens.to_s
+        end
+
+        # Add colored net place extensions
+        if colored_net? && @net.colored_places[place.id]
+          add_place_type(place_elem, @net.colored_places[place.id])
+        end
+
+        # Add graphics (optional - for visualization)
+        add_place_graphics(place_elem)
+      end
+
+      def add_place_type(place_elem, place_info)
+        return unless place_info[:color]
+
+        type_elem = place_elem.add_element('type')
+        text_elem = type_elem.add_element('text')
+        text_elem.text = place_info[:color].to_s
+      end
+
+      def add_place_graphics(place_elem)
+        graphics = place_elem.add_element('graphics')
+        position = graphics.add_element('position', { 'x' => '0', 'y' => '0' })
+        dimension = graphics.add_element('dimension', { 'x' => '40', 'y' => '40' })
+      end
+
+      def add_transition(page, transition)
+        trans_elem = page.add_element('transition', { 'id' => transition.id.to_s })
+        add_name(trans_elem, transition.name)
+
+        # Add guard if present
+        if transition.guard
+          add_guard(trans_elem, transition.guard)
+        end
+
+        # Add graphics
+        add_transition_graphics(trans_elem)
+      end
+
+      def add_guard(trans_elem, guard)
+        condition_elem = trans_elem.add_element('condition')
+        text_elem = condition_elem.add_element('text')
+
+        guard_text = if guard.respond_to?(:name) && guard.name
+                      guard.name
+                    else
+                      '[guard]'
+                    end
+        text_elem.text = guard_text
+      end
+
+      def add_transition_graphics(trans_elem)
+        graphics = trans_elem.add_element('graphics')
+        position = graphics.add_element('position', { 'x' => '0', 'y' => '0' })
+        dimension = graphics.add_element('dimension', { 'x' => '40', 'y' => '25' })
+      end
+
+      def add_arc(page, arc, index)
+        arc_id = "arc_#{index}"
+        source_id = arc.source.id.to_s
+        target_id = arc.target.id.to_s
+
+        arc_elem = page.add_element('arc', {
+          'id' => arc_id,
+          'source' => source_id,
+          'target' => target_id
+        })
+
+        # Add inscription (arc weight)
+        if arc.weight != 1
+          inscription_elem = arc_elem.add_element('inscription')
+          text_elem = inscription_elem.add_element('text')
+          text_elem.text = arc.weight.to_s
+        end
+
+        # Add arc expression if present
+        if arc.expression
+          add_arc_expression(arc_elem, arc.expression)
+        end
+      end
+
+      def add_arc_expression(arc_elem, expression)
+        inscription_elem = arc_elem.add_element('inscription')
+        text_elem = inscription_elem.add_element('text')
+
+        expr_text = if expression.respond_to?(:name) && expression.name
+                     expression.name
+                    else
+                      '[expression]'
+                    end
+        text_elem.text = expr_text
+      end
+
+      def add_color_declarations(net_element)
+        return unless colored_net? && @net.colors.any?
+
+        declaration_elem = net_element.add_element('declaration')
+        structure_elem = declaration_elem.add_element('structure')
+
+        @net.colors.each do |color_name, color|
+          add_color_declaration(structure_elem, color_name, color)
+        end
+      end
+
+      def add_color_declaration(structure_elem, color_name, color)
+        declaration = structure_elem.add_element('declaration')
+
+        name_elem = declaration.add_element('name')
+        text_elem = name_elem.add_element('text')
+        text_elem.text = color_name.to_s
+
+        # Add color attributes as structure
+        if color.attributes.any?
+          sort_elem = declaration.add_element('sort')
+          struct_elem = sort_elem.add_element('struct')
+
+          color.attributes.each do |attr_name, attr_type|
+            field_elem = struct_elem.add_element('field', {
+              'name' => attr_name.to_s,
+              'type' => attr_type.to_s
+            })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/export/yaml_exporter.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module PetriFlow
+  module Export
+    # Exports Petri nets and Colored Petri Nets to YAML format
+    # Provides the most human-readable format, ideal for configuration and documentation
+    class YamlExporter
+      attr_reader :net
+
+      def initialize(net)
+        @net = net
+      end
+
+      # Export to YAML string
+      # @return [String] YAML representation of the net
+      def to_yaml
+        to_hash.to_yaml
+      end
+
+      # Export to Ruby hash
+      # @return [Hash] Hash representation of the net
+      def to_hash
+        {
+          'meta' => meta_info,
+          'net' => net_structure,
+          'colors' => color_definitions,
+          'places' => places_data,
+          'transitions' => transitions_data,
+          'arcs' => arcs_data,
+          'marking' => current_marking,
+          'statistics' => statistics
+        }
+      end
+
+      # Save to YAML file
+      def save_yaml(filename)
+        File.write(filename, to_yaml)
+      end
+
+      private
+
+      def colored_net?
+        @net.is_a?(PetriFlow::Colored::ColoredNet)
+      end
+
+      def meta_info
+        {
+          'format' => 'PetriFlow YAML Export',
+          'version' => '1.0',
+          'exported_at' => Time.now.utc.iso8601,
+          'net_type' => colored_net? ? 'colored_petri_net' : 'petri_net'
+        }
+      end
+
+      def net_structure
+        {
+          'name' => @net.name,
+          'type' => colored_net? ? 'ColoredPetriNet' : 'PetriNet',
+          'place_count' => @net.places.size,
+          'transition_count' => @net.transitions.size,
+          'arc_count' => @net.arcs.size
+        }
+      end
+
+      def color_definitions
+        return [] unless colored_net?
+
+        @net.colors.map do |color_name, color|
+          {
+            'name' => color_name.to_s,
+            'attributes' => format_attributes(color.attributes),
+            'has_validator' => !color.validator.nil?
+          }
+        end
+      end
+
+      def format_attributes(attributes)
+        attributes.transform_keys(&:to_s).transform_values do |v|
+          v.is_a?(Symbol) ? v.to_s : v
+        end
+      end
+
+      def places_data
+        @net.places.map do |place_id, place|
+          place_hash = {
+            'id' => place_id.to_s,
+            'name' => place.name,
+            'tokens' => place.tokens,
+            'capacity' => place.capacity == Float::INFINITY ? 'infinite' : place.capacity
+          }
+
+          # Add colored net place info
+          if colored_net? && @net.colored_places[place_id]
+            colored_info = @net.colored_places[place_id]
+            place_hash['color'] = colored_info[:color].to_s if colored_info[:color]
+
+            colored_tokens = format_colored_tokens(place_id)
+            place_hash['colored_tokens'] = colored_tokens if colored_tokens.any?
+          end
+
+          place_hash
+        end
+      end
+
+      def format_colored_tokens(place_id)
+        return [] unless colored_net?
+
+        tokens = @net.token_pools[place_id] || []
+        tokens.map do |token|
+          token_hash = {
+            'id' => token.id,
+            'color' => token.color.to_s
+          }
+
+          token_hash['data'] = stringify_hash(token.data) if token.data.any?
+          token_hash['timestamp'] = token.timestamp if token.timestamp
+
+          token_hash
+        end
+      end
+
+      def stringify_hash(hash)
+        hash.transform_keys(&:to_s).transform_values do |v|
+          case v
+          when Symbol
+            v.to_s
+          when Hash
+            stringify_hash(v)
+          when Array
+            v.map { |item| item.is_a?(Hash) ? stringify_hash(item) : item }
+          else
+            v
+          end
+        end
+      end
+
+      def transitions_data
+        @net.transitions.map do |trans_id, transition|
+          trans_hash = {
+            'id' => trans_id.to_s,
+            'name' => transition.name,
+            'input_arcs' => transition.input_arcs.size,
+            'output_arcs' => transition.output_arcs.size,
+            'enabled' => transition.enabled?
+          }
+
+          # Add guard info
+          if transition.guard
+            trans_hash['guard'] = format_guard(transition.guard)
+          end
+
+          trans_hash
+        end
+      end
+
+      def format_guard(guard)
+        if guard.respond_to?(:name) && guard.name
+          {
+            'type' => 'named_guard',
+            'name' => guard.name,
+            'description' => guard.name
+          }
+        elsif guard.respond_to?(:condition)
+          {
+            'type' => 'guard',
+            'description' => 'Custom guard condition'
+          }
+        else
+          {
+            'type' => 'proc',
+            'description' => 'Lambda/Proc guard'
+          }
+        end
+      end
+
+      def arcs_data
+        @net.arcs.map.with_index do |arc, index|
+          arc_hash = {
+            'id' => "arc_#{index}",
+            'source' => {
+              'id' => arc.source.id.to_s,
+              'name' => arc.source.name,
+              'type' => arc.source.class.name.split('::').last
+            },
+            'target' => {
+              'id' => arc.target.id.to_s,
+              'name' => arc.target.name,
+              'type' => arc.target.class.name.split('::').last
+            },
+            'weight' => arc.weight,
+            'direction' => arc.input_arc? ? 'place_to_transition' : 'transition_to_place'
+          }
+
+          # Add arc expression info
+          if arc.expression
+            arc_hash['expression'] = format_expression(arc.expression)
+          end
+
+          arc_hash
+        end
+      end
+
+      def format_expression(expression)
+        if expression.respond_to?(:name) && expression.name
+          {
+            'type' => 'named_expression',
+            'name' => expression.name,
+            'description' => expression.name
+          }
+        elsif expression.respond_to?(:transformation)
+          {
+            'type' => 'arc_expression',
+            'description' => 'Custom arc expression'
+          }
+        else
+          {
+            'type' => 'proc',
+            'description' => 'Lambda/Proc expression'
+          }
+        end
+      end
+
+      def current_marking
+        marking_hash = {
+          'tokens_by_place' => stringify_hash(@net.places.transform_values(&:tokens)),
+          'total_tokens' => @net.places.values.sum(&:tokens)
+        }
+
+        if colored_net?
+          marking_hash['colored_marking'] = stringify_hash(@net.colored_marking)
+        end
+
+        marking_hash
+      end
+
+      def statistics
+        stringify_hash(@net.stats.merge({
+          enabled_transitions_list: @net.enabled_transitions.map { |t| t.id.to_s },
+          deadlocked: @net.deadlocked?
+        }))
+      end
+    end
+  end
+end