lex-conditioner 0.2.5 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7c725a33a160829135b9b2269533484ab211ee5654951d929ce49dbfffcbbe
-  data.tar.gz: c4b994cf4d00aac64316b4023b63fb02cb420288fc0eb310868c3ad9a49ec856
+  metadata.gz: a8f0f6e6d047004004fc22bbbc5e59600a19a49c0456cd469e8abfbf2182d12a
+  data.tar.gz: 9511f9d436244571f12bc15b587c028c2692c0fff54ed81ea5caaf1a59948676
 SHA512:
-  metadata.gz: 15f92eb0f63890df974300c03c72c082228b61ad165c29da251a6955060f98bbbdb25bf80d2841f2c284a3deeb6c5e099e826747e85e4a74ce9d4fd8eca83acb
-  data.tar.gz: 4a41130e68f0a464e48ff540fc442b91c7f2cef10aa0ad165484b43cf6895623f6df07be4ea8f856de6b865a8ba3d197a3771f4cc781e8f19608c8d6cce6413a
+  metadata.gz: 5a86d76e674865fa293c3dff60e8a7a7f22f6dbf632d1a336c9f2fdbc88b47a68f727408a1e358d43571b904ac53612c226c6819caaa6d1354d8b9909a61ff4b
+  data.tar.gz: bbb2646ca44322974146f11bef9c9012d5363838645f29f8d12d77b7b685d725b91891d97644baeccbdcbbb30f445107dfc46098cad35d2dadb90e052901c1bb

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,27 @@
+# Changelog
+
+## [0.3.1] - 2026-03-22
+
+### Changed
+- Migrated to sub-gem helpers (Tier 1): added runtime dependencies on legion-cache >= 1.3.11, legion-crypt >= 1.4.9, legion-data >= 1.4.17, legion-json >= 1.2.1, legion-logging >= 1.3.2, legion-settings >= 1.3.14, legion-transport >= 1.3.9
+- Replaced direct `Legion::Logging` calls in runner with `log` helper method via `Helpers::Lex` (includes `Legion::Logging::Helper`)
+- Updated spec_helper to use real sub-gem helpers with `Helpers::Lex` module and actor stubs; removed inline Legion::Logging and Legion::JSON stubs
+- Updated runner spec to remove framework stubs covered by spec_helper; added scoped `Helpers::Task`, `Transport::Messages::SubTask`, and `Exception::MissingArgument` stubs
+
+## [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,135 @@
+# 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. Groups can be nested arbitrarily.
+
+```json
+{
+  "all": [
+    { "fact": "response.code", "operator": "greater_or_equal", "value": 200 },
+    { "any": [
+      { "fact": "action", "operator": "equal", "value": "opened" },
+      { "fact": "action", "operator": "equal", "value": "reopened" }
+    ]}
+  ]
+}
+```
+
+## 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 or 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 |
+
+## Condition Evaluation Logic
+
+After evaluation, the runner routes 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` raises `MissingArgument`)
+- Condition fails: `conditioner.failed` (`send_task` is skipped)
+
+Each evaluation also returns an explanation chain with per-rule results including actual values, for use by lex-synapse and standalone callers.
+
+## Standalone Client
+
+`Legion::Extensions::Conditioner::Client` includes the `Conditioner` runner. Instantiate without the full framework:
+
+```ruby
+require 'legion/extensions/conditioner/client'
+client = Legion::Extensions::Conditioner::Client.new
+result = client.evaluate(conditions: { all: [...] }, values: { ... })
+result[:valid]        # => true/false
+result[:explanation]  # => per-rule results with actual values
+```
+
+## Dependencies
+
+| Gem | Purpose |
+|-----|---------|
+| `legion-exceptions` | Exception handling |
+
+## Testing
+
+```bash
+bundle install
+bundle exec rspec     # 140 examples, 0 failures
+bundle exec rubocop   # 0 offenses
+```
+
+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,29 @@ 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'
+  spec.add_dependency 'legion-cache',     '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',     '>= 1.4.9'
+  spec.add_dependency 'legion-data',      '>= 1.4.17'
+  spec.add_dependency 'legion-json',      '>= 1.2.1'
+  spec.add_dependency 'legion-logging',   '>= 1.3.2'
+  spec.add_dependency 'legion-settings',  '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
 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