CocoaPods/CocoaPods

View on GitHub

Showing 310 of 310 total issues

Method add_child_vertex_to_graph has 5 arguments (exceeds 4 allowed). Consider refactoring.
Open

        def self.add_child_vertex_to_graph(dependency_string, parents, dependency_graph, pods_to_unlock, added_dependency_strings)
Severity: Minor
Found in lib/cocoapods/installer/analyzer/locking_dependency_analyzer.rb - About 35 mins to fix

    Method add_app_host_main_file has 5 arguments (exceeds 4 allowed). Consider refactoring.
    Open

          def self.add_app_host_main_file(project, target, platform, group, name = 'App')
    Severity: Minor
    Found in lib/cocoapods/generator/app_target_helper.rb - About 35 mins to fix

      Method add_app_target has 5 arguments (exceeds 4 allowed). Consider refactoring.
      Open

            def self.add_app_target(project, platform_name, deployment_target, name = 'App', product_basename = nil)
      Severity: Minor
      Found in lib/cocoapods/generator/app_target_helper.rb - About 35 mins to fix

        Method create_generator has 5 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def create_generator(pod_targets_to_generate, aggregate_targets_to_generate, build_configurations, project_object_version, generate_multiple_pod_projects = false)
        Severity: Minor
        Found in lib/cocoapods/installer.rb - About 35 mins to fix

          Method initialize has 5 arguments (exceeds 4 allowed). Consider refactoring.
          Open

                  def initialize(pod_targets_to_generate, aggregate_targets_to_generate, cache_key_by_target_label,
                                 build_configurations, project_object_version)
          Severity: Minor
          Found in lib/cocoapods/installer/project_cache/project_cache_analysis_result.rb - About 35 mins to fix

            Method wire_target_dependencies has 5 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                    def wire_target_dependencies(pod_target, native_target, project, pod_target_installation_results, metadata_cache)

              Method wire_app_native_targets has 5 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                      def wire_app_native_targets(pod_target, installation_result, pod_target_installation_results, project, metadata_cache)

                Method wire_test_native_targets has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                        def wire_test_native_targets(pod_target, installation_result, pod_target_installation_results, project, metadata_cache)

                  Method initialize has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                          def initialize(cache_key_by_target_label = {}, build_configurations = nil, project_object_version = nil, podfile_plugins = {}, installation_options = {})
                  Severity: Minor
                  Found in lib/cocoapods/installer/project_cache/project_installation_cache.rb - About 35 mins to fix

                    Method initialize has 5 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                          def initialize(podfile, sandbox, installation_root, targets, targets_to_integrate, use_input_output_paths: true)
                    Severity: Minor
                    Found in lib/cocoapods/installer/user_project_integrator.rb - About 35 mins to fix

                      Method initialize has 5 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                          def initialize(sandbox, build_type, user_build_configurations, archs, platform)
                      Severity: Minor
                      Found in lib/cocoapods/target.rb - About 35 mins to fix

                        Method create_info_plist_file has 5 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                                  def create_info_plist_file(path, native_target, version, platform, bundle_package_type = :fmwk, additional_entries: {})
                        Severity: Minor
                        Found in lib/cocoapods/installer/xcode/pods_project_generator/target_installer.rb - About 35 mins to fix

                          Method create_prefix_header has 5 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                                    def create_prefix_header(path, file_accessors, platform, native_target, project_directory)

                            Method path has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                  def path(pathname)
                                    if pathname
                                      from_path = config.podfile_path.dirname if config.podfile_path
                                      from_path ||= Pathname.pwd
                                      path = begin
                            Severity: Minor
                            Found in lib/cocoapods/user_interface.rb - About 35 mins 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

                            Method resolve has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def resolve
                                  dependencies = @podfile_dependency_cache.target_definition_list.flat_map do |target|
                                    @podfile_dependency_cache.target_definition_dependencies(target).each do |dep|
                                      next unless target.platform
                                      @platforms_by_dependency[dep].push(target.platform)
                            Severity: Minor
                            Found in lib/cocoapods/resolver.rb - About 35 mins 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

                            Method _validate_module_map has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def _validate_module_map
                                  if spec.module_map
                                    unless file_accessor.module_map.exist?
                                      error('module_map', 'Unable to find the specified module map file.')
                                    end
                            Severity: Minor
                            Found in lib/cocoapods/validator.rb - About 35 mins 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

                            Method translate_output_to_linter_messages has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def translate_output_to_linter_messages(parsed_output)
                                  parsed_output.each do |message|
                                    # Checking the error for `InputFile` is to work around an Xcode
                                    # issue where linting would fail even though `xcodebuild` actually
                                    # succeeds. Xcode.app also doesn't fail when this issue occurs, so
                            Severity: Minor
                            Found in lib/cocoapods/validator.rb - About 35 mins 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

                            Method analyze has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                  def analyze(allow_fetches = true)
                                    return @result if @result
                                    validate_podfile!
                                    validate_lockfile_version!
                                    if installation_options.integrate_targets?
                            Severity: Minor
                            Found in lib/cocoapods/installer/analyzer.rb - About 35 mins 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

                            Method create_or_update_user_script_phases has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                      def create_or_update_user_script_phases(script_phases, native_target)
                                        script_phase_names = script_phases.map { |k| k[:name] }
                                        # Delete script phases no longer present in the target.
                                        native_target_script_phases = native_target.shell_script_build_phases.select do |bp|
                                          !bp.name.nil? && bp.name.start_with?(USER_BUILD_PHASE_PREFIX)
                            Severity: Minor
                            Found in lib/cocoapods/installer/user_project_integrator/target_integrator.rb - About 35 mins 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

                            Method podspec_files has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                            Open

                                    def podspec_files
                                      if @podspec
                                        path = Pathname(@podspec)
                                        raise Informative, "Couldn't find #{@podspec}" unless path.exist?
                                        [path]
                            Severity: Minor
                            Found in lib/cocoapods/command/repo/push.rb - About 35 mins 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

                            Severity
                            Category
                            Status
                            Source
                            Language