feel 0.0.1 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e07c50d749e9aac71d11c036197e5035c7f6a1d147d0e2ab547850c6ecf74594
-  data.tar.gz: 8930a354648c1f3ebd3efa7279957715b7dfefbe7ce8d37a0829237373faee67
+  metadata.gz: 2dc28e5cc40b7473deaec4d6a8c7c22d63f0674cde48b8a8b3a3b34a00da56ba
+  data.tar.gz: ff19b52d1d239a7918001f0c60995e92ea0fa8b67b6389e9e157d00719ff15ca
 SHA512:
-  metadata.gz: bf93e2d4f6ecdee1f267564639c14ee96079b7bb6c173859db8671276ed123dadec41cb9897bf1faee736d252c6374a95b845b832e2d2d8f6f8a1c5924d94c7b
-  data.tar.gz: 66dca276a2b5daa6c0d8012618406525f5666a2dc0207afbd3185c3d961e24b5c149f97ae3289da05f715bf04b66cc0b9a8f7c441ec083a5af2ba6ec4bceee86
+  metadata.gz: a69d2493f1d27317e8956abf57a8929bcd216c48f93ae0ca978cb6d49ddc5d274e50819f2983916bd468a93b01c63291f7c8b34b0a08cfb93de7c2923741e459
+  data.tar.gz: 2c67dca58835e521a6b89395008d20bde423cd8921f2216c340fad2035940d6d1cb482f44f0d91c36b4600f262c5c64bce865387b1d9951a643e7f4777d4b115

data/README.md

@@ -1,12 +1,12 @@
-# Spot Feel
+# FEEL
 
-A light-weight DMN FEEL expression evaluator and business rule engine in Ruby.
+A light-weight FEEL expression evaluator ruby gem.
 
 This gem implements a subset of FEEL (Friendly Enough Expression Language) as defined in the [DMN 1.3 specification](https://www.omg.org/spec/DMN/1.3/PDF) with some additional extensions.
 
 FEEL expressions are parsed into an abstract syntax tree (AST) and then evaluated in a context. The context is a hash of variables and functions to be resolved inside the expression.
 
-Expressions are safe, side-effect free, and deterministic. They are ideal for capturing business logic for storage in a database or embedded in DMN, BPMN, or Form documents for execution in a workflow engine like [Spot Flow](https://github.com/connectedbits/spot-flow).
+Expressions are safe, side-effect free, and deterministic. They are ideal for capturing business logic for storage in a database or embedded in DMN, BPMN, or Form documents for execution in a workflow engine.
 
 This project was inspired by these excellent libraries:
 
@@ -18,7 +18,7 @@ This project was inspired by these excellent libraries:
 To evaluate an expression:
 
 ```ruby
-SpotFeel.evaluate('"👋 Hello " + name', variables: { name: "World" })
+FEEL.evaluate('"👋 Hello " + name', variables: { name: "World" })
 # => "👋 Hello World"
 ```
 
@@ -31,55 +31,50 @@ variables = {
     age: 59,
   }
 }
-SpotFeel.evaluate('if person.age >= 18 then "adult" else "minor"', variables:)
+FEEL.evaluate('if person.age >= 18 then "adult" else "minor"', variables:)
 # => "adult"
 ```
 
+Strict mode will raise an exception if an expression references a variable that is not defined in the context.
+
+```ruby
+FEEL.configure do |config|
+  config.strict = true
+end
+
+LiteralExpression.new(text: "person.agx").evaluate({ "person": { "name": "Bob", "age": 32 } })
+# => raises EvaluationError("Identifier person.agx not found. Did you mean person.age?")
+```
+
 Calling a built-in function:
 
 ```ruby
-SpotFeel.evaluate('sum([1, 2, 3])')
+FEEL.evaluate('sum([1, 2, 3])')
 # => 6
 ```
 
 Calling a user-defined function:
 
 ```ruby
-SpotFeel.config.functions = {
+FEEL.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'))
+FEEL.test(3, '<= 10, > 50'))
 # => true
 ```
 
 ```ruby
-SpotFeel.test("Eric", '"Bob", "Holly", "Eric"')
+FEEL.test("Eric", '"Bob", "Holly", "Eric"')
 # => true
 ```
 
-![Decision Table](docs/media/decision_table.png)
-
-To evaluate a DMN decision table:
-
-```ruby
-variables = {
-  violation: {
-    type: "speed",
-    actual_speed: 100,
-    speed_limit: 65,
-  }
-}
-result = SpotFeel.decide('fine_decision', definitions_xml: fixture_source("fine.dmn"), variables:)
-# => { "amount" => 1000, "points" => 7 })
-```
-
 To get a list of variables or functions used in an expression:
 
 ```ruby
@@ -143,25 +138,18 @@ UnaryTests.new(text: '> speed - speed_limit').variable_names
 - [x] Context: `get entries`, `get value`, `get keys`
 - [x] Temporal: `now`, `today`, `day of week`, `day of year`, `month of year`, `week of year`
 
-### DMN
-
-- [x] Parse DMN XML documents
-- [x] Evaluate DMN Decision Tables
-- [x] Evaluate dependent DMN Decision Tables
-- [x] Evaluate Expression Decisions
-
 ## Installation
 
 Execute:
 
 ```bash
-$ bundle add "spot_feel"
+$ bundle add "feel"
 ```
 
 Or install it directly:
 
 ```bash
-$ gem install spot_feel
+$ gem install feel
 ```
 
 ### Setup

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

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

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

@@ -1,4 +1,4 @@
-grammar SpotFeel
+grammar FEEL
 
   rule start
     expression_or_tests
@@ -370,27 +370,22 @@ grammar SpotFeel
   end
 
   rule double_string_character
-    !('"' / "\\" / line_terminator) source_character /
-    "\\" escape_sequence /
-    line_continuation
+    !('"' / "\\") source_character /
+    "\\" escape_sequence
   end
 
   rule single_string_character
-    !("'" / "\\" / line_terminator) source_character /
-    "\\" escape_sequence /
-    line_continuation
+    !("'" / "\\") source_character /
+    "\\" escape_sequence
   end
 
   rule source_character
     .
   end
 
-  rule line_continuation
-    "\\" __ line_terminator_sequence __
-  end
-
   rule escape_sequence
-    character_escape_sequence
+    character_escape_sequence /
+    line_terminator_sequence
   end
 
   rule character_escape_sequence
@@ -398,15 +393,15 @@ grammar SpotFeel
   end
 
   rule single_escape_character
-    "'" / '"' / "\\"
+    "'" / '"' / "\\" / "n" / "r" / "t"
   end
 
   rule line_terminator
-    line_terminator_sequence
+    "\n" / "\r" / "\r\n"
   end
 
   rule line_terminator_sequence
-    "\n" / "\r" / "\r\n"
+    line_terminator
   end
 
   #

data/lib/feel/literal_expression.rb

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