active_genie 0.0.8 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 834787b505134623a3f6c4995c9dec8a0ce89a1a014600c4d676d8801bf541cd
-  data.tar.gz: 16ae75ffa3926ecd87052d72ca3f5434be80327b712bb2dba54e55c46fa5ff8d
+  metadata.gz: fbc4033f3c0880973cf732d704921bb61c3cb861c438b732aa6ebe0cc88b2de4
+  data.tar.gz: 11794293170ec43a1d3b3d09e5ec488351a22428a5370ae0e42266a6f8098646
 SHA512:
-  metadata.gz: 1772fbfa59891e7a3673b50a54bd90914007917854e78fb5f0458db681bf89bd1ec118600d23ab98d6255e1b063b5d582d3b73dc738e66aeadc7f4f0bee75af8
-  data.tar.gz: bb6a0ea9ef737f7a2ed3ec558dcea5c67bcc2f90a155828e1e25a5a7a3ebd9d0fe6c5422dd9f3d9ff6fb667b63822e3bc86627cdb3e40a3c72c4ef50cee32c68
+  metadata.gz: f6b13b3f36a8e516e5126d4cea0de52d046e498834cd10b90b1905460e9bba5ff6e7c4cebd58e6ea2c073176566601c8b806015baa01f11f28792942eec6ca1d
+  data.tar.gz: fc79aed12aaba0ca335d3a7ef8405f4a7c2809de9d5e41ca14fa7bd843d9fb69db8e124b6a2e96321432575a58b271c724a52fd3c1a1165c5ecfe346bedd4b5f

data/README.md

@@ -1,18 +1,17 @@
 # ActiveGenie 🧞‍♂️
