standard_procedure_operations 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c254fd322931c448af32ef7aef5bfba2f09293b5d2ab2b85d069783be09cb8e3
-  data.tar.gz: e329a253576b4c4756793a068eedbb275c9ddab4ce0af4059285c0d13ad5dffe
+  metadata.gz: 05e2b09556bdcf1a1be75461eb956d4be95e0a736c49cf7cf40d83feb16e7ee3
+  data.tar.gz: 5fadaecabdc294707fc6a82f57c8163390494c7bb57afddb2701a9bd35ee3cc6
 SHA512:
-  metadata.gz: 920f49215031fce81eabe5dd4aec50df392d1dfd93cc497eb47aafbb4544ab9defd378faf0bb99d88b0c5c5fbf326e2dd2e77df6f2d8c737589944e174c0e740
-  data.tar.gz: 2c5c2cc235ed70113c7881fb75f46a9962548bd333d589cc73cbcbc5fbeb50f030b5212e2e2bbd16b7b4b3509284aa1b8e04d151b84cfde07780c4da5f9a9e5c
+  metadata.gz: 5db051c5929ba86f92a0eff0417fd84bc5e0aa5f368d5ef66855b5ad94df5b205da996b96235ae8802b07fa954a09464fda892bc670fa30df65f59a7c20e67a5
+  data.tar.gz: d155b7c72d0f452f792e75cae431e196f8dd22d844e9953959ec95fa1582a963644777317ba33c7b1c74a43c28b38c4489ae166a1ebce64f83d1c58ad0d6c55d

data/README.md

@@ -560,20 +560,17 @@ If you are using RSpec, you must `require "operations/matchers"` to make the mat
 
 ## Visualization
 
-Operations tasks can be visualized as flowcharts using the built-in GraphViz exporter. This helps you understand the flow of your operations and can be useful for documentation.
+Operations tasks can be visualized as flowcharts using the built-in SVG exporter. This helps you understand the flow of your operations and can be useful for documentation.
 
 ```ruby
-# Export a task to GraphViz
-exporter = Operations::Exporters::Graphviz.new(MyTask)
-
-# Save as PNG
-exporter.save("my_task_flow.png")
+# Export a task to SVG
+exporter = Operations::Exporters::SVG.new(MyTask)
 
 # Save as SVG
-exporter.save("my_task_flow.svg", format: :svg)
+exporter.save("my_task_flow.svg")
 
-# Get DOT format
-dot_string = exporter.to_dot
+# Get SVG content directly
+svg_string = exporter.to_svg
 ```
 
 ### Custom Condition Labels
@@ -598,8 +595,6 @@ The visualization includes:
 - Transition conditions between states with custom labels when provided
 - Special handling for custom transition blocks
 
