dependabot-nuget 0.288.0 → 0.289.0

data/lib/dependabot/nuget/file_fetcher.rb

@@ -1,9 +1,10 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "dependabot/file_fetchers"
 require "dependabot/file_fetchers/base"
-require "dependabot/nuget/cache_manager"
+require "dependabot/nuget/native_discovery/native_discovery_json_reader"
+require "dependabot/nuget/native_helpers"
 require "set"
 require "sorbet-runtime"
 
@@ -13,410 +14,28 @@ module Dependabot
       extend T::Sig
       extend T::Helpers
 
-      require_relative "file_fetcher/import_paths_finder"
-      require_relative "file_fetcher/sln_project_paths_finder"
-
-      BUILD_FILE_NAMES = /^Directory\.Build\.(props|targets)$/i # Directory.Build.props, Directory.Build.targets
-
       sig { override.params(filenames: T::Array[String]).returns(T::Boolean) }
       def self.required_files_in?(filenames)
-        return true if filenames.any? { |f| f.match?(/^packages\.config$/i) }
-        return true if filenames.any? { |f| f.end_with?(".sln") }
-        return true if filenames.any? { |f| f.match?("^src$") }
-        return true if filenames.any? { |f| f.end_with?(".proj") }
-
         filenames.any? { |name| name.match?(/\.(cs|vb|fs)proj$/) }
       end
 
       sig { override.returns(String) }
       def self.required_files_message
-        "Repo must contain a .proj file, .(cs|vb|fs)proj file, or a packages.config."
-      end
-
-      sig do
-        override
-          .params(
-            source: Dependabot::Source,
-            credentials: T::Array[Credential],
-            repo_contents_path: T.nilable(String),
-            options: T::Hash[String, String]
-          ).void
-      end
-      def initialize(source:, credentials:, repo_contents_path: nil, options: {})
-        super
-
-        @sln_files = T.let(nil, T.nilable(T::Array[Dependabot::DependencyFile]))
-        @sln_project_files = T.let(nil, T.nilable(T::Array[Dependabot::DependencyFile]))
-        @project_files = T.let([], T::Array[Dependabot::DependencyFile])
-        @fetched_files = T.let({}, T::Hash[String, T::Array[Dependabot::DependencyFile]])
-        @nuget_config_files = T.let(nil, T.nilable(T::Array[Dependabot::DependencyFile]))
-        @packages_config_files = T.let(nil, T.nilable(T::Array[Dependabot::DependencyFile]))
-        @assembly_binding_redirect_config_files = T.let(nil, T.nilable(T::Array[Dependabot::DependencyFile]))
-        @packages_lock_files = T.let(nil, T.nilable(T::Array[Dependabot::DependencyFile]))
+        "Repo must contain .(cs|vb|fs)proj file."
       end
 
       sig { override.returns(T::Array[DependencyFile]) }
       def fetch_files
