decision_agent 0.2.0 → 0.3.0

data/lib/decision_agent/dmn/importer.rb

@@ -0,0 +1,77 @@
+require_relative "parser"
+require_relative "validator"
+require_relative "adapter"
+require_relative "../versioning/version_manager"
+
+module DecisionAgent
+  module Dmn
+    # Imports DMN XML files into DecisionAgent
+    class Importer
+      def initialize(version_manager: nil)
+        @version_manager = version_manager || Versioning::VersionManager.new
+      end
+
+      # Import DMN file
+      # @param file_path [String] Path to DMN XML file
+      # @param ruleset_name [String, nil] Optional custom ruleset name
+      # @param created_by [String] User who imported
+      # @return [Hash] Import result with model and version info
+      def import(file_path, ruleset_name: nil, created_by: "system")
+        xml_content = File.read(file_path)
+        import_from_xml(xml_content, ruleset_name: ruleset_name, created_by: created_by)
+      end
+
+      # Import from XML string
+      def import_from_xml(xml_content, ruleset_name: nil, created_by: "system")
+        # Parse DMN XML
+        parser = Parser.new(xml_content)
+        model = parser.parse
+
+        # Validate model
+        validator = Validator.new(model)
+        validator.validate!
+
+        # Convert to JSON rules
+        results = convert_model_to_rules(model)
+
+        # Store in versioning system
+        versions = store_in_versioning(results, ruleset_name, created_by)
+
+        {
+          model: model,
+          rules: results,
+          versions: versions,
+          decisions_imported: results.size
+        }
+      end
+
+      private
+
+      def convert_model_to_rules(model)
+        model.decisions.map do |decision|
+          next unless decision.decision_table
+
+          adapter = Adapter.new(decision.decision_table)
+          {
+            decision_id: decision.id,
+            decision_name: decision.name,
+            rules: adapter.to_json_rules
+          }
+        end.compact
+      end
+
+      def store_in_versioning(results, ruleset_name, created_by)
+        results.map do |result|
+          rule_id = ruleset_name || result[:decision_id]
+
+          @version_manager.save_version(
+            rule_id: rule_id,
+            rule_content: result[:rules],
+            created_by: created_by,
+            changelog: "Imported DMN decision: #{result[:decision_name]}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dmn/model.rb

@@ -0,0 +1,197 @@
+require_relative "errors"
+
+module DecisionAgent
+  module Dmn
+    # Root DMN model containing all decisions
+    class Model
+      attr_reader :id, :name, :namespace, :decisions
+
+      def initialize(id:, name:, namespace: "http://decision_agent.local")
+        @id = id.to_s
+        @name = name.to_s
+        @namespace = namespace.to_s
+        @decisions = []
+      end
+
+      def add_decision(decision)
+        raise TypeError, "Expected Decision, got #{decision.class}" unless decision.is_a?(Decision)
+
+        @decisions << decision
+      end
+
+      def find_decision(decision_id)
+        @decisions.find { |d| d.id == decision_id.to_s }
+      end
+
+      def freeze
+        @id.freeze
+        @name.freeze
+        @namespace.freeze
+        @decisions.each(&:freeze)
+        @decisions.freeze
+        super
+      end
+    end
+
+    # Represents a single decision element
+    class Decision
+      attr_accessor :decision_tree
+      attr_reader :id, :name, :decision_table, :description, :information_requirements
+
+      def initialize(id:, name:, description: nil)
+        @id = id.to_s
+        @name = name.to_s
+        @description = description&.to_s
+        @decision_table = nil
+        @decision_tree = nil
+        @information_requirements = []
+      end
+
+      def decision_table=(table)
+        raise TypeError, "Expected DecisionTable, got #{table.class}" unless table.is_a?(DecisionTable)
+
+        @decision_table = table
+      end
+
+      def add_information_requirement(requirement)
+        @information_requirements << requirement
+      end
+
+      def freeze
+        @id.freeze
+        @name.freeze
+        @description.freeze
+        @decision_table&.freeze
+        @decision_tree&.freeze
+        @information_requirements.freeze
+        super
+      end
+    end
+
+    # Decision table with inputs, outputs, rules, and hit policy
+    class DecisionTable
+      attr_reader :id, :hit_policy, :inputs, :outputs, :rules
+
+      VALID_HIT_POLICIES = %w[UNIQUE FIRST PRIORITY ANY COLLECT].freeze
+
+      def initialize(id:, hit_policy: "UNIQUE")
+        @id = id.to_s
+        validate_hit_policy!(hit_policy)
+        @hit_policy = hit_policy.to_s
+        @inputs = []
+        @outputs = []
+        @rules = []
+      end
+
+      def add_input(input)
+        raise TypeError, "Expected Input, got #{input.class}" unless input.is_a?(Input)
+
+        @inputs << input
+      end
+
+      def add_output(output)
+        raise TypeError, "Expected Output, got #{output.class}" unless output.is_a?(Output)
+
+        @outputs << output
+      end
+
+      def add_rule(rule)
+        raise TypeError, "Expected Rule, got #{rule.class}" unless rule.is_a?(Rule)
+
+        @rules << rule
+      end
+
+      def freeze
+        @id.freeze
+        @hit_policy.freeze
+        @inputs.each(&:freeze)
+        @inputs.freeze
+        @outputs.each(&:freeze)
+        @outputs.freeze
+        @rules.each(&:freeze)
+        @rules.freeze
+        super
+      end
+
+      private
+
+      def validate_hit_policy!(policy)
+        return if VALID_HIT_POLICIES.include?(policy.to_s)
+
+        raise UnsupportedHitPolicyError,
+              "Hit policy '#{policy}' not supported. " \
+              "Supported: #{VALID_HIT_POLICIES.join(', ')}"
+      end
+    end
+
+    # Input clause (column) in decision table
+    class Input
+      attr_reader :id, :label, :expression, :type_ref
+
+      def initialize(id:, label:, expression: nil, type_ref: "string")
+        @id = id.to_s
+        @label = label.to_s
+        @expression = expression&.to_s || label.to_s
+        @type_ref = type_ref.to_s
+      end
+
+      def freeze
+        @id.freeze
+        @label.freeze
+        @expression.freeze
+        @type_ref.freeze
+        super
+      end
+    end
+
+    # Output clause (result column) in decision table
+    class Output
+      attr_reader :id, :label, :name, :type_ref
+
+      def initialize(id:, label:, name: nil, type_ref: "string")
+        @id = id.to_s
+        @label = label.to_s
+        @name = (name || label).to_s
+        @type_ref = type_ref.to_s
+      end
+
+      def freeze
+        @id.freeze
+        @label.freeze
+        @name.freeze
+        @type_ref.freeze
+        super
+      end
+    end
+
+    # Decision table rule (row)
+    class Rule
+      attr_reader :id, :input_entries, :output_entries, :description
+
+      def initialize(id:, description: nil)
+        @id = id.to_s
+        @description = description&.to_s
+        @input_entries = []
+        @output_entries = []
+      end
+
+      def add_input_entry(entry)
+        @input_entries << entry.to_s
+      end
+
+      def add_output_entry(entry)
+        @output_entries << entry
+      end
+
+      def freeze
+        @id.freeze
+        @description.freeze
+        @input_entries.each(&:freeze)
+        @input_entries.freeze
+        @output_entries.map { |e| e.freeze if e.respond_to?(:freeze) }
+        @output_entries.freeze
+        super
+      end
+    end
+  end
+end

data/lib/decision_agent/dmn/parser.rb

@@ -0,0 +1,191 @@
+require "nokogiri"
+require "securerandom"
+require_relative "model"
+require_relative "errors"
+
+module DecisionAgent
+  module Dmn
+    # Parses DMN 1.3 XML files into Ruby model objects
+    class Parser
+      NAMESPACES = {
+        "dmn" => "https://www.omg.org/spec/DMN/20191111/MODEL/",
+        "dmn11" => "http://www.omg.org/spec/DMN/20151101/dmn.xsd",
+        "dmn13" => "https://www.omg.org/spec/DMN/20191111/MODEL/"
+      }.freeze
+
+      def initialize(xml_content)
+        @xml_content = xml_content
+        @doc = nil
+        @namespace = nil
+      end
+
+      def parse
+        parse_xml
+        extract_model
+      end
+
+      private
+
+      def parse_xml
+        @doc = Nokogiri::XML(@xml_content)
+
+        if @doc.errors.any?
+          raise InvalidDmnXmlError,
+                "XML parsing failed: #{@doc.errors.map(&:to_s).join(', ')}"
+        end
+
+        # Detect namespace
+        @namespace = detect_namespace
+      end
+
+      def detect_namespace
+        if @doc.root.namespace&.href&.include?("20191111")
+          NAMESPACES["dmn13"]
+        elsif @doc.root.namespace&.href&.include?("20151101")
+          NAMESPACES["dmn11"]
+        else
+          # Default to DMN 1.3
+          NAMESPACES["dmn13"]
+        end
+      end
+
+      def extract_model
+        definitions = @doc.at_xpath("//dmn:definitions", NAMESPACES) ||
+                      @doc.at_xpath("//*[local-name()='definitions']")
+
+        raise InvalidDmnXmlError, "No definitions element found" unless definitions
+
+        model = Model.new(
+          id: definitions["id"] || "model",
+          name: definitions["name"] || "DMN Model",
+          namespace: definitions["namespace"] || @namespace
+        )
+
+        # Parse all decisions
+        decisions = @doc.xpath("//dmn:decision", NAMESPACES)
+        decisions = @doc.xpath("//*[local-name()='decision']") if decisions.empty?
+
+        decisions.each do |decision_node|
+          decision = parse_decision(decision_node)
+          model.add_decision(decision)
+        end
+
+        model.freeze
+        model
+      end
+
+      def parse_decision(node)
+        decision = Decision.new(
+          id: node["id"] || SecureRandom.uuid,
+          name: node["name"] || "Unnamed Decision",
+          description: extract_description(node)
+        )
+
+        # Parse decision table if present
+        table_node = node.at_xpath(".//dmn:decisionTable", NAMESPACES) ||
+                     node.at_xpath(".//*[local-name()='decisionTable']")
+
+        decision.decision_table = parse_decision_table(table_node) if table_node
+
+        decision.freeze
+        decision
+      end
+
+      def parse_decision_table(node)
+        table = DecisionTable.new(
+          id: node["id"] || SecureRandom.uuid,
+          hit_policy: node["hitPolicy"] || "UNIQUE"
+        )
+
+        # Parse inputs
+        inputs = node.xpath(".//dmn:input", NAMESPACES)
+        inputs = node.xpath(".//*[local-name()='input']") if inputs.empty?
+
+        inputs.each do |input_node|
+          table.add_input(parse_input(input_node))
+        end
+
+        # Parse outputs
+        outputs = node.xpath(".//dmn:output", NAMESPACES)
+        outputs = node.xpath(".//*[local-name()='output']") if outputs.empty?
+
+        outputs.each do |output_node|
+          table.add_output(parse_output(output_node))
+        end
+
+        # Parse rules
+        rules = node.xpath(".//dmn:rule", NAMESPACES)
+        rules = node.xpath(".//*[local-name()='rule']") if rules.empty?
+
+        rules.each do |rule_node|
+          table.add_rule(parse_rule(rule_node))
+        end
+
+        table.freeze
+        table
+      end
+
+      def parse_input(node)
+        input_expr = node.at_xpath(".//dmn:inputExpression", NAMESPACES) ||
+                     node.at_xpath(".//*[local-name()='inputExpression']")
+
+        text_node = input_expr&.at_xpath(".//dmn:text", NAMESPACES) ||
+                    input_expr&.at_xpath(".//*[local-name()='text']")
+
+        Input.new(
+          id: node["id"] || SecureRandom.uuid,
+          label: node["label"] || text_node&.text || "Input",
+          expression: text_node&.text,
+          type_ref: input_expr&.[]("typeRef") || "string"
+        ).freeze
+      end
+
+      def parse_output(node)
+        Output.new(
+          id: node["id"] || SecureRandom.uuid,
+          label: node["label"] || node["name"] || "Output",
+          name: node["name"] || node["label"] || "output",
+          type_ref: node["typeRef"] || "string"
+        ).freeze
+      end
+
+      def parse_rule(node)
+        rule = Rule.new(
+          id: node["id"] || SecureRandom.uuid,
+          description: extract_description(node)
+        )
+
+        # Parse input entries
+        input_entries = node.xpath(".//dmn:inputEntry", NAMESPACES)
+        input_entries = node.xpath(".//*[local-name()='inputEntry']") if input_entries.empty?
+
+        input_entries.each do |entry_node|
+          text_node = entry_node.at_xpath(".//dmn:text", NAMESPACES) ||
+                      entry_node.at_xpath(".//*[local-name()='text']")
+          text = text_node&.text || "-"
+          rule.add_input_entry(text)
+        end
+
+        # Parse output entries
+        output_entries = node.xpath(".//dmn:outputEntry", NAMESPACES)
+        output_entries = node.xpath(".//*[local-name()='outputEntry']") if output_entries.empty?
+
+        output_entries.each do |entry_node|
+          text_node = entry_node.at_xpath(".//dmn:text", NAMESPACES) ||
+                      entry_node.at_xpath(".//*[local-name()='text']")
+          text = text_node&.text
+          rule.add_output_entry(text)
+        end
+
+        rule.freeze
+        rule
+      end
+
+      def extract_description(node)
+        desc_node = node.at_xpath(".//dmn:description", NAMESPACES) ||
+                    node.at_xpath(".//*[local-name()='description']")
+        desc_node&.text
+      end
+    end
+  end
+end