bibliothecary 8.7.4 → 8.7.5

data/lib/bibliothecary/parsers/npm.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 
 module Bibliothecary
   module Parsers
@@ -11,25 +11,25 @@ module Bibliothecary
       def self.mapping
         {
           match_filename("package.json") => {
-            kind: 'manifest',
-            parser: :parse_manifest
+            kind: "manifest",
+            parser: :parse_manifest,
           },
           match_filename("npm-shrinkwrap.json") => {
-            kind: 'lockfile',
-            parser: :parse_shrinkwrap
+            kind: "lockfile",
+            parser: :parse_shrinkwrap,
           },
           match_filename("yarn.lock") => {
-            kind: 'lockfile',
-            parser: :parse_yarn_lock
+            kind: "lockfile",
+            parser: :parse_yarn_lock,
           },
           match_filename("package-lock.json") => {
-            kind: 'lockfile',
-            parser: :parse_package_lock
+            kind: "lockfile",
+            parser: :parse_package_lock,
           },
           match_filename("npm-ls.json") => {
-            kind: 'lockfile',
-            parser: :parse_ls
-          }
+            kind: "lockfile",
+            parser: :parse_ls,
+          },
         }
       end
 
@@ -37,7 +37,7 @@ module Bibliothecary
       add_multi_parser(Bibliothecary::MultiParsers::Spdx)
       add_multi_parser(Bibliothecary::MultiParsers::DependenciesCSV)
 
