Merge pull request #91 from cipi1965/fix-rapier-sorting

Fix rapier sorting

Rapier/Sources/Rapier/FieldInfo.swift

@@ -1,13 +1,15 @@
 import Foundation
 
 public struct FieldInfo {
-    public init(type: String = "", isArray: Bool = false, isArrayOfArray: Bool = false, isOptional: Bool = false) {
+    public init(name: String = "", type: String = "", isArray: Bool = false, isArrayOfArray: Bool = false, isOptional: Bool = false) {
+        self.name = name
         self.type = type
         self.isArray = isArray
         self.isArrayOfArray = isArrayOfArray
         self.isOptional = isOptional
     }
 
+    public var name: String
     public var type: String
     public var isArray: Bool
     public var isArrayOfArray: Bool

Rapier/Sources/Rapier/MethodInfo.swift

@@ -1,11 +1,12 @@
 import Foundation
 
 public struct MethodInfo {
-    public init(parameters: [String: FieldInfo] = [:], result: FieldInfo) {
+    public init(name: String, parameters: [FieldInfo] = [], result: FieldInfo) {
+        self.name = name
         self.parameters = parameters
         self.result = result
     }
-
-    public var parameters: [String: FieldInfo]
+    public var name: String
+    public var parameters: [FieldInfo]
     public var result: FieldInfo
 }

Rapier/Sources/Rapier/Rapier.swift

@@ -4,30 +4,30 @@ import Yaml
 open class Rapier {
     public let ymlFile: String
 
-    private var types: [String: TypeInfo] = [:]
-    private var methods: [String: MethodInfo] = [:]
+    private var types: [TypeInfo] = []
+    private var methods: [MethodInfo] = []
 
     public init(ymlFile: String) {
         self.ymlFile = ymlFile
     }
 
     public func clear() {
-        types = [:]
-        methods = [:]
+        types = []
+        methods = []
     }
 
     public func generate(generator: CodeGenerator) throws {
         try generator.start()
 
         try generator.beforeGeneratingTypes()
-        try types.forEach { typeName, typeInfo in
-            try generator.generateType(name: typeName, info: typeInfo)
+        try types.forEach { typeInfo in
+            try generator.generateType(name: typeInfo.name, info: typeInfo)
         }
         try generator.afterGeneratingTypes()
 
         try generator.beforeGeneratingMethods()
-        try methods.forEach { methodName, methodInfo in
-            try generator.generateMethod(name: methodName, info: methodInfo)
+        try methods.forEach { methodInfo in
+            try generator.generateMethod(name: methodInfo.name, info: methodInfo)
         }
         try generator.afterGeneratingMethods()
 
@@ -59,42 +59,45 @@ open class Rapier {
 
     private func parseType(props: [Yaml: Yaml]) throws {
         guard let typeName = props["type"]?.string else { throw RapierError.expectedField(name: "type", parent: nil) }
-        guard let fieldsDictionary = props["fields"]?.dictionary else {
-            types[typeName] = TypeInfo(fields: [:])
+        guard let fieldsArray = props["fields"]?.array else {
+            types.append(TypeInfo(name: typeName, fields: []))
             return
         }
-        let fields = try parseFields(fieldsDictionary, parent: typeName)
-        let typeInfo = TypeInfo(fields: fields)
-        types[typeName] = typeInfo
+        let fields = try parseFields(fieldsArray, parent: typeName)
+        let typeInfo = TypeInfo(name: typeName, fields: fields)
+        types.append(typeInfo)
     }
 
     private func parseMethod(props: [Yaml: Yaml]) throws {
         guard let methodName = props["method"]?.string else { throw RapierError.expectedField(name: "method", parent: nil) }
         guard let result = props["result"]?.string else { throw RapierError.missingReturn(parent: methodName)}
 
-        let resultField = parseType(field: result)
+        let resultField = parseType(name: methodName, field: result)
 
-        guard let fieldsDictionary = props["parameters"]?.dictionary else {
-            methods[methodName] = MethodInfo(parameters: [:], result: resultField)
+        guard let fieldsArray = props["parameters"]?.array else {
+            methods.append(MethodInfo(name: methodName, parameters: [], result: resultField))
             return
         }
-        let fields = try parseFields(fieldsDictionary, parent: methodName)
-        let methodInfo = MethodInfo(parameters: fields, result: resultField)
-        methods[methodName] = methodInfo
+        let fields = try parseFields(fieldsArray, parent: methodName)
+        let methodInfo = MethodInfo(name: methodName, parameters: fields, result: resultField)
+        methods.append(methodInfo)
     }
 
-    private func parseFields(_ fieldsDictionary: [Yaml: Yaml], parent: String) throws -> [String: FieldInfo] {
-        var fields: [String: FieldInfo] = [:]
-        try fieldsDictionary.forEach { key, value in
-            guard let fieldName = key.string else { throw RapierError.fieldNameIsNotString(parent: parent) }
-            guard let fieldType = value.string else { throw RapierError.fieldTypeIsNotString(parent: parent) }
+    private func parseFields(_ fieldsArray: [Yaml], parent: String) throws -> [FieldInfo] {
+        var fields: [FieldInfo] = []
+        try fieldsArray.forEach { item in
+            guard let field = item.dictionary else {
+                throw RapierError.expectedDictionary
+            }
+            guard let fieldName = field.first?.key.string else { throw RapierError.fieldNameIsNotString(parent: parent) }
+            guard let fieldType = field.first?.value.string else { throw RapierError.fieldTypeIsNotString(parent: parent) }
 
-            fields[fieldName] = parseType(field: fieldType)
+            fields.append(parseType(name: fieldName, field: fieldType))
         }
         return fields
     }
 
-    private func parseType(field: String) -> FieldInfo {
+    private func parseType(name: String, field: String) -> FieldInfo {
         var fieldType = field
         let isOptional = fieldType.hasSuffix("?")
         if isOptional {
@@ -111,6 +114,6 @@ open class Rapier {
             fieldType = String(fieldType.dropLast(2))
         }
 
-        return FieldInfo(type: fieldType, isArray: isArray, isArrayOfArray: isArrayOfArray, isOptional: isOptional)
+        return FieldInfo(name: name, type: fieldType, isArray: isArray, isArrayOfArray: isArrayOfArray, isOptional: isOptional)
     }
 }

Rapier/Sources/Rapier/TypeInfo.swift

@@ -1,9 +1,11 @@
 import Foundation
 
 public struct TypeInfo {
-    public init(fields: [String: FieldInfo] = [:]) {
+    public init(name: String, fields: [FieldInfo] = []) {
+        self.name = name
         self.fields = fields
     }
 
-    public var fields: [String: FieldInfo]
+    public var name: String
+    public var fields: [FieldInfo]
 }

Rapier/Sources/RapierCLI/Generators/OverviewGenerator.swift

@@ -29,8 +29,8 @@ class OverviewGenerator: CodeGenerator {
 
     func generateType(name: String, info: TypeInfo) throws {
         context.outTypes.append("\(name)\n")
-        info.fields.sorted { $0.key < $1.key }.forEach { fieldName, fieldInfo in
-            context.outTypes.append("  \(fieldName): \(fieldInfo.type)")
+        info.fields.forEach { fieldInfo in
+            context.outTypes.append("  \(fieldInfo.name): \(fieldInfo.type)")
             if (fieldInfo.isOptional) {
                 context.outTypes.append(" [optional]")
             }
@@ -48,8 +48,8 @@ class OverviewGenerator: CodeGenerator {
 
     func generateMethod(name: String, info: MethodInfo) throws {
         context.outMethods.append("\(name)\n")
-        info.parameters.sorted { $0.key < $1.key }.forEach { fieldName, fieldInfo in
-            context.outMethods.append("  \(fieldName): \(fieldInfo.type)")
+        info.parameters.forEach { fieldInfo in
+            context.outMethods.append("  \(fieldInfo.name): \(fieldInfo.type)")
             if (fieldInfo.isOptional) {
                 context.outMethods.append(" [optional]")
             }

Rapier/Sources/RapierCLI/Generators/TelegramBotSDKGenerator.swift

@@ -44,10 +44,10 @@ class TelegramBotSDKGenerator: CodeGenerator {
             
             """)
         var allInitParams: [String] = []
-        info.fields.sorted { $0.key < $1.key }.forEach { fieldName, fieldInfo in
-            let getterName = makeGetterName(typeName: name, fieldName: fieldName, fieldType: fieldInfo.type)
+        info.fields.forEach { fieldInfo in
+            let getterName = makeGetterName(typeName: name, fieldName: fieldInfo.name, fieldType: fieldInfo.type)
             if fieldInfo.type == "True" {
-                allInitParams.append(#""\#(fieldName)" = true"#)
+                allInitParams.append(#""\#(fieldInfo.name)" = true"#)
             } else {
                 if let field = buildFieldTemplate(fieldName: getterName, fieldInfo: fieldInfo) {
                     context.outTypes.append(field)
@@ -97,19 +97,19 @@ class TelegramBotSDKGenerator: CodeGenerator {
 
     func generateMethod(name: String, info: MethodInfo) throws {
 
-        let parameters = info.parameters.sorted { $0.key < $1.key }
+        let parameters = info.parameters
 
-        let fields: [String] = parameters.map { fieldName, fieldInfo in
-            var result = "\(fieldName.camelized()): \(buildSwiftType(fieldInfo: fieldInfo))"
+        let fields: [String] = parameters.map { fieldInfo in
+            var result = "\(fieldInfo.name.camelized()): \(buildSwiftType(fieldInfo: fieldInfo))"
             if fieldInfo.isOptional {
                 result.append(" = nil")
             }
 
             return result
         }
 
-        let arrayFields: [String] = parameters.map { fieldName, _ in
-            return #""\#(fieldName)": \#(fieldName.camelized())"#
+        let arrayFields: [String] = parameters.map { fieldInfo in
+            return #""\#(fieldInfo.name)": \#(fieldInfo.name.camelized())"#
         }
 
         var fieldsString = fields.joined(separator: ",\n        ")