Class: Eco::CLI::Config::UseCases

Inherits:
Object
  • Object
show all
Defined in:
lib/eco/cli/config/use_cases.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(core_config:) ⇒ UseCases

Returns a new instance of UseCases.



8
9
10
11
 
# File 'lib/eco/cli/config/use_cases.rb', line 8

def initialize(core_config:)
  @core_config  = core_config
  @linked_opt_cases = {}
end

Instance Attribute Details

#core_config ⇒ Object (readonly)

Returns the value of attribute core_config.



6
7
8
 
# File 'lib/eco/cli/config/use_cases.rb', line 6

def core_config
  @core_config
end

Instance Method Details

#active(io:) ⇒ Hash

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

Parameters:

Returns:

  • (Hash) —

    where keys are cases and values a Hash with option String and callback



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/eco/cli/config/use_cases.rb', line 37

def active(io:)
  return @active_cases unless !@active_cases
  @active_cases = {}.tap do |opt_cases|
    @linked_opt_cases.each do |option_case, types|
      types.each do |type, data|
        if SCR.get_arg(option_case)
          usecase = nil
          if case_name = data[:casename]
            usecase = io.session.usecases.case(case_name, type: type)
          end

          if callback = data[:callback]
            unless usecase
              # identify usecase

              params = io.params(keyed: true).merge(type: type)
              io     = io.new(**params, validate: false)

              usecase = callback.call(*io.params)
              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 '#{option_case}'"
                msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
                raise msg
              end
            end
          end

          if usecase
            opt_cases[usecase] = {
                option:   option_case,
                callback: data[:callback]
            }
          end

        end
      end
    end

  end
end

#add(option_case, type, case_name: nil) ⇒ Object

Integrates a usecase to the command line

Parameters:

  • option_case (String) —

    the command line option to invoke the usecase

  • type (Symbol) —

    the type of usecase

  • case_name (String, nil) (defaults to: nil) —

    the name of the usecase as defined



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/eco/cli/config/use_cases.rb', line 17

def add(option_case, type, 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

  @linked_opt_cases[option_case] = {
    type => {
      casename: case_name,
      callback: callback
    }
  }

  self
end

#process(io:) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/eco/cli/config/use_cases.rb', line 78

def process(io:)
  unless io && io.is_a?(Eco::API::UseCases::BaseIO)
    raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
  end

  processed = false
  active(io: io).each do |usecase, data|
    raise "Something went wrong when scoping active cases" unless data

    processed = true

    params = io.params(keyed: true).merge(type: usecase.type)
    io     = io.new(**params)

    if callback = data[:callback]
      callback.call(*io.params)
    end

    usecase.launch(io: io)
  end
  processed
end