-        fetched_files = [
-          *project_files,
-          *directory_build_files,
-          *imported_property_files,
-          *packages_config_files,
-          *assembly_binding_redirect_config_files,
-          *nuget_config_files,
-          *packages_lock_files,
-          global_json,
-          dotnet_tools_json,
-          packages_props
-        ].compact
-
-        # dedup files based on their absolute path
-        fetched_files = fetched_files.uniq do |fetched_file|
-          Pathname.new(fetched_file.directory).join(fetched_file.name).cleanpath.to_path
-        end
-
-        if project_files.none? && packages_config_files.none?
-          raise T.must(@missing_sln_project_file_errors.first) if @missing_sln_project_file_errors&.any?
-
-          raise_dependency_file_not_found
-        end
-
-        fetched_files
-      end
-
-      private
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def project_files
-        return @project_files if @project_files.any?
-
-        @project_files =
-          begin
-            project_files = []
-            project_files += csproj_file
-            project_files += vbproj_file
-            project_files += fsproj_file
-            project_files += sln_project_files
-            project_files += proj_files
-            project_files += project_files.filter_map do |f|
-              named_file_up_tree_from_project_file(f, "Directory.Packages.props")
-            end
-            project_files
-          end
-      rescue Octokit::NotFound, Gitlab::Error::NotFound
-        raise_dependency_file_not_found
-      end
-
-      sig { returns(T.noreturn) }
-      def raise_dependency_file_not_found
-        raise(
-          Dependabot::DependencyFileNotFound.new(
-            File.join(directory, "*.(sln|csproj|vbproj|fsproj|proj)"),
-            "Unable to find `*.sln`, `*.(cs|vb|fs)proj`, or `*.proj` in directory `#{directory}`"
-          )
+        discovery_json_reader = NativeDiscoveryJsonReader.run_discovery_in_directory(
+          repo_contents_path: T.must(repo_contents_path),
+          directory: directory,
+          credentials: credentials
         )
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def packages_config_files
-        return @packages_config_files if @packages_config_files
-
-        imported_project_files = imported_property_files.filter { |f| f.name.match?(/\.(cs|vb|fs)proj$/) }
-
-        @packages_config_files = [*project_files, *imported_project_files].filter_map do |f|
-          named_file_next_to_project_file(f, "packages.config")
-        end
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def assembly_binding_redirect_config_files
-        return @assembly_binding_redirect_config_files if @assembly_binding_redirect_config_files
-
-        candidate_paths =
-          [*project_files.map { |f| File.dirname(f.name) }, "."].uniq
-
-        # Assembly binding redirects can appear in any app/web.config file for a .NET Framework project
-        # https://learn.microsoft.com/en-us/dotnet/framework/configure-apps/redirect-assembly-versions#specify-assembly-binding-in-configuration-files
-        @assembly_binding_redirect_config_files =
-          candidate_paths.filter_map do |dir|
-            file = repo_contents(dir: dir)
-                   .find { |f| f.name.match?(/^(app|web)\.config$/i) }
-            fetch_file_from_host(File.join(dir, file.name)) if file
-          end
-      end
-
-      # rubocop:disable Metrics/PerceivedComplexity
-      sig { returns(T.nilable(T::Array[T.untyped])) }
-      def sln_file_names
-        sln_files = repo_contents.select { |f| f.name.end_with?(".sln") }
-        src_dir = repo_contents.any? { |f| f.name == "src" && f.type == "dir" }
-
-        # If there are no sln files but there is a src directory, check that dir
-        if sln_files.none? && src_dir
-          sln_files = repo_contents(dir: "src")
-                      .select { |f| f.name.end_with?(".sln") }.map(&:dup)
-                      .map { |file| file.tap { |f| f.name = "src/" + f.name } }
-        end
-
-        # Return `nil` if no sln files were found
-        return if sln_files.none?
-
-        sln_files.map(&:name)
-      end
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def directory_build_files
-        @directory_build_files ||= T.let(fetch_directory_build_files, T.nilable(T::Array[Dependabot::DependencyFile]))
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def fetch_directory_build_files
-        attempted_dirs = T.let([], T::Array[Pathname])
-        directory_build_files = T.let([], T::Array[Dependabot::DependencyFile])
-        directory_path = Pathname.new(directory)
-
-        # find all build files (Directory.Build.props/.targets) relative to the given project file
-        project_files.map { |f| Pathname.new(f.directory).join(f.name).dirname }.uniq.each do |dir|
-          # Simulate MSBuild walking up the directory structure looking for a file
-          dir.descend.each do |possible_dir|
-            break if attempted_dirs.include?(possible_dir)
-
-            attempted_dirs << possible_dir
-            relative_possible_dir = Pathname.new(possible_dir).relative_path_from(directory_path).to_s
-            build_files = repo_contents(dir: relative_possible_dir).select { |f| f.name.match?(BUILD_FILE_NAMES) }
-            directory_build_files += build_files.map do |file|
-              possible_file = File.join(relative_possible_dir, file.name).delete_prefix("/")
-              fetch_file_from_host(possible_file)
-            end
-          end
-        end
-
-        directory_build_files
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def sln_project_files
-        return [] unless sln_files
-
-        @sln_project_files ||=
-          begin
-            paths = T.must(sln_files).flat_map do |sln_file|
-              SlnProjectPathsFinder
-                .new(sln_file: sln_file)
-                .project_paths
-            end
-
-            paths.filter_map do |path|
-              fetch_file_from_host(path)
-            rescue Dependabot::DependencyFileNotFound => e
-              @missing_sln_project_file_errors ||= T.let([], T.nilable(T::Array[Dependabot::DependencyFileNotFound]))
-              @missing_sln_project_file_errors << e
-              # Don't worry about missing files too much for now (at least
-              # until we start resolving properties)
-              nil
-            end
-          end
-      end
-
-      sig { returns(T.nilable(T::Array[Dependabot::DependencyFile])) }
-      def sln_files
-        return unless sln_file_names
-
-        @sln_files ||=
-          sln_file_names
-          &.map { |sln_file_name| fetch_file_from_host(sln_file_name) }
-          &.select { |file| file.content&.valid_encoding? }
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def csproj_file
-        @csproj_file ||= T.let(find_and_fetch_with_suffix(".csproj"), T.nilable(T::Array[Dependabot::DependencyFile]))
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def vbproj_file
-        @vbproj_file ||= T.let(find_and_fetch_with_suffix(".vbproj"), T.nilable(T::Array[Dependabot::DependencyFile]))
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def fsproj_file
-        @fsproj_file ||= T.let(find_and_fetch_with_suffix(".fsproj"), T.nilable(T::Array[Dependabot::DependencyFile]))
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def proj_files
-        @proj_files ||= T.let(find_and_fetch_with_suffix(".proj"), T.nilable(T::Array[Dependabot::DependencyFile]))
-      end
-
-      sig { params(suffix: String).returns(T::Array[Dependabot::DependencyFile]) }
-      def find_and_fetch_with_suffix(suffix)
-        repo_contents.select { |f| f.name.end_with?(suffix) }.map { |f| fetch_file_from_host(f.name) }
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def nuget_config_files
-        return @nuget_config_files if @nuget_config_files
-
-        @nuget_config_files = [*project_files.map do |f|
-                                 named_file_up_tree_from_project_file(f, "nuget.config")
-                               end].compact.uniq
-        @nuget_config_files
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def packages_lock_files
-        return @packages_lock_files if @packages_lock_files
-
-        candidate_paths =
-          [*project_files.map { |f| File.dirname(f.name) }, "."].uniq
-
-        @packages_lock_files =
-          candidate_paths.filter_map do |dir|
-            file = repo_contents(dir: dir)
-                   .find { |f| f.name.casecmp("packages.lock.json").zero? }
-            fetch_file_from_host(File.join(dir, file.name)) if file
-          end
-      end
-
-      sig do
-        params(
-          project_file: Dependabot::DependencyFile,
-          expected_file_name: String
-        )
-          .returns(T.nilable(Dependabot::DependencyFile))
-      end
-      def named_file_up_tree_from_project_file(project_file, expected_file_name)
-        found_expected_file = T.let(nil, T.nilable(Dependabot::DependencyFile))
-        directory_path = Pathname.new(directory)
-        full_project_dir = Pathname.new(project_file.directory).join(project_file.name).dirname
-        full_project_dir.ascend.each do |base|
-          break if found_expected_file
-
-          candidate_file_path = Pathname.new(base).join(expected_file_name).cleanpath.to_path
-          candidate_directory = Pathname.new(File.dirname(candidate_file_path))
-          relative_candidate_directory = candidate_directory.relative_path_from(directory_path)
-          candidate_file = repo_contents(dir: relative_candidate_directory).find do |f|
-            f.name.casecmp?(expected_file_name)
-          end
-          if candidate_file
-            found_expected_file = fetch_file_from_host(File.join(relative_candidate_directory,
-                                                                 candidate_file.name))
-          end
-        end
-
-        found_expected_file
-      end
-
-      sig do
-        params(
-          project_file: Dependabot::DependencyFile,
-          expected_file_name: String
-        )
-          .returns(T.nilable(Dependabot::DependencyFile))
-      end
-      def named_file_next_to_project_file(project_file, expected_file_name)
-        found_expected_file = T.let(nil, T.nilable(Dependabot::DependencyFile))
-        directory_path = Pathname.new(directory)
-        full_project_dir = Pathname.new(project_file.directory).join(project_file.name).dirname
-
-        candidate_file_path = Pathname.new(full_project_dir).join(expected_file_name).cleanpath.to_path
-        candidate_directory = Pathname.new(File.dirname(candidate_file_path))
-        relative_candidate_directory = candidate_directory.relative_path_from(directory_path)
-        candidate_file = repo_contents(dir: relative_candidate_directory).find do |f|
-          f.name.casecmp?(expected_file_name)
-        end
-        if candidate_file
-          found_expected_file = fetch_file_from_host(File.join(relative_candidate_directory,
-                                                               candidate_file.name))
-        end
-
-        found_expected_file
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def global_json
-        @global_json ||= T.let(fetch_file_if_present("global.json"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def dotnet_tools_json
-        @dotnet_tools_json ||= T.let(fetch_file_if_present(".config/dotnet-tools.json"),
-                                     T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T.nilable(Dependabot::DependencyFile)) }
-      def packages_props
-        @packages_props ||= T.let(fetch_file_if_present("Packages.props"), T.nilable(Dependabot::DependencyFile))
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def imported_property_files
-        imported_property_files = T.let([], T::Array[Dependabot::DependencyFile])
-
-        files = [*project_files, *directory_build_files]
-
-        files.each do |proj_file|
-          previously_fetched_files = project_files + imported_property_files
-          imported_property_files +=
-            fetch_imported_property_files(
-              file: proj_file,
-              previously_fetched_files: previously_fetched_files
-            )
-        end
-
-        imported_property_files
-      end
-
-      sig do
-        params(
-          file: Dependabot::DependencyFile,
-          previously_fetched_files: T::Array[Dependabot::DependencyFile]
-        )
-          .returns(T::Array[Dependabot::DependencyFile])
-      end
-      def fetch_imported_property_files(file:, previously_fetched_files:)
-        file_id = file.directory + "/" + file.name
-
-        if @fetched_files[file_id]
-          T.must(@fetched_files[file_id])
-        else
-          paths =
-            ImportPathsFinder.new(project_file: file).import_paths +
-            ImportPathsFinder.new(project_file: file).project_reference_paths +
-            ImportPathsFinder.new(project_file: file).project_file_paths
-
-          # Initialize a set to hold fetched files temporarily to avoid duplicates
-          fetched_files_set = Set.new([file])
-
-          paths.each do |path|
-            next if previously_fetched_files.map(&:name).include?(path)
-            next if file.name == path
-            next if path.include?("$(")
-
-            begin
-              fetched_file = fetch_file_from_host(path)
-              grandchild_property_files = fetch_imported_property_files(
-                file: fetched_file,
-                previously_fetched_files: previously_fetched_files + [file]
-              )
-
-              # Add fetched file and grandchild property files to the set
-              fetched_files_set << fetched_file
-              fetched_files_set.merge(grandchild_property_files)
-            rescue Dependabot::DependencyFileNotFound
-              # Don't worry about missing files, just skip them for now
-              Dependabot.logger.info("unable to find expected file #{file.name}")
-              nil
-            end
-          end
-
-          # Convert the set to an array and cache the fetched files
-          fetched_files = fetched_files_set.to_a
-          @fetched_files[file_id] = fetched_files
 
-          # Return the fetched files
-          fetched_files
+        NativeDiscoveryJsonReader.debug_report_discovery_files(error_if_missing: false)
+        discovery_json_reader.dependency_file_paths.map do |p|
+          relative_path = Pathname.new(p).relative_path_from(directory).to_path
+          fetch_file_from_host(relative_path)
         end
       end
     end

data/lib/dependabot/nuget/file_parser.rb

@@ -16,79 +16,42 @@ module Dependabot
       extend T::Sig
 
       require "dependabot/file_parsers/base/dependency_set"
-      require_relative "cache_manager"
-
-      sig { returns(T::Hash[String, T::Array[Dependabot::Dependency]]) }
-      def self.file_dependency_cache
-        T.let(CacheManager.cache("file_parser.parse"), T::Hash[String, T::Array[Dependabot::Dependency]])
-      end
 
       sig { override.returns(T::Array[Dependabot::Dependency]) }
       def parse
-        return [] unless repo_contents_path
-
-        key = NativeDiscoveryJsonReader.create_cache_key(dependency_files)
-        workspace_path = source&.directory || "/"
-        self.class.file_dependency_cache[key] ||= begin
-          # run discovery for the repo
-          discovery_json_path = NativeDiscoveryJsonReader.create_discovery_file_path_from_dependency_files(
-            dependency_files
-          )
-          NativeHelpers.run_nuget_discover_tool(job_path: job_file_path,
-                                                repo_root: T.must(repo_contents_path),
-                                                workspace_path: workspace_path,
-                                                output_path: discovery_json_path,
-                                                credentials: credentials)
-
-          discovery_json = NativeDiscoveryJsonReader.discovery_json_from_path(discovery_json_path)
-          return [] unless discovery_json
-
-          Dependabot.logger.info("Discovery JSON content: #{discovery_json.content}")
-          discovery_json_reader = NativeDiscoveryJsonReader.new(
-            discovery_json: discovery_json
-          )
-
-          # cache discovery results
-          NativeDiscoveryJsonReader.set_discovery_from_dependency_files(dependency_files: dependency_files,
-                                                                        discovery: discovery_json_reader)
-          discovery_json_reader.dependency_set.dependencies
-        end
-
-        T.must(self.class.file_dependency_cache[key])
+        dependencies
       end
 
       private
 
-      sig { returns(String) }
-      def job_file_path
-        ENV.fetch("DEPENDABOT_JOB_PATH")
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def proj_files
-        projfile = /\.proj$/
-
-        dependency_files.select do |df|
-          df.name.match?(projfile)
-        end
-      end
-
-      sig { returns(T::Array[Dependabot::DependencyFile]) }
-      def project_files
-        projectfile = /\.(cs|vb|fs)proj$/
-
-        dependency_files.select do |df|
-          df.name.match?(projectfile)
-        end
+      sig { returns(T::Array[Dependabot::Dependency]) }
+      def dependencies
+        @dependencies ||= T.let(begin
+          NativeDiscoveryJsonReader.debug_report_discovery_files(error_if_missing: true)
+          directory = source&.directory || "/"
+          discovery_json_reader = NativeDiscoveryJsonReader.run_discovery_in_directory(
+            repo_contents_path: T.must(repo_contents_path),
+            directory: directory,
+            credentials: credentials
+          )
+          discovery_json_reader.dependency_set.dependencies
+        end, T.nilable(T::Array[Dependabot::Dependency]))
       end
 
       sig { override.void }
       def check_required_files
-        return if project_files.any? || proj_files.any?
+        requirement_files = dependencies.flat_map do |dep|
+          dep.requirements.map { |r| T.let(r.fetch(:file), String) }
+        end.uniq
+
+        project_files = requirement_files.select { |f| File.basename(f).match?(/\.(cs|vb|fs)proj$/) }
+        global_json_file = requirement_files.select { |f| File.basename(f) == "global.json" }
+        dotnet_tools_json_file = requirement_files.select { |f| File.basename(f) == "dotnet-tools.json" }
+        return if project_files.any? || global_json_file.any? || dotnet_tools_json_file.any?
 
         raise Dependabot::DependencyFileNotFound.new(
-          "*.(cs|vb|fs)proj, *.proj",
-          "No project file or *.proj!"
+          "*.(cs|vb|fs)proj",
+          "No project file."
         )
       end
     end

data/lib/dependabot/nuget/file_updater.rb

@@ -57,7 +57,12 @@ module Dependabot
             try_update_projects(dependency) || try_update_json(dependency)
           end
           updated_files = dependency_files.filter_map do |f|
-            updated_content = File.read(dependency_file_path(f))
+            dependency_file_path = NativeDiscoveryJsonReader.dependency_file_path(
+              repo_contents_path: T.must(repo_contents_path),
+              dependency_file: f
+            )
+            dependency_file_path = File.join(repo_contents_path, dependency_file_path)
+            updated_content = File.read(dependency_file_path)
             next if updated_content == f.content
 
             normalized_content = normalize_content(f, updated_content)
@@ -92,7 +97,11 @@ module Dependabot
         # run update for each project file
         project_files.each do |project_file|
           project_dependencies = project_dependencies(project_file)
-          proj_path = dependency_file_path(project_file)
+          dependency_file_path = NativeDiscoveryJsonReader.dependency_file_path(
+            repo_contents_path: T.must(repo_contents_path),
+            dependency_file: project_file
+          )
+          proj_path = dependency_file_path
 
           next unless project_dependencies.any? { |dep| dep.name.casecmp?(dependency.name) }
 
@@ -119,7 +128,11 @@ module Dependabot
 
           # We just need to feed the updater a project file, grab the first
           project_file = T.must(project_files.first)
-          proj_path = dependency_file_path(project_file)
+          dependency_file_path = NativeDiscoveryJsonReader.dependency_file_path(
+            repo_contents_path: T.must(repo_contents_path),
+            dependency_file: project_file
+          )
+          proj_path = dependency_file_path
 
           return false unless repo_contents_path
 
@@ -157,8 +170,11 @@ module Dependabot
 
       sig { returns(T.nilable(NativeWorkspaceDiscovery)) }
       def workspace
-        discovery_json_reader = NativeDiscoveryJsonReader.get_discovery_from_dependency_files(dependency_files)
-        discovery_json_reader.workspace_discovery
+        dependency_file_paths = dependency_files.map do |f|
+          NativeDiscoveryJsonReader.dependency_file_path(repo_contents_path: T.must(repo_contents_path),
+                                                         dependency_file: f)
+        end
+        NativeDiscoveryJsonReader.load_discovery_for_dependency_file_paths(dependency_file_paths).workspace_discovery
       end
 
       sig { params(project_file: Dependabot::DependencyFile).returns(T::Array[String]) }
@@ -215,17 +231,6 @@ module Dependabot
       end
       # rubocop:enable Metrics/PerceivedComplexity
 
-      sig { params(dependency_file: Dependabot::DependencyFile).returns(String) }
-      def dependency_file_path(dependency_file)
-        if dependency_file.directory.start_with?(T.must(repo_contents_path))
-          File.join(dependency_file.directory, dependency_file.name)
-        else
-          file_directory = dependency_file.directory
-          file_directory = file_directory[1..-1] if file_directory.start_with?("/")
-          File.join(repo_contents_path || "", file_directory, dependency_file.name)
-        end
-      end
-
       sig { returns(T::Array[Dependabot::DependencyFile]) }
       def project_files
         dependency_files.select { |df| df.name.match?(/\.(cs|vb|fs)proj$/) }

data/lib/dependabot/nuget/native_discovery/native_dependency_file_discovery.rb

@@ -41,7 +41,7 @@ module Dependabot
       attr_reader :dependencies
 
       sig { overridable.returns(Dependabot::FileParsers::Base::DependencySet) }
-      def dependency_set # rubocop:disable Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity,Metrics/AbcSize
+      def dependency_set # rubocop:disable Metrics/PerceivedComplexity
         dependency_set = Dependabot::FileParsers::Base::DependencySet.new
 
         file_name = Pathname.new(file_path).cleanpath.to_path
@@ -65,14 +65,7 @@ module Dependabot
           # Exclude any dependencies which reference an item type
           next if dependency.name.include?("@(")
 
-          dependency_file_name = file_name
-          if dependency.type == "PackagesConfig"
-            dir_name = File.dirname(file_name)
-            dependency_file_name = "packages.config"
-            dependency_file_name = File.join(dir_name, "packages.config") unless dir_name == "."
-          end
-
-          dependency_set << build_dependency(dependency_file_name, dependency)
+          dependency_set << build_dependency(file_name, dependency)
         end
 
         dependency_set