Use Aqua to ensure project quality (#222)

* Use Aqua to ensure project quality

* Tests for Block constructor

* sentence framing in comment

* eltype promotion in mortar

* Add tests

* remove extra quotation mark in docstring

Author: jishnub

Project.toml

@@ -8,17 +8,19 @@ FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 
 [compat]
+Aqua = "0.5"
 ArrayLayouts = "0.8.1"
 FillArrays = "0.13.2"
 julia = "1.6"
 
 [extras]
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [targets]
-test = ["Base64", "OffsetArrays", "SparseArrays", "StaticArrays", "Test", "Random"]
+test = ["Aqua", "Base64", "OffsetArrays", "SparseArrays", "StaticArrays", "Test", "Random"]

README.md

@@ -1,7 +1,8 @@
 # BlockArrays.jl
 
 [![Build Status](https://github.com/JuliaArrays/BlockArrays.jl/workflows/CI/badge.svg)](https://github.com/JuliaArrays/BlockArrays.jl/actions)
- [![codecov](https://codecov.io/gh/JuliaArrays/BlockArrays.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaArrays/BlockArrays.jl) [![](https://img.shields.io/badge/docs-stable-blue.svg)](https://JuliaArrays.github.io/BlockArrays.jl/stable) [![](https://img.shields.io/badge/docs-latest-blue.svg)](https://JuliaArrays.github.io/BlockArrays.jl/latest)
+[![codecov](https://codecov.io/gh/JuliaArrays/BlockArrays.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaArrays/BlockArrays.jl) [![](https://img.shields.io/badge/docs-stable-blue.svg)](https://JuliaArrays.github.io/BlockArrays.jl/stable) [![](https://img.shields.io/badge/docs-latest-blue.svg)](https://JuliaArrays.github.io/BlockArrays.jl/latest)
+[![Aqua QA](https://raw.githubusercontent.com/JuliaTesting/Aqua.jl/master/badge.svg)](https://github.com/JuliaTesting/Aqua.jl)
 
 
 A block array is a partition of an array into blocks or subarrays, see [wikipedia](https://en.wikipedia.org/wiki/Block_matrix) for a more extensive description. This package has two purposes. Firstly, it defines an interface for an `AbstractBlockArray` block arrays that can be shared among types representing different types of block arrays. The advantage to this is that it provides a consistent API for block arrays.

src/blockarray.jl

@@ -73,7 +73,7 @@ end
 # support non-concrete eltypes in blocks
 _BlockArray(blocks::R, block_axes::BS) where {N, R<:AbstractArray{<:AbstractArray{V,N} where V,N}, BS<:NTuple{N,AbstractUnitRange{Int}}} =
     _BlockArray(convert(AbstractArray{AbstractArray{mapreduce(eltype,promote_type,blocks),N},N}, blocks), block_axes)
-_BlockArray(blocks::R, block_sizes::Vararg{AbstractVector{<:Integer}, N}) where {N, R<:AbstractArray{<:AbstractArray{V,N} where V,N}} =
+_BlockArray(blocks::R, block_sizes::Vararg{AbstractVector{<:Integer}, N}) where {N, R<:AbstractArray{<:AbstractArray{<:Any,N},N}} =
     _BlockArray(convert(AbstractArray{AbstractArray{mapreduce(eltype,promote_type,blocks),N},N}, blocks), block_sizes...)
 
 const BlockMatrix{T, R <: AbstractMatrix{<:AbstractMatrix{T}}} = BlockArray{T, 2, R}
@@ -298,10 +298,12 @@ end
 Construct a `BlockMatrix` with `n * m`  blocks.  Each `block_ij` must be an
 `AbstractMatrix`.
 """
-mortar(rows::Vararg{NTuple{M, AbstractMatrix}}) where M =
-    mortar(permutedims(reshape(
-        foldl(append!, rows, init=eltype(eltype(rows))[]),
-        M, length(rows))))
+function mortar(row1::NTuple{M, AbstractMatrix}, rows::Vararg{NTuple{M, AbstractMatrix}}) where M
+    allrows = (row1, rows...)
+    allblocks = reduce((x,y)->(x...,y...), allrows)
+    allblocks_vector = [allblocks...]
+    mortar(permutedims(reshape(allblocks_vector, M, length(allrows))))
+end
 
 # Convert AbstractArrays that conform to block array interface
 convert(::Type{BlockArray{T,N,R}}, A::BlockArray{T,N,R}) where {T,N,R} = A

src/blockindices.jl

@@ -25,16 +25,24 @@ end
 
 Block{N, T}(n::Tuple{Vararg{Any, N}}) where {N,T} = Block{N, T}(convert(NTuple{N,T}, n))
 Block{N, T}(n::Vararg{Any, N}) where {N,T} = Block{N, T}(n)
-Block{N}(n::Vararg{T, N}) where {N,T} = Block{N, T}(n)
 Block{1, T}(n::Tuple{Any}) where {T} = Block{1, T}(convert(Tuple{T}, n))
 Block{0}() = Block{0,Int}()
 Block() = Block{0}()
 Block(n::Vararg{T, N}) where {N,T} = Block{N, T}(n)
-Block{1}(n::Tuple{T}) where {T} = Block{1, T}(n)
-Block{N}(n::NTuple{N, T}) where {N,T} = Block{N, T}(n)
-Block(n::NTuple{N, T}) where {N,T} = Block{N, T}(n)
-
-@inline Block(blocks::NTuple{N, Block{1, T}}) where {N,T} = Block{N, T}(ntuple(i -> blocks[i].n[1], Val(N)))
+Block{0}(n::Tuple{}) = Block{0, Int}()
+
+# These method have been defined for Tuple{A, Vararg{A}} instead of NTuple{N,A}
+# to get Aqua to recognize that these will never be called with an empty tuple
+# (or without any argument in the Vararg case).
+# See https://github.com/JuliaTesting/Aqua.jl/issues/86
+# Arguably, being clear about this is good style
+Block{N}(x::T, n::Vararg{T}) where {N,T} = Block{N, T}(x, n...)
+Block{N}(n::Tuple{T, Vararg{T}}) where {N,T} = Block{N, T}(n)
+Block(n::Tuple{T, Vararg{T}}) where {T} = Block{length(n), T}(n)
+@inline function Block(blocks::Tuple{Block{1, T}, Vararg{Block{1, T}}}) where {T}
+    N = length(blocks)
+    Block{N, T}(ntuple(i -> blocks[i].n[1], Val(N)))
+end
 @inline Block(::Tuple{}) = Block{0,Int}(())
 
 # iterate and broadcast like Number

src/blocklinalg.jl

@@ -1,5 +1,5 @@
 blockrowsupport(_, A, k) = blockaxes(A,2)
-""""
+"""
     blockrowsupport(A, k)
 
 gives an iterator containing the possible non-zero blocks in the k-th block-row of A.
@@ -9,7 +9,7 @@ blockrowsupport(A) = blockrowsupport(A, blockaxes(A,1))
 
 blockcolsupport(_, A, j) = Block.(colsupport(blocks(A), Int.(j)))
 
-""""
+"""
     blockcolsupport(A, j)
 
 gives an iterator containing the possible non-zero blocks in the j-th block-column of A.

src/blockproduct.jl

@@ -29,7 +29,7 @@ function khatri_rao(A::AbstractMatrix, B::AbstractMatrix)
     kron(A, B)
 end
 
-""""
+"""
     BlockKron(A...)
 
 creates a lazy representation of kron(A...) with the natural
@@ -106,7 +106,7 @@ blockrowsupport(K::BlockKron, J) = Block.(rowsupport(first(K.args), Int.(J)))
 _blockkron(_, A) = BlockArray(BlockKron(A...))
 
 
-""""
+"""
     blockkron(A...)
 
 creates a blocked version of kron(A...) with the natural

test/runtests.jl

@@ -1,6 +1,9 @@
 using BlockArrays, LinearAlgebra, Test
 
-
+using Aqua
+@testset "Project quality" begin
+    Aqua.test_all(BlockArrays, ambiguities=false)
+end
 
 include("test_blockindices.jl")
 include("test_blockarrays.jl")

test/test_blockarrays.jl

@@ -173,6 +173,13 @@ end
                      zeros(2,1), zeros(1,1), rand(4,1)], 3, 3);
                 @test @inferred BlockArrays.sizes_from_blocks(blocks) == ([2, 1, 4], [2, 3, 1])
             end
+
+            t1 = (ones(Float16, 2,2), ones(Float16, 2,2))
+            t2 = (ones(Float32, 2,2), ones(Float64, 2,2))
+            M = @inferred mortar(t1, t2)
+            @test M isa BlockMatrix{Float64}
+            @test size(M) == (4,4)
+            @test all(isone, M)
         end
 
         @testset "BlockVector" begin

test/test_blockindices.jl

@@ -4,6 +4,9 @@ import BlockArrays: BlockIndex, BlockIndexRange, BlockSlice
 @testset "Blocks" begin
     @test Int(Block(2)) === Integer(Block(2)) === Number(Block(2)) === 2
     @test Block((Block(3), Block(4))) === Block(3,4)
+    @test Block() === Block(()) === Block{0}() === Block{0}(())
+    @test Block(1) === Block((1,)) === Block{1}(1) === Block{1}((1,))
+    @test Block(1,2) === Block((1,2)) === Block{2}(1,2) === Block{2}((1,2))
 
     @testset "Block iterator" begin
         B = Block(3)