dmn 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83ab9c509d78447fc0dcf11d993e79c9105baf97904af53e932e16ae7eaee2df
-  data.tar.gz: be469b68cdeab12f0ffee64e6a1c884ee9b67d10e2d9b899f1f3ecfa7905a975
+  metadata.gz: 99f8ad17d713e6ce95941ee100f3c4046a2ffc93155ea6629a6761bb3745e1ca
+  data.tar.gz: ad53db39e8b2e96884644d177486b8cf1d65a8d608d5b09c136ee37b0d3daad5
 SHA512:
-  metadata.gz: a5b1b6a24a4c6d2f305d41e94ac83bcb951f1dbfe8fc4ddccc6d5675ee5f3af70529778f288db5c7dea989a5ef7af685250ad6b7abd5dea7b80bef1afe20d019
-  data.tar.gz: 62e2cecb612379245854e09684e1632ae6fb670d0618577685d00e92c944aaf44c9e8a5e59173372280a5887879a190603bd1ec47e07f34bebb9e533f91d9a3b
+  metadata.gz: 8e8009211631110c50467c8ff2f8b857095ca497409171590d44135c2bd25ee5ced0d7d99c676f48a0137c3b7083c00e349f0853cca2cbfae0e45baa316b612e
+  data.tar.gz: bf0a15e9f42f288505314de24eec35a70fdc621238e6944bd46d69b72e82de83cddab12cc891e6f2542bf5a99c7b5c32aa17a216ba4c00ef9482692abac3289a

data/README.md

@@ -1,69 +1,11 @@
-# Spot Feel
+# DMN
 
