active_genie 0.0.10 → 0.0.12

data/lib/active_genie/scoring/basic.rb

@@ -25,15 +25,15 @@ module ActiveGenie::Scoring
     # @return [Hash] The evaluation result containing the scores and reasoning
     #   @return [Number] :final_score The final score of the text based on the criteria and reviewers
     #   @return [String] :final_reasoning Detailed explanation of why the final score was reached
-    def self.call(text, criteria, reviewers = [], config: {})
-      new(text, criteria, reviewers, config:).call
+    def self.call(...)
+      new(...).call
     end
 
     def initialize(text, criteria, reviewers = [], config: {})
       @text = text
       @criteria = criteria
       @reviewers = Array(reviewers).compact.uniq
-      @config = config
+      @config = ActiveGenie::Configuration.to_h(config)
     end
 
     def call
@@ -76,7 +76,12 @@ module ActiveGenie::Scoring
         }
       }
 
-      ::ActiveGenie::Clients::UnifiedClient.function_calling(messages, function, config:)
+      ::ActiveGenie::Clients::UnifiedClient.function_calling(
+        messages,
+        function,
+        model_tier: 'lower_tier',
+        config: @config
+      )
     end
 
     private
@@ -85,42 +90,62 @@ module ActiveGenie::Scoring
       @get_or_recommend_reviewers ||= if @reviewers.count > 0 
         @reviewers
       else
-        recommended_reviews = RecommendedReviews.call(@text, @criteria, config:)
+        result = RecommendedReviewers.call(@text, @criteria, config: @config)
 
-        [recommended_reviews[:reviewer1], recommended_reviews[:reviewer2], recommended_reviews[:reviewer3]]
+        [result['reviewer1'], result['reviewer2'], result['reviewer3']]
       end
     end
 
     PROMPT = <<~PROMPT
-    Evaluate and score the provided text based on predefined criteria, which may include rules, keywords, or patterns. Use a scoring range of 0 to 100, with 100 representing the highest possible score. Follow the instructions below to ensure an accurate and objective assessment.
+    Evaluate and score the provided text based on predefined criteria, using a scoring range of 0 to 100 with 100 representing the highest possible score.
+
+    Follow the instructions below to ensure a comprehensive and objective assessment. 
 
     # Evaluation Process
-    1. **Analysis**: Thoroughly compare the text against each criterion to ensure comprehensive evaluation.
-    2. **Document Deviations**: Clearly identify and document any areas where the content does not align with the specified criteria.
-    3. **Highlight Strengths**: Emphasize notable features or elements that enhance the overall quality or effectiveness of the content.
-    4. **Identify Weaknesses**: Specify areas where the content fails to meet the criteria or where improvements could be made.
 
-    # Output Requirements
-    Provide a detailed review, including:
-      - A final score (0-100)
-      - Specific reasoning for the assigned score, covering all evaluated criteria.
-      - Ensure the reasoning includes both positive aspects and suggested improvements.
+    1. **Analysis**: 
+      - Thoroughly compare the text against each criterion for a comprehensive evaluation.
+      
+    2. **Document Deviations**:
+      - Identify and document areas where the content does not align with the specified criteria.
+
+    3. **Highlight Strengths**:
+      - Note notable features or elements that enhance the quality or effectiveness of the content.
+
+    4. **Identify Weaknesses**:
+      - Specify areas where the content fails to meet the criteria or where improvements could be made.
+
+    # Scoring Fairness
+
+    - Ensure the assigned score reflects both the alignment with the criteria and the content's effectiveness.
+    - Consider if the fulfillment of other criteria compensates for areas lacking extreme details.
+
+    # Scoring Range
+
+    Segment scores into five parts before assigning a final score:
+    - **Terrible**: 0-20 - Content does not meet the criteria.
+    - **Bad**: 21-40 - Content is substandard but meets some criteria.
+    - **Average**: 41-60 - Content meets criteria with room for improvement.
+    - **Good**: 61-80 - Content exceeds criteria and is above average.
+    - **Great**: 81-100 - Content exceeds all expectations.
 
     # Guidelines
-    - Maintain objectivity, avoiding biases or preconceived notions.
-    - Deconstruct each criterion into actionable components for a systematic evaluation.
-    - If the text lacks information, apply reasonable judgment to assign a score while clearly explaining the rationale.
-    PROMPT
 
