When I try to run some taylor commands it crashes.

For example at the commands taylor -rc ExcessiveMethodLength=20 or taylor following error appears:

fatal error: Loading sourcekitd.framework/Versions/A/sourcekitd failed: file /Users/aculeva/Developer/SourceKitten/Source/SourceKittenFramework/library_wrapper.swift, line 59

Commands like taylor -v work, though.

I use version 0.1.3 and installed it with the .pkg file. Over Homebrew there were also some weird issues.

Handle the case when Taylor is invoked with invalid arguments:
* Remove force try inside `processArguments()` that was leading to
imminent crash and unclear error message.
* If an invalid parameter has been sent print error message and
prompt the user to play Pacman.

This PR enables code coverage status to be displayed for Taylor.I do not own Taylor so I have enabled code coverage for my fork of taylor (see the little Codecov button): https://github.com/thebugcode/Taylor

This PR enables code coverage to be sent to codecov.io

I have taken care of the setup details according to this guide https://github.com/codecov/example-swift/ so you only need to go to https://codecov.io/# and enable yopeso/Taylor. You can also give it PR access by clicking on the project, then settings, to get messages like the one below from coveralls (especially useful when PR's decrease the code coverage).

The alternative to codecov.io is coveralls.io. Integration of coveralls is not as easy (http://list.her.sh/ios-test-coverage-with-coveralls/) but you can switch back and forth between the two. For example here is a PR where someone switched from coveralls to codecov: https://github.com/splinesoft/SSDataSources/commit/9ef0465ca82086ea3ca1245cc60749dabfa86f08

• Fix getting stuck when sending multiple requests to sourcekitd simultaneously from different threads.
• Fix SIGABRT in SourceKitten when getting substructure.

Changes: * Create a tree of all available components, then filter the ones actually needed. * Refactor ExtendedComponent complex areas. * appendComponents() and divideByLines() now append to a mutable array which leads to performance increase.

This was made by running swiftlint autocorrect with 'trailing_whitespace' rule ignored. A couple of manual changes had to be made after that (especially for 'if else' statements) .

SourceKitten changes:

• Remove SwiftXPC framework dependency.
• Make all XPCRepresentables be expressed through SourceKitRepresentable.
• Add its own Structure.init(file: File) method.

Sourcekit changes:

• Closure parameters are inside closure substructure and not at the same level.
• Implicit closure parameters are not recognized at all.

General:

• Update ExcludeFileReader to Xcode 7.3.
• Remove SwiftXPC dependency.

Code:

• Remove all XPCRepresentables.
• Add temporary Array component recognition which is the only way to distinguish between simple expression calls and frequently used HOFs.

Tests:

• Update Tokenizer tests to latest 'sourcekit' changes.
• Update Integration Tests messages to the ones actually reported.
• Build Quick and Nimble with Xcode 7.3.

Hi, I just installed Taylor via brew.

When I try running it I get:

Illegal instruction: 4

In both Xcode and terminal.

I tried to download and run the release version, but it just crashes. Any idea of what could it be?

I'm running on a MacBook Pro with macOS HighSierra 10.13.3 With CLI Version: 9.2.0.0.1.1510905681

This option will be used to deactivate symlinks creation when make install is called from Homebrew formula. Executing ln -s in Homebrew formula breaks the sandbox.

Fixed the bug when closure parameters were recognized by sourcekit as simple ones and were processed by scissors as function parameters, thus leading to tooManyArguments Violation trigger. Added typeName field to ExtendedComponent, processParameters(_:) method and tests.

• Remove parameters that are inside the function body and are seen as function parameters. These include closure parameters that are reported as standalone by sourcekit.

Signing.swift:95 Method 'httpBody(parameters:encoding:)' has 4 parameters. The allowed number of parameters is 3

open static func httpBody(for parameters: [String: String], encoding: String.Encoding = .utf8) -> Data? {
    let combine: (String, String) -> String = { key, value in
        return rfc3986encode(key) + "=" + rfc3986encode(value)
    }

    return parameters.map(combine).joined(separator: "&").data(using: encoding)
}

If I have a method like:

func init
{
  let something = 1
  let another = somethingElse(start: 0,
                                end: 1)
  let anArray = [
    "1",
    "2",
    "3"
  ]
  
  if something == 1
  {
    dosomething()
  }
}

What should be the length for this function? 5 or 14?

My code style is that the { and } are on a line by itself for all keywords that require it, so this is causing false positives in my code. Functions that are really under 20 lines are being flagged due to brace being on a line by itself and some function calls that have their arguments stacked (as in the above).

Also when an array literal is defined, see above, all of the lines are counted as part of the function. While the lines are part of the function, they are not individual lines. The declaration of an array is a single line that is split into multiple lines.

Note: I would love to help out with this project. How can I help?

I know that rules can be disabled via configuration, but I would like to disable warnings for single methods only - is this possible?

I.e. the cyclomatic complexity-warning is annoying when a method only contains a switch-statement, therefore I would like to disable it for that method. Can this be achieved somehow?

The developer can easily write forEach or map instead of for-in statements to get rid of warnings and code smells. Taylor should be able to handle these cases appropriately.