-A light-weight DMN FEEL expression evaluator and business rule engine in Ruby.
+A light-weight DMN (Decision Model and Notation) business rule 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).
-
-This project was inspired by these excellent libraries:
-
-- [feelin](https://github.com/nikku/feelin)
-- [dmn-eval-js](https://github.com/mineko-io/dmn-eval-js)
+This gem depends on the [FEEL](https://github.com/connectedbits/bpmn/tree/main/feel) gem to evaluate DMN decision tables and expressions.
 
 ## Usage
 
-To evaluate an expression:
-
-```ruby
-DMN.evaluate('"👋 Hello " + name', variables: { name: "World" })
-# => "👋 Hello World"
-```
-
-A slightly more complex example:
-
-```ruby
-variables = {
-  person: {
-    name: "Eric",
-    age: 59,
-  }
-}
-DMN.evaluate('if person.age >= 18 then "adult" else "minor"', variables:)
-# => "adult"
-```
-
-Calling a built-in function:
-
-```ruby
-DMN.evaluate('sum([1, 2, 3])')
-# => 6
-```
-
-Calling a user-defined function:
-
-```ruby
-DMN.config.functions = {
-  "reverse": ->(s) { s.reverse }
-}
-DMN.evaluate('reverse("Hello World!")', functions:)
-# => "!dlroW olleH"
-```
-
-To evaluate a unary tests:
-
-```ruby
-DMN.test(3, '<= 10, > 50'))
-# => true
-```
-
-```ruby
-DMN.test("Eric", '"Bob", "Holly", "Eric"')
-# => true
-```
-
 ![Decision Table](docs/media/decision_table.png)
 
 To evaluate a DMN decision table:
@@ -80,71 +22,8 @@ result = DMN.decide('fine_decision', definitions_xml: fixture_source("fine.dmn")
 # => { "amount" => 1000, "points" => 7 })
 ```
 
-To get a list of variables or functions used in an expression:
-
-```ruby
-LiteralExpression.new(text: 'person.first_name + " " + person.last_name').variable_names
-# => ["person.age, person.last_name"]
-```
-
-```ruby
-LiteralExpression.new(text: 'sum([1, 2, 3])').function_names
-# => ["sum"]
-```
-
-```ruby
-UnaryTests.new(text: '> speed - speed_limit').variable_names
-# => ["speed, speed_limit"]
-```
-
 ## Supported Features
 
-### Data Types
-
-- [x] Boolean (true, false)
-- [x] Number (integer, decimal)
-- [x] String (single and double quoted)
-- [x] Date, Time, Duration (ISO 8601)
-- [x] List (array)
-- [x] Context (hash)
-
-### Expressions
-
-- [x] Literal
-- [x] Path
-- [x] Arithmetic
-- [x] Comparison
-- [x] Function Invocation
-- [x] Positional Parameters
-- [x] If Expression
-- [ ] For Expression
-- [ ] Quantified Expression
-- [ ] Filter Expression
-- [ ] Disjunction
-- [ ] Conjuction
-- [ ] Instance Of
-- [ ] Function Definition
-
-### Unary Tests
-
-- [x] Comparison
-- [x] Interval/Range (inclusive and exclusive)
-- [x] Disjunction
-- [x] Negation
-- [ ] Expression
-
-### Built-in Functions
-
-- [x] Conversion: `string`, `number`
-- [x] Boolean: `not`, `is defined`, `get or else`
-- [x] String: `substring`, `substring before`, `substring after`, `string length`, `upper case`, `lower case`, `contains`, `starts with`, `ends with`, `matches`, `replace`, `split`, `strip`, `extract`
-- [x] Numeric: `decimal`, `floor`, `ceiling`, `round`, `abs`, `modulo`, `sqrt`, `log`, `exp`, `odd`, `even`, `random number`
-- [x] List: `list contains`, `count`, `min`, `max`, `sum`, `product`, `mean`, `median`, `stddev`, `mode`, `all`, `any`, `sublist`, `append`, `concatenate`, `insert before`, `remove`, `reverse`, `index of`, `union`, `distinct values`, `duplicate values`, `flatten`, `sort`, `string join`
-- [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
@@ -172,10 +51,6 @@ $ bin/setup
 $ bin/guard
 ```
 
-## Development
-
-[Treetop Doumentation](https://cjheath.github.io/treetop/syntactic_recognition.html) is a good place to start learning about Treetop.
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/dmn/decision.rb

@@ -7,7 +7,7 @@ module DMN
     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]
+      literal_expression = FEEL::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

data/lib/dmn/input.rb

@@ -5,7 +5,8 @@ module DMN
     attr_reader :id, :label, :input_expression
 
     def self.from_json(json)
-      input_expression = LiteralExpression.from_json(json[:input_expression]) if json[:input_expression]
+      input_expression = FEEL::
+      LiteralExpression.from_json(json[:input_expression]) if json[:input_expression]
       Input.new(id: json[:id], label: json[:label], input_expression:)
     end
 

data/lib/dmn/rule.rb

@@ -5,8 +5,8 @@ module DMN
     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) }
+      input_entries = Array.wrap(json[:input_entry]).map { |input_entry| FEEL::UnaryTests.from_json(input_entry) }
+      output_entries = Array.wrap(json[:output_entry]).map { |output_entry| FEEL::LiteralExpression.from_json(output_entry) }
       Rule.new(id: json[:id], input_entries:, output_entries:, description: json[:description])
     end
 

data/lib/dmn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DMN
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/dmn.rb

@@ -6,16 +6,13 @@ require "active_support"
 require "active_support/time"
 require "active_support/core_ext/hash"
 
-require "treetop"
+require "feel"
+
 require "xmlhasher"
 
 require "dmn/configuration"
-require "dmn/nodes"
-require "dmn/parser"
 
 require "dmn/variable"
-require "dmn/literal_expression"
-require "dmn/unary_tests"
 require "dmn/input"
 require "dmn/output"
 require "dmn/rule"
@@ -30,13 +27,13 @@ module DMN
   class EvaluationError < StandardError; end
 
   def self.evaluate(expression_text, variables: {})
-    literal_expression = DMN::LiteralExpression.new(text: expression_text)
+    literal_expression = FEEL::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 = FEEL::UnaryTests.new(text: unary_tests_text)
     raise SyntaxError, "Unary tests are not valid" unless unary_tests.valid?
     unary_tests.test(input, variables)
   end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: dmn
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Connected Bits
 bindir: bin
 cert_chain: []
-date: 2025-03-03 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: feel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.4
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -275,15 +289,10 @@ files:
 - 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