diff --git "a/Source/Color \302\267 EightBit.swift" "b/Source/Color \302\267 EightBit.swift" index d5fe6874..2b9d756e 100644 --- "a/Source/Color \302\267 EightBit.swift" +++ "b/Source/Color \302\267 EightBit.swift" @@ -6,7 +6,7 @@ extension Color { public var code: (enable: [UInt8], disable: UInt8?) { return ( enable: [ - (self.level == .Foreground ? 38 : 48), + (self.level == .foreground ? 38 : 48), 5, self.color ], @@ -18,14 +18,14 @@ extension Color { foreground color: UInt8 ) { self.color = color - self.level = Level.Foreground + self.level = Level.foreground } public init( background color: UInt8 ) { self.color = color - self.level = Level.Background + self.level = Level.background } } diff --git "a/Source/Color \302\267 Named.swift" "b/Source/Color \302\267 Named.swift" index 25b71ef7..e78b7981 100644 --- "a/Source/Color \302\267 Named.swift" +++ "b/Source/Color \302\267 Named.swift" @@ -1,41 +1,41 @@ extension Color { public struct Named: Parameter, ColorType { public enum Color: UInt8 { - case Black = 30 - case Red - case Green - case Yellow - case Blue - case Magenta - case Cyan - case White + case black = 30 + case red + case green + case yellow + case blue + case magenta + case cyan + case white } public enum Brightness { - case Bright - case NonBright + case bright + case nonBright - public var additive: UInt8 { return self == .Bright ? 60 : 0 } + public var additive: UInt8 { return self == .bright ? 60 : 0 } public mutating func toggle() { switch self { - case .Bright: self = .NonBright - case .NonBright: self = .Bright + case .bright: self = .nonBright + case .nonBright: self = .bright } } } public var color: Color - public var brightness = Brightness.NonBright - public var level = Level.Foreground + public var brightness = Brightness.nonBright + public var level = Level.foreground public var code: (enable: [UInt8], disable: UInt8?) { return ( enable: [ self.color.rawValue + self.brightness.additive + - (self.level == .Foreground ? 0 : 10) + (self.level == .foreground ? 0 : 10) ], disable: nil ) @@ -43,20 +43,20 @@ extension Color { public init( foreground color: Color, - brightness: Brightness = .NonBright + brightness: Brightness = .nonBright ) { self.color = color self.brightness = brightness - self.level = Level.Foreground + self.level = Level.foreground } public init( background color: Color, - brightness: Brightness = .NonBright + brightness: Brightness = .nonBright ) { self.color = color self.brightness = brightness - self.level = Level.Background + self.level = Level.background } } diff --git a/Source/Color.swift b/Source/Color.swift index 5f3d7b15..f4a9466e 100644 --- a/Source/Color.swift +++ b/Source/Color.swift @@ -7,14 +7,14 @@ public protocol ColorType: Parameter { /// Foreground/Background public enum Level { - case Foreground - case Background + case foreground + case background public mutating func toggle() { - if self == .Foreground { - self = .Background + if self == .foreground { + self = .background } else { - self = .Foreground + self = .foreground } } diff --git a/Source/ColorWrap.swift b/Source/ColorWrap.swift index 151b6467..dde78492 100644 --- a/Source/ColorWrap.swift +++ b/Source/ColorWrap.swift @@ -118,23 +118,23 @@ public struct Wrap: SelectGraphicRenditionWrapType { public var foreground: Parameter? { get { - return self.filter(level: .Foreground).first + return self.filter(level: .foreground).first } mutating set(newForeground) { self.parameters = [newForeground].flatMap { $0 } + // Empty array or array containing new foreground - self.filter(level: .Foreground, inverse: true) // All non-foreground parameters + self.filter(level: .foreground, inverse: true) // All non-foreground parameters } } public var background: Parameter? { get { - return self.filter(level: .Background).first + return self.filter(level: .background).first } mutating set(newBackground) { self.parameters = [newBackground].flatMap { $0 } + // Empty array or array containing new background - self.filter(level: .Background, inverse: true) // All non-background parameters + self.filter(level: .background, inverse: true) // All non-background parameters } } @@ -156,14 +156,14 @@ public struct Wrap: SelectGraphicRenditionWrapType { /// Synchronously transform all ColorTypes with a `Level` of `Foreground`. public mutating func foreground(transform: (ColorType) -> ColorType) -> Bool { - let transformation = levelTransform(.Foreground, transform: transform) + let transformation = levelTransform(.foreground, transform: transform) self.parameters = transformation.parameters return transformation.transformed } /// Synchronously transform all ColorTypes with a `Level` of `Background`. public mutating func background(transform: (ColorType) -> ColorType) -> Bool { - let transformation = levelTransform(.Background, transform: transform) + let transformation = levelTransform(.background, transform: transform) self.parameters = transformation.parameters return transformation.transformed } @@ -244,8 +244,8 @@ extension Color.Wrap: ExpressibleByArrayLiteral {} extension Color.Wrap: Equatable { public enum EqualityType { - case Array - case Set + case array + case set } private func setEqualilty(_ a: Color.Wrap, _ b: Color.Wrap) -> Bool { @@ -255,13 +255,13 @@ extension Color.Wrap: Equatable { return x == y } - public func isEqual(to other: Color.Wrap, equality: Color.Wrap.EqualityType = .Array) -> Bool { + public func isEqual(to other: Color.Wrap, equality: Color.Wrap.EqualityType = .array) -> Bool { switch equality { - case .Array: + case .array: return self.parameters.count == other.parameters.count && self.code.enable == other.code.enable - case .Set: + case .set: return setEqualilty(self, other) } } @@ -269,5 +269,5 @@ extension Color.Wrap: Equatable { } public func == (a: Color.Wrap, b: Color.Wrap) -> Bool { - return a.isEqual(to: b, equality: .Array) + return a.isEqual(to: b, equality: .array) } diff --git a/Source/StyleParameter.swift b/Source/StyleParameter.swift index 0b94f87f..8efd8363 100644 --- a/Source/StyleParameter.swift +++ b/Source/StyleParameter.swift @@ -1,32 +1,32 @@ /// Based on: ECMA-048 — 8.3.117 public enum StyleParameter: UInt8, Parameter { // Reference: Terminal Support Table: https://github.com/jdhealy/PrettyColors/wiki/Terminal-Support - case Bold = 01 // bold or increased intensity - case Faint = 02 // faint, decreased intensity or second colour - case Italic = 03 // italicized - case Underlined = 04 // singly underlined - case BlinkSlow = 05 // slowly blinking (less then 150 per minute) - case Blink = 06 // rapidly blinking (150 per minute or more) - case Negative = 07 // negative image — a.k.a. Inverse - case Concealed = 08 // concealed characters - case CrossedOut = 09 // (characters still legible but marked as to be deleted) - case Font1 = 11 - case Font2 = 12 - case Font3 = 13 - case Font4 = 14 - case Font5 = 15 - case Font6 = 16 - case Font7 = 17 - case Font8 = 18 - case Font9 = 19 - case Fraktur = 20 // Gothic - case UnderlinedDouble = 21 // doubly underlined - case Normal = 22 // normal colour or normal intensity (neither bold nor faint) - case Positive = 27 // positive image - case Revealed = 28 // revealed characters - case Framed = 51 - case Encircled = 52 - case Overlined = 53 + case bold = 01 // bold or increased intensity + case faint = 02 // faint, decreased intensity or second colour + case italic = 03 // italicized + case underlined = 04 // singly underlined + case blinkSlow = 05 // slowly blinking (less then 150 per minute) + case blink = 06 // rapidly blinking (150 per minute or more) + case negative = 07 // negative image — a.k.a. Inverse + case concealed = 08 // concealed characters + case crossedOut = 09 // (characters still legible but marked as to be deleted) + case font1 = 11 + case font2 = 12 + case font3 = 13 + case font4 = 14 + case font5 = 15 + case font6 = 16 + case font7 = 17 + case font8 = 18 + case font9 = 19 + case fraktur = 20 // Gothic + case underlinedDouble = 21 // doubly underlined + case normal = 22 // normal colour or normal intensity (neither bold nor faint) + case positive = 27 // positive image + case revealed = 28 // revealed characters + case framed = 51 + case encircled = 52 + case overlined = 53 public struct Reset { /// Some parameters have corresponding resets, diff --git a/Tests/Unit/Equality.swift b/Tests/Unit/Equality.swift index b5a43aeb..163b8f4d 100644 --- a/Tests/Unit/Equality.swift +++ b/Tests/Unit/Equality.swift @@ -17,20 +17,20 @@ class EqualityTests: XCTestCase { let one = [ Color.EightBit(foreground: 100), Color.EightBit(background: 200), - (StyleParameter.Encircled) + (StyleParameter.encircled) ] as Color.Wrap let two = [ Color.EightBit(background: 200), - StyleParameter.Encircled, + StyleParameter.encircled, Color.EightBit(foreground: 100) ] as Color.Wrap XCTAssert( - one.isEqual(to: two, equality: Color.Wrap.EqualityType.Set) + one.isEqual(to: two, equality: Color.Wrap.EqualityType.set) ) XCTAssert( - !one.isEqual(to: two, equality: Color.Wrap.EqualityType.Array) + !one.isEqual(to: two, equality: Color.Wrap.EqualityType.array) ) // Defaults to Array Equality @@ -44,14 +44,14 @@ class EqualityTests: XCTestCase { func testB() { let one = [ - Color.Named(foreground: .Green), + Color.Named(foreground: .green), Color.EightBit(background: 200), - StyleParameter.Encircled + StyleParameter.encircled ] as Color.Wrap let two = [ Color.EightBit(background: 200), - StyleParameter.Encircled, + StyleParameter.encircled, Color.EightBit(foreground: 100) ] as Color.Wrap @@ -60,14 +60,14 @@ class EqualityTests: XCTestCase { func testC() { let one = [ - Color.Named(foreground: .Green), + Color.Named(foreground: .green), Color.EightBit(background: 200), - StyleParameter.Encircled + StyleParameter.encircled ] as Color.Wrap let two = [ Color.EightBit(background: 200), - StyleParameter.CrossedOut, + StyleParameter.crossedOut, Color.EightBit(foreground: 100) ] as Color.Wrap @@ -75,11 +75,11 @@ class EqualityTests: XCTestCase { } func testD() { - let one = Color.Wrap(foreground: .Green) + let one = Color.Wrap(foreground: .green) let two = [ Color.EightBit(background: 200), - StyleParameter.CrossedOut, + StyleParameter.crossedOut, Color.EightBit(foreground: 100) ] as Color.Wrap @@ -87,8 +87,8 @@ class EqualityTests: XCTestCase { } func testE() { - let one: Parameter = Color.Named(foreground: .Yellow) - let two: Parameter = Color.Named(background: .Yellow) + let one: Parameter = Color.Named(foreground: .yellow) + let two: Parameter = Color.Named(background: .yellow) // TODO: DOCUMENT: Parameters don't conform to Equatable XCTAssert(!(one == two)) XCTAssert(one != two) diff --git a/Tests/Unit/PrettyColorsTests.swift b/Tests/Unit/PrettyColorsTests.swift index b26b7edc..85c160bb 100644 --- a/Tests/Unit/PrettyColorsTests.swift +++ b/Tests/Unit/PrettyColorsTests.swift @@ -14,16 +14,16 @@ class PrettyColorsTests: XCTestCase { } func test_basics() { - let redText: String = Color.Wrap(foreground: .Red).wrap("A red piece of text.") + let redText: String = Color.Wrap(foreground: .red).wrap("A red piece of text.") print(redText) _ = (( - Color.Wrap(foreground: .Yellow, style: .Bold), - Color.Wrap(foreground: .Green, background: .Black, style: .Bold, .Underlined), + Color.Wrap(foreground: .yellow, style: .bold), + Color.Wrap(foreground: .green, background: .black, style: .bold, .underlined), // 8-bit (256) color support Color.Wrap(foreground: 114), - Color.Wrap(foreground: 114, style: .Bold) + Color.Wrap(foreground: 114, style: .bold) )) } @@ -32,17 +32,17 @@ class PrettyColorsTests: XCTestCase { As of `swiftlang-700.0.57.3`, the following statement errors: «Ambiguous use of 'init(foreground:background:style:)'» */ - // Color.Wrap(style: .Bold) + // Color.Wrap(style: .bold) _ = (( // Workarounds: - Color.Wrap(foreground: nil as UInt8?, style: .Bold), - Color.Wrap(foreground: nil as Color.Named.Color?, style: .Bold), - [StyleParameter.Bold] as Color.Wrap, - Color.Wrap(styles: .Bold), + Color.Wrap(foreground: nil as UInt8?, style: .bold), + Color.Wrap(foreground: nil as Color.Named.Color?, style: .bold), + [StyleParameter.bold] as Color.Wrap, + Color.Wrap(styles: .bold), // Multiple - Color.Wrap(styles: .Bold, .Blink) + Color.Wrap(styles: .bold, .blink) )) } @@ -52,9 +52,9 @@ class PrettyColorsTests: XCTestCase { /* Color.Wrap( parameters: [ - Color.Named(foreground: .Green), + Color.Named(foreground: .green), Color.EightBit(foreground: 114), - StyleParameter.Bold + StyleParameter.bold ] ) */ @@ -63,37 +63,37 @@ class PrettyColorsTests: XCTestCase { // Workarounds: Color.Wrap( parameters: [ - Color.Named(foreground: .Green), + Color.Named(foreground: .green), Color.EightBit(foreground: 114), - StyleParameter.Bold + StyleParameter.bold ] as [Color.Wrap.Element] ), Color.Wrap( parameters: [ - Color.Named(foreground: .Green), + Color.Named(foreground: .green), Color.EightBit(foreground: 114), - StyleParameter.Bold + StyleParameter.bold ] as [Parameter] ), [ - Color.Named(foreground: .Green), + Color.Named(foreground: .green), Color.EightBit(foreground: 114), - StyleParameter.Bold + StyleParameter.bold ] as Color.Wrap )) } func testImmutableFilterOrMap() { - let redBold = Color.Wrap(foreground: .Red, style: .Bold) - let redItalic = Color.Wrap(foreground: .Red, style: .Italic) + let redBold = Color.Wrap(foreground: .red, style: .bold) + let redItalic = Color.Wrap(foreground: .red, style: .italic) // Filter XCTAssert( redBold == redItalic - .filter { $0 != StyleParameter.Italic } - + [ StyleParameter.Bold ] + .filter { $0 != StyleParameter.italic } + + [ StyleParameter.bold ] ) // Map @@ -102,7 +102,7 @@ class PrettyColorsTests: XCTestCase { [] + redItalic .map { switch $0 as? StyleParameter { - case .some: /* replace value */ return StyleParameter.Bold + case .some: /* replace value */ return StyleParameter.bold case .none: /* same value */ return $0 } } @@ -124,7 +124,7 @@ class PrettyColorsTests: XCTestCase { func testMulti() { let multi = [ Color.EightBit(foreground: 227), - Color.Named(foreground: .Green, brightness: .NonBright) + Color.Named(foreground: .green, brightness: .nonBright) ] as Color.Wrap XCTAssert( multi.code.enable == @@ -137,16 +137,16 @@ class PrettyColorsTests: XCTestCase { } func testLetWorkflow() { - let redOnBlack = Color.Wrap(foreground: .Red, background: .Black) - let boldRedOnBlack: Color.Wrap = redOnBlack + [ StyleParameter.Bold ] as Color.Wrap + let redOnBlack = Color.Wrap(foreground: .red, background: .black) + let boldRedOnBlack: Color.Wrap = redOnBlack + [ StyleParameter.bold ] as Color.Wrap XCTAssert( - boldRedOnBlack == Color.Wrap(foreground: .Red, background: .Black, style: .Bold) + boldRedOnBlack == Color.Wrap(foreground: .red, background: .black, style: .bold) ) XCTAssert( [ boldRedOnBlack, - Color.Wrap(foreground: .Red, background: .Black, style: .Bold) + Color.Wrap(foreground: .red, background: .black, style: .bold) ].reduce(true) { (previous, value) in return previous && value.parameters.reduce(true) { @@ -156,9 +156,9 @@ class PrettyColorsTests: XCTestCase { // error for the returned expression… 😕 _ = value return previous && ( - value == Color.Named(foreground: .Red) as Parameter || - value == Color.Named(background: .Black) as Parameter || - value == StyleParameter.Bold + value == Color.Named(foreground: .red) as Parameter || + value == Color.Named(background: .black) as Parameter || + value == StyleParameter.bold ) } } == true @@ -167,57 +167,57 @@ class PrettyColorsTests: XCTestCase { func testAppendStyleParameter() { - let red = Color.Wrap(foreground: .Red) + let red = Color.Wrap(foreground: .red) let _ = { (wrap: Color.Wrap) -> Void in var formerlyRed = wrap - formerlyRed.append(StyleParameter.Bold) + formerlyRed.append(StyleParameter.bold) XCTAssert( - formerlyRed == Color.Wrap(foreground: .Red, style: .Bold) + formerlyRed == Color.Wrap(foreground: .red, style: .bold) ) }(red) let _ = { (wrap: Color.Wrap) -> Void in var formerlyRed = wrap - formerlyRed.append(style: .Bold) + formerlyRed.append(style: .bold) XCTAssert( - formerlyRed == Color.Wrap(foreground: .Red, style: .Bold) + formerlyRed == Color.Wrap(foreground: .red, style: .bold) ) }(red) XCTAssert( - red + Color.Wrap(styles: .Bold) == Color.Wrap(foreground: .Red, style: .Bold) + red + Color.Wrap(styles: .bold) == Color.Wrap(foreground: .red, style: .bold) ) // Multiple let _ = { (wrap: Color.Wrap) -> Void in var formerlyRed = wrap - formerlyRed.append(StyleParameter.Bold) - formerlyRed.append(StyleParameter.Italic) + formerlyRed.append(StyleParameter.bold) + formerlyRed.append(StyleParameter.italic) XCTAssert( - formerlyRed == Color.Wrap(foreground: .Red, style: .Bold, .Italic) + formerlyRed == Color.Wrap(foreground: .red, style: .bold, .italic) ) }(red) let _ = { (wrap: Color.Wrap) -> Void in var formerlyRed = wrap - formerlyRed.append(style: .Bold, .Italic) + formerlyRed.append(style: .bold, .italic) XCTAssert( - formerlyRed == Color.Wrap(foreground: .Red, style: .Bold, .Italic) + formerlyRed == Color.Wrap(foreground: .red, style: .bold, .italic) ) }(red) XCTAssert( - red + Color.Wrap(styles: .Bold, .Italic) == Color.Wrap(foreground: .Red, style: .Bold, .Italic) + red + Color.Wrap(styles: .bold, .italic) == Color.Wrap(foreground: .red, style: .bold, .italic) ) } func testMutableAppend() { - var formerlyRed = Color.Wrap(foreground: .Red) - let redBlackBackground = Color.Wrap(foreground: .Red, background: .Black) + var formerlyRed = Color.Wrap(foreground: .red) + let redBlackBackground = Color.Wrap(foreground: .red, background: .black) - formerlyRed.append( Color.Named(background: .Black) ) + formerlyRed.append( Color.Named(background: .black) ) XCTAssert( formerlyRed == redBlackBackground @@ -229,7 +229,7 @@ class PrettyColorsTests: XCTestCase { //------------------------------------------------------------------------------ func testSetForeground() { - var formerlyRed = Color.Wrap(foreground: .Red) + var formerlyRed = Color.Wrap(foreground: .red) formerlyRed.foreground = Color.EightBit(foreground: 227) // A nice yellow XCTAssert( formerlyRed == Color.Wrap(foreground: 227) @@ -237,7 +237,7 @@ class PrettyColorsTests: XCTestCase { } func testSetForegroundToNil() { - var formerlyRed = Color.Wrap(foreground: .Red) + var formerlyRed = Color.Wrap(foreground: .red) formerlyRed.foreground = nil XCTAssert( @@ -249,15 +249,15 @@ class PrettyColorsTests: XCTestCase { } func testSetForegroundToParameter() { - var formerlyRed = Color.Wrap(foreground: .Red) - formerlyRed.foreground = StyleParameter.Bold + var formerlyRed = Color.Wrap(foreground: .red) + formerlyRed.foreground = StyleParameter.bold - XCTAssert( formerlyRed == [StyleParameter.Bold] as Color.Wrap ) + XCTAssert( formerlyRed == [StyleParameter.bold] as Color.Wrap ) } func testTransformForeground() { - var formerlyRed = Color.Wrap(foreground: .Red) + var formerlyRed = Color.Wrap(foreground: .red) _ = formerlyRed.foreground { _ in return Color.EightBit(foreground: 227) // A nice yellow } @@ -275,19 +275,19 @@ class PrettyColorsTests: XCTestCase { } func testTransformForegroundWithVar() { - var formerlyRed = Color.Wrap(foreground: .Red) + var formerlyRed = Color.Wrap(foreground: .red) _ = formerlyRed.foreground { color in if let namedColor = color as? Color.Named { var soonYellow = namedColor - soonYellow.color = .Yellow + soonYellow.color = .yellow return soonYellow } else { return color } } - XCTAssert( formerlyRed == Color.Wrap(foreground: .Yellow) ) + XCTAssert( formerlyRed == Color.Wrap(foreground: .yellow) ) } func testTransformForegroundToBright() { - var formerlyRed = Color.Wrap(foreground: .Red) + var formerlyRed = Color.Wrap(foreground: .red) _ = formerlyRed.foreground { var clone = $0 as! Color.Named @@ -296,7 +296,7 @@ class PrettyColorsTests: XCTestCase { } let brightRed = [ - Color.Named(foreground: .Red, brightness: .Bright) + Color.Named(foreground: .red, brightness: .bright) ] as Color.Wrap XCTAssert( formerlyRed == brightRed ) @@ -304,13 +304,13 @@ class PrettyColorsTests: XCTestCase { func testComputedVariableForegroundEquality() { XCTAssert( - Color.Named(foreground: .Red) == Color.Wrap(foreground: .Red).foreground! as! Color.Named + Color.Named(foreground: .red) == Color.Wrap(foreground: .red).foreground! as! Color.Named ) } func testEightBitForegroundBackgroundDifference() { - let foreground = Color.Named(foreground: .Green).code.enable - let background = Color.Named(background: .Green).code.enable + let foreground = Color.Named(foreground: .green).code.enable + let background = Color.Named(background: .green).code.enable let difference = zip(foreground, background) .reduce(0 as UInt8) { sum, values in @@ -322,8 +322,8 @@ class PrettyColorsTests: XCTestCase { } func testNamedForegroundBackgroundDifference() { - let foreground = Color.Named(foreground: .Green).code.enable - let background = Color.Named(background: .Green).code.enable + let foreground = Color.Named(foreground: .green).code.enable + let background = Color.Named(background: .green).code.enable let difference = zip(foreground, background) .reduce(0 as UInt8) { sum, values in @@ -335,8 +335,8 @@ class PrettyColorsTests: XCTestCase { } func testNamedBrightnessDifference() { - let non·bright = Color.Named(foreground: .Green).code.enable - let bright = Color.Named(foreground: .Green, brightness: .Bright).code.enable + let non·bright = Color.Named(foreground: .green).code.enable + let bright = Color.Named(foreground: .green, brightness: .bright).code.enable let difference = zip(non·bright, bright) .reduce(0 as UInt8) { sum, values in @@ -354,14 +354,14 @@ class PrettyColorsTests: XCTestCase { func testZapAllStyleParameters() { for wrap in [ - Color.Wrap(foreground: .Red), + Color.Wrap(foreground: .red), Color.Wrap(foreground: 114) ] { - for (number, style·wrap) in ( + for (number, style·wrap): (UInt8, Color.Wrap) in ( (1 as UInt8 ... 55).flatMap /* more accurately, concatenate optionals */ { guard let style = StyleParameter(rawValue: $0) else { return nil } return ($0 as UInt8, [style] as Color.Wrap) - } /* type-inference fails without */ as [(UInt8, Color.Wrap)] + } ) { let formatted·number = NSString(format: "%02d", number) as String @@ -369,9 +369,9 @@ class PrettyColorsTests: XCTestCase { (wrap, "normal"), // TODO: Investigate why `as (Color.Wrap, String)` before above comma // doesn't provide enough type info for the remaining lines in the array. - (wrap + [ StyleParameter.Bold ], "bold"), - (wrap + [ StyleParameter.Italic ], "italic"), - (wrap + [ StyleParameter.Underlined ], "underlined") + (wrap + [ StyleParameter.bold ], "bold"), + (wrap + [ StyleParameter.italic ], "italic"), + (wrap + [ StyleParameter.underlined ], "underlined") ] /* type-inference fails without */ as [(Color.Wrap, String)] { let styled·output = (appended·wrap + style·wrap).wrap("__|øat·•ªº^∆©|__") print( "• \(styled·output) \(formatted·number) + \(suffix)" )