lex-conditioner 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7c725a33a160829135b9b2269533484ab211ee5654951d929ce49dbfffcbbe
-  data.tar.gz: c4b994cf4d00aac64316b4023b63fb02cb420288fc0eb310868c3ad9a49ec856
+  metadata.gz: 906d2b96665278b78cb003349e7d5733546ededdfd2eade4f61e270f5c778a7f
+  data.tar.gz: 60bbb47534fc56690960b82717dbfbb5dc76edd79465517f481f881686edde6c
 SHA512:
-  metadata.gz: 15f92eb0f63890df974300c03c72c082228b61ad165c29da251a6955060f98bbbdb25bf80d2841f2c284a3deeb6c5e099e826747e85e4a74ce9d4fd8eca83acb
-  data.tar.gz: 4a41130e68f0a464e48ff540fc442b91c7f2cef10aa0ad165484b43cf6895623f6df07be4ea8f856de6b865a8ba3d197a3771f4cc781e8f19608c8d6cce6413a
+  metadata.gz: 8477f380f05f478cd823f8acf6e435a691f303682c07d849016445770f890a55c3f5fa2f755dd9b3050d92e56dc1cd8e75d55f2c5c49039a4c87c70018337a1c
+  data.tar.gz: e5b6063b50c13fd4e454356a6df9afe724ceb0653868e32180ffc9e49e7e1c35bcf500fd05981c10b2a4d9a96b523141d63687186950416ed2d7b5a6b860fade

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+Gemfile.lock

data/.rubocop.yml

@@ -1,33 +1,49 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
 Layout/LineLength:
-  Max: 120
+  Max: 160
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
 Metrics/MethodLength:
-  Max: 30
+  Max: 50
 Metrics/ClassLength:
   Max: 1500
+Metrics/ModuleLength:
+  Max: 1500
 Metrics/BlockLength:
-  Max: 50
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
 Metrics/AbcSize:
-  Max: 20
+  Max: 60
 Metrics/CyclomaticComplexity:
-  Max: 20
+  Max: 15
 Metrics/PerceivedComplexity:
-  Max: 20
-Layout/SpaceAroundEqualsInParameterDefault:
-  EnforcedStyle: space
-Style/SymbolArray:
-  Enabled: true
-Layout/HashAlignment:
-  EnforcedHashRocketStyle: table
-  EnforcedColonStyle: table
+  Max: 17
+Metrics/ParameterLists:
+  Enabled: false
+
 Style/Documentation:
   Enabled: false
-AllCops:
-  TargetRubyVersion: 2.5
-  NewCops: enable
-  SuggestExtensions: false
+Style/SymbolArray:
+  Enabled: true
 Style/FrozenStringLiteralComment:
-  Enabled: false
+  Enabled: true
+  EnforcedStyle: always
+
 Naming/FileName:
   Enabled: false
