dmn 0.0.1

data/lib/spot_feel/dmn/literal_expression.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+module SpotFeel
+  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 ||= SpotFeel::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 = (SpotFeel.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?(SpotFeel::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?(SpotFeel::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
+end

data/lib/spot_feel/dmn/output.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SpotFeel
+  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
+end

data/lib/spot_feel/dmn/rule.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SpotFeel
+  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
+end

data/lib/spot_feel/dmn/unary_tests.rb

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

data/lib/spot_feel/dmn/variable.rb

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

data/lib/spot_feel/dmn.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "dmn/variable"
+require_relative "dmn/literal_expression"
+require_relative "dmn/unary_tests"
+require_relative "dmn/input"
+require_relative "dmn/output"
+require_relative "dmn/rule"
+require_relative "dmn/decision_table"
+require_relative "dmn/information_requirement"
+require_relative "dmn/decision"
+require_relative "dmn/definitions"
+
+module SpotFeel
+  module Dmn
+  end
+end