dmn 0.0.1 → 0.0.2

data/lib/{spot_feel → dmn}/nodes.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpotFeel
+module DMN
   class Node < Treetop::Runtime::SyntaxNode
     #
     # Takes a context hash and returns an array of qualified names
@@ -225,11 +225,11 @@ module SpotFeel
   class QualifiedName < Node
     def eval(context = {})
       if tail.empty?
-        raise_evaluation_error(head.text_value, context) if SpotFeel.config.strict && !context.key?(head.text_value.to_sym)
+        raise_evaluation_error(head.text_value, context) if DMN.config.strict && !context.key?(head.text_value.to_sym)
         context[head.text_value.to_sym]
       else
         tail.elements.flat_map { |element| element.name.text_value.split('.') }.inject(context[head.text_value.to_sym]) do |hash, key|
-          raise_evaluation_error("#{head.text_value}#{tail.text_value}", context) if SpotFeel.config.strict && (hash.blank? || !hash.key?(key.to_sym))
+          raise_evaluation_error("#{head.text_value}#{tail.text_value}", context) if DMN.config.strict && (hash.blank? || !hash.key?(key.to_sym))
           return nil unless hash
           hash[key.to_sym]
         end
@@ -385,7 +385,7 @@ module SpotFeel
       fn = context[fn_name.text_value.to_sym]
 
       unless fn
-        raise_evaluation_error(fn_name.text_value, context) if SpotFeel.config.strict
+        raise_evaluation_error(fn_name.text_value, context) if DMN.config.strict
         return nil
       end
 

data/lib/dmn/output.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DMN
+  class Output
+    attr_reader :id, :label, :name, :type_ref
+
+    def self.from_json(json)
+      Output.new(id: json[:id], label: json[:label], name: json[:name], type_ref: json[:type_ref])
+    end
+
+    def initialize(id:, label:, name:, type_ref:)
+      @id = id
+      @label = label
+      @name = name
+      @type_ref = type_ref
+    end
+
+    def as_json
+      {
+        id: id,
+        label: label,
+        name: name,
+        type_ref: type_ref,
+      }
+    end
+  end
+end

data/lib/{spot_feel → dmn}/parser.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-module SpotFeel
+module DMN
   class Parser
-    # Load the Treetop grammar from the 'spot_feel' file, and create a new
+    # Load the Treetop grammar from the 'feel' file, and create a new
     # instance of that parser as a class variable so we don't have to re-create
     # it every time we need to parse a string
-    Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'spot_feel.treetop')))
-    @@parser = SpotFeelParser.new
+    Treetop.load(File.expand_path(File.join(File.dirname(__FILE__), 'dmn.treetop')))
+    @@parser = DMNParser.new
 
     def self.parse(expression, root: nil)
       @@parser.parse(expression, root:).tap do |ast|

data/lib/dmn/rule.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module DMN
+  class Rule
+    attr_accessor :id, :input_entries, :output_entries, :description
+
+    def self.from_json(json)
+      input_entries = Array.wrap(json[:input_entry]).map { |input_entry| UnaryTests.from_json(input_entry) }
+      output_entries = Array.wrap(json[:output_entry]).map { |output_entry| LiteralExpression.from_json(output_entry) }
+      Rule.new(id: json[:id], input_entries:, output_entries:, description: json[:description])
+    end
+
+    def initialize(id:, input_entries:, output_entries:, description: nil)
+      @id = id
+      @input_entries = input_entries
+      @output_entries = output_entries
+      @description = description
+    end
+
+    def evaluate(input_values = [], variables = {})
+      [].tap do |test_results|
+        input_entries.each_with_index do |input_entry, index|
+          test_results.push input_entry.test(input_values[index], variables)
+        end
+      end
+    end
+
+    def as_json
+      {
+        id: id,
+        input_entries: input_entries.map(&:as_json),
+        output_entries: output_entries.map(&:as_json),
+        description: description,
+      }
+    end
+
+    def output_value(outputs, variables)
+      HashWithIndifferentAccess.new.tap do |ov|
+        output_entries.each_with_index do |output_entry, index|
+          if output_entry.valid?
+            val = output_entry.evaluate(variables)
+            nested_hash_value(ov, outputs[index].name, val)
+          end
+        end
+      end
+    end
+
+    private
+
+    def nested_hash_value(hash, key_string, value)
+      keys = key_string.split('.')
+      current = hash
+      keys[0...-1].each do |key|
+        current[key] ||= {}
+        current = current[key]
+      end
+      current[keys.last] = value
+      hash
+    end
+  end
+end