-> Transform your Ruby application with powerful, production-ready GenAI features
+> The lodash for GenAI, stop reinventing the wheel
 
 [![Gem Version](https://badge.fury.io/rb/active_genie.svg?icon=si%3Arubygems)](https://badge.fury.io/rb/active_genie)
 [![Ruby](https://github.com/roriz/active_genie/actions/workflows/ruby.yml/badge.svg)](https://github.com/roriz/active_genie/actions/workflows/ruby.yml)
 
-ActiveGenie 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.
+ActiveGenie is a Ruby gem that provides a polished, production-ready interface for working with Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie simplifies GenAI integration in your Ruby applications.
 
 ## Features
 
 - 🎯 **Data Extraction**: Extract structured data from unstructured text with type validation
-- 📊 **Smart Scoring**: Multi-reviewer evaluation system with automatic expert selection
-- 💭 **Sentiment Analysis**: Advanced sentiment analysis with customizable rules
-- 🔒 **Safe & Secure**: Built-in validation and sanitization
-- 🛠️ **Configurable**: Supports multiple GenAI providers and models
+- 📊 **Data Scoring**: Multi-reviewer evaluation system
+- ⚔️ **Data Battle**: Battle between two data like a political debate
+- 💭 **Data Ranking**: Consistent rank data using scoring + elo ranking + battles
 
 ## Installation
 
@@ -32,19 +31,13 @@ echo "ActiveGenie.load_tasks" >> Rakefile
 rails g active_genie:install
 ```
 
-4. [Optional] Configure your credentials in `config/active_genie.yml`:
-```yaml
-GPT-4o-mini:
-  api_key: <%= ENV['OPENAI_API_KEY'] %>
-  provider: "openai"
-
-claude-3-5-sonnet:
-  api_key: <%= ENV['ANTHROPIC_API_KEY'] %>
-  provider: "anthropic"
+4. Configure your credentials in `config/initializers/active_genie.rb`:
+```ruby
+ActiveGenie.configure do |config|
+  config.openai.api_key = ENV['OPENAI_API_KEY']
+end
 ```
 
-> The first key will be used as default in all modules, in this example `GPT-4o-mini`
-
 ## Quick Start
 
 ### Data Extractor
@@ -87,14 +80,14 @@ Features:
 
 See the [Data Extractor README](lib/active_genie/data_extractor/README.md) for informal text processing, advanced schemas, and detailed interface documentation.
 
-### Scoring
+### Data Scoring
 Text 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.
 
 ```ruby
 text = "The code implements a binary search algorithm with O(log n) complexity"
 criteria = "Evaluate technical accuracy and clarity"
 
-result = ActiveGenie::Scoring::Basic.call(text, criteria)
+result = ActiveGenie::Scoring.basic(text, criteria)
 # => {
 #      algorithm_expert_score: 95,
 #      algorithm_expert_reasoning: "Accurately describes binary search and its complexity",
@@ -112,7 +105,7 @@ Features:
 
 See the [Scoring README](lib/active_genie/scoring/README.md) for advanced usage, custom reviewers, and detailed interface documentation.
 
-### Battle
+### Data Battle
 AI-powered battle evaluation system that determines winners between two players based on specified criteria.
 
 ```ruby
@@ -122,7 +115,7 @@ player_a = "Implementation uses dependency injection for better testability"
 player_b = "Code has high test coverage but tightly coupled components"
 criteria = "Evaluate code quality and maintainability"
 
-result = ActiveGenie::Battle::Basic.call(player_a, player_b, criteria)
+result = ActiveGenie::Battle.call(player_a, player_b, criteria)
 # => {
 #      winner_player: "Implementation uses dependency injection for better testability",
 #      reasoning: "Player A's implementation demonstrates better maintainability through dependency injection, 
@@ -140,66 +133,37 @@ Features:
 
 See the [Battle README](lib/active_genie/battle/README.md) for advanced usage, custom reviewers, and detailed interface documentation.
 
-### Summarizer (WIP)
-The 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.
-
-```ruby
-require 'active_genie'
-
-text = "Example text to be summarized. The fox jumps over the dog"
-summarized_text = ActiveGenie::Summarizer.call(text)
-puts summarized_text # => "The fox jumps over the dog"
-```
+### Data Ranking
+The Ranking module provides competitive ranking through multi-stage evaluation:
 
-### Language detector (WIP)
-The 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.
 
 ```ruby
 require 'active_genie'
 
-text = "Example text to be detected"
-language = ActiveGenie::LanguageDetector.call(text)
-puts language # => "en"
-```
-
-### Translator (WIP)
-The 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.
+players = ['REST API', 'GraphQL API', 'SOAP API', 'gRPC API', 'Websocket API']
+criteria = "Best one to be used into a high changing environment"
 
-```ruby
-require 'active_genie'
-
-text = "Example text to be translated"
-translated_text = ActiveGenie::Translator.call(text, from: 'en', to: 'pt')
-puts translated_text # => "Exemplo de texto a ser traduzido"
-```
-
-### Sentiment analyzer (WIP)
-The 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.
-
-```ruby
-require 'active_genie'
-
-text = "Example text to be analyzed"
-sentiment = ActiveGenie::SentimentAnalyzer.call(text)
-puts sentiment # => "positive"
+result = ActiveGenie::Ranking.call(players, criteria)
+# => {
+#      winner_player: "gRPC API",
+#      reasoning: "gRPC API is the best one to be used into a high changing environment",
+#    }
 ```
 
-### Elo ranking (WIP)
-The Elo ranking is a tool that can be used to rank a set of items. It uses a set of rules to rank the items out of the box. Uses the best practices of prompt engineering and engineering to make the ranking as accurate as possible.
+- **Multi-phase ranking system** combining expert scoring and ELO algorithms
+- **Automatic elimination** of inconsistent performers using statistical analysis
+- **Dynamic ranking adjustments** based on simulated pairwise battles, from bottom to top
 
-```ruby
-require 'active_genie'
-
-items = ['Square', 'Circle', 'Triangle']
-criterias = 'items that look rounded'
-ranked_items = ActiveGenie::EloRanking.call(items, criterias, rounds: 10)
-puts ranked_items # => [{ name: "Circle", score: 1500 }, { name: "Square", score: 800 }, { name: "Triangle", score: 800 }]
-```
+See the [Ranking README](lib/active_genie/ranking/README.md) for implementation details, configuration, and advanced ranking strategies.
 
+### Text Summarizer (Future)
+### Language detector (Future)
+### Translator (Future)
+### Sentiment analyzer (Future)
 
-## Configuration Options
+## Configuration
 
-| Option | Description | Default |
+| Config | Description | Default |
 |--------|-------------|---------|
 | `provider` | LLM provider (openai, anthropic, etc) | `nil` |
 | `model` | Model to use | `nil` |
@@ -207,7 +171,7 @@ puts ranked_items # => [{ name: "Circle", score: 1500 }, { name: "Square", score
 | `timeout` | Request timeout in seconds | `5` |
 | `max_retries` | Maximum retry attempts | `3` |
 
-> **Note:** Each module can append its own set of configuration options, see the individual module documentation for details.
+> **Note:** Each module can append its own set of configuration, see the individual module documentation for details.
 
 ## Contributing
 
@@ -216,7 +180,7 @@ puts ranked_items # => [{ name: "Circle", score: 1500 }, { name: "Square", score
 3. Commit your changes (`git commit -m 'Add amazing feature'`)
 4. Push to the branch (`git push origin feature/amazing-feature`)
 5. Open a Pull Request
-## License
 
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+## License
 
+This project is licensed under the Apache License 2.0 License - see the [LICENSE](LICENSE) file for details.

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.12

data/lib/active_genie/battle/README.md

@@ -27,11 +27,11 @@ result = ActiveGenie::Battle::Basic.call(player_a, player_b, criteria)
 ```
 
 ## Interface
-### Basic.call(player_a, player_b, criteria, options: {})
+### Basic.call(player_a, player_b, criteria, config: {})
 - `player_a` [String, Hash] - The content or submission from the first player
 - `player_b` [String, Hash] - The content or submission from the second player
 - `criteria` [String] - The evaluation criteria or rules to assess against
-- `options` [Hash] - Additional configuration options that modify the battle evaluation behavior
+- `config` [Hash] - Additional configuration config that modify the battle evaluation behavior
 
 Returns a Hash containing:
 - `winner_player` [String, Hash] - The winning player's content (either player_a or player_b)

data/lib/active_genie/battle/basic.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../clients/router'
+require_relative '../clients/unified_client'
 
 module ActiveGenie::Battle
   # The Basic class provides a foundation for evaluating battles between two players
@@ -14,87 +14,71 @@ module ActiveGenie::Battle
   #   Basic.call("Player A content", "Player B content", "Evaluate keyword usage and pattern matching")
   #
   class Basic
-    def self.call(player_a, player_b, criteria, options: {})
-      new(player_a, player_b, criteria, options:).call
+    def self.call(...)
+      new(...).call
     end
 
     # @param player_a [String] The content or submission from the first player
     # @param player_b [String] The content or submission from the second player
     # @param criteria [String] The evaluation criteria or rules to assess against
-    # @param options [Hash] Additional configuration options that modify the battle evaluation behavior
+    # @param config [Hash] Additional configuration config that modify the battle evaluation behavior
     # @return [Hash] The evaluation result containing the winner and reasoning
     #   @return [String] :winner The @param player_a or player_b
     #   @return [String] :reasoning Detailed explanation of why the winner was chosen
     #   @return [String] :what_could_be_changed_to_avoid_draw A suggestion on how to avoid a draw
-    def initialize(player_a, player_b, criteria, options: {})
+    def initialize(player_a, player_b, criteria, config: {})
       @player_a = player_a
       @player_b = player_b
       @criteria = criteria
-      @options = options
-      @response = nil
+      @config = ActiveGenie::Configuration.to_h(config)
     end
 
     def call
       messages = [
         {  role: 'system', content: PROMPT },
         {  role: 'user', content: "criteria: #{@criteria}" },
-        {  role: 'user', content: "player_a: #{player_content(@player_a)}" },
-        {  role: 'user', content: "player_b: #{player_content(@player_b)}" },
+        {  role: 'user', content: "player_a: #{@player_a}" },
+        {  role: 'user', content: "player_b: #{@player_b}" },
       ]
 
-      @response = ::ActiveGenie::Clients::Router.function_calling(messages, FUNCTION, options: @options)
+      response = ::ActiveGenie::Clients::UnifiedClient.function_calling(
+        messages,
+        FUNCTION,
+        model_tier: 'lower_tier',
+        config: @config
+      )
 
-      response_formatted
+      response_formatted(response)
     end
 
     private
 
-    def player_content(player)
-      return player.dig('content') if player.is_a?(Hash)
+    def response_formatted(response)
+      winner = response['impartial_judge_winner']
+      loser = case response['impartial_judge_winner']
+              when 'player_a' then 'player_b'
+              when 'player_b' then 'player_a'
+              else 'draw'
+              end
 
-      player
-    end
-
-    def response_formatted
-      if @response['winner'] == 'player_a'
-        @response['winner'] = @player_a
-        @response['loser'] = @player_b
-      elsif @response['winner'] == 'player_b'
-        @response['winner'] = @player_b
-        @response['loser'] = @player_a
-      else
-        @response['winner'] = nil
-        @response['loser'] = nil
-      end
-
-      @response
+      { winner:, loser:, reasoning: response['impartial_judge_winner_reasoning'] }
     end
 
     PROMPT = <<~PROMPT
-    Evaluate a battle between player_a and player_b using predefined criteria and identify the winner.
-
-    Consider rules, keywords, and patterns as the criteria for evaluation. Analyze the content from both players objectively, focusing on who meets the criteria most effectively. Explain your decision clearly, with specific reasoning on how the chosen player fulfilled the criteria better than the other. Avoid selecting a draw unless absolutely necessary.
+    Based on two players, player_a and player_b, they will battle against each other based on criteria. Criteria are vital as they provide a clear metric to compare the players. Follow these criteria strictly.
 
     # Steps
-    1. **Review Predefined Criteria**: Understand the specific rules, keywords, and patterns that serve as the basis for evaluation.
-    2. **Analyze Content**: Examine the contributions of both player_a and player_b. Look for how each player meets or fails to meet the criteria.
-    3. **Comparison**: Compare both players against each criterion to determine who aligns better with the standards set.
-    4. **Decision-Making**: Based on the analysis, determine the player who meets the most or all criteria effectively.
-    5. **Provide Justification**: Offer a clear and concise reason for your choice detailing how the winner outperformed the other.
+    1. Player_a sells himself, highlighting his strengths and how he meets the criteria. Max of 100 words.
+    2. Player_b sells himself, highlighting his strengths and how he meets the criteria. Max of 100 words.
+    3. Player_a argues why he is the winner compared to player_b. Max of 100 words.
+    4. Player_b counter-argues why he is the winner compared to player_a. Max of 100 words.
+    5. The impartial judge chooses which player as the winner.
 
-    # Examples
-    - **Example 1**:
-      - Input: Player A uses keyword X, follows rule Y, Player B uses keyword Z, breaks rule Y.
-      - Output: winner: player_a
-        - Justification: Player A successfully used keyword X and followed rule Y, whereas Player B broke rule Y.
-
-    - **Example 2**:
-      - Input: Player A matches pattern P, Player B matches pattern P, uses keyword Q.
-      - Output: winner: player_b
-        - Justification: Both matched pattern P, but Player B also used keyword Q, meeting more criteria.
+    # Output Format
+    - The impartial judge chooses this player as the winner.
 
     # Notes
-    - Avoid drawing if a clear winner can be discerned.
+    - Avoid resulting in a draw. Use reasoning or make fair assumptions if needed.
     - Critically assess each player's adherence to the criteria.
     - Clearly communicate the reasoning behind your decision.
     PROMPT
@@ -105,19 +89,31 @@ module ActiveGenie::Battle
       schema: {
         type: "object",
         properties: {
-          winner: {
+          player_a_sell_himself: {
             type: 'string',
-            description: 'The player who won the battle based on the criteria.',
-            enum: ['player_a', 'player_b', 'draw']
+            description: 'player_a sell himself, highlighting his strengths and how he meets the criteria. Max of 100 words.',
+          },
+          player_b_sell_himself: {
+            type: 'string',
+            description: 'player_b sell himself, highlighting his strengths and how he meets the criteria. Max of 100 words.',
+          },
+          player_a_arguments: {
+            type: 'string',
+            description: 'player_a arguments why he is the winner compared to player_b. Max of 100 words.',
           },
-          reasoning_of_winner: {
+          player_b_counter: {
             type: 'string',
-            description: 'The detailed reasoning about why the winner won based on the criteria.',
+            description: 'player_b counter arguments why he is the winner compared to player_a. Max of 100 words.',
           },
-          what_could_be_changed_to_avoid_draw: {
+          impartial_judge_winner_reasoning: {
             type: 'string',
-            description: 'Suggestions on how to avoid a draw based on the criteria. Be as objective and short as possible. Can be empty.',
-          }
+            description: 'The detailed reasoning about why the impartial judge chose the winner. Max of 100 words.',
+          },
+          impartial_judge_winner: {
+            type: 'string',
+            description: 'The impartial judge chose this player as the winner.',
+            enum: ['player_a', 'player_b', 'draw']
+          },
         }
       }
     }

data/lib/active_genie/battle.rb

@@ -2,7 +2,7 @@
 require_relative 'battle/basic'
 
 module ActiveGenie
-  # Battle module
+  # See the [Battle README](lib/active_genie/battle/README.md) for more information.
   module Battle
     module_function
 

data/lib/active_genie/clients/openai_client.rb

@@ -0,0 +1,119 @@
+require 'json'
+require 'net/http'
+
+module ActiveGenie::Clients
+  class OpenaiClient
+    MAX_RETRIES = 3
+    
+    class OpenaiError < StandardError; end
+    class RateLimitError < OpenaiError; end
+
+    def initialize(config)
+      @app_config = config
+    end
+
+    def function_calling(messages, function, model_tier: nil, config: {})
+      model = config[:model] || @app_config.tier_to_model(model_tier)
+
+      payload = {
+        messages:,
+        response_format: {
+          type: 'json_schema',
+          json_schema: function
+        },
+        model:,
+      }
+
+      api_key = config[:api_key] || @app_config.api_key
+      headers = DEFAULT_HEADERS.merge(
+        'Authorization': "Bearer #{api_key}"
+      ).compact
+
+      response = request(payload, headers, config:)
+
+      parsed_response = JSON.parse(response.dig('choices', 0, 'message', 'content'))
+      parsed_response.dig('properties') || parsed_response
+    rescue JSON::ParserError
+      nil
+    end
+
+    private
+
+    def request(payload, headers, config:)
+      retries = config[:max_retries] || MAX_RETRIES
+      start_time = Time.now
+      
+      begin
+        response = Net::HTTP.post(
+          URI("#{@app_config.api_url}/chat/completions"),
+          payload.to_json,
+          headers
+        )
+
+        if response.is_a?(Net::HTTPTooManyRequests)
+          raise RateLimitError, "OpenAI API rate limit exceeded: #{response.body}"
+        end
+
+        raise OpenaiError, response.body unless response.is_a?(Net::HTTPSuccess)
+
+        return nil if response.body.empty?
+
+        parsed_body = JSON.parse(response.body)
+        # log_response(start_time, parsed_body, config:)
+
+        parsed_body
+      rescue OpenaiError, Net::HTTPError, JSON::ParserError, Errno::ECONNRESET, Errno::ETIMEDOUT, Net::OpenTimeout, Net::ReadTimeout => e
+        if retries > 0
+          retries -= 1
+          backoff_time = calculate_backoff(MAX_RETRIES - retries)
+          ActiveGenie::Logger.trace(
+            {
+              category: :llm,
+              trace: "#{config.dig(:log, :trace)}/#{self.class.name}",
+              message: "Retrying request after error: #{e.message}. Attempts remaining: #{retries}",
+              backoff_time: backoff_time
+            }
+          )
+          sleep(backoff_time)
+          retry
+        else
+          ActiveGenie::Logger.trace(
+            {
+              category: :llm,
+              trace: "#{config.dig(:log, :trace)}/#{self.class.name}",
+              message: "Max retries reached. Failing with error: #{e.message}"
+            }
+          )
+          raise
+        end
+      end
+    end
+
+    BASE_DELAY = 0.5
+    def calculate_backoff(retry_count)
+      # Exponential backoff with jitter: 2^retry_count + random jitter
+      # Base delay is 0.5 seconds, doubles each retry, plus up to 0.5 seconds of random jitter
+      # Simplified example: 0.5, 1, 2, 4, 8, 12, 16, 20, 24, 28, 30 seconds
+      jitter = rand * BASE_DELAY
+      [BASE_DELAY * (2 ** retry_count) + jitter, 30].min # Cap at 30 seconds
+    end
+
+    DEFAULT_HEADERS = {
+      'Content-Type': 'application/json',
+    }
+
+    def log_response(start_time, response, config: {})
+      ActiveGenie::Logger.trace(
+        {
+          **config.dig(:log),
+          category: :llm,
+          trace: "#{config.dig(:log, :trace)}/#{self.class.name}",
+          total_tokens: response.dig('usage', 'total_tokens'),
+          model: response.dig('model'),
+          request_duration: Time.now - start_time,
+          openai: response
+        }
+      )
+    end
+  end
+end

data/lib/active_genie/clients/unified_client.rb

@@ -0,0 +1,19 @@
+module ActiveGenie::Clients
+  class UnifiedClient
+    class << self
+      def function_calling(messages, function, model_tier: nil, config: {})
+        provider_name = config[:provider]&.downcase&.strip&.to_sym
+        provider = ActiveGenie.configuration.providers.all[provider_name] || ActiveGenie.configuration.providers.default
+
+        raise InvalidProviderError if provider.nil? || provider.client.nil?
+
+        provider.client.function_calling(messages, function, model_tier:, config:)
+      end
+
+      private
+
+      # TODO: improve error message
+      class InvalidProviderError < StandardError; end
+    end
+  end
+end

data/lib/active_genie/configuration/log_config.rb

@@ -0,0 +1,14 @@
+
+module ActiveGenie::Configuration
+  class LogConfig
+    attr_writer :log_level
+
+    def log_level
+      @log_level ||= :info
+    end
+
+    def to_h(config = {})
+      { log_level:, **config }
+    end
+  end
+end

data/lib/active_genie/configuration/openai_config.rb

@@ -0,0 +1,56 @@
+require_relative '../clients/openai_client'
+
+module ActiveGenie::Configuration
+  class OpenaiConfig
+    attr_writer :api_key, :organization, :api_url, :client,
+      :lower_tier_model, :middle_tier_model, :upper_tier_model
+
+    def api_key
+      @api_key || ENV['OPENAI_API_KEY']
+    end
+
+    def organization
+      @organization || ENV['OPENAI_ORGANIZATION']
+    end
+
+    def api_url
+      @api_url || 'https://api.openai.com/v1'
+    end
+
+    def client
+      @client ||= ::ActiveGenie::Clients::OpenaiClient.new(self)
+    end
+
+    def lower_tier_model
+      @lower_tier_model || 'gpt-4o-mini'
+    end
+
+    def middle_tier_model
+      @middle_tier_model || 'gpt-4o'
+    end
+
+    def upper_tier_model
+      @upper_tier_model || 'o1-preview'
+    end
+
+    def tier_to_model(tier)
+      {
+        lower_tier: lower_tier_model,
+        middle_tier: middle_tier_model,
+        upper_tier: upper_tier_model
+      }[tier&.to_sym] || lower_tier_model
+    end
+
+    def to_h(config = {})
+      {
+        api_key:,
+        organization:,
+        api_url:,
+        lower_tier_model:,
+        middle_tier_model:,
+        upper_tier_model:,
+        **config
+      }
+    end
+  end
+end

data/lib/active_genie/configuration/providers_config.rb

@@ -0,0 +1,37 @@
+module ActiveGenie::Configuration
+  class ProvidersConfig
+    def initialize
+      @all = {}
+      @default = nil
+    end
+
+    def register(name, provider_class)
+      @all ||= {}
+      @all[name] = provider_class.new
+      define_singleton_method(name) do
+        instance_variable_get("@#{name}") || instance_variable_set("@#{name}", @all[name])
+      end
+
+      self
+    end
+
+    def default
+      @default || @all.values.first
+    end
+
+    def all
+      @all
+    end
+
+    def to_h(config = {})
+      hash_all = {}
+      @all.each do |name, provider|
+        hash_all[name] = provider.to_h(config.dig(name) || {})
+      end
+      hash_all
+    end
+
+    private
+    attr_writer :default
+  end
+end