dependabot-elm 0.82.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e4631c5a095b12bcb7680efa489f38c3706a65f02b6aff6bb5ac77efc5252301
+  data.tar.gz: f501e81ff96e0262008737a04ef0c952ae1ca6b4a799ed686761af7b29c25dc8
+SHA512:
+  metadata.gz: 1289f30665a25cd7b5e98ced8d71c1b794311ccb9cbbfec89f6be6dab6d5f9210e135181ea979a5b3031149d316f3602e5480616c42cc4ae313552e63e78c1a6
+  data.tar.gz: a7ceb51fa33fbc0e94f44a305fe513e1483777dbfeb09f53a0e3b06d5d4163beaec1bec7c6ebaee6b7f05eb6a2a72026a101cac10d2d47ec122b286b86e5239e

data/lib/dependabot/elm/file_fetcher.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dependabot/file_fetchers"
+require "dependabot/file_fetchers/base"
+
+module Dependabot
+  module Elm
+    class FileFetcher < Dependabot::FileFetchers::Base
+      def self.required_files_in?(filenames)
+        return true if filenames.include?("elm-package.json")
+
+        filenames.include?("elm.json")
+      end
+
+      def self.required_files_message
+        "Repo must contain an elm-package.json or an elm.json"
+      end
+
+      private
+
+      def fetch_files
+        fetched_files = []
+
+        fetched_files << elm_package if elm_package
+        fetched_files << elm_json if elm_json
+
+        # Note: We *do not* fetch the exact-dependencies.json file, as it is
+        # recommended that this is not committed
+
+        check_required_files_present
+        fetched_files
+      end
+
+      def check_required_files_present
+        return if elm_package || elm_json
+
+        path = Pathname.new(File.join(directory, "elm.json")).
+               cleanpath.to_path
+        raise Dependabot::DependencyFileNotFound, path
+      end
+
+      def elm_package
+        @elm_package ||= fetch_file_if_present("elm-package.json")
+      end
+
+      def elm_json
+        @elm_json ||= fetch_file_if_present("elm.json")
+      end
+    end
+  end
+end
+
+Dependabot::FileFetchers.register("elm-package", Dependabot::Elm::FileFetcher)

