[libcalamares] Consistent namespace usage in partition service

- The sub-directories under libcalamares (e.g. Utils, ..)
   all live in namespace CalamaresUtils (well, except for Logger).
   The services (e.g. subdirs other than utils/) live in their
   own nested namespace, so partitioning should go into
   CalamaresUtils::Partition for consistency.

src/libcalamares/partition/PartitionSize.cpp

@@ -21,7 +21,9 @@
 #include "utils/Logger.h"
 #include "utils/Units.h"
 
-namespace Calamares
+namespace CalamaresUtils
+{
+namespace Partition
 {
 
 static const NamedEnumTable<SizeUnit>&
@@ -232,4 +234,5 @@ PartitionSize::operator== ( const PartitionSize& other ) const
     NOTREACHED return false;
 }
 
-} // namespace Calamares
+}
+}  // namespace

src/libcalamares/partition/PartitionSize.h

@@ -26,7 +26,9 @@
 // Qt
 #include <QString>
 
-namespace Calamares
+namespace CalamaresUtils
+{
+namespace Partition
 {
 
 enum class SizeUnit
@@ -98,9 +100,9 @@ public:
      * @return  the size in bytes, or -1 if it cannot be calculated.
      */
     qint64 toBytes() const;
-    
+
     /** @brief Are the units comparable?
-     * 
+     *
      * None units cannot be compared with anything. Percentages can
      * be compared with each other, and all the explicit sizes (KiB, ...)
      * can be compared with each other.
@@ -114,6 +116,7 @@ public:
 
 };
 
-} // namespace Calamares
+}
+}  // namespace
 
 #endif // PARTITION_PARTITIONSIZE_H

src/libcalamares/partition/Tests.cpp

@@ -20,7 +20,10 @@
 
 #include "PartitionSize.h"
 
-Q_DECLARE_METATYPE( Calamares::SizeUnit )
+using SizeUnit = CalamaresUtils::Partition::SizeUnit;
+using PartitionSize = CalamaresUtils::Partition::PartitionSize;
+
+Q_DECLARE_METATYPE( SizeUnit )
 
 #include "utils/Logger.h"
 
@@ -41,28 +44,26 @@ PartitionSizeTests::initTestCase()
 {
 }
 
-void 
+void
 PartitionSizeTests::testUnitComparison_data()
 {
-    QTest::addColumn<Calamares::SizeUnit>("u1");
+    QTest::addColumn<SizeUnit>("u1");
-    QTest::addColumn<Calamares::SizeUnit>("u2");
+    QTest::addColumn<SizeUnit>("u2");
     QTest::addColumn<bool>("comparable");
 
-    using Calamares::SizeUnit;
-    
     QTest::newRow("nones") << SizeUnit::None << SizeUnit::None << false;
     QTest::newRow("none+%") << SizeUnit::None << SizeUnit::Percent<< false;
     QTest::newRow("%+none") << SizeUnit::Percent << SizeUnit::None << false;
     QTest::newRow("KiB+none") << SizeUnit::KiB << SizeUnit::None << false;
     QTest::newRow("none+MiB") << SizeUnit::None << SizeUnit::MiB << false;
-    
+
     QTest::newRow("KiB+KiB") << SizeUnit::KiB << SizeUnit::KiB << true;
     QTest::newRow("KiB+MiB") << SizeUnit::KiB << SizeUnit::MiB << true;
     QTest::newRow("KiB+GiB") << SizeUnit::KiB << SizeUnit::GiB << true;
     QTest::newRow("MiB+MiB") << SizeUnit::MiB << SizeUnit::MiB << true;
     QTest::newRow("MiB+GiB") << SizeUnit::MiB << SizeUnit::GiB << true;
     QTest::newRow("GiB+GiB") << SizeUnit::GiB << SizeUnit::GiB << true;
-    
+
     QTest::newRow("%+None") << SizeUnit::Percent << SizeUnit::None << false;
     QTest::newRow("%+%") << SizeUnit::Percent << SizeUnit::Percent << true;
     QTest::newRow("%+KiB") << SizeUnit::Percent << SizeUnit::KiB << false;
@@ -70,53 +71,51 @@ PartitionSizeTests::testUnitComparison_data()
 
 
 static bool
-original_compare( Calamares::SizeUnit m_unit, Calamares::SizeUnit other_m_unit )
+original_compare( SizeUnit m_unit, SizeUnit other_m_unit )
 {
-    if ( ( m_unit == Calamares::SizeUnit::None    || other_m_unit == Calamares::SizeUnit::None    ) ||
+    if ( ( m_unit == SizeUnit::None    || other_m_unit == SizeUnit::None    ) ||
-         ( m_unit == Calamares::SizeUnit::Percent && other_m_unit != Calamares::SizeUnit::Percent ) ||
+         ( m_unit == SizeUnit::Percent && other_m_unit != SizeUnit::Percent ) ||
-         ( m_unit != Calamares::SizeUnit::Percent && other_m_unit == Calamares::SizeUnit::Percent ) )
+         ( m_unit != SizeUnit::Percent && other_m_unit == SizeUnit::Percent ) )
         return false;
     return true;
 }
 
-void 
+void
 PartitionSizeTests::testUnitComparison()
 {
-    QFETCH( Calamares::SizeUnit, u1 );
+    QFETCH( SizeUnit, u1 );
-    QFETCH( Calamares::SizeUnit, u2 );
+    QFETCH( SizeUnit, u2 );
     QFETCH( bool, comparable );
-    
+
     if ( comparable )
     {
-        QVERIFY( Calamares::PartitionSize::unitsComparable( u1, u2 ) );
+        QVERIFY( PartitionSize::unitsComparable( u1, u2 ) );
-        QVERIFY( Calamares::PartitionSize::unitsComparable( u2, u1 ) );
+        QVERIFY( PartitionSize::unitsComparable( u2, u1 ) );
     }
     else
     {
-        QVERIFY( !Calamares::PartitionSize::unitsComparable( u1, u2 ) );
+        QVERIFY( !PartitionSize::unitsComparable( u1, u2 ) );
-        QVERIFY( !Calamares::PartitionSize::unitsComparable( u2, u1 ) );
+        QVERIFY( !PartitionSize::unitsComparable( u2, u1 ) );
     }
-    
+
-    QCOMPARE( original_compare( u1, u2 ), Calamares::PartitionSize::unitsComparable( u1, u2 ) );
+    QCOMPARE( original_compare( u1, u2 ), PartitionSize::unitsComparable( u1, u2 ) );
 }
 
-void 
+void
 PartitionSizeTests::testUnitNormalisation_data()
 {
-    QTest::addColumn<Calamares::SizeUnit>("u1");
+    QTest::addColumn<SizeUnit>("u1");
     QTest::addColumn<int>("v");
     QTest::addColumn<long>("bytes");
-    
+
-    using Calamares::SizeUnit;
-    
     QTest::newRow("none") << SizeUnit::None << 16 << -1L;
     QTest::newRow("none") << SizeUnit::None << 0 << -1L;
     QTest::newRow("none") << SizeUnit::None << -2 << -1L;
-    
+
     QTest::newRow("percent") << SizeUnit::Percent << 0 << -1L;
     QTest::newRow("percent") << SizeUnit::Percent << 16 << -1L;
     QTest::newRow("percent") << SizeUnit::Percent << -2 << -1L;
-    
+
     QTest::newRow("KiB") << SizeUnit::KiB << 0 << -1L;
     QTest::newRow("KiB") << SizeUnit::KiB << 1 << 1024L;
     QTest::newRow("KiB") << SizeUnit::KiB << 1000 << 1024000L;
@@ -134,12 +133,12 @@ PartitionSizeTests::testUnitNormalisation_data()
     QTest::newRow("GiB") << SizeUnit::GiB << 2 << 2048 * 1024 * 1024L;
 }
 
-void 
+void
 PartitionSizeTests::testUnitNormalisation()
 {
-    QFETCH( Calamares::SizeUnit, u1 );
+    QFETCH( SizeUnit, u1 );
     QFETCH( int, v );
     QFETCH( long, bytes );
-    
+
-    QCOMPARE( Calamares::PartitionSize( v, u1 ).toBytes(), static_cast<qint64>( bytes ) );
+    QCOMPARE( PartitionSize( v, u1 ).toBytes(), static_cast<qint64>( bytes ) );
 }

src/modules/fsresizer/ResizeFSJob.cpp

@@ -272,8 +272,8 @@ ResizeFSJob::setConfigurationMap( const QVariantMap& configurationMap )
         return;
     }
 
-    m_size = Calamares::PartitionSize( configurationMap["size"].toString() );
+    m_size = PartitionSize( configurationMap["size"].toString() );
-    m_atleast = Calamares::PartitionSize( configurationMap["atleast"].toString() );
+    m_atleast = PartitionSize( configurationMap["atleast"].toString() );
 
     m_required = CalamaresUtils::getBool( configurationMap, "required", false );
 }

src/modules/fsresizer/ResizeFSJob.h

@@ -33,6 +33,8 @@ class CoreBackend;  // From KPMCore
 class Device;  // From KPMCore
 class Partition;
 
+using PartitionSize = CalamaresUtils::Partition::PartitionSize;
+
 class PLUGINDLLEXPORT ResizeFSJob : public Calamares::CppJob
 {
     Q_OBJECT
@@ -59,19 +61,19 @@ public:
         return m_fsname.isEmpty() ? m_devicename : m_fsname;
     }
 
-    Calamares::PartitionSize size() const
+    PartitionSize size() const
     {
         return m_size;
     }
 
-    Calamares::PartitionSize minimumSize() const
+    PartitionSize minimumSize() const
     {
         return m_atleast;
     }
 
 private:
-    Calamares::PartitionSize m_size;
+    PartitionSize m_size;
-    Calamares::PartitionSize m_atleast;
+    PartitionSize m_atleast;
     QString m_fsname;  // Either this, or devicename, is set, not both
     QString m_devicename;
     bool m_required;

src/modules/fsresizer/Tests.cpp

@@ -18,6 +18,8 @@
 
 #include "Tests.h"
 
+#include "ResizeFSJob.h"
+
 #include "GlobalStorage.h"
 #include "JobQueue.h"
 #include "Settings.h"
@@ -30,7 +32,7 @@
 #include <QFileInfo>
 #include <QStringList>
 
-#include "ResizeFSJob.h"
+using SizeUnit = CalamaresUtils::Partition::SizeUnit;
 
 QTEST_GUILESS_MAIN( FSResizerTests )
 
@@ -54,8 +56,8 @@ void FSResizerTests::testConfigurationRobust()
     // Empty config
     j.setConfigurationMap( QVariantMap() );
     QVERIFY( j.name().isEmpty() );
-    QCOMPARE( j.size().unit(), Calamares::SizeUnit::None );
+    QCOMPARE( j.size().unit(), SizeUnit::None );
-    QCOMPARE( j.minimumSize().unit(), Calamares::SizeUnit::None );
+    QCOMPARE( j.minimumSize().unit(), SizeUnit::None );
 
     // Config is missing fs and dev, so it isn't valid
     YAML::Node doc0 = YAML::Load( R"(---
@@ -64,8 +66,8 @@ atleast: 600MiB
 )" );
     j.setConfigurationMap( CalamaresUtils::yamlMapToVariant( doc0 ).toMap() );
     QVERIFY( j.name().isEmpty() );
-    QCOMPARE( j.size().unit(), Calamares::SizeUnit::None );
+    QCOMPARE( j.size().unit(), SizeUnit::None );
-    QCOMPARE( j.minimumSize().unit(), Calamares::SizeUnit::None );
+    QCOMPARE( j.minimumSize().unit(), SizeUnit::None );
     QCOMPARE( j.size().value(), 0 );
     QCOMPARE( j.minimumSize().value(), 0 );
 }
@@ -82,8 +84,8 @@ atleast: 600MiB
 )" );
     j.setConfigurationMap( CalamaresUtils::yamlMapToVariant( doc0 ).toMap() );
     QVERIFY( j.name().isEmpty() );
-    QCOMPARE( j.size().unit(), Calamares::SizeUnit::Percent );
+    QCOMPARE( j.size().unit(), SizeUnit::Percent );
-    QCOMPARE( j.minimumSize().unit(), Calamares::SizeUnit::MiB );
+    QCOMPARE( j.minimumSize().unit(), SizeUnit::MiB );
     QCOMPARE( j.size().value(), 100 );
     QCOMPARE( j.minimumSize().value(), 600 );
 
@@ -96,8 +98,8 @@ atleast: 127 %
 )" );
     j.setConfigurationMap( CalamaresUtils::yamlMapToVariant( doc0 ).toMap() );
     QVERIFY( !j.name().isEmpty() );
-    QCOMPARE( j.size().unit(), Calamares::SizeUnit::MiB );
+    QCOMPARE( j.size().unit(), SizeUnit::MiB );
-    QCOMPARE( j.minimumSize().unit(), Calamares::SizeUnit::None );
+    QCOMPARE( j.minimumSize().unit(), SizeUnit::None );
     QCOMPARE( j.size().value(), 72 );
     QCOMPARE( j.minimumSize().value(), 0 );
 
@@ -110,8 +112,8 @@ size: 71MiB
 )" );
     j.setConfigurationMap( CalamaresUtils::yamlMapToVariant( doc0 ).toMap() );
     QVERIFY( j.name().isEmpty() );
-    QCOMPARE( j.size().unit(), Calamares::SizeUnit::MiB );
+    QCOMPARE( j.size().unit(), SizeUnit::MiB );
-    QCOMPARE( j.minimumSize().unit(), Calamares::SizeUnit::None );
+    QCOMPARE( j.minimumSize().unit(), SizeUnit::None );
     QCOMPARE( j.size().value(), 71 );
     QCOMPARE( j.minimumSize().value(), 0 );
 }

src/modules/partition/core/PartitionActions.cpp

@@ -103,7 +103,7 @@ doAutopartition( PartitionCoreModule* core, Device* dev, Choices::AutoPartitionO
     {
         if ( gs->contains( "efiSystemPartitionSize" ) )
         {
-            Calamares::PartitionSize part_size = Calamares::PartitionSize(
+            CalamaresUtils::Partition::PartitionSize part_size = CalamaresUtils::Partition::PartitionSize(
                     gs->value( "efiSystemPartitionSize" ).toString() );
             uefisys_part_sizeB = part_size.toBytes( dev->capacity() );
         }

src/modules/partition/core/PartitionLayout.cpp

@@ -86,10 +86,10 @@ PartitionLayout::addEntry( PartitionLayout::PartitionEntry entry )
 }
 
 PartitionLayout::PartitionEntry::PartitionEntry( const QString& size, const QString& min, const QString& max )
+    : partSize( size )
+    , partMinSize( min )
+    , partMaxSize( max )
 {
-    partSize = Calamares::PartitionSize( size );
-    partMinSize = Calamares::PartitionSize( min );
-    partMaxSize = Calamares::PartitionSize( max );
 }
 
 bool

src/modules/partition/core/PartitionLayout.h

@@ -43,9 +43,9 @@ public:
         QString partLabel;
         QString partMountPoint;
         FileSystem::Type partFileSystem = FileSystem::Unknown;
-        Calamares::PartitionSize partSize;
+        CalamaresUtils::Partition::PartitionSize partSize;
-        Calamares::PartitionSize partMinSize;
+        CalamaresUtils::Partition::PartitionSize partMinSize;
-        Calamares::PartitionSize partMaxSize;
+        CalamaresUtils::Partition::PartitionSize partMaxSize;
 
         /// @brief All-zeroes PartitionEntry
         PartitionEntry() {}