compare cache.toml and fpm.toml dependencies and force update when changed

Author: perazz

src/fpm.f90

@@ -63,7 +63,6 @@ subroutine build_model(model, settings, package, error)
     do i = 1, model%deps%ndep
 
        if (model%deps%dep(i)%update) then
-            print *, ' Updating model dependency ',model%deps%dep(i)%name,' ...'
             call model%deps%update(model%deps%dep(i)%name,error)
             if (allocated(error)) return
        end if

src/fpm/dependency.f90

@@ -59,9 +59,10 @@ module fpm_dependency
   use fpm_environment, only : get_os_type, OS_WINDOWS
   use fpm_error, only : error_t, fatal_error
   use fpm_filesystem, only : exists, join_path, mkdir, canon_path, windows_path
-  use fpm_git, only : git_target_revision, git_target_default, git_revision
+  use fpm_git, only : git_target_revision, git_target_default, git_revision, operator(==)
   use fpm_manifest, only : package_config_t, dependency_config_t, &
     get_package_data
+  use fpm_manifest_dependency, only: manifest_has_changed
   use fpm_strings, only : string_t, operator(.in.)
   use fpm_toml, only : toml_table, toml_key, toml_error, toml_serializer, &
     toml_parse, get_value, set_value, add_table
@@ -217,8 +218,6 @@ subroutine new_dependency_node(self, dependency, version, proj_dir, update)
       self%update = update
     end if
 
-    print *, 'new node from self=',self%name,' dep=',dependency%name, 'update=',update
-
   end subroutine new_dependency_node
 
   !> Add project dependencies, each depth level after each other.
@@ -368,12 +367,33 @@ subroutine add_dependency(self, dependency, error)
     type(error_t), allocatable, intent(out) :: error
 
     integer :: id
+    logical :: needs_update
+    type(dependency_node_t) :: new_dep
 
     id = self%find(dependency)
-    if (id == 0) then
+
+    exists: if (id > 0) then
+
+      !> A dependency with this same name is already in the dependency tree.
+
+      !> check if it needs to be updated
+      call new_dependency_node(new_dep, dependency)
+      needs_update = dependency_has_changed(self%dep(id), new_dep)
+
+      !> Ensure an update is requested whenever the dependency has changed
+      if (needs_update) then
+         write(self%unit, out_fmt) "Update needed:", dependency%name
+         call new_dependency_node(self%dep(id), dependency, update=.true.)
+      endif
+
+    else exists
+
+      !> New dependency: add from scratch
       self%ndep = self%ndep + 1
       call new_dependency_node(self%dep(self%ndep), dependency)
-    end if
+
+    end if exists
+
 
   end subroutine add_dependency
 
@@ -457,8 +477,6 @@ subroutine resolve_dependency(self, dependency, root, error)
     character(len=:), allocatable :: manifest, proj_dir, revision
     logical :: fetch
 
-    print *, 'resolving dependency ',dependency%name,': done=',dependency%done,' update=',dependency%update
-
     if (dependency%done) return
 
     fetch = .false.
@@ -562,34 +580,17 @@ subroutine register(self, package, root, fetch, revision, error)
     type(error_t), allocatable, intent(out) :: error
 
     logical :: update
