debian-mirror-gitlab/lib/system_check/base_check.rb

module SystemCheck
  # Base class for Checks. You must inherit from here
  # and implement the methods below when necessary
  class BaseCheck
    include ::SystemCheck::Helpers

    # Define a custom term for when check passed
    #
    # @param [String] term used when check passed (default: 'yes')
    def self.set_check_pass(term)
      @check_pass = term
    end

    # Define a custom term for when check failed
    #
    # @param [String] term used when check failed (default: 'no')
    def self.set_check_fail(term)
      @check_fail = term
    end

    # Define the name of the SystemCheck that will be displayed during execution
    #
    # @param [String] name of the check
    def self.set_name(name)
      @name = name
    end

    # Define the reason why we skipped the SystemCheck
    #
    # This is only used if subclass implements `#skip?`
    #
    # @param [String] reason to be displayed
    def self.set_skip_reason(reason)
      @skip_reason = reason
    end

    # Term to be displayed when check passed
    #
    # @return [String] term when check passed ('yes' if not re-defined in a subclass)
    def self.check_pass
      call_or_return(@check_pass) || 'yes'
    end

    ## Term to be displayed when check failed
    #
    # @return [String] term when check failed ('no' if not re-defined in a subclass)
    def self.check_fail
      call_or_return(@check_fail) || 'no'
    end

    # Name of the SystemCheck defined by the subclass
    #
    # @return [String] the name
    def self.display_name
      call_or_return(@name) || self.name
    end

    # Skip reason defined by the subclass
    #
    # @return [String] the reason
    def self.skip_reason
      call_or_return(@skip_reason) || 'skipped'
    end

    # Does the check support automatically repair routine?
    #
    # @return [Boolean] whether check implemented `#repair!` method or not
    def can_repair?
      self.class.instance_methods(false).include?(:repair!)
    end

    def can_skip?
      self.class.instance_methods(false).include?(:skip?)
    end

    def is_multi_check?
      self.class.instance_methods(false).include?(:multi_check)
    end

    # Execute the check routine
    #
    # This is where you should implement the main logic that will return
    # a boolean at the end
    #
    # You should not print any output to STDOUT here, use the specific methods instead
    #
    # @return [Boolean] whether check passed or failed
    def check?
      raise NotImplementedError
    end

    # Execute a custom check that cover multiple unities
    #
    # When using multi_check you have to provide the output yourself
    def multi_check
      raise NotImplementedError
    end

    # Prints troubleshooting instructions
    #
    # This is where you should print detailed information for any error found during #check?
    #
    # You may use helper methods to help format the output:
    #
    # @see #try_fixing_it
    # @see #fix_and_rerun
    # @see #for_more_infromation
    def show_error
      raise NotImplementedError
    end

    # When implemented by a subclass, will attempt to fix the issue automatically
    def repair!
      raise NotImplementedError
    end

    # When implemented by a subclass, will evaluate whether check should be skipped or not
    #
    # @return [Boolean] whether or not this check should be skipped
    def skip?
      raise NotImplementedError
    end

    def self.call_or_return(input)
      input.respond_to?(:call) ? input.call : input
    end
    private_class_method :call_or_return
  end
end