data/lib/dmn/unary_tests.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DMN
+  class UnaryTests < LiteralExpression
+    attr_reader :id, :text
+
+    def self.from_json(json)
+      UnaryTests.new(id: json[:id], text: json[:text])
+    end
+
+    def tree
+      @tree ||= Parser.parse_test(text)
+    end
+
+    def valid?
+      return true if text.nil? || text == '-'
+      tree.present?
+    end
+
+    def test(input, variables = {})
+      return true if text.nil? || text == '-'
+      tree.eval(functions.merge(variables)).call(input)
+    end
+  end
+end

data/lib/dmn/variable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DMN
+  class Variable
+    attr_reader :id, :name, :type_ref
+
+    def self.from_json(json)
+      Variable.new(id: json[:id], name: json[:name], type_ref: json[:type_ref])
+    end
+
+    def initialize(id:, name:, type_ref:)
+      @id = id
+      @name = name
+      @type_ref = type_ref
+    end
+
+    def as_json
+      {
+        id: id,
+        name: name,
+        type_ref: type_ref,
+      }
+    end
+  end
+end

data/lib/dmn/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DMN
+  VERSION = '0.0.2'
+end

data/lib/{spot_feel.rb → dmn.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "spot_feel/version"
+require_relative "dmn/version"
 
 require "awesome_print"
 
@@ -14,43 +14,53 @@ require "active_support/configurable"
 require "treetop"
 require "xmlhasher"
 
-require "spot_feel/configuration"
-require "spot_feel/nodes"
-require "spot_feel/parser"
+require "dmn/configuration"
+require "dmn/nodes"
+require "dmn/parser"
 
-require "spot_feel/dmn"
+require "dmn/variable"
+require "dmn/literal_expression"
+require "dmn/unary_tests"
+require "dmn/input"
+require "dmn/output"
+require "dmn/rule"
+require "dmn/decision_table"
+require "dmn/information_requirement"
+require "dmn/decision"
+require "dmn/definitions"
 
-module SpotFeel
+
+module DMN
   class SyntaxError < StandardError; end
   class EvaluationError < StandardError; end
 
   def self.evaluate(expression_text, variables: {})
-    literal_expression = Dmn::LiteralExpression.new(text: expression_text)
+    literal_expression = DMN::LiteralExpression.new(text: expression_text)
     raise SyntaxError, "Expression is not valid" unless literal_expression.valid?
     literal_expression.evaluate(variables)
   end
 
   def self.test(input, unary_tests_text, variables: {})
-    unary_tests = Dmn::UnaryTests.new(text: unary_tests_text)
+    unary_tests = DMN::UnaryTests.new(text: unary_tests_text)
     raise SyntaxError, "Unary tests are not valid" unless unary_tests.valid?
     unary_tests.test(input, variables)
   end
 
   def self.decide(decision_id, definitions: nil, definitions_json: nil, definitions_xml: nil, variables: {})
     if definitions_xml.present?
-      definitions = Dmn::Definitions.from_xml(definitions_xml)
+      definitions = DMN::Definitions.from_xml(definitions_xml)
     elsif definitions_json.present?
-      definitions = Dmn::Definitions.from_json(definitions_json)
+      definitions = DMN::Definitions.from_json(definitions_json)
     end
     definitions.evaluate(decision_id, variables: variables)
   end
 
   def self.definitions_from_xml(xml)
-    Dmn::Definitions.from_xml(xml)
+    DMN::Definitions.from_xml(xml)
   end
 
   def self.definitions_from_json(json)
-    Dmn::Definitions.from_json(json)
+    DMN::Definitions.from_json(json)
   end
 
   def self.config

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dmn
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Connected Bits
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-30 00:00:00.000000000 Z
+date: 2024-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -271,29 +271,28 @@ extra_rdoc_files: []
 files:
 - README.md
 - Rakefile
-- lib/spot_feel.rb
-- lib/spot_feel/configuration.rb
-- lib/spot_feel/dmn.rb
-- lib/spot_feel/dmn/decision.rb
-- lib/spot_feel/dmn/decision_table.rb
-- lib/spot_feel/dmn/definitions.rb
-- lib/spot_feel/dmn/information_requirement.rb
-- lib/spot_feel/dmn/input.rb
-- lib/spot_feel/dmn/literal_expression.rb
-- lib/spot_feel/dmn/output.rb
-- lib/spot_feel/dmn/rule.rb
-- lib/spot_feel/dmn/unary_tests.rb
-- lib/spot_feel/dmn/variable.rb
-- lib/spot_feel/nodes.rb
-- lib/spot_feel/parser.rb
-- lib/spot_feel/spot_feel.treetop
-- lib/spot_feel/version.rb
+- lib/dmn.rb
+- lib/dmn/configuration.rb
+- lib/dmn/decision.rb
+- lib/dmn/decision_table.rb
+- lib/dmn/definitions.rb
+- lib/dmn/dmn.treetop
+- lib/dmn/information_requirement.rb
+- lib/dmn/input.rb
+- lib/dmn/literal_expression.rb
+- lib/dmn/nodes.rb
+- lib/dmn/output.rb
+- lib/dmn/parser.rb
+- lib/dmn/rule.rb
+- lib/dmn/unary_tests.rb
+- lib/dmn/variable.rb
+- lib/dmn/version.rb
 homepage: https://www.connectedbits.com
 licenses:
 - MIT
 metadata:
   homepage_uri: https://www.connectedbits.com
-  source_code_uri: https://github.com/connectedbits/feel
+  source_code_uri: https://github.com/connectedbits/bpmn/feel
 post_install_message:
 rdoc_options: []
 require_paths:

data/lib/spot_feel/dmn/decision.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFeel
-  module Dmn
-    class Decision
-      attr_reader :id, :name, :decision_table, :variable, :literal_expression, :information_requirements
-
-      def self.from_json(json)
-        information_requirements = Array.wrap(json[:information_requirement]).map { |ir| InformationRequirement.from_json(ir) } if json[:information_requirement]
-        decision_table = DecisionTable.from_json(json[:decision_table]) if json[:decision_table]
-        literal_expression = LiteralExpression.from_json(json[:literal_expression]) if json[:literal_expression]
-        variable = Variable.from_json(json[:variable]) if json[:variable]
-        Decision.new(id: json[:id], name: json[:name], decision_table:, variable:, literal_expression:, information_requirements:)
-      end
-
-      def initialize(id:, name:, decision_table:, variable:, literal_expression:, information_requirements:)
-        @id = id
-        @name = name
-        @decision_table = decision_table
-        @variable = variable
-        @literal_expression = literal_expression
-        @information_requirements = information_requirements
-      end
-
-      def evaluate(variables = {})
-        if literal_expression.present?
-          result = literal_expression.evaluate(variables)
-          variable.present? ? { variable.name => result } : result
-        elsif decision_table.present?
-          decision_table.evaluate(variables)
-        end
-      end
-
-      def required_decision_ids
-        information_requirements&.map(&:required_decision_id)
-      end
-
-      def as_json
-        {
-          id: id,
-          name: name,
-          decision_table: decision_table.as_json,
-          variable: variable.as_json,
-          literal_expression: literal_expression.as_json,
-          information_requirements: information_requirements&.map(&:as_json),
-        }
-      end
-    end
-  end
-end

data/lib/spot_feel/dmn/decision_table.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFeel
-  module Dmn
-    class DecisionTable
-      attr_reader :id, :hit_policy, :inputs, :outputs, :rules
-
-      def self.from_json(json)
-        inputs = Array.wrap(json[:input]).map { |input| Input.from_json(input) }
-        outputs = Array.wrap(json[:output]).map { |output| Output.from_json(output) }
-        rules = Array.wrap(json[:rule]).map { |rule| Rule.from_json(rule) }
-        DecisionTable.new(id: json[:id], hit_policy: json[:hit_policy], inputs: inputs, outputs: outputs, rules: rules)
-      end
-
-      def initialize(id:, hit_policy:, inputs:, outputs:, rules:)
-        @id = id
-        @hit_policy = hit_policy&.downcase&.to_sym || :unique
-        @inputs = inputs
-        @outputs = outputs
-        @rules = rules
-      end
-
-      def evaluate(variables = {})
-        output_values = []
-
-        input_values = inputs.map do |input|
-          input.input_expression.evaluate(variables)
-        end
-
-        rules.each do |rule|
-          results = rule.evaluate(input_values, variables)
-          if results.all?
-            output_value = rule.output_value(outputs, variables)
-            return output_value if hit_policy == :first || hit_policy == :unique
-            output_values << output_value
-          end
-        end
-
-        output_values.empty? ? nil : output_values
-      end
-
-      def as_json
-        {
-          id: id,
-          hit_policy: hit_policy,
-          inputs: inputs.map(&:as_json),
-          outputs: outputs.map(&:as_json),
-          rules: rules.map(&:as_json),
-        }
-      end
-    end
-  end
-end

data/lib/spot_feel/dmn/definitions.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFeel
-  module Dmn
-    class Definitions
-      attr_reader :id, :name, :namespace, :exporter, :exporter_version, :execution_platform, :execution_platform_version
-      attr_reader :decisions
-
-      def self.from_xml(xml)
-        XmlHasher.configure do |config|
-          config.snakecase = true
-          config.ignore_namespaces = true
-          config.string_keys = false
-        end
-        json = XmlHasher.parse(xml)
-        Definitions.from_json(json[:definitions])
-      end
-
-      def self.from_json(json)
-        decisions = Array.wrap(json[:decision]).map { |decision| Decision.from_json(decision) }
-        Definitions.new(id: json[:id], name: json[:name], namespace: json[:namespace], exporter: json[:exporter], exporter_version: json[:exporter_version], execution_platform: json[:execution_platform], execution_platform_version: json[:execution_platform_version], decisions: decisions)
-      end
-
-      def initialize(id:, name:, namespace:, exporter:, exporter_version:, execution_platform:, execution_platform_version:, decisions:)
-        @id = id
-        @name = name
-        @namespace = namespace
-        @exporter = exporter
-        @exporter_version = exporter_version
-        @execution_platform = execution_platform
-        @execution_platform_version = execution_platform_version
-        @decisions = decisions
-      end
-
-      def evaluate(decision_id, variables: {}, already_evaluated_decisions: {})
-        decision = decisions.find { |d| d.id == decision_id }
-        raise EvaluationError, "Decision #{decision_id} not found" unless decision
-
-        # Evaluate required decisions recursively
-        decision.required_decision_ids&.each do |required_decision_id|
-          next if already_evaluated_decisions[required_decision_id]
-          next if decisions.find { |d| d.id == required_decision_id }.nil?
-
-          result = evaluate(required_decision_id, variables:, already_evaluated_decisions:)
-
-          variables.merge!(result) if result.is_a?(Hash)
-
-          already_evaluated_decisions[required_decision_id] = true
-        end
-
-        decision.evaluate(variables)
-      end
-
-      def as_json
-        {
-          id: id,
-          name: name,
-          namespace: namespace,
-          exporter: exporter,
-          exporter_version: exporter_version,
-          execution_platform: execution_platform,
-          execution_platform_version: execution_platform_version,
-          decisions: decisions.map(&:as_json),
-        }
-      end
-    end
-  end
-end

data/lib/spot_feel/dmn/information_requirement.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFeel
-  module Dmn
-    class InformationRequirement
-      attr_reader :id, :required_input_id, :required_decision_id
-
-      def self.from_json(json)
-        required_input_id = json[:required_input][:href].delete_prefix("#") if json[:required_input]
-        required_decision_id = json[:required_decision][:href].delete_prefix("#") if json[:required_decision]
-        InformationRequirement.new(id: json[:id], required_input_id: required_input_id, required_decision_id: required_decision_id)
-      end
-
-      def initialize(id:, required_input_id:, required_decision_id:)
-        @id = id
-        @required_input_id = required_input_id
-        @required_decision_id = required_decision_id
-      end
-
-      def as_json
-        {
-          id: id,
-          required_decision_id: required_decision_id,
-          required_input_id: required_input_id,
-        }
-      end
-    end
-  end
-end

data/lib/spot_feel/dmn/input.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFeel
-  module Dmn
-    class Input
-      attr_reader :id, :label, :input_expression
-
-      def self.from_json(json)
-        input_expression = LiteralExpression.from_json(json[:input_expression]) if json[:input_expression]
-        Input.new(id: json[:id], label: json[:label], input_expression:)
-      end
-
-      def initialize(id:, label:, input_expression:)
-        @id = id
-        @label = label
-        @input_expression = input_expression
-      end
-
-      def as_json
-        {
-          id: id,
-          label: label,
-          input_expression: input_expression.as_json,
-        }
-      end
-    end
-  end
-end