-    def config
-      {
-        all_providers: { model_tier: 'lower_tier' },
-        log: {
-          **(@config.dig(:log) || {}),
-          trace: self.class.name,
-        },
-        **@config
-      }
-    end
+    - Maintain objectivity and avoid biases.
+    - Deconstruct each criterion into actionable components for systematic evaluation.
+    - Apply reasonable judgment in assigning a score, justifying your rationale clearly.
+
+    # Output Format
+
+    - Provide a detailed review including:
+      - A final score (0-100)
+      - Specific reasoning for the assigned score, detailing all evaluated criteria
+      - Include both positive aspects and suggested improvements
+
+    # Notes
+
+    - Consider edge cases where the text may partially align with criteria.
+    - If lacking information, reasonably judge and explain your scoring approach.
+    PROMPT
   end
 end

data/lib/active_genie/scoring/{recommended_reviews.rb → recommended_reviewers.rb}

@@ -3,7 +3,7 @@
 require_relative '../clients/unified_client'
 
 module ActiveGenie::Scoring
-  # The RecommendedReviews class intelligently suggests appropriate reviewer roles
+  # The RecommendedReviewers class intelligently suggests appropriate reviewer roles
   # for evaluating text content based on specific criteria. It uses AI to analyze
   # the content and criteria to identify the most suitable subject matter experts.
   #
@@ -11,14 +11,14 @@ module ActiveGenie::Scoring
   # three distinct reviewer roles with complementary expertise and perspectives.
   #
   # @example Getting recommended reviewers for technical content
-  #   RecommendedReviews.call("Technical documentation about API design", 
+  #   RecommendedReviewers.call("Technical documentation about API design", 
   #                           "Evaluate technical accuracy and clarity")
   #   # => { reviewer1: "API Architect", reviewer2: "Technical Writer", 
   #   #      reviewer3: "Developer Advocate", reasoning: "..." }
   #
-  class RecommendedReviews
-    def self.call(text, criteria, config: {})
-      new(text, criteria, config:).call
+  class RecommendedReviewers
+    def self.call(...)
+      new(...).call
     end
 
     # Initializes a new reviewer recommendation instance
@@ -29,7 +29,7 @@ module ActiveGenie::Scoring
     def initialize(text, criteria, config: {})
       @text = text
       @criteria = criteria
-      @config = config
+      @config = ActiveGenie::Configuration.to_h(config)
     end
 
     def call
@@ -53,7 +53,14 @@ module ActiveGenie::Scoring
         }
       }
 
-      ::ActiveGenie::Clients::UnifiedClient.function_calling(messages, function, config: @config)
+      result = client.function_calling(
+        messages,
+        function,
+        model_tier: 'lower_tier',
+        config: @config
+      )
+
+      result
     end
 
     private
@@ -72,5 +79,9 @@ module ActiveGenie::Scoring
     - Include reasoning for how each choice supports a thorough and insightful review.
     - Avoid redundant or overly similar titles/roles to maintain diversity.
     PROMPT
+
+    def client
+      ::ActiveGenie::Clients::UnifiedClient
+    end
   end
 end

data/lib/active_genie/scoring.rb

@@ -1,5 +1,5 @@
 require_relative 'scoring/basic'
-require_relative 'scoring/recommended_reviews'
+require_relative 'scoring/recommended_reviewers'
 
 module ActiveGenie
   # See the [Scoring README](lib/active_genie/scoring/README.md) for more information.
@@ -10,8 +10,8 @@ module ActiveGenie
       Basic.call(...)
     end
 
-    def recommended_reviews(...)
-      RecommendedReviews.call(...)
+    def recommended_reviewers(...)
+      RecommendedReviewers.call(...)
     end
   end
 end

data/lib/active_genie.rb

@@ -5,7 +5,7 @@ module ActiveGenie
   autoload :DataExtractor, File.join(__dir__, 'active_genie/data_extractor')
   autoload :Battle, File.join(__dir__, 'active_genie/battle')
   autoload :Scoring, File.join(__dir__, 'active_genie/scoring')
-  autoload :Leaderboard, File.join(__dir__, 'active_genie/leaderboard')
+  autoload :Ranking, File.join(__dir__, 'active_genie/ranking')
 
   class << self
     def configure