-    character(:), allocatable :: sver,pver
 
     update = .false.
     if (self%name /= package%name) then
       call fatal_error(error, "Dependency name '"//package%name// &
         & "' found, but expected '"//self%name//"' instead")
     end if
 
-    ! If this is the package node, always request an update of
-    ! the cache whenever its version changes
-    is_package: if (self%name==package%name .and. self%path==".") then
-
-       if (self%version/=package%version) update = .true.
-
-    end if is_package
-
-    call self%version%to_string(sver)
-    call package%version%to_string(pver)
-    print *, 'self%version=',sver,' package version = ',pver
-
     self%version = package%version
-
-    print *, 'self%proj_dir=',self%proj_dir,' package dir = ',root
-
     self%proj_dir = root
 
     if (allocated(self%git).and.present(revision)) then
-      print *, 'self revision = ',self%revision,' revision = ',revision,' fetch = ',fetch
       self%revision = revision
       if (.not.fetch) then
         ! git object is HEAD always allows an update
@@ -604,8 +605,6 @@ subroutine register(self, package, root, fetch, revision, error)
     self%update = update
     self%done = .true.
 
-    print *, 'dep = ',self%name,' update=',update
-
   end subroutine register
 
   !> Read dependency tree from file
@@ -835,4 +834,32 @@ pure subroutine resize_dependency_node(var, n)
 
   end subroutine resize_dependency_node
 
+  !> Check if a dependency node has changed
+  logical function dependency_has_changed(this,that) result(has_changed)
+     !> Two instances of the same dependency to be compared
+     type(dependency_node_t), intent(in) :: this,that
+
+     has_changed = .true.
+
+     !> All the following entities must be equal for the dependency to not have changed
+     if (manifest_has_changed(this, that)) return
+
+     !> For now, only perform the following checks if both are available. A dependency in cache.toml
+     !> will always have this metadata; a dependency from fpm.toml which has not been fetched yet
+     !> may not have it
+     if (allocated(this%version) .and. allocated(that%version)) then
+        if (this%version/=that%version) return
+     endif
+     if (allocated(this%revision) .and. allocated(that%revision)) then
+        if (this%revision/=that%revision) return
+     endif
+     if (allocated(this%proj_dir) .and. allocated(that%proj_dir)) then
+        if (this%proj_dir/=that%proj_dir) return
+     endif
+
+     !> All checks passed: the two dependencies have no differences
+     has_changed = .false.
+
+  end function dependency_has_changed
+
 end module fpm_dependency

src/fpm/git.f90

@@ -8,6 +8,7 @@ module fpm_git
     public :: git_target_default, git_target_branch, git_target_tag, &
         & git_target_revision
     public :: git_revision
+    public :: operator(==)
 
 
     !> Possible git target
@@ -54,6 +55,10 @@ module fpm_git
     end type git_target_t
 
 
+    interface operator(==)
+        module procedure git_target_eq
+    end interface
+
 contains
 
 
@@ -128,6 +133,18 @@ function git_target_tag(url, tag) result(self)
 
     end function git_target_tag
 
+    !> Check that two git targets are equal
+    logical function git_target_eq(this,that) result(is_equal)
+
+        !> Two input git targets
+        type(git_target_t), intent(in) :: this,that
+
+        is_equal = this%descriptor == that%descriptor .and. &
+                   this%url        == that%url        .and. &
+                   this%object     == that%object
+
+    end function git_target_eq
+
 
     subroutine checkout(self, local_path, error)
 

src/fpm/manifest/dependency.f90

@@ -25,14 +25,14 @@
 module fpm_manifest_dependency
     use fpm_error, only : error_t, syntax_error
     use fpm_git, only : git_target_t, git_target_tag, git_target_branch, &
-        & git_target_revision, git_target_default
+        & git_target_revision, git_target_default, operator(==)
     use fpm_toml, only : toml_table, toml_key, toml_stat, get_value
     use fpm_filesystem, only: windows_path
     use fpm_environment, only: get_os_type, OS_WINDOWS
     implicit none
     private
 
-    public :: dependency_config_t, new_dependency, new_dependencies
+    public :: dependency_config_t, new_dependency, new_dependencies, manifest_has_changed
 
 
     !> Configuration meta data for a dependency
@@ -159,7 +159,7 @@ subroutine check(table, error)
                     exit
                 end if
                 url_present = .true.
-                
+
             case("path")
                 if (url_present) then
                     call syntax_error(error, "Dependency "//name//" cannot have both git and path entries")
@@ -266,5 +266,26 @@ subroutine info(self, unit, verbosity)
 
     end subroutine info
 
+    !> Check if two dependency configurations are different
+    logical function manifest_has_changed(this, that) result(has_changed)
+
+        !> Two instances of the dependency configuration
+        class(dependency_config_t), intent(in) :: this, that
+
+        has_changed = .true.
+
+        !> Perform all checks
+        if (this%name/=that%name) return
+        if (this%path/=that%path) return
+        if (allocated(this%git).neqv.allocated(that%git)) return
+        if (allocated(this%git)) then
+            if (.not.(this%git==that%git)) return
+        end if
+
+        !> All checks passed! The two instances are equal
+        has_changed = .false.
+
+    end function manifest_has_changed
+
 
 end module fpm_manifest_dependency