From 4f179bc1cb9c783b3cf648b565879a95dfde8b79 Mon Sep 17 00:00:00 2001 From: Anh Mac Date: Thu, 3 Sep 2020 10:59:42 +0700 Subject: [PATCH] refactor code --- Kana.podspec | 2 +- Sources/Kana/Kana.swift | 79 ++++++++++++----------- Sources/Kana/KanaColumns.swift | 30 +++++++++ Sources/Kana/KanaTable.swift | 8 +++ Tests/KanaTests/KanaColumnsTestCase.swift | 31 +++++++++ Tests/KanaTests/KanaTableTestCase.swift | 13 ++++ Tests/KanaTests/KanaTestCase.swift | 50 +++++++++----- 7 files changed, 157 insertions(+), 56 deletions(-) create mode 100644 Sources/Kana/KanaColumns.swift create mode 100644 Tests/KanaTests/KanaColumnsTestCase.swift diff --git a/Kana.podspec b/Kana.podspec index 347fe5a..6bbdb46 100644 --- a/Kana.podspec +++ b/Kana.podspec @@ -1,7 +1,7 @@ Pod::Spec.new do |spec| spec.name = "Kana" -spec.version = "1.0.0" +spec.version = "1.1.0" spec.summary = " An utitity Swift package to generate Japanese basic characters or convert between Katakana, Hiragana, and Romaji " spec.homepage = "https://github.com/anhmv/Kana" diff --git a/Sources/Kana/Kana.swift b/Sources/Kana/Kana.swift index b757549..33cea7b 100644 --- a/Sources/Kana/Kana.swift +++ b/Sources/Kana/Kana.swift @@ -7,9 +7,7 @@ import Foundation -public struct Kana: Equatable { - - public static let invalidKana = Kana() +public struct Kana: Equatable, Hashable { // MARK: - Properties @@ -17,6 +15,17 @@ public struct Kana: Equatable { public let katakana: String? public let hiragana: String? + public var isInvalid: Bool { + if romaji == nil || katakana == nil || hiragana == nil { + return true + } + + return false + } + + public var isValid: Bool { + return !self.isInvalid + } // MARK: - Enums @@ -26,25 +35,13 @@ public struct Kana: Equatable { case romaji } - public enum VoiceType { - case seion - case dakuon - case yoon - } - public enum KanaError: Error { case characterNotFound } // MARK: - Constructors - - private init() { - romaji = nil - katakana = nil - hiragana = nil - } - + public init(romaji: String) { if let hiragana = Kana.toHiragana(of: romaji, in: .romaji) { self.romaji = romaji @@ -70,10 +67,6 @@ public struct Kana: Equatable { // MARK: - Static methods and properties - static let seionColumns = [0, 1, 3, 5, 7, 10, 11, 12, 13, 14, 15] - static let dakuonColumns = [2, 4, 6, 8, 9] - static let yoonColumns = [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26] - static let romajiChart: [[String]] = [ ["a", "ka", "ga", "sa" , "za" , "ta" , "da", "na", "ha", "ba", "pa", "ma", "ya", "ra", "wa", "n", "kya", "gya", "ja", "sha", "cha", "nya", "hya", "bya", "pya", "mya", "rya"], ["i", "ki", "gi", "shi", "ji", "chi", "di", "ni", "hi", "bi", "pi", "mi", "" , "ri", "" , "" , "", "", "", "", "", "", "", "", "", "", ""], @@ -98,22 +91,13 @@ public struct Kana: Equatable { ["オ", "コ", "ゴ", "ソ", "ゾ", "ト", "ド", "ノ", "ホ", "ボ", "ポ", "モ", "ヨ", "ロ", "ヲ" , "" , "キョ", "ギョ", "ジョ", "ショ", "チョ", "ニョ", "ヒョ", "ビョ", "ピョ", "ニョ", "リョ"], ] - public static func getTable(_ of: VoiceType) -> KanaTable { - var columns: [Int]? - - switch of { - case .seion: - columns = seionColumns - case .dakuon: - columns = dakuonColumns - case .yoon: - columns = yoonColumns - } + public static func getTable(with keys: [KanaColumns.Keys]) -> KanaTable { + let columns: [Int] = keys.map { $0.rawValue } var kanaTable: [[Kana]] = [] for i in 0.. Kana { - let table = getTable(voiceType) + public static func random(in table: KanaTable) -> Kana { var randomKana: Kana? while true { let row = Int.random(in: 0.. [Kana] { - return (0.. Kana { + let table = getTable(with: columns) + return self.random(in: table) + } + + public static func random(in table: KanaTable, count number: Int, uniq repeatable: Bool = false) -> [Kana] { + if repeatable { + return (0..() + while randomItems.count < number { + randomItems.insert(Kana.random(in: table)) + } + + return Array(randomItems) + } + + public static func random(with columns: [KanaColumns.Keys], count number: Int, uniq repeatable: Bool = false) -> [Kana] { + let table = getTable(with: columns) + return self.random(in: table, count: number, uniq: repeatable) } } @@ -259,4 +261,3 @@ fileprivate extension CFStringTokenizer { return mutableString as String } } - diff --git a/Sources/Kana/KanaColumns.swift b/Sources/Kana/KanaColumns.swift new file mode 100644 index 0000000..f2baaf6 --- /dev/null +++ b/Sources/Kana/KanaColumns.swift @@ -0,0 +1,30 @@ +// +// KanaColumns.swift +// +// +// Created by Mac Van Anh on 8/31/20. +// Copyright © 2020 Mac Van Anh. All rights reserved. +// + + +import Foundation + +public struct KanaColumns { + + public enum Keys: Int { + case a = 0, ka, ga, sa , za , ta , da, na, ha, ba, pa, ma, ya, ra, wa, n, kya, gya, ja, sha, cha, nya, hya, bya, pya, mya, rya + } + + public static var seion: [KanaColumns.Keys] { + return [.a, .ka, .sa, .ta, .na, .ha, .ma, .ya, .ra, .wa, .n] + } + + public static var dakuon: [KanaColumns.Keys] { + return [.ga, .za, .da, .ba, .pa] + } + + public static var yoon: [KanaColumns.Keys] { + return [.kya, .gya, .ja, .sha, .cha, .nya, .hya, .bya, .pya, .mya, .rya] + } + +} diff --git a/Sources/Kana/KanaTable.swift b/Sources/Kana/KanaTable.swift index 0afa61a..c663da1 100644 --- a/Sources/Kana/KanaTable.swift +++ b/Sources/Kana/KanaTable.swift @@ -17,5 +17,13 @@ public struct KanaTable { public subscript(row: Int) -> [Kana] { return values[row] } + + public static func + (left: KanaTable, right: KanaTable) -> KanaTable { + let values: [[Kana]] = (0.. Int { var count = 0 table.values.forEach { row in row.forEach { kana in - if kana != Kana.invalidKana { + if kana.isValid { count += 1 } } @@ -125,21 +143,21 @@ final class KanaTestCase: XCTestCase { return count } - let seion = Kana.getTable(.seion) + let seion = Kana.getTable(with: KanaColumns.seion) let numberOfSeionWithEmptyCells = seion.count * seion[0].count let numberOfSeions = withoutEmpty(seion) XCTAssertEqual(numberOfSeionWithEmptyCells, 55) XCTAssertEqual(numberOfSeions, 46) - let dakuon = Kana.getTable(.dakuon) + let dakuon = Kana.getTable(with: KanaColumns.dakuon) let numberOfDakuonWithEmptyCells = dakuon.count * dakuon[0].count let numberOfDakuons = withoutEmpty(dakuon) XCTAssertEqual(numberOfDakuonWithEmptyCells, 25) XCTAssertEqual(numberOfDakuons, 25) - let yoon = Kana.getTable(.yoon) + let yoon = Kana.getTable(with: KanaColumns.yoon) let numberOfYoonWithEmptyCells = yoon.count * yoon[0].count let numberOfYoons = withoutEmpty(yoon)