From 76480b7625dbcd9074babefc248d87e336f13071 Mon Sep 17 00:00:00 2001 From: Sindre Sorhus Date: Fri, 21 Feb 2020 19:11:54 +0700 Subject: [PATCH] Rename to `Percentage` #1 --- .../{Percent.xcscheme => Percentage.xcscheme} | 32 +++++----- Package.swift | 12 ++-- .../Percentage.swift} | 62 +++++++++---------- .../PercentageTests.swift} | 28 ++++----- readme.md | 16 ++--- 5 files changed, 74 insertions(+), 76 deletions(-) rename .swiftpm/xcode/xcshareddata/xcschemes/{Percent.xcscheme => Percentage.xcscheme} (78%) rename Sources/{Percent/Percent.swift => Percentage/Percentage.swift} (71%) rename Tests/{PercentTests/PercentTests.swift => PercentageTests/PercentageTests.swift} (81%) diff --git a/.swiftpm/xcode/xcshareddata/xcschemes/Percent.xcscheme b/.swiftpm/xcode/xcshareddata/xcschemes/Percentage.xcscheme similarity index 78% rename from .swiftpm/xcode/xcshareddata/xcschemes/Percent.xcscheme rename to .swiftpm/xcode/xcshareddata/xcschemes/Percentage.xcscheme index 715adaa..82bd04d 100644 --- a/.swiftpm/xcode/xcshareddata/xcschemes/Percent.xcscheme +++ b/.swiftpm/xcode/xcshareddata/xcschemes/Percentage.xcscheme @@ -1,6 +1,6 @@ @@ -28,9 +28,9 @@ buildForAnalyzing = "YES"> @@ -40,17 +40,15 @@ buildConfiguration = "Debug" selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB" - shouldUseLaunchSchemeArgsEnv = "YES" - codeCoverageEnabled = "YES"> + shouldUseLaunchSchemeArgsEnv = "YES"> + skipped = "NO"> @@ -76,9 +74,9 @@ diff --git a/Package.swift b/Package.swift index 5fbfcfa..522ecc8 100644 --- a/Package.swift +++ b/Package.swift @@ -2,23 +2,23 @@ import PackageDescription let package = Package( - name: "Percent", + name: "Percentage", products: [ .library( - name: "Percent", + name: "Percentage", targets: [ - "Percent" + "Percentage" ] ), ], targets: [ .target( - name: "Percent" + name: "Percentage" ), .testTarget( - name: "PercentTests", + name: "PercentageTests", dependencies: [ - "Percent" + "Percentage" ] ) ] diff --git a/Sources/Percent/Percent.swift b/Sources/Percentage/Percentage.swift similarity index 71% rename from Sources/Percent/Percent.swift rename to Sources/Percentage/Percentage.swift index c23ecbe..33490d1 100644 --- a/Sources/Percent/Percent.swift +++ b/Sources/Percentage/Percentage.swift @@ -3,7 +3,7 @@ import CoreGraphics /** ``` -import Percent +import Percentage 10% + 5.5% //=> 15.5% @@ -20,10 +20,10 @@ import Percent 50%.of(200) //=> 100 -Percent(50) +Percentage(50) //=> 50% -Percent(fraction: 0.5) +Percentage(fraction: 0.5) //=> 50% 50%.fraction @@ -36,9 +36,9 @@ print("\(1%)") //=> "1%" ``` */ -public struct Percent: Hashable, Codable { +public struct Percentage: Hashable, Codable { /** - The raw percent number. + The raw percentage number. ``` 10%.rawValue @@ -48,7 +48,7 @@ public struct Percent: Hashable, Codable { public let rawValue: Double /** - Get the percent as a fraction. + Get the percentage as a fraction. ``` 50%.fraction @@ -58,48 +58,48 @@ public struct Percent: Hashable, Codable { public var fraction: Double { rawValue / 100 } /** - Create a `Percent` from a `Double`. + Create a `Percentage` from a `Double`. ``` - Percent(50.5) + Percentage(50.5) //=> 50.5% ``` */ - public init(_ percent: Double) { - self.rawValue = percent + public init(_ percentage: Double) { + self.rawValue = percentage } /** - Create a `Percent` from a `CGFloat`. + Create a `Percentage` from a `CGFloat`. ``` let cgFloat: CGFloat = 50.5 - Percent(cgFloat) + Percentage(cgFloat) //=> 50.5% ``` */ - public init(_ percent: CGFloat) { - self.rawValue = Double(percent) + public init(_ percentage: CGFloat) { + self.rawValue = Double(percentage) } /** - Create a `Percent` from an `Int`. + Create a `Percentage` from an `Int`. ``` let int = 50 - Percent(int) + Percentage(int) //=> 50% ``` */ - public init(_ percent: Int) { - self.rawValue = Double(percent) + public init(_ percentage: Int) { + self.rawValue = Double(percentage) } /** - Create a `Percent` from a fraction. + Create a `Percentage` from a fraction. ``` - Percent(fraction: 0.5) + Percentage(fraction: 0.5) //=> "50%" ``` */ @@ -108,7 +108,7 @@ public struct Percent: Hashable, Codable { } /** - Returns how much the percent of the given value is. + Returns how much the percentage of the given value is. ``` 50%.of(200) @@ -118,19 +118,19 @@ public struct Percent: Hashable, Codable { public func of(_ value: Double) -> Double { value * rawValue / 100 } } -extension Percent: RawRepresentable { +extension Percentage: RawRepresentable { public init(rawValue: Double) { self.rawValue = rawValue } } -extension Percent: Comparable { +extension Percentage: Comparable { public static func < (lhs: Self, rhs: Self) -> Bool { lhs.rawValue < rhs.rawValue } } -extension Percent: CustomStringConvertible { +extension Percentage: CustomStringConvertible { internal static var formatter: NumberFormatter = { let formatter = NumberFormatter() formatter.numberStyle = .percent @@ -145,22 +145,22 @@ extension Percent: CustomStringConvertible { // swiftlint:disable static_operator prefix operator - -public prefix func - (percent: Percent) -> Percent { - return Percent(-percent.rawValue) +public prefix func - (percentage: Percentage) -> Percentage { + return Percentage(-percentage.rawValue) } postfix operator % -public postfix func % (value: Double) -> Percent { - return Percent(value) +public postfix func % (value: Double) -> Percentage { + return Percentage(value) } -public postfix func % (value: Int) -> Percent { - return Percent(Double(value)) +public postfix func % (value: Int) -> Percentage { + return Percentage(Double(value)) } // swiftlint:enable static_operator -extension Percent { +extension Percentage { public static func + (lhs: Self, rhs: Self) -> Self { Self(lhs.rawValue + rhs.rawValue) } diff --git a/Tests/PercentTests/PercentTests.swift b/Tests/PercentageTests/PercentageTests.swift similarity index 81% rename from Tests/PercentTests/PercentTests.swift rename to Tests/PercentageTests/PercentageTests.swift index afec2b2..057ea77 100644 --- a/Tests/PercentTests/PercentTests.swift +++ b/Tests/PercentageTests/PercentageTests.swift @@ -1,24 +1,24 @@ import XCTest -@testable import Percent +@testable import Percentage -final class PercentTests: XCTestCase { - func testPercent() { +final class PercentageTests: XCTestCase { + func testPercentage() { XCTAssertEqual(10%, 10%) XCTAssertEqual(-10% / 2, -5%) XCTAssertEqual(1.1%.rawValue, 1.1) XCTAssertEqual(10% + 5.5%, 15.5%) XCTAssertEqual((40% + 93%) * 3, 399%) XCTAssertEqual(50%.of(200), 100) - XCTAssertEqual(Percent(50.5), 50.5%) - XCTAssertEqual(Percent(rawValue: 50.5), 50.5%) + XCTAssertEqual(Percentage(50.5), 50.5%) + XCTAssertEqual(Percentage(rawValue: 50.5), 50.5%) let int = 50 - XCTAssertEqual(Percent(int), 50%) + XCTAssertEqual(Percentage(int), 50%) let cgFloat: CGFloat = 50.5 - XCTAssertEqual(Percent(cgFloat), 50.5%) + XCTAssertEqual(Percentage(cgFloat), 50.5%) - XCTAssertEqual(Percent(fraction: 0.5), 50%) + XCTAssertEqual(Percentage(fraction: 0.5), 50%) XCTAssertEqual(50%.fraction, 0.5) XCTAssertTrue(30% > 25%) @@ -76,7 +76,7 @@ final class PercentTests: XCTestCase { func testCodable() { struct Foo: Codable { - let alpha: Percent + let alpha: Percentage } let foo = Foo(alpha: 1%) @@ -91,26 +91,26 @@ final class PercentTests: XCTestCase { formatter.numberStyle = .percent formatter.locale = Locale(identifier: "ru") - Percent.formatter = formatter + Percentage.formatter = formatter XCTAssertEqual("\(50%)", formatter.string(for: 50%.fraction)) XCTAssertEqual("\(1%)", formatter.string(for: 1%.fraction)) formatter.locale = Locale(identifier: "tr") - Percent.formatter = formatter + Percentage.formatter = formatter XCTAssertEqual("\(50%)", formatter.string(for: 50%.fraction)) XCTAssertEqual("\(1%)", formatter.string(for: 1%.fraction)) formatter.locale = Locale(identifier: "eu") - Percent.formatter = formatter + Percentage.formatter = formatter XCTAssertEqual("\(50%)", formatter.string(for: 50%.fraction)) XCTAssertEqual("\(1%)", formatter.string(for: 1%.fraction)) formatter.locale = Locale(identifier: "ar") - Percent.formatter = formatter + Percentage.formatter = formatter XCTAssertEqual("\(50%)", formatter.string(for: 50%.fraction)) XCTAssertEqual("\(1%)", formatter.string(for: 1%.fraction)) formatter.locale = Locale.current - Percent.formatter = formatter + Percentage.formatter = formatter } } diff --git a/readme.md b/readme.md index 3ede2a4..c603757 100644 --- a/readme.md +++ b/readme.md @@ -1,4 +1,4 @@ -# Percent [![Build Status](https://travis-ci.com/sindresorhus/Percent.svg?branch=master)](https://travis-ci.com/sindresorhus/Percent) +# Percentage [![Build Status](https://travis-ci.com/sindresorhus/Percentage.svg?branch=master)](https://travis-ci.com/sindresorhus/Percentage) > A percentage type for Swift @@ -15,7 +15,7 @@ Makes percentages more readable and type-safe, for example, for APIs that curren SwiftPM: ```swift -.package(url: "https://github.com/sindresorhus/Percent", from: "0.2.0") +.package(url: "https://github.com/sindresorhus/Percentage", from: "0.2.0") ``` Or just copy-paste it. @@ -23,10 +23,10 @@ Or just copy-paste it. ## Usage -See the [source](Sources/Percent/Percent.swift) for docs. +See the [source](Sources/Percentage/Percentage.swift) for docs. ```swift -import Percent +import Percentage 10% + 5.5% //=> 15.5% @@ -43,10 +43,10 @@ import Percent 50%.of(200) //=> 100 -Percent(50) +Percentage(50) //=> 50% -Percent(fraction: 0.5) +Percentage(fraction: 0.5) //=> 50% 50%.fraction @@ -63,11 +63,11 @@ The type conforms to `Hashable`, `Codable`, `RawRepresentable`, `Comparable`, an ### Codable -The percent value is encoded as a single value: +The percentage value is encoded as a single value: ```swift struct Foo: Codable { - let alpha: Percent + let alpha: Percentage } let foo = Foo(alpha: 1%)