-Style/ClassAndModuleChildren:
-  Enabled: false
+Naming/PredicateMethod:
+  Enabled: false
+Naming/PredicatePrefix:
+  Enabled: false
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [0.3.0] - 2026-03-17
+
+### Added
+- 14 new operators: `greater_than`, `less_than`, `greater_or_equal`, `less_or_equal`, `between` (numeric); `contains`, `starts_with`, `ends_with`, `matches` (string); `in_set`, `not_in_set`, `empty`, `not_empty`, `size_equal` (collection) — 23 total
+- Structured condition explanation via `Condition#explain` returning per-rule results with `fact`, `operator`, `value`, `actual`, and `result`
+- Standalone `Client` class for framework-independent evaluation
+- SimpleCov coverage reporting
+- Modern packaging: grouped test dependencies, `require_relative` in gemspec, `rubocop-rspec`
+
+### Fixed
+- `Comparator.false?` returning `nil` instead of `false` for truthy values
+- Typo `funciton_id` corrected to `function_id` in runner `send_task` whitelist
+
+## [0.2.5] - 2026-03-13
+
+### Added
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,89 @@
+# lex-conditioner: Conditional Rule Engine for LegionIO
+
+**Repository Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-core/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Legion Extension that applies conditional statements to tasks within relationships. Evaluates JSON-based rules against task payloads to determine whether downstream tasks should execute, enabling branching logic in task chains.
+
+**GitHub**: https://github.com/LegionIO/lex-conditioner
+**License**: MIT
+**Version**: 0.3.0
+
+## Architecture
+
+```
+Legion::Extensions::Conditioner
+├── Actors/
+│   └── Conditioner       # Subscription actor consuming condition evaluation requests
+├── Runners/
+│   └── Conditioner       # Executes conditional logic against task payloads
+│       ├── check         # Main entry point: evaluates conditions, dispatches or fails
+│       └── send_task     # Routes to transformation or task queue based on result
+├── Helpers/
+│   ├── Condition         # Condition parsing (all/any nesting, dotted-path facts)
+│   └── Comparator        # Comparison operator implementations (class methods)
+└── Transport/
+    ├── Exchanges/Task    # Publishes to the task exchange
+    ├── Queues/Conditioner # Subscribes to condition evaluation queue
+    └── Messages/Conditioner # Message format for condition requests
+```
+
+## Key Files
+
+| Path | Purpose |
+|------|---------|
+| `lib/legion/extensions/conditioner.rb` | Entry point, extension registration |
+| `lib/legion/extensions/conditioner/runners/conditioner.rb` | Core condition evaluation logic |
+| `lib/legion/extensions/conditioner/helpers/condition.rb` | Condition parsing and all/any evaluation |
+| `lib/legion/extensions/conditioner/helpers/comparator.rb` | Comparison operator implementations |
+| `lib/legion/extensions/conditioner/actors/conditioner.rb` | AMQP subscription actor |
+
+## Condition Rule Format
+
+Rules use `all`/`any` grouping with `fact`/`operator`/`value` entries. Facts use dot notation to address nested payload keys.
+
+### Operators
+
+**Binary** (require `fact` + `value`):
+- `equal` - exact equality
+- `not_equal` - inequality
+
+**Unary** (require `fact` only):
+- `nil` - value is nil
+- `not_nil` - value is not nil
+- `is_true` - value is truthy
+- `is_false` - value is falsy
+- `is_string` - value is a String
+- `is_array` - value is an Array
+- `is_integer` - value is an Integer
+
+## Condition Evaluation Logic
+
+After evaluation, the runner sets task status based on outcome:
+- Condition passes + transformation present: `transformation.queued` (routes to `task.subtask.transform`)
+- Condition passes + routing key present: `task.queued` (routes to `runner_routing_key`)
+- Condition passes but no routing info: `task.exception` (`send_task` is still called and raises `MissingArgument`)
+- Condition fails: `conditioner.failed` (`send_task` is skipped)
+
+## Dependencies
+
+| Gem | Purpose |
+|-----|---------|
+| `legion-exceptions` | Exception handling |
+
+## Testing
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+Spec files: `spec/legion/extensions/conditioner_spec.rb`, `spec/legion/extensions/comparator_spec.rb`, `spec/legion/extensions/condition_spec.rb`, `spec/legion/extensions/conditioner/runners/conditioner_spec.rb`
+
+---
+
+**Maintained By**: Matthew Iverson (@Esity)

data/Dockerfile

@@ -5,4 +5,4 @@ RUN apk update && apk add build-base tzdata postgresql-dev mysql-client mariadb-
 
 COPY . ./
 RUN gem install lex-conditioner legion-data --no-document --no-prerelease
-CMD ruby $(which legionio)
+CMD ruby --yjit $(which legionio)

data/Gemfile

@@ -1,3 +1,14 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec', '~> 3.13'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop', '~> 1.75'
+  gem 'rubocop-rspec'
+  gem 'simplecov'
+end

data/README.md

@@ -1,38 +1,125 @@
-# Legion::Extensions::Conditioner
+# lex-conditioner
 
