dmn 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b9993953a743d1305667dd56353fa828ff9e3bf3cfecd1f1fffb94dd7eb1842
-  data.tar.gz: a7a498cf1098796664b33dc5cac84969ddacc6df8a2b418032befcdc51ea5eb2
+  metadata.gz: 83ab9c509d78447fc0dcf11d993e79c9105baf97904af53e932e16ae7eaee2df
+  data.tar.gz: be469b68cdeab12f0ffee64e6a1c884ee9b67d10e2d9b899f1f3ecfa7905a975
 SHA512:
-  metadata.gz: fc9de27ca64c128d7d6401792fbdf8a61ce97e6eef64c936e7c1e7bab74214fa109bcdb3f07fcc9f63aeeceddf74490e4ea6ca61d54061c46e6576e322ececef
-  data.tar.gz: 88913ed1996eeaf913e366368d180d6cb7e3b941bfaa7366b8d387b2ccc6213677471797cd5ffc02f9c15959cae80798b1a6f0cf3d16662e03b3608b020e8f2b
+  metadata.gz: a5b1b6a24a4c6d2f305d41e94ac83bcb951f1dbfe8fc4ddccc6d5675ee5f3af70529778f288db5c7dea989a5ef7af685250ad6b7abd5dea7b80bef1afe20d019
+  data.tar.gz: 62e2cecb612379245854e09684e1632ae6fb670d0618577685d00e92c944aaf44c9e8a5e59173372280a5887879a190603bd1ec47e07f34bebb9e533f91d9a3b

data/README.md

@@ -18,7 +18,7 @@ This project was inspired by these excellent libraries:
 To evaluate an expression:
 
 ```ruby
-SpotFeel.evaluate('"👋 Hello " + name', variables: { name: "World" })
+DMN.evaluate('"👋 Hello " + name', variables: { name: "World" })
 # => "👋 Hello World"
 ```
 
@@ -31,36 +31,36 @@ variables = {
     age: 59,
   }
 }
-SpotFeel.evaluate('if person.age >= 18 then "adult" else "minor"', variables:)
+DMN.evaluate('if person.age >= 18 then "adult" else "minor"', variables:)
 # => "adult"
 ```
 
 Calling a built-in function:
 
 ```ruby
-SpotFeel.evaluate('sum([1, 2, 3])')
+DMN.evaluate('sum([1, 2, 3])')
 # => 6
 ```
 
 Calling a user-defined function:
 
 ```ruby
-SpotFeel.config.functions = {
+DMN.config.functions = {
   "reverse": ->(s) { s.reverse }
 }
-SpotFeel.evaluate('reverse("Hello World!")', functions:)
+DMN.evaluate('reverse("Hello World!")', functions:)
 # => "!dlroW olleH"
 ```
 
 To evaluate a unary tests:
 
 ```ruby
-SpotFeel.test(3, '<= 10, > 50'))
+DMN.test(3, '<= 10, > 50'))
 # => true
 ```
 
 ```ruby
-SpotFeel.test("Eric", '"Bob", "Holly", "Eric"')
+DMN.test("Eric", '"Bob", "Holly", "Eric"')
 # => true
 ```
 
@@ -76,7 +76,7 @@ variables = {
     speed_limit: 65,
   }
 }
-result = SpotFeel.decide('fine_decision', definitions_xml: fixture_source("fine.dmn"), variables:)
+result = DMN.decide('fine_decision', definitions_xml: fixture_source("fine.dmn"), variables:)
 # => { "amount" => 1000, "points" => 7 })
 ```
 
@@ -155,13 +155,13 @@ UnaryTests.new(text: '> speed - speed_limit').variable_names
 Execute:
 
 ```bash
-$ bundle add "spot_feel"
+$ bundle add "dmn"
 ```
 
 Or install it directly:
 
 ```bash
-$ gem install spot_feel
+$ gem install dmn
 ```
 
 ### Setup

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpotFeel
+module DMN
   class Configuration
     attr_accessor :functions, :strict
 

data/lib/dmn/decision.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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

data/lib/dmn/decision_table.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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

data/lib/dmn/definitions.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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

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

@@ -1,4 +1,4 @@
-grammar SpotFeel
+grammar DMN
 
   rule start
     expression_or_tests

data/lib/dmn/information_requirement.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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

data/lib/dmn/input.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+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

