dmn 0.0.1 → 0.0.3

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-module SpotFeel
+module DMN
   class Node < Treetop::Runtime::SyntaxNode
     #
     # Takes a context hash and returns an array of qualified names
     # { "person": { "name": { "first": "Eric", "last": "Carlson" }, "age": 60 } } => ["person", "person.name.first", "person.name.last", "person.age"]
     #
-    def qualified_names_in_context(hash = {}, prefix = '', qualified_names = Set.new)
+    def qualified_names_in_context(hash = {}, prefix = "", qualified_names = Set.new)
       hash.each do |key, value|
         new_prefix = prefix.empty? ? "#{key}" : "#{prefix}.#{key}"
         if value.is_a?(Hash)
@@ -114,13 +114,13 @@ module SpotFeel
       second_val = second.eval(context)
 
       case [start, finish]
-      when ['(', ')']
+      when ["(", ")"]
         ->(input) { first_val < input && input < second_val }
-      when ['[', ']']
+      when ["[", "]"]
         ->(input) { first_val <= input && input <= second_val }
-      when ['(', ']']
+      when ["(", "]"]
         ->(input) { first_val < input && input <= second_val }
-      when ['[', ')']
+      when ["[", ")"]
         ->(input) { first_val <= input && input < second_val }
       end
     end
@@ -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))
+        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 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
 
@@ -492,12 +492,12 @@ module SpotFeel
   class Comparison < Node
     def eval(context = {})
       case operator.text_value
-      when '<' then left.eval(context) < right.eval(context)
-      when '<=' then left.eval(context) <= right.eval(context)
-      when '>=' then left.eval(context) >= right.eval(context)
-      when '>' then left.eval(context) > right.eval(context)
-      when '!=' then left.eval(context) != right.eval(context)
-      when '=' then left.eval(context) == right.eval(context)
+      when "<" then left.eval(context) < right.eval(context)
+      when "<=" then left.eval(context) <= right.eval(context)
+      when ">=" then left.eval(context) >= right.eval(context)
+      when ">" then left.eval(context) > right.eval(context)
+      when "!=" then left.eval(context) != right.eval(context)
+      when "=" then left.eval(context) == right.eval(context)
       end
     end
   end
@@ -522,7 +522,7 @@ module SpotFeel
   # 53. instance of = expression , "instance" , "of" , type ;
   #
   class InstanceOf < Node
-    def eval(context = {})
+    def eval(_context = {})
       case type.text_value
       when "string"
         ->(input) { input.is_a?(String) }
@@ -556,8 +556,6 @@ module SpotFeel
         ->(input) { input.is_a?(ActiveSupport::Duration) && input.parts.keys.sort == [:seconds] }
       when "time duration"
         ->(input) { input.is_a?(ActiveSupport::Duration) && input.parts.keys.sort == [:hours, :minutes, :seconds] }
-      when "years and months duration"
-        ->(input) { input.is_a?(ActiveSupport::Duration) && input.parts.keys.sort == [:months, :years] }
       when "list"
         ->(input) { input.is_a?(Array) }
       when "interval"

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|
@@ -15,15 +15,15 @@ module SpotFeel
     end
 
     def self.parse_test(expression)
-      @@parser.parse(expression || '-', root: :simple_unary_tests).tap do |ast|
+      @@parser.parse(expression || "-", root: :simple_unary_tests).tap do |ast|
         raise SyntaxError, "Invalid unary test: #{expression.inspect}" unless ast
       end
     end
 
     def self.clean_tree(root_node)
       return if(root_node.elements.nil?)
-      root_node.elements.delete_if{|node| node.class.name == "Treetop::Runtime::SyntaxNode" }
-      root_node.elements.each {|node| self.clean_tree(node) }
+      root_node.elements.delete_if{ |node| node.class.name == "Treetop::Runtime::SyntaxNode" }
+      root_node.elements.each { |node| self.clean_tree(node) }
     end
   end
 end

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.3"
+end

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

@@ -1,56 +1,61 @@
 # frozen_string_literal: true
 
-require_relative "spot_feel/version"
-
-require "awesome_print"
+require_relative "dmn/version"
 
 require "active_support"
-require "active_support/duration"
 require "active_support/time"
 require "active_support/core_ext/hash"
-require "active_support/core_ext/object/json"
-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 "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"
 
-require "spot_feel/dmn"
 
-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,13 @@
 --- !ruby/object:Gem::Specification
 name: dmn
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Connected Bits
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-30 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -39,33 +38,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 7.0.2.3
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: ostruct
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: treetop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.6.12
 - !ruby/object:Gem::Dependency
   name: xmlhasher
   requirement: !ruby/object:Gem::Requirement
@@ -271,30 +270,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
-post_install_message:
+  source_code_uri: https://github.com/connectedbits/bpmn/feel
 rdoc_options: []
 require_paths:
 - lib
@@ -309,8 +306,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.5
 specification_version: 4
 summary: A light-weight DMN FEEL expression evaluator and business rule engine in
   Ruby.

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