Although there are many false-positives, it would still be useful to produce warnings that can be picked up by xcode (if run for example as part of build phase). This way it is easier to process warnings.

example:

/*func saveButtonDoen(sender:UIButton)
      {
!=====
}

False positives reported for Cocoa protocols may be explicitly filtered out. Either common used protocols may be collected, or search in SDK may be performed.

Usage looks like customClass="BaseButton".

I am not a ruby guy but can you suggest any changes that could help to remove the non used code automatically when read ?

I have the following code:

    /// When the URLSessionTask is complete the validateCompletion() function will return one of these values
    /// to indicate to APIDispatcher how it should proceed
    enum CompletionValidation {
        case completionValidated    /// Indicates to APIDispatcher that the last response you received is valid, and it should consider this request complete
        case rejectedIsRetriable    /// Indicates to APIDispatcher that your class implements APIRetriableRequestCompatible and the last received response was invalid. APIDispatcher will confirm the re-attempt and cooldown interval using the shouldReattempt function
        case rejectedDontRetry      /// Indicates to APIDispatcher that the last response you received was invalid, it should not attempt a retry and it should stop processing the request
    }

Unused.rb complains that "class implements is unused". This refers to the comment of the rejectedIsRetriable enum in which you can find the word "class". This is obviously not a class definition syntax.

The script is currently very useful since its well maintained, does the job and is extremely simple to integrate.

You could add this to the installation
1- Place the file inside your project folder directory
2- Call it via $SRCROOT/unused.rb xcode

Given that there are a lot of false positives like mentioning the word protocol in a comment or others, it would be nice to have a way like swift-lint to disable specific warnings.

ex unused-disable-this which would disable the warning on the specific line
unused-disable-all which would disable warnings for all the class

What do you think about it ?

Awesome project btw

Great lib! Would suggest to distribute it via Cocoapods. Thanks
@PaulTaykalo

In SwiftUI you'll use files named something like OnboardingView_Previews using the PreviewProvider-protocol to create previews. Unused.rb reports them as unused, which is somewhat correct, but they are used by the developers to see what they're coding.

You can define a function type variable or a lazy stored property and not using it and your script is blind.

Lazy stored properties

Function type variable

I do not think closing an active bug will solve the problem.

Maybe the script can have a mode for scanning a framework VS an app, because for many of the properties and functions of a framework class whose access modifiers are public, the script is reporting false positive since those properties and functions are most likely not referenced inside the framework.

After running the script i saw a "lazy var" not used in a class.

Here's an example of a function which exists as a cocoa-style value observer. It is hooked up, runs at runtime, and the code will not compile without it. Yet, unused.rb says it is unused:

The script detects an unused item when I return the result of a function with a comment at the same line:

Here an example:

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    return getCell() // Bla bla bla
}

Hi,

As you can see drawNothing function is used in draw function but it appears as unused.

Thanks.

e.g:
class A {
func method1() {
}
}

class B {
func method1() {
}
}

expect that print all of two methods but not

In order to not run script every time there is a setting. More info: realm/SwiftLint#4015

Hi Paul, I'd like feedback on the following change as well as permissions to PR if possible.

Currently in Master

non_private_items, private_items = file_items.partition {  |f|
    !f.modifiers.include?("private") 
        && !f.modifiers.include?("fileprivate") 
}

Proposed Change

private_items, non_private_items = file_items.partition { |f|
    (
        f.modifiers.include?("private")
            && !f.modifiers.include?("(set)")
    ) || (
            f.modifiers.include?("fileprivate")
    )
}

Basically I want to make sure to only count private items if they don't contain (set).