data/lib/dmn/literal_expression.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+module DMN
+  class LiteralExpression
+    attr_reader :id, :text
+
+    def self.from_json(json)
+      LiteralExpression.new(id: json[:id], text: json[:text])
+    end
+
+    def initialize(id: nil, text:)
+      @id = id
+      @text = text&.strip
+    end
+
+    def tree
+      @tree ||= DMN::Parser.parse(text)
+    end
+
+    def valid?
+      return false if text.blank?
+      tree.present?
+    end
+
+    def evaluate(variables = {})
+      tree.eval(functions.merge(variables))
+    end
+
+    def functions
+      builtins = LiteralExpression.builtin_functions
+      custom = (DMN.config.functions || {})
+      ActiveSupport::HashWithIndifferentAccess.new(builtins.merge(custom))
+    end
+
+    def named_functions
+      # Initialize a set to hold the qualified names
+      function_names = Set.new
+
+      # Define a lambda for the recursive function
+      walk_tree = lambda do |node|
+        # If the node is a qualified name, add it to the set
+        if node.is_a?(DMN::FunctionInvocation)
+          function_names << node.fn_name.text_value
+        end
+
+        # Recursively walk the child nodes
+        node.elements&.each do |child|
+          walk_tree.call(child)
+        end
+      end
+
+      # Start walking the tree from the root
+      walk_tree.call(tree)
+
+      # Return the array of functions
+      function_names.to_a
+    end
+
+    def named_variables
+      # Initialize a set to hold the qualified names
+      qualified_names = Set.new
+
+      # Define a lambda for the recursive function
+      walk_tree = lambda do |node|
+        # If the node is a qualified name, add it to the set
+        if node.is_a?(DMN::QualifiedName)
+          qualified_names << node.text_value
+        end
+
+        # Recursively walk the child nodes
+        node.elements&.each do |child|
+          walk_tree.call(child)
+        end
+      end
+
+      # Start walking the tree from the root
+      walk_tree.call(tree)
+
+      # Return the array of qualified names
+      qualified_names.to_a
+    end
+
+    def self.builtin_functions
+      HashWithIndifferentAccess.new({
+        # Conversion functions
+        "string": ->(from) {
+          return if from.nil?
+          from.to_s
+        },
+        "number": ->(from) {
+          return if from.nil?
+          from.include?(".") ? from.to_f : from.to_i
+        },
+        # Boolean functions
+        "not": ->(value) {
+          if value == true || value == false
+            !value
+          end
+        },
+        "is defined": ->(value) {
+          return if value.nil?
+          !value.nil?
+        },
+        "get or else": ->(value, default) {
+          value.nil? ? default : value
+        },
+        # String functions
+        "substring": ->(string, start, length) {
+          return if string.nil? || start.nil?
+          return "" if length.nil?
+          string[start - 1, length]
+        },
+        "substring before": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.split(match).first
+        },
+        "substring after": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.split(match).last
+        },
+        "string length": ->(string) {
+          return if string.nil?
+          string.length
+        },
+        "upper case": ->(string) {
+          return if string.nil?
+          string.upcase
+        },
+        "lower case": -> (string) {
+          return if string.nil?
+          string.downcase
+        },
+        "contains": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.include?(match)
+        },
+        "starts with": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.start_with?(match)
+        },
+        "ends with": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.end_with?(match)
+        },
+        "matches": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.match?(match)
+        },
+        "replace": ->(string, match, replacement) {
+          return if string.nil? || match.nil? || replacement.nil?
+          string.gsub(match, replacement)
+        },
+        "split": ->(string, match) {
+          return if string.nil? || match.nil?
+          string.split(match)
+        },
+        "strip": -> (string) {
+          return if string.nil?
+          string.strip
+        },
+        "extract": -> (string, pattern) {
+          return if string.nil? || pattern.nil?
+          string.match(pattern).captures
+        },
+        # Numeric functions
+        "decimal": ->(n, scale) {
+          return if n.nil? || scale.nil?
+          n.round(scale)
+        },
+        "floor": ->(n) {
+          return if n.nil?
+          n.floor
+        },
+        "ceiling": ->(n) {
+          return if n.nil?
+          n.ceil
+        },
+        "round up": ->(n) {
+          return if n.nil?
+          n.ceil
+        },
+        "round down": ->(n) {
+          return if n.nil?
+          n.floor
+        },
+        "abs": ->(n) {
+          return if n.nil?
+          n.abs
+        },
+        "modulo": ->(n, divisor) {
+          return if n.nil? || divisor.nil?
+          n % divisor
+        },
+        "sqrt": ->(n) {
+          return if n.nil?
+          Math.sqrt(n)
+        },
+        "log": ->(n) {
+          return if n.nil?
+          Math.log(n)
+        },
+        "exp": ->(n) {
+          return if n.nil?
+          Math.exp(n)
+        },
+        "odd": ->(n) {
+          return if n.nil?
+          n.odd?
+        },
+        "even": ->(n) {
+          return if n.nil?
+          n.even?
+        },
+        "random number": ->(n) {
+          return if n.nil?
+          rand(n)
+        },
+        # List functions
+        "list contains": ->(list, match) {
+          return if list.nil?
+          return false if match.nil?
+          list.include?(match)
+        },
+        "count": ->(list) {
+          return if list.nil?
+          return 0 if list.empty?
+          list.length
+        },
+        "min": ->(list) {
+          return if list.nil?
+          list.min
+        },
+        "max": ->(list) {
+          return if list.nil?
+          list.max
+        },
+        "sum": ->(list) {
+          return if list.nil?
+          list.sum
+        },
+        "product": ->(list) {
+          return if list.nil?
+          list.inject(:*)
+        },
+        "mean": ->(list) {
+          return if list.nil?
+          list.sum / list.length
+        },
+        "median": ->(list) {
+          return if list.nil?
+          list.sort[list.length / 2]
+        },
+        "stddev": ->(list) {
+          return if list.nil?
+          mean = list.sum / list.length.to_f
+          Math.sqrt(list.map { |n| (n - mean)**2 }.sum / list.length)
+        },
+        "mode": ->(list) {
+          return if list.nil?
+          list.group_by(&:itself).values.max_by(&:size).first
+        },
+        "all": ->(list) {
+          return if list.nil?
+          list.all?
+        },
+        "any": ->(list) {
+          return if list.nil?
+          list.any?
+        },
+        "sublist": ->(list, start, length) {
+          return if list.nil? || start.nil?
+          return [] if length.nil?
+          list[start - 1, length]
+        },
+        "append": ->(list, item) {
+          return if list.nil?
+          list + [item]
+        },
+        "concatenate": ->(list1, list2) {
+          return [nil, nil] if list1.nil? && list2.nil?
+          return [nil] + list2 if list1.nil?
+          return list1 + [nil] if list2.nil?
+          Array.wrap(list1) + Array.wrap(list2)
+        },
+        "insert before": ->(list, position, item) {
+          return if list.nil? || position.nil?
+          list.insert(position - 1, item)
+        },
+        "remove": ->(list, position) {
+          return if list.nil? || position.nil?
+          list.delete_at(position - 1); list
+        },
+        "reverse": ->(list) {
+          return if list.nil?
+          list.reverse
+        },
+        "index of": ->(list, match) {
+          return if list.nil?
+          return [] if match.nil?
+          list.index(match) + 1
+        },
+        "union": ->(list1, list2) {
+          return if list1.nil? || list2.nil?
+          list1 | list2
+        },
+        "distinct values": ->(list) {
+          return if list.nil?
+          list.uniq
+        },
+        "duplicate values": ->(list) {
+          return if list.nil?
+          list.select { |e| list.count(e) > 1 }.uniq
+        },
+        "flatten": ->(list) {
+          return if list.nil?
+          list.flatten
+        },
+        "sort": ->(list) {
+          return if list.nil?
+          list.sort
+        },
+        "string join": ->(list, separator) {
+          return if list.nil?
+          list.join(separator)
+        },
+        # Context functions
+        "get value": ->(context, name) {
+          return if context.nil? || name.nil?
+          context[name]
+        },
+        "context put": ->(context, name, value) {
+          return if context.nil? || name.nil?
+          context[name] = value; context
+        },
+        "context merge": ->(context1, context2) {
+          return if context1.nil? || context2.nil?
+          context1.merge(context2)
+        },
+        "get entries": ->(context) {
+          return if context.nil?
+          context.entries
+        },
+        # Temporal functions
+        "now": ->() { Time.now },
+        "today": ->() { Date.today },
+        "day of week": ->(date) {
+          return if date.nil?
+          date.wday
+        },
+        "day of year": ->(date) {
+          return if date.nil?
+          date.yday
+        },
+        "week of year": ->(date) {
+          return if date.nil?
+          date.cweek
+        },
+        "month of year": ->(date) {
+          return if date.nil?
+          date.month
+        },
+      })
+    end
+
+    def as_json
+      {
+        id: id,
+        text: text,
+      }
+    end
+  end
+end