metadata

@@ -1,57 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.12
 platform: ruby
 authors:
 - Radamés Roriz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-03-17 00:00:00.000000000 Z
 dependencies: []
-description: "# ActiveGenie \U0001F9DE‍♂️\n> Transform your Ruby application with
-  powerful, production-ready GenAI features\n\n[![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)\n[![Ruby](https://github.com/roriz/active_genie/actions/workflows/ruby.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/ruby.yml)\n\nActiveGenie
+description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop reinventing
+  the wheel\n\n[![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)\n[![Ruby](https://github.com/roriz/active_genie/actions/workflows/ruby.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/ruby.yml)\n\nActiveGenie
   is a Ruby gem that provides a polished, production-ready interface for working with
-  Generative AI (GenAI) models. Just like ActiveStorage simplifies file handling in
-  Rails, ActiveGenie makes it effortless to integrate GenAI capabilities into your
-  Ruby applications.\n\n## Features\n\n- \U0001F3AF **Data Extraction**: Extract structured
-  data from unstructured text with type validation\n- \U0001F4CA **Smart Scoring**:
-  Multi-reviewer evaluation system with automatic expert selection\n- \U0001F4AD **Leaderboard**:
-  Consistent rank items based on custom criteria, using multiple tecniques of ranking\n\n##
-  Installation\n\n1. Add to your Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2.
-  Install the gem:\n```shell\nbundle install\n```\n\n3. Generate the configuration:\n```shell\necho
-  \"ActiveGenie.load_tasks\" >> Rakefile\nrails g active_genie:install\n```\n\n4.
-  Configure your credentials in `config/initializers/active_genie.rb`:\n```ruby\nActiveGenie.configure
-  do |config|\n  config.openai.api_key = ENV['OPENAI_API_KEY']\nend\n```\n\n## Quick
-  Start\n\n### Data Extractor\nExtract structured data from text using AI-powered
-  analysis, handling informal language and complex expressions.\n\n```ruby\ntext =
-  \"Nike Air Max 90 - Size 42 - $199.99\"\nschema = {\n  brand: { \n    type: 'string',\n
-  \   enum: [\"Nike\", \"Adidas\", \"Puma\"]\n  },\n  price: { \n    type: 'number',\n
-  \   minimum: 0\n  },\n  size: {\n    type: 'integer',\n    minimum: 35,\n    maximum:
-  46\n  }\n}\n\nresult = ActiveGenie::DataExtractor.call(text, schema)\n# => { \n#
-  \     brand: \"Nike\", \n#      brand_explanation: \"Brand name found at start of
-  text\",\n#      price: 199.99,\n#      price_explanation: \"Price found in USD format
-  at end\",\n#      size: 42,\n#      size_explanation: \"Size explicitly stated in
-  the middle\"\n#    }\n```\n\nFeatures:\n- Structured data extraction with type validation\n-
-  Schema-based extraction with custom constraints\n- Informal text analysis (litotes,
-  hedging)\n- Detailed explanations for extracted values\n\nSee the [Data Extractor
-  README](lib/active_genie/data_extractor/README.md) for informal text processing,
-  advanced schemas, and detailed interface documentation.\n\n### Scoring\nText evaluation
-  system that provides detailed scoring and feedback using multiple expert reviewers.
-  Get balanced scoring through AI-powered expert reviewers that automatically adapt
-  to your content.\n\n```ruby\ntext = \"The code implements a binary search algorithm
-  with O(log n) complexity\"\ncriteria = \"Evaluate technical accuracy and clarity\"\n\nresult
-  = ActiveGenie::Scoring.basic(text, criteria)\n# => {\n#      algorithm_expert_score:
-  95,\n#      algorithm_expert_reasoning: \"Accurately describes binary search and
-  its complexity\",\n#      technical_writer_score: 90,\n#      technical_writer_reasoning:
-  \"Clear and concise explanation of the algorithm\",\n#      final_score: 92.5\n#
-  \   }\n```\n\nFeatures:\n- Multi-reviewer evaluation with automatic expert selection\n-
-  Detailed feedback with scoring reasoning\n- Customizable reviewer weights\n- Flexible
-  evaluation criteria\n\nSee the [Scoring README](lib/active_genie/scoring/README.md)
+  Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie simplifies
+  GenAI integration in your Ruby applications.\n\n## Features\n\n- \U0001F3AF **Data
+  Extraction**: Extract structured data from unstructured text with type validation\n-
+  \U0001F4CA **Data Scoring**: Multi-reviewer evaluation system\n- ⚔️ **Data Battle**:
+  Battle between two data like a political debate\n- \U0001F4AD **Data Ranking**:
+  Consistent rank data using scoring + elo ranking + battles\n\n## Installation\n\n1.
+  Add to your Gemfile:\n```ruby\ngem 'active_genie'\n```\n\n2. Install the gem:\n```shell\nbundle
+  install\n```\n\n3. Generate the configuration:\n```shell\necho \"ActiveGenie.load_tasks\"
+  >> Rakefile\nrails g active_genie:install\n```\n\n4. Configure your credentials
+  in `config/initializers/active_genie.rb`:\n```ruby\nActiveGenie.configure do |config|\n
+  \ config.openai.api_key = ENV['OPENAI_API_KEY']\nend\n```\n\n## Quick Start\n\n###
+  Data Extractor\nExtract structured data from text using AI-powered analysis, handling
+  informal language and complex expressions.\n\n```ruby\ntext = \"Nike Air Max 90
+  - Size 42 - $199.99\"\nschema = {\n  brand: { \n    type: 'string',\n    enum: [\"Nike\",
+  \"Adidas\", \"Puma\"]\n  },\n  price: { \n    type: 'number',\n    minimum: 0\n
+  \ },\n  size: {\n    type: 'integer',\n    minimum: 35,\n    maximum: 46\n  }\n}\n\nresult
+  = ActiveGenie::DataExtractor.call(text, schema)\n# => { \n#      brand: \"Nike\",
+  \n#      brand_explanation: \"Brand name found at start of text\",\n#      price:
+  199.99,\n#      price_explanation: \"Price found in USD format at end\",\n#      size:
+  42,\n#      size_explanation: \"Size explicitly stated in the middle\"\n#    }\n```\n\nFeatures:\n-
+  Structured data extraction with type validation\n- Schema-based extraction with
+  custom constraints\n- Informal text analysis (litotes, hedging)\n- Detailed explanations
+  for extracted values\n\nSee the [Data Extractor README](lib/active_genie/data_extractor/README.md)
+  for informal text processing, advanced schemas, and detailed interface documentation.\n\n###
+  Data Scoring\nText evaluation system that provides detailed scoring and feedback
+  using multiple expert reviewers. Get balanced scoring through AI-powered expert
+  reviewers that automatically adapt to your content.\n\n```ruby\ntext = \"The code
+  implements a binary search algorithm with O(log n) complexity\"\ncriteria = \"Evaluate
+  technical accuracy and clarity\"\n\nresult = ActiveGenie::Scoring.basic(text, criteria)\n#
+  => {\n#      algorithm_expert_score: 95,\n#      algorithm_expert_reasoning: \"Accurately
+  describes binary search and its complexity\",\n#      technical_writer_score: 90,\n#
+  \     technical_writer_reasoning: \"Clear and concise explanation of the algorithm\",\n#
+  \     final_score: 92.5\n#    }\n```\n\nFeatures:\n- Multi-reviewer evaluation with
+  automatic expert selection\n- Detailed feedback with scoring reasoning\n- Customizable
+  reviewer weights\n- Flexible evaluation criteria\n\nSee the [Scoring README](lib/active_genie/scoring/README.md)
   for advanced usage, custom reviewers, and detailed interface documentation.\n\n###
-  Battle\nAI-powered battle evaluation system that determines winners between two
-  players based on specified criteria.\n\n```ruby\nrequire 'active_genie'\n\nplayer_a
+  Data Battle\nAI-powered battle evaluation system that determines winners between
+  two players based on specified criteria.\n\n```ruby\nrequire 'active_genie'\n\nplayer_a
   = \"Implementation uses dependency injection for better testability\"\nplayer_b
   = \"Code has high test coverage but tightly coupled components\"\ncriteria = \"Evaluate
   code quality and maintainability\"\n\nresult = ActiveGenie::Battle.call(player_a,
@@ -65,50 +64,29 @@ description: "# ActiveGenie \U0001F9DE‍♂️\n> Transform your Ruby applicati
   evaluation with automatic expert selection\n- Detailed feedback with scoring reasoning\n-
   Customizable reviewer weights\n- Flexible evaluation criteria\n\nSee the [Battle
   README](lib/active_genie/battle/README.md) for advanced usage, custom reviewers,
-  and detailed interface documentation.\n\n### League\nThe League module provides
+  and detailed interface documentation.\n\n### Data Ranking\nThe Ranking module provides
   competitive ranking through multi-stage evaluation:\n\n\n```ruby\nrequire 'active_genie'\n\nplayers
   = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']\ncriteria
-  = \"Best one to be used into a high changing environment\"\n\nresult = ActiveGenie::League.call(players,
+  = \"Best one to be used into a high changing environment\"\n\nresult = ActiveGenie::Ranking.call(players,
   criteria)\n# => {\n#      winner_player: \"gRPC API\",\n#      reasoning: \"gRPC
   API is the best one to be used into a high changing environment\",\n#    }\n```\n\n-
   **Multi-phase ranking system** combining expert scoring and ELO algorithms\n- **Automatic
   elimination** of inconsistent performers using statistical analysis\n- **Dynamic
   ranking adjustments** based on simulated pairwise battles, from bottom to top\n\nSee
-  the [League README](lib/active_genie/league/README.md) for implementation details,
-  configuration, and advanced ranking strategies.\n\n### Summarizer (WIP)\nThe summarizer
-  is a tool that can be used to summarize a given text. It uses a set of rules to
-  summarize the text out of the box. Uses the best practices of prompt engineering
-  and engineering to make the summarization as accurate as possible.\n\n```ruby\nrequire
-  'active_genie'\n\ntext = \"Example text to be summarized. The fox jumps over the
-  dog\"\nsummarized_text = ActiveGenie::Summarizer.call(text)\nputs summarized_text
-  # => \"The fox jumps over the dog\"\n```\n\n### Language detector (WIP)\nThe language
-  detector is a tool that can be used to detect the language of a given text. It uses
-  a set of rules to detect the language of the text out of the box. Uses the best
-  practices of prompt engineering and engineering to make the language detection as
-  accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext = \"Example text
-  to be detected\"\nlanguage = ActiveGenie::LanguageDetector.call(text)\nputs language
-  # => \"en\"\n```\n\n### Translator (WIP)\nThe translator is a tool that can be used
-  to translate a given text. It uses a set of rules to translate the text out of the
-  box. Uses the best practices of prompt engineering and engineering to make the translation
-  as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext = \"Example
-  text to be translated\"\ntranslated_text = ActiveGenie::Translator.call(text, from:
-  'en', to: 'pt')\nputs translated_text # => \"Exemplo de texto a ser traduzido\"\n```\n\n###
-  Sentiment analyzer (WIP)\nThe sentiment analyzer is a tool that can be used to analyze
-  the sentiment of a given text. It uses a set of rules to analyze the sentiment of
-  the text out of the box. Uses the best practices of prompt engineering and engineering
-  to make the sentiment analysis as accurate as possible.\n\n```ruby\nrequire 'active_genie'\n\ntext
-  = \"Example text to be analyzed\"\nsentiment = ActiveGenie::SentimentAnalyzer.call(text)\nputs
-  sentiment # => \"positive\"\n```\n\n## Configuration\n\n| Config | Description |
-  Default |\n|--------|-------------|---------|\n| `provider` | LLM provider (openai,
-  anthropic, etc) | `nil` |\n| `model` | Model to use | `nil` |\n| `api_key` | Provider
-  API key | `nil` |\n| `timeout` | Request timeout in seconds | `5` |\n| `max_retries`
-  | Maximum retry attempts | `3` |\n\n> **Note:** Each module can append its own set
-  of configuration, see the individual module documentation for details.\n\n## Contributing\n\n1.
-  Fork the repository\n2. Create your feature branch (`git checkout -b feature/amazing-feature`)\n3.
-  Commit your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch
-  (`git push origin feature/amazing-feature`)\n5. Open a Pull Request\n## License\n\nThis
-  project is licensed under the MIT License - see the [LICENSE](LICENSE) file for
-  details.\n"
+  the [Ranking README](lib/active_genie/ranking/README.md) for implementation details,
+  configuration, and advanced ranking strategies.\n\n### Text Summarizer (Future)\n###
+  Language detector (Future)\n### Translator (Future)\n### Sentiment analyzer (Future)\n\n##
+  Configuration\n\n| Config | Description | Default |\n|--------|-------------|---------|\n|
+  `provider` | LLM provider (openai, anthropic, etc) | `nil` |\n| `model` | Model
+  to use | `nil` |\n| `api_key` | Provider API key | `nil` |\n| `timeout` | Request
+  timeout in seconds | `5` |\n| `max_retries` | Maximum retry attempts | `3` |\n\n>
+  **Note:** Each module can append its own set of configuration, see the individual
+  module documentation for details.\n\n## Contributing\n\n1. Fork the repository\n2.
+  Create your feature branch (`git checkout -b feature/amazing-feature`)\n3. Commit
+  your changes (`git commit -m 'Add amazing feature'`)\n4. Push to the branch (`git
+  push origin feature/amazing-feature`)\n5. Open a Pull Request\n\n## License\n\nThis
+  project is licensed under the Apache License 2.0 License - see the [LICENSE](LICENSE)
+  file for details.\n"
 email:
 - radames@roriz.dev
 executables: []
@@ -132,18 +110,19 @@ files:
 - lib/active_genie/data_extractor/README.md
 - lib/active_genie/data_extractor/basic.rb
 - lib/active_genie/data_extractor/from_informal.rb
-- lib/active_genie/league.rb
-- lib/active_genie/league/README.md
-- lib/active_genie/league/elo_ranking.rb
-- lib/active_genie/league/free_for_all.rb
-- lib/active_genie/league/league.rb
-- lib/active_genie/league/player.rb
-- lib/active_genie/league/players_collection.rb
 - lib/active_genie/logger.rb
+- lib/active_genie/ranking.rb
+- lib/active_genie/ranking/README.md
+- lib/active_genie/ranking/elo_round.rb
+- lib/active_genie/ranking/free_for_all.rb
+- lib/active_genie/ranking/player.rb
+- lib/active_genie/ranking/players_collection.rb
+- lib/active_genie/ranking/ranking.rb
+- lib/active_genie/ranking/ranking_scoring.rb
 - lib/active_genie/scoring.rb
 - lib/active_genie/scoring/README.md
 - lib/active_genie/scoring/basic.rb
-- lib/active_genie/scoring/recommended_reviews.rb
+- lib/active_genie/scoring/recommended_reviewers.rb
 - lib/tasks/install.rake
 - lib/tasks/templates/active_genie.rb
 homepage: https://github.com/Roriz/active_genie

data/lib/active_genie/league/elo_ranking.rb

@@ -1,121 +0,0 @@
-require_relative '../battle/basic'
-
-module ActiveGenie::Leaderboard
-  class EloRanking
-    def self.call(players, criteria, config: {})
-      new(players, criteria, config:).call
-    end
-
-    def initialize(players, criteria, config: {})
-      @players = players
-      @criteria = criteria
-      @config = config
-      @start_time = Time.now
-    end
-
-    def call
-      @players.each(&:generate_elo_by_score)
-
-      round_count = 0
-      while @players.eligible_size > MINIMAL_PLAYERS_TO_BATTLE
-        round = create_round(@players.tier_relegation, @players.tier_defense)
-
-        round.each do |player_a, player_b|
-          winner, loser = battle(player_a, player_b) # This can take a while, can be parallelized
-          update_elo(winner, loser)
-          ActiveGenie::Logger.trace({ **log, step: :elo_battle, winner_id: winner.id, loser_id: loser.id, winner_elo: winner.elo, loser_elo: loser.elo })
-        end
-
-        eliminate_all_relegation_players
-        round_count += 1
-      end
-
-      ActiveGenie::Logger.info({ **log, step: :elo_end, round_count:, eligible_size: @players.eligible_size })
-      @players
-    end
-
-    private
-
-    MATCHS_PER_PLAYER = 3
-    LOSE_PENALTY = 15
-    MINIMAL_PLAYERS_TO_BATTLE = 10
-    K = 32
-
-    # Create a round of matches
-    # each round is exactly 1 regation player vs 3 defense players for all regation players
-    # each match is unique (player vs player)
-    # each defense player is battle exactly 3 times
-    def create_round(relegation_players, defense_players)
-      matches = []
-
-      relegation_players.each do |player_a|
-        player_enemies = []
-        MATCHS_PER_PLAYER.times do
-          defender = nil
-          while defender.nil? || player_enemies.include?(defender.id)
-            defender = defense_players.sample
-          end
-
-          matches << [player_a, defender].shuffle
-          player_enemies << defender.id
-        end
-      end
-
-      matches
-    end
-
-    def battle(player_a, player_b)
-      ActiveGenie::Battle.basic(
-        player_a,
-        player_b,
-        @criteria,
-        config:
-      ).values_at('winner', 'loser')
-    end
-
-    def update_elo(winner, loser)
-      return if winner.nil? || loser.nil?
-
-      new_winner_elo, new_loser_elo = calculate_new_elo(winner.elo, loser.elo)
-
-      winner.elo = [new_winner_elo, max_defense_elo].min
-      loser.elo = [new_loser_elo - LOSE_PENALTY, min_relegation_elo].max
-    end
-
-    def max_defense_elo
-      @players.tier_defense.max_by(&:elo).elo
-    end
-
-    def min_relegation_elo
-      @players.tier_relegation.min_by(&:elo).elo
-    end
-
-    # Read more about the formula on https://en.wikipedia.org/wiki/Elo_rating_system
-    def calculate_new_elo(winner_elo, loser_elo)
-      expected_score_a = 1 / (1 + 10**((loser_elo - winner_elo) / 400))
-      expected_score_b = 1 - expected_score_a
-
-      new_elo_winner = winner_elo + K * (1 - expected_score_a)
-      new_elo_loser = loser_elo + K * (1 - expected_score_b)
-
-      [new_elo_winner, new_elo_loser]
-    end
-
-    def eliminate_all_relegation_players
-      eliminations = @players.tier_relegation.size
-      @players.tier_relegation.each { |player| player.eliminated = 'tier_relegation' }
-      ActiveGenie::Logger.trace({ **log, step: :elo_round, eligible_size: @players.eligible_size, eliminations: })
-    end
-
-    def config
-      { **@config }
-    end
-
-    def log
-      {
-        **(@config.dig(:log) || {}),
-        duration: Time.now - @start_time
-      }
-    end
-  end
-end

data/lib/active_genie/league/free_for_all.rb

@@ -1,62 +0,0 @@
-require_relative '../battle/basic'
-
-module ActiveGenie::Leaderboard
-  class FreeForAll
-    def self.call(players, criteria, config: {})
-      new(players, criteria, config:).call
-    end
-
-    def initialize(players, criteria, config: {})
-      @players = players
-      @criteria = criteria
-      @config = config
-      @start_time = Time.now
-    end
-
-    def call
-      matches.each do |player_a, player_b|
-        winner, loser = battle(player_a, player_b)
-
-        if winner.nil? || loser.nil?
-          player_a.free_for_all[:draw] += 1
-          player_b.free_for_all[:draw] += 1
-        else
-          winner.free_for_all[:win] += 1
-          loser.free_for_all[:lose] += 1
-        end
-
-        ActiveGenie::Logger.trace({**log, step: :free_for_all_battle, winner_id: winner&.id, player_a_id: player_a.id, player_a_free_for_all_score: player_a.free_for_all_score, player_b_id: player_b.id, player_b_free_for_all_score: player_b.free_for_all_score })
-      end
-
-      @players
-    end
-
-    private
-
-    # TODO: reduce the number of matches based on transitivity.
-    #       For example, if A is better than B, and B is better than C, then A should clearly be better than C
-    def matches
-      @players.eligible.combination(2).to_a
-    end
-
-    def battle(player_a, player_b)
-      result = ActiveGenie::Battle.basic(
-        player_a,
-        player_b,
-        @criteria,
-        config:
-      )
-
-
-      result.values_at('winner', 'loser')
-    end
-
-    def config
-      { **@config }
-    end
-
-    def log
-      { **(@config.dig(:log) || {}), duration: Time.now - @start_time }
-    end
-  end
-end