Merge pull request #13 from PlugFox/develop

3.1.0

Author: PlugFox

.github/workflows/main.yml

@@ -2,15 +2,15 @@ name: platform_info
 
 on:
   push:
-    branches: [ master, dev, feature/null_safety ]
+    branches: [ master, dev, feature/** ]
   pull_request:
-    branches: [ master, dev, feature/null_safety ]
+    branches: [ master, dev, feature/** ]
 
 jobs:
-  build:
+  check:
     runs-on: ubuntu-latest
     container:
-      image: google/dart:2.12
+      image: google/dart:latest
     steps:
       - uses: actions/checkout@v2
         with:
@@ -22,7 +22,10 @@ jobs:
       - name: Check analyzer
         run: dart analyze --fatal-infos --fatal-warnings .
       - name: Run tests
-        run: dart test --coverage=coverage && dart run coverage:format_coverage --lcov --in=coverage --out=coverage/lcov.info --packages=.packages --report-on=lib
+        run: |
+          dart test --coverage=coverage \
+            && dart run coverage:format_coverage --lcov --in=coverage \
+            --out=coverage/lcov.info --packages=.packages --report-on=lib
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v1
         with:

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 3.1.0 - 2021-05-29 
+### Added  
+- Extensions for enums BuildMode, HostPlatformType, OperatingSystem
+
 ## 3.0.0 - 2021-03-27 
 ### Changed  
 - Non nullable ready  

lib/src/enums.dart

@@ -13,6 +13,49 @@ enum BuildMode {
   debug
 }
 
+/// Build mode extension
+extension BuildModeX on BuildMode {
+  /// Is release build mode
+  bool get isRelease => this == BuildMode.release;
+
+  /// Is profile build mode
+  bool get isProfile => this == BuildMode.profile;
+
+  /// Is debug build mode
+  bool get isDebug => this == BuildMode.debug;
+
+  /// Run callback on specific build mode
+  BuildModeResult when<BuildModeResult extends Object?>({
+    required BuildModeResult Function() release,
+    required BuildModeResult Function() profile,
+    required BuildModeResult Function() debug,
+  }) {
+    switch (this) {
+      case BuildMode.profile:
+        return profile();
+      case BuildMode.debug:
+        return debug();
+      case BuildMode.release:
+      default:
+        return release();
+    }
+  }
+
+  /// Run callback on specific build mode,
+  /// if not specified run orElse
+  BuildModeResult maybeWhen<BuildModeResult extends Object?>({
+    required BuildModeResult Function() orElse,
+    BuildModeResult Function()? release,
+    BuildModeResult Function()? profile,
+    BuildModeResult Function()? debug,
+  }) =>
+      when<BuildModeResult>(
+        debug: debug ?? orElse,
+        profile: profile ?? orElse,
+        release: release ?? orElse,
+      );
+}
+
 /// Host platform type
 ///  + io (vm, desktops, mobile, console)
 ///  + web (html, js, browser)
@@ -24,6 +67,22 @@ enum HostPlatformType {
   web,
 }
 
+/// Host platform extension
+extension HostPlatformTypeX on HostPlatformType {
+  /// Is I/O (vm, desktops, mobile, console)
+  bool get isIO => this == HostPlatformType.io;
+
+  /// Is Web (html, js, browser)
+  bool get isWeb => this == HostPlatformType.web;
+
+  /// Run callback on specific host platform
+  HostPlatformTypeResult when<HostPlatformTypeResult extends Object?>({
+    required HostPlatformTypeResult Function() io,
+    required HostPlatformTypeResult Function() web,
+  }) =>
+      this == HostPlatformType.web ? web() : io();
+}
+
 /// Operation system
 ///  + Fuchsia
 ///  + Linux
@@ -54,3 +113,77 @@ enum OperatingSystem {
   /// Fuchsia
   fuchsia,
 }
+
+/// Operation system extension
+extension OperatingSystemX on OperatingSystem {
+  /// Android
+  bool get isAndroid => this == OperatingSystem.android;
+
+  /// Fuchsia
+  bool get isFuchsia => this == OperatingSystem.fuchsia;
+
+  /// iOS
+  bool get isIOS => this == OperatingSystem.iOS;
+
+  /// Linux
+  bool get isLinux => this == OperatingSystem.linux;
+
+  /// MacOS
+  bool get isMacOS => this == OperatingSystem.macOS;
+
+  /// Windows
+  bool get isWindows => this == OperatingSystem.windows;
+
+  /// Unknown
+  bool get isUnknown => this == OperatingSystem.unknown;
+
+  /// Run callback on specific operation system
+  OperatingSystemResult when<OperatingSystemResult extends Object?>({
+    required OperatingSystemResult Function() android,
+    required OperatingSystemResult Function() fuchsia,
+    required OperatingSystemResult Function() iOS,
+    required OperatingSystemResult Function() linux,
+    required OperatingSystemResult Function() macOS,
+    required OperatingSystemResult Function() windows,
+    required OperatingSystemResult Function() unknown,
+  }) {
+    switch (this) {
+      case OperatingSystem.windows:
+        return windows();
+      case OperatingSystem.linux:
+        return linux();
+      case OperatingSystem.macOS:
+        return macOS();
+      case OperatingSystem.iOS:
+        return iOS();
+      case OperatingSystem.android:
+        return android();
+      case OperatingSystem.fuchsia:
+        return fuchsia();
+      case OperatingSystem.unknown:
+      default:
+        return unknown();
+    }
+  }
+
+  /// Run callback on specific operation system,
+  /// if not specified run orElse
+  OperatingSystemResult maybeWhen<OperatingSystemResult extends Object?>({
+    required OperatingSystemResult Function() orElse,
+    OperatingSystemResult Function()? android,
+    OperatingSystemResult Function()? fuchsia,
+    OperatingSystemResult Function()? iOS,
+    OperatingSystemResult Function()? linux,
+    OperatingSystemResult Function()? macOS,
+    OperatingSystemResult Function()? windows,
+  }) =>
+      when<OperatingSystemResult>(
+        android: android ?? orElse,
+        fuchsia: fuchsia ?? orElse,
+        iOS: iOS ?? orElse,
+        linux: linux ?? orElse,
+        macOS: macOS ?? orElse,
+        windows: windows ?? orElse,
+        unknown: orElse,
+      );
+}

lib/src/platform.dart

@@ -145,7 +145,7 @@ class Platform extends ExtendedHostPlatform with PlatformMethods {
   Platform._internal({
     required this.buildMode,
     required HostPlatform hostPlatform,
-  })   : _hostPlatform = hostPlatform,
+  })  : _hostPlatform = hostPlatform,
         isOperatingSystemKnown =
             hostPlatform.operatingSystem != OperatingSystem.unknown,
         isMobile = kListOSForMobile.contains(hostPlatform.operatingSystem),

pubspec.yaml

@@ -2,7 +2,7 @@ name: platform_info
 description: >
   Contains info about current platform
   such as Build mode and Operating system.
-version: 3.0.0
+version: 3.1.0
 repository: https://github.com/PlugFox/platform_info/tree/master
 issue_tracker: https://github.com/PlugFox/platform_info/issues
 homepage: https://github.com/PlugFox/platform_info
@@ -16,5 +16,5 @@ dependencies:
   meta: ^1.3.0
 
 dev_dependencies:
-  coverage: ^0.14.2
+  coverage: '>=0.14.2 <2.0.0'
   test: ^1.16.0

test/platform_info_test.dart

@@ -287,4 +287,132 @@ void main() {
       );
     });
   });
+
+  group('Enum extensions', () {
+    test('BuildMode', () {
+      expect(BuildMode.release.isRelease, isTrue);
+      expect(BuildMode.profile.isProfile, isTrue);
+      expect(BuildMode.debug.isDebug, isTrue);
+      expect(
+        BuildMode.release.maybeWhen(
+          orElse: () => false,
+          debug: () => false,
+          profile: () => false,
+          release: () => true,
+        ),
+        isTrue,
+      );
+      expect(
+        BuildMode.profile.maybeWhen(
+          orElse: () => false,
+          debug: () => false,
+          profile: () => true,
+          release: () => false,
+        ),
+        isTrue,
+      );
+      expect(
+        BuildMode.debug.maybeWhen(
+          orElse: () => false,
+          debug: () => true,
+          profile: () => false,
+          release: () => false,
+        ),
+        isTrue,
+      );
+      expect(
+        BuildMode.debug.maybeWhen(
+          orElse: () => true,
+          release: () => false,
+          profile: () => false,
+        ),
+        isTrue,
+      );
+    });
+
+    test('HostPlatformType', () {
+      expect(HostPlatformType.io.isIO, isTrue);
+      expect(HostPlatformType.web.isWeb, isTrue);
+      expect(
+        HostPlatformType.io.when(
+          io: () => true,
+          web: () => false,
+        ),
+        isTrue,
+      );
+      expect(
+        HostPlatformType.web.when(
+          io: () => false,
+          web: () => true,
+        ),
+        isTrue,
+      );
+    });
+
+    test('OperatingSystem', () {
+      expect(OperatingSystem.fuchsia.isFuchsia, isTrue);
+      expect(OperatingSystem.unknown.isUnknown, isTrue);
+      expect(OperatingSystem.android.isAndroid, isTrue);
+      expect(OperatingSystem.iOS.isIOS, isTrue);
+      expect(OperatingSystem.linux.isLinux, isTrue);
+      expect(OperatingSystem.macOS.isMacOS, isTrue);
+      expect(OperatingSystem.windows.isWindows, isTrue);
+
+      expect(
+        OperatingSystem.fuchsia.maybeWhen(
+          fuchsia: () => true,
+          orElse: () => false,
+        ),
+        isTrue,
+      );
+
+      expect(
+        OperatingSystem.windows.maybeWhen(
+          windows: () => true,
+          orElse: () => false,
+        ),
+        isTrue,
+      );
+
+      expect(
+        OperatingSystem.macOS.maybeWhen(
+          macOS: () => true,
+          orElse: () => false,
+        ),
+        isTrue,
+      );
+
+      expect(
+        OperatingSystem.linux.maybeWhen(
+          linux: () => true,
+          orElse: () => false,
+        ),
+        isTrue,
+      );
+
+      expect(
+        OperatingSystem.iOS.maybeWhen(
+          iOS: () => true,
+          orElse: () => false,
+        ),
+        isTrue,
+      );
+
+      expect(
+        OperatingSystem.android.maybeWhen(
+          android: () => true,
+          orElse: () => false,
+        ),
+        isTrue,
+      );
+
+      expect(
+        OperatingSystem.unknown.maybeWhen(
+          fuchsia: () => false,
+          orElse: () => true,
+        ),
+        isTrue,
+      );
+    });
+  });
 }