feel 0.0.1 → 0.0.4

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-module SpotFeel
+module FEEL
   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 FEEL.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 FEEL.config.strict && (hash.blank? || !hash.key?(key.to_sym))
           return nil unless hash
           hash[key.to_sym]
         end
@@ -330,9 +330,40 @@ module SpotFeel
   #
   # 35. string literal = '"' , { character – ('"' | vertical space) }, '"' ;
   #
-  class StringLiteral < Node
-    def eval(_context = {})
-      text_value[1..-2]
+  class StringLiteral < Treetop::Runtime::SyntaxNode
+    def eval(context={})
+      # Collect all characters and process escape sequences
+      string_value = chars.elements.map do |char|
+        if char.respond_to?(:text_value) && char.text_value.start_with?('\\')
+          process_escape_sequence(char.text_value)
+        else
+          char.text_value
+        end
+      end.join
+      
+      string_value
+    end
+    
+    private
+    
+    def process_escape_sequence(escape_seq)
+      case escape_seq
+      when '\\n'
+        "\n"
+      when '\\r'
+        "\r"
+      when '\\t'
+        "\t"
+      when '\\"'
+        '"'
+      when '\\\''
+        "'"
+      when '\\\\'
+        '\\'
+      else
+        # Return the character after the backslash for unknown escape sequences
+        escape_seq[1..-1]
+      end
     end
   end
 
@@ -385,7 +416,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 FEEL.config.strict
         return nil
       end
 
@@ -492,12 +523,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 +553,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 +587,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/{spot_feel → feel}/parser.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-module SpotFeel
+module FEEL
   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__), "feel.treetop")))
+    @@parser = FEELParser.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/feel/unary_tests.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FEEL
+  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/feel/version.rb

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

data/lib/feel.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "feel/version"
+
+require "active_support"
+require "active_support/time"
+require "active_support/core_ext/hash"
+
+require "treetop"
+
+require "feel/configuration"
+require "feel/nodes"
+require "feel/parser"
+
+require "feel/literal_expression"
+require "feel/unary_tests"
+
+module FEEL
+  class SyntaxError < StandardError; end
+  class EvaluationError < StandardError; end
+
+  def self.evaluate(expression_text, variables: {})
+    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 = FEEL::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.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: feel
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.4
 platform: ruby
 authors:
 - Connected Bits
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-30 00:00:00.000000000 Z
+date: 2025-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -39,21 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 7.0.2.3
 - !ruby/object:Gem::Dependency
-  name: awesome_print
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.9'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.9'
-- !ruby/object:Gem::Dependency
-  name: treetop
+  name: ostruct
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,19 +52,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: xmlhasher
+  name: treetop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: 1.6.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: 1.6.12
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -271,30 +256,20 @@ 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/feel.rb
+- lib/feel/configuration.rb
+- lib/feel/feel.treetop
+- lib/feel/literal_expression.rb
+- lib/feel/nodes.rb
+- lib/feel/parser.rb
+- lib/feel/unary_tests.rb
+- lib/feel/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,9 +284,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.
+summary: A light-weight FEEL expression evaluator in Ruby.
 test_files: []

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

data/lib/spot_feel/dmn/input.rb

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