-      def self.parse_package_lock(file_contents, options: {})
+      def self.parse_package_lock(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse(file_contents)
         # https://docs.npmjs.com/cli/v9/configuring-npm/package-lock-json#lockfileversion
         if manifest["lockfileVersion"].to_i <= 1
@@ -56,54 +56,54 @@ module Bibliothecary
       end
 
       def self.parse_package_lock_v1(manifest)
-        parse_package_lock_deps_recursively(manifest.fetch('dependencies', []))
+        parse_package_lock_deps_recursively(manifest.fetch("dependencies", []))
       end
 
       def self.parse_package_lock_v2(manifest)
         # "packages" is a flat object where each key is the installed location of the dep, e.g. node_modules/foo/node_modules/bar.
         manifest
           .fetch("packages")
-          .reject { |name, dep| name == "" } # this is the lockfile's package itself
+          .reject { |name, _dep| name == "" } # this is the lockfile's package itself
           .map do |name, dep|
             {
               name: name.split("node_modules/").last,
               requirement: dep["version"],
-              type: dep.fetch("dev", false) || dep.fetch("devOptional", false)  ? "development" : "runtime"
+              type: dep.fetch("dev", false) || dep.fetch("devOptional", false)  ? "development" : "runtime",
             }
           end
       end
 
       def self.parse_package_lock_deps_recursively(dependencies, depth=1)
         dependencies.flat_map do |name, requirement|
-          type = requirement.fetch("dev", false) ? 'development' : 'runtime'
+          type = requirement.fetch("dev", false) ? "development" : "runtime"
           version = requirement.key?("from") ? requirement["from"][/#(?:semver:)?v?(.*)/, 1] : nil
           version ||= requirement["version"].split("#").last
           child_dependencies = if depth >= PACKAGE_LOCK_JSON_MAX_DEPTH
             []
           else
-            parse_package_lock_deps_recursively(requirement.fetch('dependencies', []), depth + 1)
-          end
+            parse_package_lock_deps_recursively(requirement.fetch("dependencies", []), depth + 1)
+                               end
 
           [{
             name: name,
             requirement: version,
-            type: type
+            type: type,
           }] + child_dependencies
         end
       end
 
-      def self.parse_manifest(file_contents, options: {})
+      def self.parse_manifest(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse(file_contents)
-        raise "appears to be a lockfile rather than manifest format" if manifest.key?('lockfileVersion')
+        raise "appears to be a lockfile rather than manifest format" if manifest.key?("lockfileVersion")
 
         (
-          map_dependencies(manifest, 'dependencies', 'runtime') +
-          map_dependencies(manifest, 'devDependencies', 'development')
+          map_dependencies(manifest, "dependencies", "runtime") +
+          map_dependencies(manifest, "devDependencies", "development")
         )
           .reject { |dep| dep[:name].start_with?("//") } # Omit comment keys. They are valid in package.json: https://groups.google.com/g/nodejs/c/NmL7jdeuw0M/m/yTqI05DRQrIJ
       end
 
-      def self.parse_yarn_lock(file_contents, options: {})
+      def self.parse_yarn_lock(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         response = Typhoeus.post("#{Bibliothecary.configuration.yarn_parser_host}/parse", body: file_contents)
 
         raise Bibliothecary::RemoteParsingError.new("Http Error #{response.response_code} when contacting: #{Bibliothecary.configuration.yarn_parser_host}/parse", response.response_code) unless response.success?
@@ -114,15 +114,15 @@ module Bibliothecary
             name: dep[:name],
             requirement: dep[:version],
             lockfile_requirement: dep[:requirement],
-            type: dep[:type]
+            type: dep[:type],
           }
         end
       end
 
-      def self.parse_ls(file_contents, options: {})
+      def self.parse_ls(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse(file_contents)
 
-        transform_tree_to_array(manifest.fetch('dependencies', {}))
+        transform_tree_to_array(manifest.fetch("dependencies", {}))
       end
 
       def self.lockfile_preference_order(file_infos)
@@ -143,9 +143,9 @@ module Bibliothecary
             {
               name: name,
               requirement: metadata["version"],
-              lockfile_requirement: metadata.fetch("from", "").split('@').last,
-              type: "runtime"
-            }
+              lockfile_requirement: metadata.fetch("from", "").split("@").last,
+              type: "runtime",
+            },
           ] + transform_tree_to_array(metadata.fetch("dependencies", {}))
         end.flatten(1)
       end

data/lib/bibliothecary/parsers/nuget.rb

@@ -1,5 +1,5 @@
-require 'ox'
-require 'json'
+require "ox"
+require "json"
 
 module Bibliothecary
   module Parsers
@@ -10,37 +10,37 @@ module Bibliothecary
       def self.mapping
         {
           match_filename("Project.json") => {
-            kind: 'manifest',
-            parser: :parse_json_runtime_manifest
+            kind: "manifest",
+            parser: :parse_json_runtime_manifest,
           },
           match_filename("Project.lock.json") => {
-            kind: 'lockfile',
-            parser: :parse_project_lock_json
+            kind: "lockfile",
+            parser: :parse_project_lock_json,
           },
           match_filename("packages.lock.json") => {
-            kind: 'lockfile',
-            parser: :parse_packages_lock_json
+            kind: "lockfile",
+            parser: :parse_packages_lock_json,
           },
           match_filename("packages.config") => {
-            kind: 'manifest',
-            parser: :parse_packages_config
+            kind: "manifest",
+            parser: :parse_packages_config,
           },
           match_extension(".nuspec") => {
-            kind: 'manifest',
-            parser: :parse_nuspec
+            kind: "manifest",
+            parser: :parse_nuspec,
           },
           match_extension(".csproj") => {
-            kind: 'manifest',
-            parser: :parse_csproj
+            kind: "manifest",
+            parser: :parse_csproj,
           },
           match_filename("paket.lock") => {
-            kind: 'lockfile',
-            parser: :parse_paket_lock
+            kind: "lockfile",
+            parser: :parse_paket_lock,
           },
           match_filename("project.assets.json") => {
-            kind: 'lockfile',
-            parser: :parse_project_assets_json
-          }
+            kind: "lockfile",
+            parser: :parse_project_assets_json,
+          },
         }
       end
 
@@ -48,23 +48,23 @@ module Bibliothecary
       add_multi_parser(Bibliothecary::MultiParsers::DependenciesCSV)
       add_multi_parser(Bibliothecary::MultiParsers::Spdx)
 
-      def self.parse_project_lock_json(file_contents, options: {})
+      def self.parse_project_lock_json(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse file_contents
-        manifest.fetch('libraries',[]).map do |name, _requirement|
-          dep = name.split('/')
+        manifest.fetch("libraries",[]).map do |name, _requirement|
+          dep = name.split("/")
           {
             name: dep[0],
             requirement: dep[1],
-            type: 'runtime'
+            type: "runtime",
           }
         end
       end
 
-      def self.parse_packages_lock_json(file_contents, options: {})
+      def self.parse_packages_lock_json(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse file_contents
 
         frameworks = {}
-        manifest.fetch('dependencies',[]).each do |framework, deps|
+        manifest.fetch("dependencies",[]).each do |framework, deps|
           frameworks[framework] = deps
             .reject { |_name, details| details["type"] == "Project" } # Projects do not have versions
             .map do |name, details|
@@ -72,8 +72,8 @@ module Bibliothecary
                 name: name,
                 # 'resolved' has been set in all examples so far
                 # so fallback to requested is pure paranoia
-                requirement: details.fetch('resolved', details.fetch('requested', '*')),
-                type: 'runtime'
+                requirement: details.fetch("resolved", details.fetch("requested", "*")),
+                type: "runtime",
               }
             end
         end
@@ -89,23 +89,23 @@ module Bibliothecary
         []
       end
 
-      def self.parse_packages_config(file_contents, options: {})
+      def self.parse_packages_config(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = Ox.parse file_contents
-        manifest.packages.locate('package').map do |dependency|
+        manifest.packages.locate("package").map do |dependency|
           {
             name: dependency.id,
             requirement: (dependency.version if dependency.respond_to? "version") || "*",
-            type: dependency.respond_to?("developmentDependency") && dependency.developmentDependency == "true" ? 'development' : 'runtime'
+            type: dependency.respond_to?("developmentDependency") && dependency.developmentDependency == "true" ? "development" : "runtime",
           }
         end
       rescue
         []
       end
 
-      def self.parse_csproj(file_contents, options: {})
+      def self.parse_csproj(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = Ox.parse file_contents
 
-        packages = manifest.locate('ItemGroup/PackageReference').select{ |dep| dep.respond_to? "Include" }.map do |dependency|
+        packages = manifest.locate("ItemGroup/PackageReference").select{ |dep| dep.respond_to? "Include" }.map do |dependency|
           requirement = (dependency.Version if dependency.respond_to? "Version") || "*"
           if requirement.is_a?(Ox::Element)
             requirement = dependency.nodes.detect{ |n| n.value == "Version" }&.text
@@ -120,7 +120,7 @@ module Bibliothecary
           {
             name: dependency.Include,
             requirement: requirement,
-            type: type
+            type: type,
           }
         end
         packages.uniq {|package| package[:name] }
@@ -128,48 +128,48 @@ module Bibliothecary
         []
       end
 
-      def self.parse_nuspec(file_contents, options: {})
+      def self.parse_nuspec(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = Ox.parse file_contents
-        manifest.package.metadata.dependencies.locate('dependency').map do |dependency|
+        manifest.package.metadata.dependencies.locate("dependency").map do |dependency|
           {
             name: dependency.id,
-            requirement: dependency.attributes[:version] || '*',
-            type: dependency.respond_to?("developmentDependency") && dependency.developmentDependency == "true" ? 'development' : 'runtime'
+            requirement: dependency.attributes[:version] || "*",
+            type: dependency.respond_to?("developmentDependency") && dependency.developmentDependency == "true" ? "development" : "runtime",
           }
         end
       rescue
         []
       end
 
-      def self.parse_paket_lock(file_contents, options: {})
+      def self.parse_paket_lock(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         lines = file_contents.split("\n")
         package_version_re = /\s+(?<name>\S+)\s\((?<version>\d+\.\d+[\.\d+[\.\d+]*]*)\)/
         packages = lines.select { |line| package_version_re.match(line) }.map { |line| package_version_re.match(line) }.map do |match|
           {
             name: match[:name].strip,
             requirement: match[:version],
-            type: 'runtime'
+            type: "runtime",
           }
         end
         # we only have to enforce uniqueness by name because paket ensures that there is only the single version globally in the project
         packages.uniq {|package| package[:name] }
       end
 
-      def self.parse_project_assets_json(file_contents, options: {})
+      def self.parse_project_assets_json(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse file_contents
 
         frameworks = {}
         manifest.fetch("targets",[]).each do |framework, deps|
           frameworks[framework] = deps
-                                    .select { |_name, details| details["type"] == "package" }
-                                    .map do |name, _details|
+            .select { |_name, details| details["type"] == "package" }
+            .map do |name, _details|
             name_split = name.split("/")
             {
               name: name_split[0],
               requirement: name_split[1],
-              type: "runtime"
+              type: "runtime",
             }
-          end
+            end
         end
 
         if frameworks.size > 0

data/lib/bibliothecary/parsers/packagist.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 
 module Bibliothecary
   module Parsers
@@ -8,13 +8,13 @@ module Bibliothecary
       def self.mapping
         {
           match_filename("composer.json") => {
-            kind: 'manifest',
-            parser: :parse_manifest
+            kind: "manifest",
+            parser: :parse_manifest,
           },
           match_filename("composer.lock") => {
-            kind: 'lockfile',
-            parser: :parse_lockfile
-          }
+            kind: "lockfile",
+            parser: :parse_lockfile,
+          },
         }
       end
 
@@ -22,22 +22,22 @@ module Bibliothecary
       add_multi_parser(Bibliothecary::MultiParsers::DependenciesCSV)
       add_multi_parser(Bibliothecary::MultiParsers::Spdx)
 
-      def self.parse_lockfile(file_contents, options: {})
+      def self.parse_lockfile(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse file_contents
-        manifest.fetch('packages',[]).map do |dependency|
+        manifest.fetch("packages",[]).map do |dependency|
           {
             name: dependency["name"],
             requirement: dependency["version"],
-            type: "runtime"
+            type: "runtime",
           }.tap do |result|
             # Store Drupal version if Drupal, but include the original manifest version for reference
             result[:original_requirement], result[:requirement] = result[:requirement], dependency.dig("source", "reference") if is_drupal_module(dependency)
           end
-        end + manifest.fetch('packages-dev',[]).map do |dependency|
+        end + manifest.fetch("packages-dev",[]).map do |dependency|
           {
             name: dependency["name"],
             requirement: dependency["version"],
-            type: "development"
+            type: "development",
           }.tap do |result|
             # Store Drupal version if Drupal, but include the original manifest version for reference
             result[:original_requirement], result[:requirement] = result[:requirement], dependency.dig("source", "reference") if is_drupal_module(dependency)
@@ -45,10 +45,10 @@ module Bibliothecary
         end
       end
 
-      def self.parse_manifest(file_contents, options: {})
+      def self.parse_manifest(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = JSON.parse file_contents
-        map_dependencies(manifest, 'require', 'runtime') +
-        map_dependencies(manifest, 'require-dev', 'development')
+        map_dependencies(manifest, "require", "runtime") +
+        map_dependencies(manifest, "require-dev", "development")
       end
 
       # Drupal hosts its own Composer repository, where its "modules" are indexed and searchable. The best way to

data/lib/bibliothecary/parsers/pub.rb

@@ -1,4 +1,4 @@
-require 'yaml'
+require "yaml"
 
 module Bibliothecary
   module Parsers
@@ -8,31 +8,31 @@ module Bibliothecary
       def self.mapping
         {
           match_filename("pubspec.yaml", case_insensitive: true) => {
-            kind: 'manifest',
-            parser: :parse_yaml_manifest
+            kind: "manifest",
+            parser: :parse_yaml_manifest,
           },
           match_filename("pubspec.lock", case_insensitive: true) => {
-            kind: 'lockfile',
-            parser: :parse_yaml_lockfile
-          }
+            kind: "lockfile",
+            parser: :parse_yaml_lockfile,
+          },
         }
       end
 
       add_multi_parser(Bibliothecary::MultiParsers::DependenciesCSV)
 
-      def self.parse_yaml_manifest(file_contents, options: {})
+      def self.parse_yaml_manifest(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = YAML.load file_contents
-        map_dependencies(manifest, 'dependencies', 'runtime') +
-        map_dependencies(manifest, 'dev_dependencies', 'development')
+        map_dependencies(manifest, "dependencies", "runtime") +
+        map_dependencies(manifest, "dev_dependencies", "development")
       end
 
-      def self.parse_yaml_lockfile(file_contents, options: {})
+      def self.parse_yaml_lockfile(file_contents, options: {}) # rubocop:disable Lint/UnusedMethodArgument
         manifest = YAML.load file_contents
-        manifest.fetch('packages', []).map do |name, dep|
+        manifest.fetch("packages", []).map do |name, dep|
           {
             name: name,
-            requirement: dep['version'],
-            type: 'runtime'
+            requirement: dep["version"],
+            type: "runtime",
           }
         end
       end