class Eco::CLI::Config::UseCases

Attributes

core_config[R]

Public Class Methods

new(core_config:) click to toggle source
# File lib/eco/cli/config/use_cases.rb, line 26
def initialize(core_config:)
  @core_config  = core_config
  @linked_cases = {}
end

Public Instance Methods

active(io:) click to toggle source

Scopes/identifies which usecases are being invoked from the command line @note

- this method will sort the active usecases by the position they hold in the command line

@param io [Eco::API::UseCases::BaseIO] the input/output object @return [Hash] where keys are cases and values a `Hash` with `option` String and `callback`

# File lib/eco/cli/config/use_cases.rb, line 65
def active(io:)
  validate_io!(io)
  return @active_cases unless !@active_cases
  @active_cases = @linked_cases.each_with_object({}) do |(option_case, data), active_cases|
    next nil unless SCR.get_arg(option_case)
    if usecase = get_usecase(io: io, data: data)
      index = SCR.get_arg_index(option_case)
      active_cases[usecase] = ActiveCase.new(index, option_case, data.callback)
    end
  end.sort_by {|c, d| d.index}.to_h
end
add(option_case, type, desc = nil, case_name: nil) click to toggle source

Integrates a usecase to the command line. @param option_case [String] the command line option to invoke the usecase. @param type [Symbol] the type of usecase. @param desc [String] description of the case. @param case_name [String, nil] the name of the usecase as defined.

# File lib/eco/cli/config/use_cases.rb, line 50
def add(option_case, type, desc = nil, case_name: nil)
  Eco::API::UseCases::UseCase.validate_type(type)
  unless callback = block_given?? Proc.new : nil
    raise "You must specify a valid 'case_name' when no block is provided" unless case_name
    raise "'case_name' expected to be a String. Given: #{case_name.class}" unless case_name.is_a?(String)
  end
  puts "Overriding case config '#{option_case}'" if @linked_cases.key?(option_case)
  @linked_cases[option_case] = CaseConfig.new(self, option_case, type, desc, case_name, callback)
end
help(refine: nil) click to toggle source

@return [String] summary of the use cases.

# File lib/eco/cli/config/use_cases.rb, line 32
def help(refine: nil)
  refinement = refine.is_a?(String)? " (containing: '#{refine}')" : ""
  ["The following are the available use cases#{refinement}:"].yield_self do |lines|
    max_len = keys_max_len(@linked_cases.keys)
    @linked_cases.keys.sort.select do |key|
      !refine.is_a?(String) || key.include?(refine)
    end.each do |option_case|
      lines << help_line(option_case, @linked_cases[option_case].description, max_len)
    end
    lines
  end.join("\n")
end
process(io:) click to toggle source
# File lib/eco/cli/config/use_cases.rb, line 77
def process(io:)
  validate_io!(io)
  processed = false
  active(io: io).each do |usecase, data|
    raise "Something went wrong when scoping active cases" unless data
    processed = true
    io = case_io(io: io, usecase: usecase)
    # some usecases have a callback to collect the parameters
    data.callback&.call(*io.params)
    io = usecase.launch(io: io)
  end
  processed
end

Private Instance Methods

case_io(io:, usecase:) click to toggle source

Gets a `UseCaseIO`

# File lib/eco/cli/config/use_cases.rb, line 94
def case_io(io:, usecase:)
  validate_io!(io)
  case io
  when Eco::API::UseCases::UseCaseIO
    io.chain(usecase: usecase)
  when Eco::API::UseCases::BaseIO
    params = io.params(keyed: true, all: true).merge(usecase: usecase)
    Eco::API::UseCases::UseCaseIO.new(**params)
  end
end
get_usecase(io:, data:) click to toggle source
# File lib/eco/cli/config/use_cases.rb, line 105
def get_usecase(io:, data:)
  usecase    = if case_name = data.casename
    io.session.usecases.case(case_name, type: data.type)
  end
  usecase  ||= if callback  = data.callback
    # identify/retrieve usecase via callback
    params  = io.params(keyed: true).merge(type: data.type)
    io      = io.new(**params, validate: false)
    callback.call(*io.params).tap do |usecase|
      unless usecase.is_a?(Eco::API::UseCases::UseCase)
        msg  = "When adding a usecase, without specifying 'case_name:', "
        msg += "the block that integrates usecase for cli option '#{data.option}'"
        msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
        raise msg
      end
    end
  end
end
validate_io!(io) click to toggle source
# File lib/eco/cli/config/use_cases.rb, line 124
def validate_io!(io)
  unless io && io.is_a?(Eco::API::UseCases::BaseIO)
    raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
  end
end