data/lib/dependabot/elm/file_parser.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "dependabot/dependency"
+require "dependabot/errors"
+require "dependabot/file_parsers"
+require "dependabot/file_parsers/base"
+require "dependabot/elm/requirement"
+
+module Dependabot
+  module Elm
+    class FileParser < Dependabot::FileParsers::Base
+      require "dependabot/file_parsers/base/dependency_set"
+
+      DEPENDENCY_TYPES = %w(dependencies test-dependencies).freeze
+
+      def parse
+        dependency_set = DependencySet.new
+
+        dependency_set += elm_package_dependencies if elm_package
+        dependency_set += elm_json_dependencies if elm_json
+
+        dependency_set.dependencies.sort_by(&:name)
+      end
+
+      private
+
+      def elm_package_dependencies
+        dependency_set = DependencySet.new
+
+        parsed_package_file.fetch("dependencies").each do |name, req|
+          dependency_set <<
+            Dependency.new(
+              name: name,
+              version: version_for(req)&.to_s,
+              requirements: [{
+                requirement: req, # 4.0 <= v <= 4.0
+                groups: [], # we don't have this (its dev vs non-dev)
+                source: nil, # elm-package only has elm-package sources
+                file: "elm-package.json"
+              }],
+              package_manager: "elm-package"
+            )
+        end
+
+        dependency_set
+      end
+
+      # For docs on elm.json, see:
+      # https://github.com/elm/compiler/blob/master/docs/elm.json/application.md
+      # https://github.com/elm/compiler/blob/master/docs/elm.json/package.md
+      def elm_json_dependencies
+        dependency_set = DependencySet.new
+
+        DEPENDENCY_TYPES.each do |dep_type|
+          if repo_type == "application"
+            dependencies_hash = parsed_elm_json.fetch(dep_type, {})
+            dependencies_hash.fetch("direct", {}).each do |name, req|
+              dependency_set << build_elm_json_dependency(
+                name: name, group: dep_type, requirement: req, direct: true
+              )
+            end
+            dependencies_hash.fetch("indirect", {}).each do |name, req|
+              dependency_set << build_elm_json_dependency(
+                name: name, group: dep_type, requirement: req, direct: false
+              )
+            end
+          elsif repo_type == "package"
+            parsed_elm_json.fetch(dep_type, {}).each do |name, req|
+              dependency_set << build_elm_json_dependency(
+                name: name, group: dep_type, requirement: req, direct: true
+              )
+            end
+          else raise "Unexpected repo type for Elm repo: #{repo_type}"
+          end
+        end
+
+        dependency_set
+      end
+
+      def build_elm_json_dependency(name:, group:, requirement:, direct:)
+        requirements = [{
+          requirement: requirement,
+          groups: [group],
+          source: nil,
+          file: "elm.json"
+        }]
+
+        Dependency.new(
+          name: name,
+          version: version_for(requirement)&.to_s,
+          requirements: direct ? requirements : [],
+          package_manager: "elm-package"
+        )
+      end
+
+      def repo_type
+        parsed_elm_json.fetch("type")
+      end
+
+      def check_required_files
+        return if elm_json || elm_package
+
+        raise "No elm.json or elm-package.json!"
+      end
+
+      def version_for(version_requirement)
+        req = Dependabot::Elm::Requirement.new(version_requirement)
+
+        return unless req.exact?
+
+        req.requirements.first.last
+      end
+
+      def parsed_package_file
+        @parsed_package_file ||= JSON.parse(elm_package.content)
+      rescue JSON::ParserError
+        raise Dependabot::DependencyFileNotParseable, elm_package.path
+      end
+
+      def parsed_elm_json
+        @parsed_elm_json ||= JSON.parse(elm_json.content)
+      rescue JSON::ParserError
+        raise Dependabot::DependencyFileNotParseable, elm_json.path
+      end
+
+      def elm_package
+        @elm_package ||= get_original_file("elm-package.json")
+      end
+
+      def elm_json
+        @elm_json ||= get_original_file("elm.json")
+      end
+    end
+  end
+end
+
+Dependabot::FileParsers.register("elm-package", Dependabot::Elm::FileParser)

data/lib/dependabot/elm/file_updater.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "dependabot/file_updaters"
+require "dependabot/file_updaters/base"
+
+module Dependabot
+  module Elm
+    class FileUpdater < Dependabot::FileUpdaters::Base
+      require_relative "file_updater/elm_package_updater"
+      require_relative "file_updater/elm_json_updater"
+
+      def self.updated_files_regex
+        [
+          /^elm-package\.json$/,
+          /^elm\.json$/
+        ]
+      end
+
+      def updated_dependency_files
+        updated_files = []
+
+        elm_package_files.each do |file|
+          next unless file_changed?(file)
+
+          updated_files <<
+            updated_file(
+              file: file,
+              content: updated_elm_package_content(file)
+            )
+        end
+
+        elm_json_files.each do |file|
+          next unless file_changed?(file)
+
+          updated_files <<
+            updated_file(
+              file: file,
+              content: updated_elm_json_content(file)
+            )
+        end
+
+        raise "No files have changed!" if updated_files.none?
+
+        updated_files
+      end
+
+      private
+
+      def check_required_files
+        return if elm_json_files.any? || elm_package_files.any?
+
+        raise "No elm.json or elm-package.json!"
+      end
+
+      def updated_elm_package_content(file)
+        ElmPackageUpdater.new(
+          dependencies: dependencies,
+          elm_package_file: file
+        ).updated_elm_package_file_content
+      end
+
+      def updated_elm_json_content(file)
+        ElmJsonUpdater.new(
+          dependencies: dependencies,
+          elm_json_file: file
+        ).updated_content
+      end
+
+      def elm_package_files
+        dependency_files.select { |f| f.name.end_with?("elm-package.json") }
+      end
+
+      def elm_json_files
+        dependency_files.select { |f| f.name.end_with?("elm.json") }
+      end
+    end
+  end
+end
+
+Dependabot::FileUpdaters.register("elm-package", Dependabot::Elm::FileUpdater)

