allow overriding metapackages with standard deps

Author: perazz

src/fpm/manifest/dependency.f90

@@ -29,7 +29,8 @@ module fpm_manifest_dependency
     use fpm_toml, only: toml_table, toml_key, toml_stat, get_value, check_keys
     use fpm_filesystem, only: windows_path, join_path
     use fpm_environment, only: get_os_type, OS_WINDOWS
-    use fpm_manifest_metapackages, only: metapackage_config_t, is_meta_package, new_meta_config
+    use fpm_manifest_metapackages, only: metapackage_config_t, is_meta_package, new_meta_config, &
+            metapackage_request_t, new_meta_request
     use fpm_versioning, only: version_t, new_version
     implicit none
     private
@@ -223,46 +224,74 @@ subroutine new_dependencies(deps, table, root, meta, error)
 
         type(toml_table), pointer :: node
         type(toml_key), allocatable :: list(:)
-        logical, allocatable :: non_meta(:)
+        type(dependency_config_t), allocatable :: all_deps(:)
+        type(metapackage_request_t) :: meta_request
+        logical, allocatable :: is_meta(:)
+        logical :: metapackages_allowed
         integer :: idep, stat, ndep
 
         call table%get_keys(list)
         ! An empty table is okay
         if (size(list) < 1) return
 
-        !> Count non-metapackage dependencies, and parse metapackage config
-        if (present(meta)) then
-            ndep = 0
-            do idep = 1, size(list)
-                if (is_meta_package(list(idep)%key)) cycle
-                ndep = ndep+1
-            end do
+        !> Flag dependencies that should be treated as metapackages
+        metapackages_allowed = present(meta)
+        allocate(is_meta(size(list)),source=.false.)
+        allocate(all_deps(size(list)))
 
-            !> Return metapackages config from this node
-            call new_meta_config(meta, table, error)
-            if (allocated(error)) return
-        else
-            ndep = size(list)
-        end if
-
-        ! Generate non-metapackage dependencies
-        allocate(deps(ndep))
-        ndep = 0
+        !> Parse all meta- and non-metapackage dependencies
         do idep = 1, size(list)
 
-            if (present(meta) .and. is_meta_package(list(idep)%key)) cycle
-
-            ndep = ndep+1
-
             call get_value(table, list(idep)%key, node, stat=stat)
             if (stat /= toml_stat%success) then
                 call syntax_error(error, "Dependency "//list(idep)%key//" must be a table entry")
                 exit
             end if
-            call new_dependency(deps(ndep), node, root, error)
-            if (allocated(error)) exit
+
+            ! Try to parse as a standard dependency
+            call new_dependency(all_deps(idep), node, root, error)
+
+            is_standard_dependency: if (.not.allocated(error)) then
+
+                ! If a valid git/local config is found, use it always
+                is_meta(idep) = .false.
+
+            elseif (metapackages_allowed .and. is_meta_package(list(idep)%key)) then
+
+                !> Metapackage name: Check if this is a valid metapackage request
+                call new_meta_request(meta_request, list(idep)%key, table, error=error)
+
+                !> Neither a standard dep nor a metapackage
+                if (allocated(error)) return
+
+                !> Valid meta dependency
+                is_meta(idep) = .true.
+
+            else
+
+                !> Not a standard dependency and not a metapackage: dump an error
+                call syntax_error(error, "Dependency "//list(idep)%key//" cannot be parsed. Check input format")
+                return
+
+            endif is_standard_dependency
+
+        end do
+
+        ! Non-meta dependencies
+        ndep = count(.not.is_meta)
+
+        ! Finalize standard dependencies
+        allocate(deps(ndep))
+        ndep = 0
+        do idep = 1, size(list)
+            if (is_meta(idep)) cycle
+            ndep = ndep+1
+            deps(ndep) = all_deps(idep)
         end do
 
+        ! Finalize meta dependencies
+        if (metapackages_allowed) call new_meta_config(meta,table,is_meta,error)
+
     end subroutine new_dependencies
 
     !> Write information on instance

src/fpm/manifest/meta.f90

@@ -16,6 +16,7 @@ module fpm_manifest_metapackages
     private
 
     public :: metapackage_config_t, new_meta_config, is_meta_package
+    public :: metapackage_request_t, new_meta_request
 
 
     !> Configuration data for a single metapackage request
@@ -95,7 +96,7 @@ subroutine request_parse(self, version_request, error)
     end subroutine request_parse
 
     !> Construct a new metapackage request from the dependencies table
-    subroutine new_request(self, key, table, error)
+    subroutine new_meta_request(self, key, table, meta_allowed, error)
 
         type(metapackage_request_t), intent(out) :: self
 
@@ -105,12 +106,16 @@ subroutine new_request(self, key, table, error)
         !> Instance of the TOML data structure
         type(toml_table), intent(inout) :: table
 
+        !> List of keys allowed to be metapackages
+        logical, intent(in), optional :: meta_allowed(:)
+
         !> Error handling
         type(error_t), allocatable, intent(out) :: error
 
 
         integer :: stat,i
         character(len=:), allocatable :: value
+        logical, allocatable :: allow_meta(:)
         type(toml_key), allocatable :: keys(:)
 
         call request_destroy(self)
@@ -127,7 +132,23 @@ subroutine new_request(self, key, table, error)
 
         call table%get_keys(keys)
 
+        !> Set list of entries that are allowed to be metapackages
+        if (present(meta_allowed)) then
+            if (size(meta_allowed)/=size(keys)) then
+                 call fatal_error(error,"Internal error: list of metapackage-enable entries does not match table size")
+                 return
+            end if
+            allow_meta = meta_allowed
+        else
+            allocate(allow_meta(size(keys)),source=.true.)
+        endif
+
+
         do i=1,size(keys)
+
+            ! Skip standard dependencies
+            if (.not.meta_allowed(i)) cycle
+
             if (keys(i)%key==key) then
                 call get_value(table, key, value)
                 if (.not. allocated(value)) then
@@ -143,34 +164,37 @@ subroutine new_request(self, key, table, error)
         ! Key is not present, metapackage not requested
         return
 
-    end subroutine new_request
+    end subroutine new_meta_request
 
     !> Construct a new build configuration from a TOML data structure
-    subroutine new_meta_config(self, table, error)
+    subroutine new_meta_config(self, table, meta_allowed, error)
 
         !> Instance of the build configuration
         type(metapackage_config_t), intent(out) :: self
 
         !> Instance of the TOML data structure
         type(toml_table), intent(inout) :: table
 
+        !> List of keys allowed to be metapackages
+        logical, intent(in) :: meta_allowed(:)
+
         !> Error handling
         type(error_t), allocatable, intent(out) :: error
 
         integer :: stat
 
         !> The toml table is not checked here because it already passed
         !> the "new_dependencies" check
-        call new_request(self%openmp, "openmp", table, error)
+        call new_meta_request(self%openmp, "openmp", table, meta_allowed, error)
         if (allocated(error)) return
 
-        call new_request(self%stdlib, "stdlib", table, error)
+        call new_meta_request(self%stdlib, "stdlib", table, meta_allowed, error)
         if (allocated(error)) return
 
-        call new_request(self%minpack, "minpack", table, error)
+        call new_meta_request(self%minpack, "minpack", table, meta_allowed, error)
         if (allocated(error)) return
 
-        call new_request(self%mpi, "mpi", table, error)
+        call new_meta_request(self%mpi, "mpi", table, meta_allowed, error)
         if (allocated(error)) return
 
     end subroutine new_meta_config