class Eco::API::UseCases::UseCaseChain

Class that enables to chain multiple UseCase

Constants

MAX_CHAINS

Public Class Methods

new(name = nil, type: nil, root:, usecase: nil, &block) click to toggle source
Calls superclass method Eco::API::UseCases::UseCase::new
# File lib/eco/api/usecases/use_case_chain.rb, line 11
def initialize(name = nil, type: nil, root:, usecase: nil, &block)
  if usecase
    raise "Expected Eco::API::UseCases::UseCase. Given #{usecase.class}" if !usecase.is_a?(Eco::API::UseCases::UseCase)
    type = usecase.type
    name = usecase.name
    block = usecase.callback unless block
  end

  super(name, type: type, root: root, &block)
  @chains   = []
  @resolved_chains = nil
end

Public Instance Methods

chain(usecase = nil) click to toggle source
# File lib/eco/api/usecases/use_case_chain.rb, line 60
def chain(usecase = nil)
  @@num_chains += 1
  raise "Reached maximum number of chained use cases (#{MAX_CHAINS}). Looks like a recursive cyclic chain 'use'" if @@num_chains >= MAX_CHAINS
  raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
  raise "Missuse. Please use either parameter or block but not both" if block_given? && usecase
  usecase = block_given?? Proc.new : usecase
  @chains.push(usecase)
  self
end
launch(io: nil, **kargs) click to toggle source

@see Eco::API::UseCases::UseCase#launch

Calls superclass method Eco::API::UseCases::UseCase#launch
# File lib/eco/api/usecases/use_case_chain.rb, line 50
def launch(io: nil, **kargs)
  super(io: io, **kargs).tap do |uio|
    next if resolved_chains.empty?

    resolved_chains.each do |usecase|
      uio = usecase.launch(io: uio.chain(usecase: usecase))
    end
  end
end
root=(value) click to toggle source
Calls superclass method Eco::API::UseCases::UseCase#root=
# File lib/eco/api/usecases/use_case_chain.rb, line 24
def root=(value)
  raise "You cannot change root Eco::API::UseCases once the chains have been resolved" if @resolved_chains
  super(value)
end
use(preserve_chains: false, recursive: false) click to toggle source
# File lib/eco/api/usecases/use_case_chain.rb, line 29
def use(preserve_chains: false, recursive: false)
  UseCase.new(@name, type: @type, root: @root, &@case).tap do |newcase|
    if preserve_chains
      chain_use = {preserve_chains: recursive, recursive: recursive}
      @chains = @chains.map do |usecase|
        if usecase.respond_to? :call
          Proc.new do |usegroup|
            usecase = usecase.call(usegroup)
            usecase.use(chain_use).chain_to(newcase)
            usecase
          end
        elsif usecase.is_a?(UseCase)
          usecase.use(chain_use).chain_to(newcase)
          usecase
        end
      end
    end
  end
end

Protected Instance Methods

chain_to(usecase) click to toggle source
# File lib/eco/api/usecases/use_case_chain.rb, line 72
def chain_to(usecase)
  raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
  usecase.chain(self)
end
resolved_chains(use_group = nil) click to toggle source
# File lib/eco/api/usecases/use_case_chain.rb, line 77
def resolved_chains(use_group = nil)
  return @resolved_chains if @resolved_chains
  raise "Only Eco::API::UseCases object can contain resolved chains. Given: #{use_group.class} " if use_group && !use_group.is_a?(Eco::API::UseCases)

  use_group = use_group || @root
  @resolved_chains = @chains.map do |usecase|
    usecase = usecase.call(use_group)  if usecase.respond_to?(:call)
    raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
    usecase.resolved_chains(use_group) if usecase.respond_to?(:resolved_chains)
    usecase
  end
end