data/lib/dependabot/elm/file_updater/elm_json_updater.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "dependabot/elm/file_updater"
+
+module Dependabot
+  module Elm
+    class FileUpdater
+      class ElmJsonUpdater
+        def initialize(elm_json_file:, dependencies:)
+          @elm_json_file = elm_json_file
+          @dependencies = dependencies
+        end
+
+        def updated_content
+          dependencies.
+            select { |dep| requirement_changed?(elm_json_file, dep) }.
+            reduce(elm_json_file.content.dup) do |content, dep|
+              updated_content = content
+
+              updated_content = update_requirement(
+                content: updated_content,
+                filename: elm_json_file.name,
+                dependency: dep
+              )
+
+              next updated_content unless content == updated_content
+
+              raise "Expected content to change!"
+            end
+        end
+
+        private
+
+        attr_reader :elm_json_file, :dependencies
+
+        def requirement_changed?(file, dependency)
+          changed_requirements =
+            dependency.requirements - dependency.previous_requirements
+
+          changed_requirements.any? { |f| f[:file] == file.name }
+        end
+
+        def update_requirement(content:, filename:, dependency:)
+          updated_req =
+            dependency.requirements.
+            find { |r| r.fetch(:file) == filename }.
+            fetch(:requirement)
+
+          old_req =
+            dependency.previous_requirements.
+            find { |r| r.fetch(:file) == filename }.
+            fetch(:requirement)
+
+          return content unless old_req
+
+          dep = dependency
+          regex =
+            /"#{Regexp.quote(dep.name)}"\s*:\s+"#{Regexp.quote(old_req)}"/
+
+          content.gsub(regex) do |declaration|
+            declaration.gsub(%("#{old_req}"), %("#{updated_req}"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dependabot/elm/file_updater/elm_package_updater.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "dependabot/elm/file_updater"
+
+module Dependabot
+  module Elm
+    class FileUpdater
+      class ElmPackageUpdater
+        def initialize(elm_package_file:, dependencies:)
+          @elm_package_file = elm_package_file
+          @dependencies = dependencies
+        end
+
+        def updated_elm_package_file_content
+          dependencies.
+            select { |dep| requirement_changed?(elm_package_file, dep) }.
+            reduce(elm_package_file.content.dup) do |content, dep|
+              updated_content = content
+
+              updated_content = update_requirement(
+                content: updated_content,
+                filename: elm_package_file.name,
+                dependency: dep
+              )
+
+              next updated_content unless content == updated_content
+
+              raise "Expected content to change!"
+            end
+        end
+
+        private
+
+        attr_reader :elm_package_file, :dependencies
+
+        def requirement_changed?(file, dependency)
+          changed_requirements =
+            dependency.requirements - dependency.previous_requirements
+
+          changed_requirements.any? { |f| f[:file] == file.name }
+        end
+
+        def update_requirement(content:, filename:, dependency:)
+          updated_req =
+            dependency.requirements.
+            find { |r| r.fetch(:file) == filename }.
+            fetch(:requirement)
+
+          old_req =
+            dependency.previous_requirements.
+            find { |r| r.fetch(:file) == filename }.
+            fetch(:requirement)
+
+          return content unless old_req
+
+          dep = dependency
+          regex =
+            /"#{Regexp.quote(dep.name)}"\s*:\s+"#{Regexp.quote(old_req)}"/
+
+          content.gsub(regex) do |declaration|
+            declaration.gsub(%("#{old_req}"), %("#{updated_req}"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dependabot/elm/metadata_finder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "dependabot/metadata_finders"
+require "dependabot/metadata_finders/base"
+require "dependabot/source"
+
+module Dependabot
+  module Elm
+    class MetadataFinder < Dependabot::MetadataFinders::Base
+      private
+
+      def look_up_source
+        # For Elm 0.18 an elm-package is guaranteed to be `owner/name`
+        # on github. For 0.19 a lot will change, including the name of
+        # the dependency file, so I won't try to build something more
+        # sophisticated here for now.
+        Source.from_url("https://github.com/" + dependency.name)
+      end
+    end
+  end
+end
+
+Dependabot::MetadataFinders.
+  register("elm-package", Dependabot::Elm::MetadataFinder)

data/lib/dependabot/elm/requirement.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "dependabot/utils"
+require "dependabot/elm/version"
+
+module Dependabot
+  module Elm
+    class Requirement < Gem::Requirement
+      # Override the version pattern to allow local versions
+      PATTERN_RAW =
+        "(#{Elm::Version::VERSION_PATTERN}) (<=?) v (<=?) " \
+        "(#{Elm::Version::VERSION_PATTERN})"
+      PATTERN = /\A#{PATTERN_RAW}\z/.freeze
+      EXACT_PATTERN = /\A#{Elm::Version::VERSION_PATTERN}\z/.freeze
+
+      # Returns an array of requirements. At least one requirement from the
+      # returned array must be satisfied for a version to be valid.
+      def self.requirements_array(requirement_string)
+        [new(requirement_string)]
+      end
+
+      # Override the parser to create Elm::Versions and return an
+      # array of parsed requirements
+      def self.parse(obj)
+        # If a version is given this is an equals requirement
+        if EXACT_PATTERN.match?(obj.to_s)
+          return [["=", Elm::Version.new(obj.to_s)]]
+        end
+
+        unless (matches = PATTERN.match(obj.to_s))
+          msg = "Illformed requirement #{obj.inspect}"
+          raise BadRequirementError, msg
+        end
+
+        # If the two versions specified are identical this is an equals
+        # requirement
+        if matches[1] == matches[4] && matches[3] == "<="
+          return [["=", Elm::Version.new(matches[4])]]
+        end
+
+        [
+          [matches[2].tr("<", ">"), Elm::Version.new(matches[1])],
+          [matches[3], Elm::Version.new(matches[4])]
+        ]
+      end
+
+      # Overwrite superclass method to use `flat_map`
+      def initialize(*requirements)
+        if requirements.any?(&:nil?)
+          raise BadRequirementError, "Nil requirement not supported in Elm"
+        end
+
+        requirements = requirements.flatten
+        requirements.compact!
+        requirements.uniq!
+
+        if requirements.empty?
+          @requirements = [DefaultRequirement]
+        else
+          @requirements = requirements.flat_map { |r| self.class.parse(r) }
+          sort_requirements!
+        end
+      end
+
+      # Overwrite superclass method to use `flat_map`
+      def concat(new)
+        new = new.flatten
+        new.compact!
+        new.uniq!
+        new = new.flat_map { |r| self.class.parse(r) }
+
+        @requirements.concat new
+        sort_requirements!
+      end
+
+      def sort_requirements!
+        @requirements.sort! do |l, r|
+          comp = l.last <=> r.last # first, sort by the requirement's version
+          next comp unless comp.zero?
+
+          l.first <=> r.first # then, sort by the operator (for stability)
+        end
+      end
+
+      def satisfied_by?(version)
+        version = Elm::Version.new(version.to_s)
+        super
+      end
+    end
+  end
+end
+
+Dependabot::Utils.
+  register_requirement_class("elm-package", Dependabot::Elm::Requirement)