-Note: To use the GraphViz exporter, you need to have the GraphViz tool installed on your system. On macOS, you can install it with `brew install graphviz`, on Ubuntu with `apt-get install graphviz`, and on Windows with the installer from the [GraphViz website](https://graphviz.org/download/).
-
 ## Installation
 Step 1: Add the gem to your Rails application's Gemfile:
 ```ruby
@@ -642,5 +637,5 @@ The gem is available as open source under the terms of the [LGPL License](/LICEN
 - [x] Make Operations::Task work in the background using ActiveJob
 - [x] Add pause/resume capabilities (for example, when a task needs to wait for user input)
 - [x] Add wait for sub-tasks capabilities
-- [x] Add GraphViz visualization export for task flows
-- [ ] Option to change background job queue and priority settings
+- [x] Add visualization export for task flows
+- [ ] Option to change background job queue and priority settings

data/lib/operations/exporters/svg.rb

@@ -0,0 +1,399 @@
+module Operations
+  module Exporters
+    # A pure Ruby SVG exporter for task visualization with no external dependencies
+    class SVG
+      attr_reader :task_class
+
+      COLORS = {
+        decision: "#4e79a7",  # Blue
+        action: "#f28e2b",    # Orange
+        wait: "#76b7b2",      # Teal
+        result: "#59a14f",    # Green
+        start: "#59a14f",     # Green
+        block: "#bab0ab"      # Grey
+      }
+
+      def self.export(task_class)
+        new(task_class).to_svg
+      end
+
+      def initialize(task_class)
+        @task_class = task_class
+        @node_positions = {}
+        @next_id = 0
+      end
+
+      # Generate SVG representation of the task flow
+      def to_svg
+        task_hash = task_class.to_h
+
+        # Calculate node positions using simple layout algorithm
+        calculate_node_positions(task_hash)
+
+        # Generate SVG
+        generate_svg(task_hash)
+      end
+
+      # Save the SVG to a file
+      def save(filename, format: :svg)
+        if format != :svg && format != :png
+          raise ArgumentError, "Only SVG format is supported without GraphViz"
+        end
+
+        File.write(filename, to_svg)
+      end
+
+      private
+
+      def generate_id
+        id = "node_#{@next_id}"
+        @next_id += 1
+        id
+      end
+
+      def calculate_node_positions(task_hash)
+        # Simple layout algorithm that positions nodes in columns by state type
+        # This is a minimal implementation; a real layout algorithm would be more complex
+
+        # Group nodes by type for column-based layout
+        nodes_by_type = {decision: [], action: [], wait: [], result: []}
+
+        task_hash[:states].each do |state_name, state_info|
+          nodes_by_type[state_info[:type]] << state_name if nodes_by_type.key?(state_info[:type])
+        end
+
+        # Process destination states from the go_to transitions to ensure they're included
+        task_hash[:states].each do |state_name, state_info|
+          state_info[:transitions]&.each do |_, target|
+            next if target.nil? || target.is_a?(Proc)
+            target_sym = target.to_sym
+
+            # Ensure target state exists in task hash
+            unless task_hash[:states].key?(target_sym)
+              # This is a placeholder for a missing state (likely a result)
+              task_hash[:states][target_sym] = {type: :result}
+              nodes_by_type[:result] << target_sym if nodes_by_type.key?(:result)
+            end
+          end
+
+          # Also process next_state for actions
+          if state_info[:next_state] && !task_hash[:states].key?(state_info[:next_state])
+            task_hash[:states][state_info[:next_state]] = {type: :result}
+            nodes_by_type[:result] << state_info[:next_state] if nodes_by_type.key?(:result)
+          end
+        end
+
+        # Calculate positions (this is simplified - a real algorithm would handle edge crossings better)
+        x_offset = 200  # Increased from 100 to give more space
+        column_width = 200
+        row_height = 150
+
+        # Position initial state (usually a decision)
+        task_hash[:initial_state]
+        @node_positions["START"] = [100, 100]  # Moved START from 50 to 100
+
+        # Position nodes by type in columns
+        [:decision, :action, :wait, :result].each_with_index do |type, col_idx|
+          nodes_by_type[type].each_with_index do |node_name, row_idx|
+            # Position nodes in a grid layout
+            x = x_offset + (col_idx * column_width)
+            y = 100 + (row_idx * row_height)
+            @node_positions[node_name] = [x, y]
+          end
+        end
+      end
+
+      def generate_svg(task_hash)
+        # SVG dimensions based on node positions
+        max_x = @node_positions.values.map(&:first).max + 150
+        max_y = @node_positions.values.map(&:last).max + 150
+
+        # Start SVG document
+        svg = <<~SVG
+          <svg xmlns="http://www.w3.org/2000/svg" width="#{max_x}" height="#{max_y}" viewBox="0 0 #{max_x} #{max_y}">
+            <defs>
+              <marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">
+                <polygon points="0 0, 10 3.5, 0 7" fill="#333" />
+              </marker>
+            </defs>
+        SVG
+
+        # Draw edges (connections between nodes)
+        svg += draw_edges(task_hash)
+
+        # Draw all nodes
+        svg += draw_nodes(task_hash)
+
+        # Close SVG document
+        svg += "</svg>"
+
+        svg
+      end
+
+      def draw_nodes(task_hash)
+        svg = ""
+
+        # Add starting node
+        if task_hash[:initial_state] && @node_positions[task_hash[:initial_state]]
+          svg += draw_circle(
+            @node_positions["START"][0],
+            @node_positions["START"][1],
+            20,
+            COLORS[:start],
+            "START"
+          )
+        end
+
+        # Add nodes for each state
+        task_hash[:states].each do |state_name, state_info|
+          next unless @node_positions[state_name]
+
+          x, y = @node_positions[state_name]
+          node_label = create_node_label(state_name, state_info)
+
+          svg += case state_info[:type]
+          when :decision
+            draw_diamond(x, y, 120, 80, COLORS[:decision], node_label)
+          when :action
+            draw_rectangle(x, y, 160, 80, COLORS[:action], node_label)
+          when :wait
+            draw_rectangle(x, y, 160, 80, COLORS[:wait], node_label, dashed: true)
+          when :result
+            draw_rectangle(x, y, 160, 80, COLORS[:result], node_label)
+          else
+            draw_rectangle(x, y, 160, 80, "#cccccc", node_label)
+          end
+        end
+
+        svg
+      end
+
+      def draw_edges(task_hash)
+        svg = ""
+
+        # Add edge from START to initial state
+        if task_hash[:initial_state] && @node_positions[task_hash[:initial_state]]
+          start_x, start_y = @node_positions["START"]
+          end_x, end_y = @node_positions[task_hash[:initial_state]]
+          svg += draw_arrow(start_x + 20, start_y, end_x - 60, end_y, "")
+        end
+
+        # Add edges for transitions
+        task_hash[:states].each do |state_name, state_info|
+          case state_info[:type]
+          when :decision
+            state_info[:transitions]&.each do |condition, target|
+              # Skip Proc targets as they're custom actions or nil targets
+              next if target.nil? || target.is_a?(Proc)
+
+              if @node_positions[state_name] && @node_positions[target.to_sym]
+                start_x, start_y = @node_positions[state_name]
+                end_x, end_y = @node_positions[target.to_sym]
+
+                # Use condition as label, or target state name if no condition
+                label = condition.to_s
+                if label.empty? || label == "nil"
+                  label = "→ #{target}"
+                end
+
+                svg += draw_arrow(start_x + 60, start_y, end_x - 80, end_y, label)
+              end
+            end
+          when :action
+            if state_info[:next_state] && @node_positions[state_name] && @node_positions[state_info[:next_state]]
+              start_x, start_y = @node_positions[state_name]
+              end_x, end_y = @node_positions[state_info[:next_state]]
+              label = "→ #{state_info[:next_state]}"
+              svg += draw_arrow(start_x + 80, start_y, end_x - 80, end_y, label)
+            end
+          when :wait
+            # Add a self-loop for wait condition
+            if @node_positions[state_name]
+              x, y = @node_positions[state_name]
+              svg += draw_self_loop(x, y, 160, 80, "waiting")
+
+              # Add transitions
+              state_info[:transitions]&.each do |condition, target|
+                # Skip Proc targets or nil targets
+                next if target.nil? || target.is_a?(Proc)
+
+                if @node_positions[target.to_sym]
+                  start_x, start_y = @node_positions[state_name]
+                  end_x, end_y = @node_positions[target.to_sym]
+
+                  # Use condition as label, or target state name if no condition
+                  label = condition.to_s
+                  if label.empty? || label == "nil"
+                    label = "→ #{target}"
+                  end
+
+                  svg += draw_arrow(start_x + 80, start_y, end_x - 80, end_y, label)
+                end
+              end
+            end
+          end
+        end
+
+        svg
+      end
+
+      # Helper methods for drawing SVG elements
+
+      def draw_rectangle(x, y, width, height, color, text, dashed: false)
+        style = dashed ? "fill:#{color};stroke:#333;stroke-width:2;stroke-dasharray:5,5;" : "fill:#{color};stroke:#333;stroke-width:2;"
+
+        # Create a unique ID for a group to contain both the shape and text
+        id = "rect-#{generate_id}"
+
+        <<~SVG
+          <g id="#{id}">
+            <rect x="#{x - width / 2}" y="#{y - height / 2}" width="#{width}" height="#{height}" rx="10" ry="10" style="#{style}" />
+            <text x="#{x}" y="#{y}" text-anchor="middle" fill="white" font-family="Arial" font-size="12px">#{escape_text(text)}</text>
+          </g>
+        SVG
+      end
+
+      def draw_diamond(x, y, width, height, color, text)
+        points = [
+          [x, y - height / 2],
+          [x + width / 2, y],
+          [x, y + height / 2],
+          [x - width / 2, y]
+        ].map { |px, py| "#{px},#{py}" }.join(" ")
+
+        # Create a unique ID for a group to contain both the shape and text
+        id = "diamond-#{generate_id}"
+
+        <<~SVG
+          <g id="#{id}">
+            <polygon points="#{points}" style="fill:#{color};stroke:#333;stroke-width:2;" />
+            <text x="#{x}" y="#{y}" text-anchor="middle" fill="white" font-family="Arial" font-size="12px">#{escape_text(text)}</text>
+          </g>
+        SVG
+      end
+
+      def draw_circle(x, y, radius, color, text)
+        # Create a unique ID for a group to contain both the shape and text
+        id = "circle-#{generate_id}"
+
+        <<~SVG
+          <g id="#{id}">
+            <circle cx="#{x}" cy="#{y}" r="#{radius}" style="fill:#{color};stroke:#333;stroke-width:2;" />
+            <text x="#{x}" y="#{y}" text-anchor="middle" fill="white" font-family="Arial" font-size="12px">#{escape_text(text)}</text>
+          </g>
+        SVG
+      end
+
+      def draw_arrow(x1, y1, x2, y2, label, dashed: false)
+        # Calculate the line and add an offset to avoid overlap with nodes
+        dx = x2 - x1
+        dy = y2 - y1
+        length = Math.sqrt(dx * dx + dy * dy)
+
+        # Make sure we don't divide by zero
+        if length.zero?
+          return ""
+        end
+
+        # Calculate control points for a slight curve
+        # This helps when there are multiple edges between the same nodes
+        mx = (x1 + x2) / 2
+        my = (y1 + y2) / 2
+
+        # Add slight curve for better visualization
+        cx = mx + dy * 0.2
+        cy = my - dx * 0.2
+
+        style = dashed ? "stroke:#333;stroke-width:2;fill:none;stroke-dasharray:5,5;" : "stroke:#333;stroke-width:2;fill:none;"
+        marker = "marker-end=\"url(#arrowhead)\""
+
+        # Create a unique ID for a group to contain both the path and label
+        id = "arrow-#{generate_id}"
+
+        svg = <<~SVG
+          <g id="#{id}">
+            <path d="M#{x1},#{y1} Q#{cx},#{cy} #{x2},#{y2}" style="#{style}" #{marker} />
+        SVG
+
+        # Add label if provided
+        if label && !label.empty?
+          # Create a white background for the label to improve readability
+          svg += <<~SVG
+            <rect x="#{mx + dy * 0.1 - 40}" y="#{my - dx * 0.1 - 10}" width="80" height="20" rx="5" ry="5" fill="white" fill-opacity="0.8" />
+            <text x="#{mx + dy * 0.1}" y="#{my - dx * 0.1}" text-anchor="middle" fill="#333" font-family="Arial" font-size="10px">#{escape_text(label)}</text>
+          SVG
+        end
+
+        svg += "</g>"
+        svg
+      end
+
+      def draw_self_loop(x, y, width, height, label)
+        # Create a self-loop arrow (circle with an arrow)
+        style = "stroke:#333;stroke-width:2;fill:none;stroke-dasharray:5,5;"
+
+        # Create a unique ID for a group to contain both the loop and label
+        id = "loop-#{generate_id}"
+
+        svg = <<~SVG
+          <g id="#{id}">
+            <ellipse cx="#{x - width / 2}" cy="#{y}" rx="20" ry="30" style="#{style}" />
+            <path d="M#{x - width / 2 - 10},#{y - 10} L#{x - width / 2 - 20},#{y} L#{x - width / 2 - 10},#{y + 10}" style="stroke:#333;stroke-width:2;fill:none;" />
+        SVG
+
+        # Add label with background
+        label_x = x - width / 2 - 30
+        label_y = y - 25
+
+        svg += <<~SVG
+            <rect x="#{label_x - 30}" y="#{label_y - 10}" width="60" height="20" rx="5" ry="5" fill="white" fill-opacity="0.8" />
+            <text x="#{label_x}" y="#{label_y}" text-anchor="middle" fill="#333" font-family="Arial" font-size="10px">#{escape_text(label)}</text>
+          </g>
+        SVG
+
+        svg
+      end
+
+      def create_node_label(state_name, state_info)
+        label = state_name.to_s
+
+        # Add inputs if present
+        if state_info[:inputs].present?
+          inputs_list = state_info[:inputs].map(&:to_s).join(", ")
+          label += "\nInputs: #{inputs_list}"
+        end
+
+        # Add optional inputs if present
+        if state_info[:optional_inputs].present?
+          optional_list = state_info[:optional_inputs].map(&:to_s).join(", ")
+          label += "\nOptional: #{optional_list}"
+        end
+
+        label
+      end
+
+      def escape_text(text)
+        # Split the text into lines for multi-line support
+        lines = text.to_s.split("\n")
+
+        if lines.length <= 1
+          # Simple case: just escape the text for a single line
+          return text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+        end
+
+        # For multi-line text, create tspan elements with proper alignment
+        line_height = 1.2 # em units
+        total_height = (lines.length - 1) * line_height
+        y_offset = -total_height / 2 # Start at negative half height to center vertically
+
+        # Escape XML special characters and add tspan elements for multi-line text
+        lines.map do |line|
+          line_text = line.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub("\"", "&quot;")
+          tspan = "<tspan x=\"0\" y=\"#{y_offset}em\" text-anchor=\"middle\">#{line_text}</tspan>"
+          y_offset += line_height # Move down for next line
+          tspan
+        end.join("")
+      end
+    end
+  end
+end

data/lib/operations/version.rb

@@ -1,3 +1,3 @@
 module Operations
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

data/lib/operations.rb

@@ -15,5 +15,5 @@ module Operations
   require "operations/cannot_wait_in_foreground"
   require "operations/timeout"
   require "operations/no_decision"
-  require "operations/exporters/graphviz"
+  require "operations/exporters/svg"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: standard_procedure_operations
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - Rahoul Baruah
 bindir: bin
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 2025-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -70,7 +70,7 @@ files:
 - lib/operations.rb
 - lib/operations/cannot_wait_in_foreground.rb
 - lib/operations/engine.rb
-- lib/operations/exporters/graphviz.rb
+- lib/operations/exporters/svg.rb
 - lib/operations/failure.rb
 - lib/operations/matchers.rb
 - lib/operations/no_decision.rb

data/lib/operations/exporters/graphviz.rb

@@ -1,164 +0,0 @@
-require "graphviz"
-
-module Operations
-  module Exporters
-    class Graphviz
-      attr_reader :task_class
-
-      def self.export(task_class)
-        new(task_class).to_dot
-      end
-
-      def initialize(task_class)
-        @task_class = task_class
-      end
-
-      # Generate a DOT representation of the task flow
-      def to_dot
-        graph.output(dot: String)
-      end
-
-      # Generate and save the graph to a file
-      # Supported formats: dot, png, svg, pdf, etc.
-      def save(filename, format: :png)
-        graph.output(format => filename)
-      end
-
-      # Generate GraphViz object representing the task flow
-      def graph
-        @graph ||= build_graph
-      end
-
-      private
-
-      def build_graph
-        task_hash = task_class.to_h
-        g = GraphViz.new(:G, type: :digraph, rankdir: "LR")
-
-        # Set up node styles
-        g.node[:shape] = "box"
-        g.node[:style] = "rounded"
-        g.node[:fontname] = "Arial"
-        g.node[:fontsize] = "12"
-        g.edge[:fontname] = "Arial"
-        g.edge[:fontsize] = "10"
-
-        # Create nodes for each state
-        nodes = {}
-        task_hash[:states].each do |state_name, state_info|
-          node_style = node_style_for(state_info[:type])
-          node_label = create_node_label(state_name, state_info)
-          nodes[state_name] = g.add_nodes(state_name.to_s, label: node_label, **node_style)
-        end
-
-        # Add edges for transitions
-        task_hash[:states].each do |state_name, state_info|
-          case state_info[:type]
-          when :decision
-            add_decision_edges(g, nodes, state_name, state_info[:transitions])
-          when :action
-            if state_info[:next_state]
-              g.add_edges(nodes[state_name], nodes[state_info[:next_state]])
-            end
-          when :wait
-            add_wait_edges(g, nodes, state_name, state_info[:transitions])
-          end
-        end
-
-        # Mark initial state
-        if nodes[task_hash[:initial_state]]
-          initial_node = g.add_nodes("START", shape: "circle", style: "filled", fillcolor: "#59a14f", fontcolor: "white")
-          g.add_edges(initial_node, nodes[task_hash[:initial_state]])
-        end
-
-        g
-      end
-
-      def node_style_for(type)
-        case type
-        when :decision
-          {shape: "diamond", style: "filled", fillcolor: "#4e79a7", fontcolor: "white"}
-        when :action
-          {shape: "box", style: "filled", fillcolor: "#f28e2b", fontcolor: "white"}
-        when :wait
-          {shape: "box", style: "filled,dashed", fillcolor: "#76b7b2", fontcolor: "white"}
-        when :result
-          {shape: "box", style: "filled", fillcolor: "#59a14f", fontcolor: "white"}
-        else
-          {shape: "box"}
-        end
-      end
-
-      def create_node_label(state_name, state_info)
-        label = state_name.to_s
-
-        # Add inputs if present
-        if state_info[:inputs].present?
-          inputs_list = state_info[:inputs].map(&:to_s).join(", ")
-          label += "\nInputs: #{inputs_list}"
-        end
-
-        # Add optional inputs if present
-        if state_info[:optional_inputs].present?
-          optional_list = state_info[:optional_inputs].map(&:to_s).join(", ")
-          label += "\nOptional: #{optional_list}"
-        end
-
-        label
-      end
-
-      def add_decision_edges(graph, nodes, state_name, transitions)
-        # Get the handler for this state to access condition labels
-        task_state = task_class.respond_to?(:states) ? task_class.states[state_name.to_sym] : nil
-        handler = task_state[:handler] if task_state
-
-        transitions.each_with_index do |(condition, target), index|
-          # Get custom label if available
-          label = (handler&.respond_to?(:condition_labels) && handler.condition_labels[index]) ? handler.condition_labels[index] : target.to_s
-
-          if (target.is_a?(Symbol) || target.is_a?(String)) && nodes[target.to_sym]
-            graph.add_edges(nodes[state_name], nodes[target.to_sym], label: label)
-          elsif target.respond_to?(:call)
-            # Create a special node to represent the custom action
-            block_node_name = "#{state_name}_#{condition}_block"
-            block_node = graph.add_nodes(block_node_name,
-              label: "#{condition} Custom Action",
-              shape: "note",
-              style: "filled",
-              fillcolor: "#bab0ab",
-              fontcolor: "black")
-
-            graph.add_edges(nodes[state_name], block_node,
-              label: label,
-              style: "dashed")
-          end
-        end
-      end
-
-      def add_wait_edges(graph, nodes, state_name, transitions)
-        # Get the handler for this state to access condition labels
-        task_state = task_class.respond_to?(:states) ? task_class.states[state_name.to_sym] : nil
-        handler = task_state[:handler] if task_state
-
-        # Add a self-loop for wait condition
-        graph.add_edges(nodes[state_name], nodes[state_name],
-          label: "waiting",
-          style: "dashed",
-          constraint: "false",
-          dir: "back")
-
-        # Add edges for each transition
-        transitions.each_with_index do |(condition, target), index|
-          # Get custom label if available
-          label = (handler&.respond_to?(:condition_labels) && handler.condition_labels[index]) ? handler.condition_labels[index] : target.to_s
-
-          if (target.is_a?(Symbol) || target.is_a?(String)) && nodes[target.to_sym]
-            graph.add_edges(nodes[state_name], nodes[target.to_sym],
-              label: label,
-              style: "solid")
-          end
-        end
-      end
-    end
-  end
-end