-A core Legion Extension used to evaluate conditions for sub tasks to run
+Conditional rule engine for [LegionIO](https://github.com/LegionIO/LegionIO). Evaluates JSON-based rules against task payloads to determine whether downstream tasks should execute, enabling branching logic in task chains.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+```bash
+gem install lex-conditioner
+```
+
+Or add to your Gemfile:
 
 ```ruby
 gem 'lex-conditioner'
 ```
 
-And then execute:
+## Standalone Client
+
+Use the conditioner without the full LegionIO framework:
+
+```ruby
+require 'legion/extensions/conditioner/client'
+
+client = Legion::Extensions::Conditioner::Client.new
+
+result = client.evaluate(
+  conditions: { all: [
+    { fact: 'response.code', operator: 'greater_or_equal', value: 200 },
+    { fact: 'response.code', operator: 'less_than', value: 300 }
+  ] },
+  values: { response: { code: 200, body: 'OK' } }
+)
+
+result[:valid]       # => true
+result[:explanation] # => { valid: true, group: :all, rules: [...] }
+```
+
+The explanation includes per-rule results with actual values:
 
-    $ bundle install
+```ruby
+result[:explanation][:rules]
+# => [
+#   { fact: "response.code", operator: "greater_or_equal", value: 200, actual: 200, result: true },
+#   { fact: "response.code", operator: "less_than", value: 300, actual: 200, result: true }
+# ]
+```
 
-Or install it yourself as:
+## Condition Format
 
-    $ gem install lex-conditioner
+Rules use `all`/`any` grouping with `fact`/`operator`/`value` entries. Facts use dot notation for nested keys.
 
-## Adding to Legion
-You can manually install with a `gem install lex-http` command or by adding it into your settings with something like this
 ```json
 {
-  "extensions": {
-    "conditioner": {
-      "enabled": true, "workers": 1
-    }
-  }
+  "all": [
+    { "fact": "response.code", "operator": "greater_or_equal", "value": 200 },
+    { "any": [
+      { "fact": "action", "operator": "equal", "value": "opened" },
+      { "fact": "action", "operator": "equal", "value": "reopened" }
+    ]}
+  ]
 }
 ```
 
-## Usage
+## Operators
+
+### Binary (require `fact` + `value`)
+
+| Operator | Description |
+|----------|-------------|
+| `equal` | Exact equality |
+| `not_equal` | Inequality |
+| `greater_than` | Numeric greater than |
+| `less_than` | Numeric less than |
+| `greater_or_equal` | Numeric greater than or equal |
+| `less_or_equal` | Numeric less than or equal |
+| `between` | Value within range (value is `[min, max]`) |
+| `contains` | String contains substring |
+| `starts_with` | String starts with prefix |
+| `ends_with` | String ends with suffix |
+| `matches` | String matches regex pattern |
+| `in_set` | Value is in the given array |
+| `not_in_set` | Value is not in the given array |
+| `size_equal` | Collection/string size equals value |
+
+### Unary (require `fact` only)
+
+| Operator | Description |
+|----------|-------------|
+| `nil` | Value is nil |
+| `not_nil` | Value is not nil |
+| `is_true` | Value is truthy |
+| `is_false` | Value is falsy |
+| `is_string` | Value is a String |
+| `is_array` | Value is an Array |
+| `is_integer` | Value is an Integer |
+| `empty` | Value is nil or empty |
+| `not_empty` | Value is present and not empty |
+
+## Runners
+
+### Conditioner
+
+#### `check(conditions:, **payload)`
+
+Evaluates conditions against the payload. Routes to transformation or task queue based on result:
+
+- Condition passes + transformation present: routes to `task.subtask.transform`
+- Condition passes + routing key present: routes to `runner_routing_key`
+- Condition fails: `conditioner.failed`, no dispatch
+
+## Transport
+
+- **Exchange**: `task` (inherits from `Legion::Transport::Exchanges::Task`)
+- **Queue**: `task.conditioner`
+- **Routing keys**: `task.subtask`, `task.subtask.conditioner`
+
+## Requirements
 
+- Ruby >= 3.4
+- [LegionIO](https://github.com/LegionIO/LegionIO) framework (for AMQP actor mode)
+- Standalone Client works without the framework
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/docker_deploy.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 name = 'conditioner'
 require "./lib/legion/extensions/#{name}/version"

data/lex-conditioner.gemspec

@@ -1,6 +1,6 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'legion/extensions/conditioner/version'
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/conditioner/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'lex-conditioner'
@@ -8,28 +8,21 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Esity']
   spec.email         = ['matthewdiverson@gmail.com']
 
-  spec.summary       = 'LEX-Conditioner is used to apply conditional statements to tasks'
-  spec.description   = 'Runs relationship conditional statements against tasks in a relationship'
-  spec.homepage      = 'https://bitbucket.org/legion-io/lex-conditioner'
+  spec.summary       = 'Conditional rule engine for LegionIO task chains'
+  spec.description   = 'Evaluates JSON-based rules against task payloads with 18+ operators, structured explanations, and standalone client support'
+  spec.homepage      = 'https://github.com/LegionIO/lex-conditioner'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+  spec.required_ruby_version = '>= 3.4'
 
   spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://bitbucket.org/legion-io/lex-conditioner'
-  spec.metadata['documentation_uri'] = 'https://legionio.atlassian.net/wiki/spaces/LEX/pages/614957181'
-  spec.metadata['changelog_uri'] = 'https://legionio.atlassian.net/wiki/spaces/LEX/pages/612270436'
-  spec.metadata['bug_tracker_uri'] = 'https://bitbucket.org/legion-io/lex-conditioner/issues'
+  spec.metadata['source_code_uri'] = 'https://github.com/LegionIO/lex-conditioner'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-conditioner'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-conditioner/blob/main/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-conditioner/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'legionio'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rubocop'
-  spec.add_development_dependency 'simplecov'
-
-  spec.add_dependency 'legion-exceptions'
 end

data/lib/legion/extensions/conditioner/actors/conditioner.rb

@@ -1,16 +1,22 @@
-module Legion::Extensions::Conditioner
-  module Actor
-    class Conditioner < Legion::Extensions::Actors::Subscription
-      def runner_function
-        'check'
-      end
+# frozen_string_literal: true
 
-      def check_subtask?
-        false
-      end
+module Legion
+  module Extensions
+    module Conditioner
+      module Actor
+        class Conditioner < Legion::Extensions::Actors::Subscription
+          def runner_function
+            'check'
+          end
+
+          def check_subtask?
+            false
+          end
 
-      def generate_task?
-        false
+          def generate_task?
+            false
+          end
+        end
       end
     end
   end

data/lib/legion/extensions/conditioner/client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'helpers/condition'
+
+module Legion
+  module Extensions
+    module Conditioner
+      class Client
+        def evaluate(conditions:, values:)
+          conditions_json = conditions.is_a?(String) ? conditions : Legion::JSON.dump(conditions)
+          condition = Condition.new(conditions: conditions_json, values: values)
+          {
+            valid:       condition.valid?,
+            explanation: condition.explain
+          }
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/conditioner/helpers/comparator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Legion
   module Extensions
     module Conditioner
@@ -18,25 +20,84 @@ module Legion
           !values[fact].nil?
         end
 
-        def self.is_false?(fact, values) # rubocop:disable Naming/PredicateName
-          true unless values[fact]
+        def self.false?(fact, values)
+          values[fact] ? false : true
         end
 
-        def self.is_true?(fact, values) # rubocop:disable Naming/PredicateName
+        def self.true?(fact, values)
           values[fact]
         end
 
-        def self.is_array?(fact, values) # rubocop:disable Naming/PredicateName
-          !values[fact]
+        def self.array?(fact, values)
+          values[fact].is_a? Array
         end
 
-        def self.is_string?(fact, values) # rubocop:disable Naming/PredicateName
+        def self.string?(fact, values)
           values[fact].is_a? String
         end
 
-        def self.is_integer?(fact, values) # rubocop:disable Naming/PredicateName
+        def self.integer?(fact, values)
           values[fact].is_a? Integer
         end
+
+        def self.greater_than?(fact, value, values)
+          values[fact] > value
+        end
+
+        def self.less_than?(fact, value, values)
+          values[fact] < value
+        end
+
+        def self.greater_or_equal?(fact, value, values)
+          values[fact] >= value
+        end
+
+        def self.less_or_equal?(fact, value, values)
+          values[fact] <= value
+        end
+
+        def self.between?(fact, value, values)
+          values[fact].between?(value[0], value[1])
+        end
+
+        def self.contains?(fact, value, values)
+          values[fact].to_s.include?(value.to_s)
+        end
+
+        def self.starts_with?(fact, value, values)
+          values[fact].to_s.start_with?(value.to_s)
+        end
+
+        def self.ends_with?(fact, value, values)
+          values[fact].to_s.end_with?(value.to_s)
+        end
+
+        def self.matches?(fact, value, values)
+          Regexp.new(value).match?(values[fact].to_s)
+        end
+
+        def self.in_set?(fact, value, values)
+          Array(value).include?(values[fact])
+        end
+
+        def self.not_in_set?(fact, value, values)
+          !Array(value).include?(values[fact])
+        end
+
+        def self.empty?(fact, values)
+          val = values[fact]
+          val.nil? || (val.respond_to?(:empty?) && val.empty?)
+        end
+
+        def self.not_empty?(fact, values)
+          val = values[fact]
+          !val.nil? && !(val.respond_to?(:empty?) && val.empty?)
+        end
+
+        def self.size_equal?(fact, value, values)
+          val = values[fact]
+          val.respond_to?(:size) && val.size == value
+        end
       end
     end
   end

data/lib/legion/extensions/conditioner/helpers/condition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'comparator'
 
 module Legion
@@ -33,32 +35,19 @@ module Legion
           raise Legion::Exception::WrongType::Hash, @conditions.class unless @conditions.is_a? Hash
         end
 
-        def validate_test(conditions = @conditions) # rubocop:disable Metrics/AbcSize
+        BINARY_OPS = %w[equal not_equal greater_than less_than greater_or_equal less_or_equal between contains starts_with ends_with matches in_set not_in_set
+                        size_equal].freeze
+        UNARY_OPS = %w[nil not_nil is_false is_true is_string is_array is_integer empty not_empty].freeze
+        UNARY_METHOD_MAP = {
+          'is_false' => :false?, 'is_true' => :true?,
+          'is_string' => :string?, 'is_array' => :array?, 'is_integer' => :integer?,
+          'empty' => :empty?, 'not_empty' => :not_empty?
+        }.freeze
+
+        def validate_test(conditions = @conditions)
           conditions.each do |condition|
             condition[1].each do |rule|
-              result = validate_test('conditions' => { 'all' => rule[:all] }) if rule.include? :all
-              result = validate_test('conditions' => { 'any' => rule[:any] }) if rule.include? :any
-              case rule[:operator]
-              when 'equal'
-                result = Legion::Extensions::Conditioner::Comparator.equal?(rule[:fact], rule[:value], @values)
-              when 'not_equal'
-                result = Legion::Extensions::Conditioner::Comparator.not_equal?(rule[:fact], rule[:value], @values)
-              when 'nil'
-                result = Legion::Extensions::Conditioner::Comparator.nil?(rule[:fact], @values)
-              when 'not_nil'
-                result = Legion::Extensions::Conditioner::Comparator.not_nil?(rule[:fact], @values)
-              when 'is_false'
-                result = Legion::Extensions::Conditioner::Comparator.is_false?(rule[:fact], @values)
-              when 'is_true'
-                result = Legion::Extensions::Conditioner::Comparator.is_true?(rule[:fact], @values)
-              when 'is_string'
-                result = Legion::Extensions::Conditioner::Comparator.is_string?(rule[:fact], @values)
-              when 'is_array'
-                result = Legion::Extensions::Conditioner::Comparator.is_array?(rule[:fact], @values)
-              when 'is_integer'
-                result = Legion::Extensions::Conditioner::Comparator.is_integer?(rule[:fact], @values)
-              end
-
+              result = evaluate_rule(rule)
               return true if condition[0] == :any && result == true
               return false if condition[0] == :all && result == false
             end
@@ -67,10 +56,56 @@ module Legion
           end
         end
 
+        def evaluate_rule(rule)
+          return validate_test(all: rule[:all]) if rule.include?(:all)
+          return validate_test(any: rule[:any]) if rule.include?(:any)
+
+          comp = Legion::Extensions::Conditioner::Comparator
+          op = rule[:operator]
+
+          if BINARY_OPS.include?(op)
+            comp.send(:"#{op}?", rule[:fact], rule[:value], @values)
+          elsif UNARY_OPS.include?(op)
+            method_name = UNARY_METHOD_MAP[op] || :"#{op}?"
+            comp.send(method_name, rule[:fact], @values)
+          end
+        end
+
         def valid?
           @valid = validate_test if @valid.nil?
           @valid
         end
+
+        def explain_test(conditions = @conditions)
+          group = conditions.keys.first
+          rules = conditions[group].map do |rule|
+            explain_rule(rule)
+          end
+
+          valid = group == :all ? rules.all? { |r| r[:result] } : rules.any? { |r| r[:result] }
+          { valid: valid, group: group, rules: rules }
+        end
+
+        def explain_rule(rule)
+          if rule.include?(:all)
+            result = explain_test(all: rule[:all])
+            return { group: :all, rules: result[:rules], result: result[:valid] }
+          end
+          if rule.include?(:any)
+            result = explain_test(any: rule[:any])
+            return { group: :any, rules: result[:rules], result: result[:valid] }
+          end
+
+          result = evaluate_rule(rule)
+          explanation = { fact: rule[:fact], operator: rule[:operator], result: result }
+          explanation[:value] = rule[:value] if rule.key?(:value)
+          explanation[:actual] = @values[rule[:fact]]
+          explanation
+        end
+
+        def explain
+          @explain ||= explain_test
+        end
       end
     end
   end

data/lib/legion/extensions/conditioner/runners/conditioner.rb

@@ -1,61 +1,67 @@
+# frozen_string_literal: true
+
 require 'legion/extensions/conditioner/helpers/condition'
 
-module Legion::Extensions::Conditioner
-  module Runners
+module Legion
+  module Extensions
     module Conditioner
-      def check(conditions:, **payload) # rubocop:disable Metrics/AbcSize
-        conditioner = Legion::Extensions::Conditioner::Condition.new(conditions: conditions,
-                                                                     values:     payload,
-                                                                     type:       payload[:type])
-
-        status = if conditioner.valid? && payload.key?(:transformation)
-                   'transformation.queued'
-                 elsif conditioner.valid? && payload.key?(:runner_routing_key)
-                   'task.queued'
-                 elsif conditioner.valid?
-                   'task.exception'
-                 else
-                   'conditioner.failed'
-                 end
-
-        send_task(**payload) unless status == 'conditioner.failed'
-        task_update(payload[:task_id], status, **payload) unless payload[:task_id].nil?
-
-        if payload[:debug] && payload.key?(:task_id)
-          generate_task_log(task_id:    payload[:task_id],
-                            function:   'check',
-                            valid:      conditioner.valid?,
-                            conditions: payload[:conditions],
-                            values:     payload)
-        end
+      module Runners
+        module Conditioner
+          def check(conditions:, **payload)
+            conditioner = Legion::Extensions::Conditioner::Condition.new(conditions: conditions,
+                                                                         values:     payload,
+                                                                         type:       payload[:type])
 
-        { success: true, valid: conditioner.valid? }
-      rescue StandardError => e
-        Legion::Logging.error 'LEX::Conditioner::Runners::Condition had an exception'
-        Legion::Logging.warn e.message
-        Legion::Logging.warn e.backtrace
-        task_update(payload[:task_id], 'conditioner.exception', **payload) unless payload[:task_id].nil?
-      end
+            status = if conditioner.valid? && payload.key?(:transformation)
+                       'transformation.queued'
+                     elsif conditioner.valid? && payload.key?(:runner_routing_key)
+                       'task.queued'
+                     elsif conditioner.valid?
+                       'task.exception'
+                     else
+                       'conditioner.failed'
+                     end
 
-      def send_task(**opts)
-        subtask_hash = {}
-        %i[runner_routing_key relationship_id chain_id trigger_runner_id trigger_function_id funciton_id function runner_id runner_class transformation debug task_id results].each do |column| # rubocop:disable Layout/LineLength
-          subtask_hash[column] = opts[column] if opts.key? column
-        end
+            send_task(**payload) unless status == 'conditioner.failed'
+            task_update(payload[:task_id], status, **payload) unless payload[:task_id].nil?
 
-        subtask_hash[:routing_key] = if subtask_hash.key? :transformation
-                                       'task.subtask.transform'
-                                     elsif subtask_hash.key? :runner_routing_key
-                                       subtask_hash[:runner_routing_key]
-                                     end
+            if payload[:debug] && payload.key?(:task_id)
+              generate_task_log(task_id:    payload[:task_id],
+                                function:   'check',
+                                valid:      conditioner.valid?,
+                                conditions: payload[:conditions],
+                                values:     payload)
+            end
 
-        raise Legion::Exception::MissingArgument 'Missing :routing_key' unless subtask_hash.key? :routing_key
+            { success: true, valid: conditioner.valid? }
+          rescue StandardError => e
+            Legion::Logging.error 'LEX::Conditioner::Runners::Condition had an exception'
+            Legion::Logging.warn e.message
+            Legion::Logging.warn e.backtrace
+            task_update(payload[:task_id], 'conditioner.exception', **payload) unless payload[:task_id].nil?
+          end
 
-        Legion::Transport::Messages::SubTask.new(**subtask_hash).publish
-      end
+          def send_task(**opts)
+            subtask_hash = {}
+            %i[runner_routing_key relationship_id chain_id trigger_runner_id trigger_function_id function_id function runner_id runner_class transformation debug task_id results].each do |column| # rubocop:disable Layout/LineLength
+              subtask_hash[column] = opts[column] if opts.key? column
+            end
 
-      include Legion::Extensions::Helpers::Lex
-      include Legion::Extensions::Helpers::Task
+            subtask_hash[:routing_key] = if subtask_hash.key? :transformation
+                                           'task.subtask.transform'
+                                         elsif subtask_hash.key? :runner_routing_key
+                                           subtask_hash[:runner_routing_key]
+                                         end
+
+            raise Legion::Exception::MissingArgument 'Missing :routing_key' unless subtask_hash.key? :routing_key
+
+            Legion::Transport::Messages::SubTask.new(**subtask_hash).publish
+          end
+
+          include Legion::Extensions::Helpers::Lex
+          include Legion::Extensions::Helpers::Task
+        end
+      end
     end
   end
 end

data/lib/legion/extensions/conditioner/transport/exchanges/task.rb

@@ -1,7 +1,13 @@
-module Legion::Extensions::Conditioner
-  module Transport
-    module Exchanges
-      class Conditioner < Legion::Transport::Exchanges::Task
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Conditioner
+      module Transport
+        module Exchanges
+          class Conditioner < Legion::Transport::Exchanges::Task
+          end
+        end
       end
     end
   end

data/lib/legion/extensions/conditioner/transport/messages/conditioner.rb

@@ -1,13 +1,19 @@
-module Legion::Extensions::Conditioner
-  module Transport
-    module Messages
-      class Conditioner < Legion::Transport::Message
-        def routing_key
-          'task.conditioner.succeeded'
-        end
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Conditioner
+      module Transport
+        module Messages
+          class Conditioner < Legion::Transport::Message
+            def routing_key
+              'task.conditioner.succeeded'
+            end
 
-        def exchange
-          Legion::Transport::Exchanges::Task
+            def exchange
+              Legion::Transport::Exchanges::Task
+            end
+          end
         end
       end
     end

data/lib/legion/extensions/conditioner/transport/queues/conditioner.rb

@@ -1,9 +1,15 @@
-module Legion::Extensions::Conditioner
-  module Transport
-    module Queues
-      class Conditioner < Legion::Transport::Queue
-        def queue_name
-          'task.conditioner'
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Conditioner
+      module Transport
+        module Queues
+          class Conditioner < Legion::Transport::Queue
+            def queue_name
+              'task.conditioner'
+            end
+          end
         end
       end
     end

data/lib/legion/extensions/conditioner/transport.rb

@@ -1,13 +1,20 @@
+# frozen_string_literal: true
+
 require 'legion/extensions/transport'
 
-module Legion::Extensions::Conditioner
-  module Transport
-    extend Legion::Extensions::Transport
-    def self.additional_e_to_q
-      [
-        { from: 'task', to: 'conditioner', routing_key: 'task.subtask' },
-        { from: 'task', to: 'conditioner', routing_key: 'task.subtask.conditioner' }
-      ]
+module Legion
+  module Extensions
+    module Conditioner
+      module Transport
+        extend Legion::Extensions::Transport
+
+        def self.additional_e_to_q
+          [
+            { from: 'task', to: 'conditioner', routing_key: 'task.subtask' },
+            { from: 'task', to: 'conditioner', routing_key: 'task.subtask.conditioner' }
+          ]
+        end
+      end
     end
   end
 end

data/lib/legion/extensions/conditioner/version.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Legion
   module Extensions
     module Conditioner
-      VERSION = '0.2.5'.freeze
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/legion/extensions/conditioner.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'legion/extensions/conditioner/version'
+require_relative 'conditioner/client'
 
 module Legion
   module Extensions

metadata

@@ -1,120 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: lex-conditioner
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Esity
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-03 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: legionio
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: legion-exceptions
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: Runs relationship conditional statements against tasks in a relationship
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Evaluates JSON-based rules against task payloads with 18+ operators,
+  structured explanations, and standalone client support
 email:
 - matthewdiverson@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
 - Dockerfile
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
-- bitbucket-pipelines.yml
 - docker_deploy.rb
 - lex-conditioner.gemspec
 - lib/legion/extensions/conditioner.rb
 - lib/legion/extensions/conditioner/actors/conditioner.rb
+- lib/legion/extensions/conditioner/client.rb
 - lib/legion/extensions/conditioner/helpers/comparator.rb
 - lib/legion/extensions/conditioner/helpers/condition.rb
 - lib/legion/extensions/conditioner/runners/conditioner.rb
@@ -123,16 +41,16 @@ files:
 - lib/legion/extensions/conditioner/transport/messages/conditioner.rb
 - lib/legion/extensions/conditioner/transport/queues/conditioner.rb
 - lib/legion/extensions/conditioner/version.rb
-homepage: https://bitbucket.org/legion-io/lex-conditioner
+homepage: https://github.com/LegionIO/lex-conditioner
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://bitbucket.org/legion-io/lex-conditioner
-  source_code_uri: https://bitbucket.org/legion-io/lex-conditioner
-  documentation_uri: https://legionio.atlassian.net/wiki/spaces/LEX/pages/614957181
-  changelog_uri: https://legionio.atlassian.net/wiki/spaces/LEX/pages/612270436
-  bug_tracker_uri: https://bitbucket.org/legion-io/lex-conditioner/issues
-post_install_message: 
+  homepage_uri: https://github.com/LegionIO/lex-conditioner
+  source_code_uri: https://github.com/LegionIO/lex-conditioner
+  documentation_uri: https://github.com/LegionIO/lex-conditioner
+  changelog_uri: https://github.com/LegionIO/lex-conditioner/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-conditioner/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -140,15 +58,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: LEX-Conditioner is used to apply conditional statements to tasks
+summary: Conditional rule engine for LegionIO task chains
 test_files: []

data/Gemfile.lock

@@ -1,119 +0,0 @@
-PATH
-  remote: .
-  specs:
-    lex-conditioner (0.2.5)
-      legion-exceptions
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    amq-protocol (2.3.2)
-    ast (2.4.2)
-    aws-eventstream (1.1.0)
-    aws-sigv4 (1.2.2)
-      aws-eventstream (~> 1, >= 1.0.2)
-    bunny (2.17.0)
-      amq-protocol (~> 2.3, >= 2.3.1)
-    concurrent-ruby (1.1.8)
-    concurrent-ruby-ext (1.1.8)
-      concurrent-ruby (= 1.1.8)
-    connection_pool (2.2.3)
-    daemons (1.3.1)
-    dalli (2.7.11)
-    diff-lcs (1.4.4)
-    docile (1.3.5)
-    json_pure (2.5.1)
-    legion-cache (1.1.1)
-      connection_pool (>= 2.2.3)
-      dalli (>= 2.7)
-      redis (>= 4.2)
-    legion-crypt (0.3.0)
-      vault (>= 0.15.0)
-    legion-exceptions (1.1.5)
-    legion-json (1.1.4)
-      json_pure
-      legion-exceptions (>= 1.1.5)
-      multi_json
-    legion-logging (1.1.4)
-      rainbow (~> 3)
-    legion-settings (1.1.3)
-      legion-json
-      legion-logging
-    legion-transport (1.1.9)
-      bunny (>= 2.17.0)
-      concurrent-ruby (>= 1.1.7)
-      legion-json
-    legionio (0.4.3)
-      concurrent-ruby (>= 1.1.7)
-      concurrent-ruby-ext (>= 1.1.7)
-      daemons (>= 1.3.1)
-      legion-cache
-      legion-crypt (>= 0.2.0)
-      legion-exceptions
-      legion-json
-      legion-logging
-      legion-settings
-      legion-transport (>= 1.1.9)
-      lex-node
-      oj (>= 3.10)
-      thor (>= 1)
-    lex-node (0.1.7)
-    multi_json (1.15.0)
-    oj (3.11.2)
-    parallel (1.20.1)
-    parser (3.0.0.0)
-      ast (~> 2.4.1)
-    rainbow (3.0.0)
-    rake (13.0.3)
-    redis (4.2.5)
-    regexp_parser (2.1.1)
-    rexml (3.2.4)
-    rspec (3.10.0)
-      rspec-core (~> 3.10.0)
-      rspec-expectations (~> 3.10.0)
-      rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.1)
-      rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-support (3.10.2)
-    rubocop (1.11.0)
-      parallel (~> 1.10)
-      parser (>= 3.0.0.0)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.2.0, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.4.1)
-      parser (>= 2.7.1.5)
-    ruby-progressbar (1.11.0)
-    simplecov (0.21.2)
-      docile (~> 1.1)
-      simplecov-html (~> 0.11)
-      simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.12.3)
-    simplecov_json_formatter (0.1.2)
-    thor (1.1.0)
-    unicode-display_width (2.0.0)
-    vault (0.15.0)
-      aws-sigv4
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  legionio
-  lex-conditioner!
-  rake
-  rspec
-  rubocop
-  simplecov
-
-BUNDLED WITH
-   2.2.6

data/bitbucket-pipelines.yml

@@ -1,19 +0,0 @@
-image: ruby:2.7
-
-pipelines:
-  tags:
-    "v*":
-      - step:
-          name: Push to RubyGems
-          deployment: RubyGems
-          script:
-            - gem install gem-release
-            - (umask  077 ; echo $gem_creds | base64 --decode > ~/.gem/credentials)
-            - gem release
-          artifacts:
-            - pkg/**
-      - step:
-          name: Push to Docker
-          deployment: Docker
-          script:
-            - './docker_deploy.rb'