class Licensed::Commands::Command

Attributes

config[R]
options[R]
reporter[R]

Public Class Methods

new(config:) click to toggle source
# File lib/licensed/commands/command.rb, line 9
def initialize(config:)
  @config = config
end

Public Instance Methods

create_reporter(options) click to toggle source

Creates a reporter to use during a command run

options - The options the command was run with

Returns the reporter to use during the command run

# File lib/licensed/commands/command.rb, line 34
def create_reporter(options)
  return options[:reporter] if options[:reporter].is_a?(Licensed::Reporters::Reporter)

  if options[:reporter].is_a?(String)
    klass = "#{options[:reporter].capitalize}Reporter"
    return Licensed::Reporters.const_get(klass).new if Licensed::Reporters.const_defined?(klass)
  end

  default_reporter(options)
end
default_reporter(options) click to toggle source

Returns the default reporter to use during the command run

options - The options the command was run with

Raises an error

# File lib/licensed/commands/command.rb, line 50
def default_reporter(options)
  raise "`default_reporter` must be implemented by commands"
end
run(**options) click to toggle source

Run the command

options - Options to run the command with

Returns whether the command was a success

# File lib/licensed/commands/command.rb, line 18
def run(**options)
  @options = options
  @reporter = create_reporter(options)

  command_report = Licensed::Report.new(name: nil, target: self)
  run_command(command_report)
ensure
  @options = nil
  @reporter = nil
end

Protected Instance Methods

evaluate_dependency(app, source, dependency, report) click to toggle source

Evaluate a dependency for the command. Must be implemented by a command implementation.

app - The application configuration for the dependency source - The dependency source enumerator for the dependency dependency - An application dependency report - A report hash for the command to provide extra data for the report output.

Returns whether the command succeeded for the dependency

# File lib/licensed/commands/command.rb, line 196
def evaluate_dependency(app, source, dependency, report)
  raise "`evaluate_dependency` must be implemented by a command"
end
run_app(app, report) { |result| ... } click to toggle source

Run the command for all enabled sources for an application configuration, recording results in a report.

app - An application configuration report - A report object for this application

Returns whether the command succeeded for the application.

# File lib/licensed/commands/command.rb, line 86
def run_app(app, report)
  reporter.begin_report_app(app, report)

  # ensure the app source path exists before evaluation
  if !Dir.exist?(app.source_path)
    report.errors << "No such directory #{app.source_path}"
    return false
  end

  Dir.chdir app.source_path do
    sources = app.sources.select(&:enabled?)
                         .sort_by { |source| source.class.type }
    results = sources.map do |source|
      source_report = Licensed::Report.new(name: [report.name, source.class.type].join("."), target: source)
      report.reports << source_report
      run_source(app, source, source_report)
    end

    result = results.all?

    result = yield(result) if block_given?

    result
  end
rescue Licensed::Shell::Error => err
  report.errors << err.message
  false
ensure
  reporter.end_report_app(app, report)
end
run_command(report) { |result| ... } click to toggle source

Run the command for all application configurations

report - A Licensed::Report object for this command

Returns whether the command succeeded

# File lib/licensed/commands/command.rb, line 61
def run_command(report)
  reporter.begin_report_command(self, report)
  apps = config.apps.sort_by { |app| app["name"] }
  results = apps.map do |app|
    app_report = Licensed::Report.new(name: app["name"], target: app)
    report.reports << app_report
    run_app(app, app_report)
  end

  result = results.all?

  result = yield(result) if block_given?

  result
ensure
  reporter.end_report_command(self, report)
end
run_dependency(app, source, dependency, report) { |result| ... } click to toggle source

Run the command for a dependency, evaluating the dependency and recording results in a report. Dependencies that were found with errors are not evaluated and add any errors to the dependency report.

app - The application configuration for the dependency source - The dependency source enumerator for the dependency dependency - An application dependency report - A report object for this dependency

Returns whether the command succeeded for the dependency

# File lib/licensed/commands/command.rb, line 168
def run_dependency(app, source, dependency, report)
  reporter.begin_report_dependency(dependency, report)

  if dependency.errors?
    report.errors.concat(dependency.errors)
    return false
  end

  result = evaluate_dependency(app, source, dependency, report)

  result = yield(result) if block_given?

  result
rescue Licensed::DependencyRecord::Error, Licensed::Shell::Error => err
  report.errors << err.message
  false
ensure
  reporter.end_report_dependency(dependency, report)
end
run_source(app, source, report) { |result| ... } click to toggle source

Run the command for all enumerated dependencies found in a dependency source, recording results in a report.

app - The application configuration for the source source - A dependency source enumerator report - A report object for this source

Returns whether the command succeeded, failed, or was skipped for the dependency source enumerator

# File lib/licensed/commands/command.rb, line 125
def run_source(app, source, report)
  reporter.begin_report_source(source, report)

  if !sources_overrides.empty? && !sources_overrides.include?(source.class.type)
    report.warnings << "skipped source"

    # return a symbol to speficy the source was skipped.
    # This is truthy and will result in the source being considered successful
    return :skipped
  end

  dependencies = source.dependencies.sort_by { |dependency| dependency.name }
  results = dependencies.map do |dependency|
    dependency_report = Licensed::Report.new(name: [report.name, dependency.name].join("."), target: dependency)
    report.reports << dependency_report
    run_dependency(app, source, dependency, dependency_report)
  end

  result = results.all?

  result = yield(result) if block_given?

  result
rescue Licensed::Shell::Error => err
  report.errors << err.message
  false
rescue Licensed::Sources::Source::Error => err
  report.errors << err.message
  false
ensure
  reporter.end_report_source(source, report)
end
sources_overrides() click to toggle source
# File lib/licensed/commands/command.rb, line 200
def sources_overrides
  @sources_overrides = Array(options[:sources])
end