Module: Ace::Git::Providers

Defined in:
lib/ace/git/providers.rb,
lib/ace/git/providers/base.rb

Overview

Registry of provider implementations owned by provider packages.

The core never executes provider CLIs. Provider packages register their contract implementation here when loaded; downstream consumers then obtain a provider via Providers.for.

Examples:

Registering (inside a provider package)

Ace::Git::Providers.register(:acme, Ace::Git::Acme::Provider)

Resolving (in consumers)

server = Ace::Git::ServerRegistry.resolve_default
provider = Ace::Git::Providers.for(server)
pr = provider.pull_request(number: 25)

Defined Under Namespace

Classes: Base

Class Method Summary collapse

Class Method Details

.for(server, timeout: nil, runner: nil) ⇒ Providers::Base

Build the provider implementation for a resolved server.

Parameters:

  • server (ResolvedServer) —

    exactly-resolved server identity

  • timeout (Integer, nil) (defaults to: nil) —

    provider operation timeout in seconds

  • runner (Proc, nil) (defaults to: nil) —

    optional command runner injection for tests; see Providers::Base

Returns:

Raises:



52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/ace/git/providers.rb', line 52

def for(server, timeout: nil, runner: nil)
  key = normalize_type(server.provider)
  provider_class = @mutex.synchronize { @registry[key] }
  unless provider_class
    raise UnknownProviderError,
      "No provider registered for type #{key.inspect} (server '#{server.name}'); " \
      "install and require the provider package that owns #{key.inspect}"
  end

  provider_class.new(server: server, timeout: timeout, runner: runner)
end

.register(type, provider_class) ⇒ Object

Register a provider implementation for a provider type.

Parameters:

  • type (Symbol, String) —

    provider type (e.g. :acme)

  • provider_class (Class) —

    class implementing Providers::Base; must respond to .new

Raises:

  • (ArgumentError) —

    when type or provider_class is invalid



33
34
35
36
37
38
39
40
41
 
# File 'lib/ace/git/providers.rb', line 33

def register(type, provider_class)
  key = normalize_type(type)
  unless provider_class.respond_to?(:new)
    raise ArgumentError, "Provider for #{key.inspect} must be a class (got #{provider_class.inspect})"
  end

  @mutex.synchronize { @registry[key] = provider_class }
  provider_class
end

.registered?(type) ⇒ Boolean

Returns true when a provider is registered for the type.

Parameters:

  • type (Symbol, String) —

    provider type

Returns:

  • (Boolean) —

    true when a provider is registered for the type



66
67
68
69
 
# File 'lib/ace/git/providers.rb', line 66

def registered?(type)
  key = normalize_type(type)
  @mutex.synchronize { @registry.key?(key) }
end

.reset! ⇒ Object

Clear all registrations (test seam).



77
78
79
 
# File 'lib/ace/git/providers.rb', line 77

def reset!
  @mutex.synchronize { @registry.clear }
end

.types ⇒ Array<Symbol>

Returns registered provider types, sorted.

Returns:

  • (Array<Symbol>) —

    registered provider types, sorted



72
73
74
 
# File 'lib/ace/git/providers.rb', line 72

def types
  @mutex.synchronize { @registry.keys.sort }
end