Sign upLogin

Kinvey/swift-sdk

View on GitHub
Star

Showing 2,011 of 2,013 total issues

File User.swift has 1568 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import Foundation
import PromiseKit

#if os(iOS) || os(OSX)
    import SafariServices
Severity: Major
Found in Kinvey/Kinvey/User.swift - About 4 days to fix

    File FileStore.swift has 1185 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    import Foundation
import PromiseKit

#if os(macOS)
    import AppKit
    Severity: Major
    Found in Kinvey/Kinvey/FileStore.swift - About 3 days to fix

      File DataStore.swift has 1174 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

      import Foundation
import PromiseKit

/// Class to interact with a specific collection in the backend.
open class DataStore<T: Persistable> where T: NSObject {
      Severity: Major
      Found in Kinvey/Kinvey/DataStore.swift - About 3 days to fix

        Function execute has a Cognitive Complexity of 147 (exceeds 5 allowed). Consider refactoring.
        Open

            func execute(completionHandler: CompletionHandler?) -> AnyRequest<ResultType> {
        var count = UInt(0)
        var errors: [Swift.Error] = []
        
        let collectionName = try! T.collectionName()
        Severity: Minor
        Found in Kinvey/Kinvey/PushOperation.swift - About 2 days to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        File Query.swift has 948 lines of code (exceeds 250 allowed). Consider refactoring.
        Open

        import Foundation
#if !os(watchOS)
    import MapKit
#endif
        Severity: Major
        Found in Kinvey/Kinvey/Query.swift - About 2 days to fix

          File HttpRequestFactory.swift has 854 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          import Foundation

struct HttpRequestFactory: RequestFactory {
    
    let client: Client
          Severity: Major
          Found in Kinvey/Kinvey/HttpRequestFactory.swift - About 2 days to fix

            Similar blocks of code found in 4 locations. Consider refactoring.
            Open

                @discardableResult
    open func group<Avg: AddableType>(
        keys: [String],
        avg: String,
        avgType: Avg.Type? = nil,
            Severity: Major
            Found in Kinvey/Kinvey/DataStore.swift and 3 other locations - About 1 day to fix
            Kinvey/Kinvey/DataStore.swift on lines 414..480
            Kinvey/Kinvey/DataStore.swift on lines 550..616
            Kinvey/Kinvey/DataStore.swift on lines 618..684

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 683.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 4 locations. Consider refactoring.
            Open

                @discardableResult
    open func group<Sum: AddableType>(
        keys: [String],
        sum: String,
        sumType: Sum.Type? = nil,
            Severity: Major
            Found in Kinvey/Kinvey/DataStore.swift and 3 other locations - About 1 day to fix
            Kinvey/Kinvey/DataStore.swift on lines 482..548
            Kinvey/Kinvey/DataStore.swift on lines 550..616
            Kinvey/Kinvey/DataStore.swift on lines 618..684

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 683.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 4 locations. Consider refactoring.
            Open

                @discardableResult
    open func group<Min: MinMaxType>(
        keys: [String],
        min: String,
        minType: Min.Type? = nil,
            Severity: Major
            Found in Kinvey/Kinvey/DataStore.swift and 3 other locations - About 1 day to fix
            Kinvey/Kinvey/DataStore.swift on lines 414..480
            Kinvey/Kinvey/DataStore.swift on lines 482..548
            Kinvey/Kinvey/DataStore.swift on lines 618..684

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 683.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Similar blocks of code found in 4 locations. Consider refactoring.
            Open

                @discardableResult
    open func group<Max: MinMaxType>(
        keys: [String],
        max: String,
        maxType: Max.Type? = nil,
            Severity: Major
            Found in Kinvey/Kinvey/DataStore.swift and 3 other locations - About 1 day to fix
            Kinvey/Kinvey/DataStore.swift on lines 414..480
            Kinvey/Kinvey/DataStore.swift on lines 482..548
            Kinvey/Kinvey/DataStore.swift on lines 550..616

            Duplicated Code

            Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

            Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

            When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

            Tuning

            This issue has a mass of 683.

            We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

            The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

            If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

            See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

            Refactorings

            Further Reading

            Function presentMICViewController has a Cognitive Complexity of 57 (exceeds 5 allowed). Consider refactoring.
            Open

                open class func presentMICViewController<U: User>(
        redirectURI: URL,
        micUserInterface: MICUserInterface = MICUserInterface.default,
        currentViewController: UIViewController? = nil,
        options: Options? = nil,
            Severity: Minor
            Found in Kinvey/Kinvey/User.swift - About 1 day to fix

            Cognitive Complexity

            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

            A method's cognitive complexity is based on a few simple rules:

            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
            • Code is considered more complex for each "break in the linear flow of the code"
            • Code is considered more complex when "flow breaking structures are nested"

            Further reading

            File MIC.swift has 528 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            import Foundation
import PromiseKit

class URLSessionDelegateAdapter : NSObject, URLSessionTaskDelegate {
            Severity: Major
            Found in Kinvey/Kinvey/MIC.swift - About 1 day to fix

              Function createBucket has a Cognitive Complexity of 52 (exceeds 5 allowed). Consider refactoring.
              Open

                  fileprivate func createBucket<ResultType>(
        _ file: FileType,
        fromSource source: InputSource,
        options: Options?,
        requests: MultiRequest<ResultType>
              Severity: Minor
              Found in Kinvey/Kinvey/FileStore.swift - About 1 day to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              File HttpRequest.swift has 496 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              import Foundation

#if os(iOS) || os(tvOS)
    import UIKit
#elseif os(watchOS)
              Severity: Minor
              Found in Kinvey/Kinvey/HttpRequest.swift - About 7 hrs to fix

                User has 48 methods (exceeds 20 allowed). Consider refactoring.
                Open

                open class User: NSObject, Credential {
    
    /// Username Key.
    @available(*, deprecated, message: "Deprecated in version 3.17.0. Please use User.CodingKeys.username instead")
    public static let PersistableUsernameKey = "username"
                Severity: Minor
                Found in Kinvey/Kinvey/User.swift - About 6 hrs to fix

                  Function translate has a Cognitive Complexity of 43 (exceeds 5 allowed). Consider refactoring.
                  Open

                      internal func translate(expression: NSExpression, otherSideExpression: NSExpression) -> NSExpression {
        switch expression.expressionType {
        case .keyPath:
            var keyPath = expression.keyPath
            var type: AnyClass? = self.persistableType as? AnyClass
                  Severity: Minor
                  Found in Kinvey/Kinvey/Query.swift - About 6 hrs to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  DataStore has 44 methods (exceeds 20 allowed). Consider refactoring.
                  Open

                  open class DataStore<T: Persistable> where T: NSObject {
    
    @available(*, deprecated, message: "Deprecated in version 3.17.0. Please use Result<AnyRandomAccessCollection<T>, Swift.Error> instead")
    public typealias ArrayCompletionHandler = ([T]?, Swift.Error?) -> Void
                  Severity: Minor
                  Found in Kinvey/Kinvey/DataStore.swift - About 6 hrs to fix

                    FileStore has 44 methods (exceeds 20 allowed). Consider refactoring.
                    Open

                    open class FileStore<FileType: File> {
    
    @available(*, deprecated, message: "Deprecated in version 3.17.0. Please use Result<FileType, Swift.Error> instead")
    public typealias FileCompletionHandler = (FileType?, Swift.Error?) -> Void
                    Severity: Minor
                    Found in Kinvey/Kinvey/FileStore.swift - About 6 hrs to fix

                      Function execute has 146 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          func execute(completionHandler: CompletionHandler?) -> AnyRequest<ResultType> {
        var count = UInt(0)
        var errors: [Swift.Error] = []
        
        let collectionName = try! T.collectionName()
                      Severity: Major
                      Found in Kinvey/Kinvey/PushOperation.swift - About 5 hrs to fix

                        File FindOperation.swift has 403 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

                        import Foundation
import PromiseKit

private let MaxIdsPerQuery = 200
private let MaxSizePerResultSet = 10_000
                        Severity: Minor
                        Found in Kinvey/Kinvey/FindOperation.swift - About 5 hrs to fix
                          Severity
                          Category
                          Status
                          Source
                          Language