Tools/plutil/main.swift - third_party/swift-corelibs-foundation - Git at Google

 // This source file is part of the Swift.org open source project
 //
 // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 #if os(OSX) || os(iOS)
 import Darwin
 import SwiftFoundation
 #elseif os(Linux)
 import Foundation
 import Glibc
 #endif

 func help() -> Int32 {
     print("plutil: [command_option] [other_options] file...\n" +
     "The file '-' means stdin\n" +
     "Command options are (-lint is the default):\n" +
     " -help                         show this message and exit\n" +
     " -lint                         check the property list files for syntax errors\n" +
     " -convert fmt                  rewrite property list files in format\n" +
     "                               fmt is one of: xml1 binary1 json\n" +
     " -p                            print property list in a human-readable fashion\n" +
     "                               (not for machine parsing! this 'format' is not stable)\n" +
     "There are some additional optional arguments that apply to -convert\n" +
     " -s                            be silent on success\n" +
     " -o path                       specify alternate file path name for result;\n" +
     "                               the -o option is used with -convert, and is only\n" +
     "                               useful with one file argument (last file overwrites);\n" +
     "                               the path '-' means stdout\n" +
     " -e extension                  specify alternate extension for converted files\n" +
     " -r                            if writing JSON, output in human-readable form\n" +
     " --                            specifies that all further arguments are file names\n")
     return EXIT_SUCCESS
 }

 enum ExecutionMode {
     case help
     case lint
     case convert
     case print
 }

 enum ConversionFormat {
     case xml1
     case binary1
     case json
 }

 struct Options {
     var mode: ExecutionMode = .lint
     var silent: Bool = false
     var output: String?
     var fileExtension: String?
     var humanReadable: Bool?
     var conversionFormat: ConversionFormat?
     var inputs = [String]()
 }

 enum OptionParseError : Swift.Error {
     case unrecognizedArgument(String)
     case missingArgument(String)
     case invalidFormat(String)
 }

 func parseArguments(_ args: [String]) throws -> Options {
     var opts = Options()
     var iterator = args.makeIterator()
     while let arg = iterator.next() {
         switch arg {
             case "--":
                 while let path = iterator.next() {
                     opts.inputs.append(path)
                 }
             case "-s":
                 opts.silent = true
             case "-o":
                 if let path = iterator.next() {
                     opts.output = path
                 } else {
                     throw OptionParseError.missingArgument("-o requires a path argument")
                 }
             case "-convert":
                 opts.mode = .convert
                 if let format = iterator.next() {
                     switch format {
                         case "xml1":
                             opts.conversionFormat = .xml1
                         case "binary1":
                             opts.conversionFormat = .binary1
                         case "json":
                             opts.conversionFormat = .json
                         default:
                             throw OptionParseError.invalidFormat(format)
                     }
                 } else {
                     throw OptionParseError.missingArgument("-convert requires a format argument of xml1 binary1 json")
                 }
             case "-e":
                 if let ext = iterator.next() {
                     opts.fileExtension = ext
                 } else {
                     throw OptionParseError.missingArgument("-e requires an extension argument")
                 }
             case "-help":
                 opts.mode = .help
             case "-lint":
                 opts.mode = .lint
             case "-p":
                 opts.mode = .print
             default:
                 if arg.hasPrefix("-") && arg.utf8.count > 1 {
                     throw OptionParseError.unrecognizedArgument(arg)
                 }
         }
     }

     return opts
 }


 func lint(_ options: Options) -> Int32 {
     if options.output != nil {
         print("-o is not used with -lint")
         let _ = help()
         return EXIT_FAILURE
     }

     if options.fileExtension != nil {
         print("-e is not used with -lint")
         let _ = help()
         return EXIT_FAILURE
     }

     if options.inputs.count < 1 {
         print("No files specified.")
         let _ = help()
         return EXIT_FAILURE
     }

     let silent = options.silent

     var doError = false
     for file in options.inputs {
         let data : Data?
         if file == "-" {
             // stdin
             data = FileHandle.standardInput.readDataToEndOfFile()
         } else {
             data = try? Data(contentsOf: URL(fileURLWithPath: file))
         }

         if let d = data {
             do {
                 let _ = try PropertyListSerialization.propertyList(from: d, options: [], format: nil)
                 if !silent {
                     print("\(file): OK")
                 }
             } catch {
                 print("\(file): \(error)")

             }

         } else {
             print("\(file) does not exists or is not readable or is not a regular file")
             doError = true
             continue
         }
     }

     if doError {
         return EXIT_FAILURE
     } else {
         return EXIT_SUCCESS
     }
 }

 func convert(_ options: Options) -> Int32 {
     print("Unimplemented")
     return EXIT_FAILURE
 }

 enum DisplayType {
     case primary
     case key
     case value
 }

 extension Dictionary {
     func display(_ indent: Int = 0, type: DisplayType = .primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         switch type {
         case .primary, .key:
             print("\(indentation)[\n", terminator: "")
         case .value:
             print("[\n", terminator: "")
         }

         forEach() {
             if let key = $0.0 as? String {
                 key.display(indent + 1, type: .key)
             } else {
                 fatalError("plists should have strings as keys but got a \(type(of: $0.0))")
             }
             print(" => ", terminator: "")
             displayPlist($0.1, indent: indent + 1, type: .value)
         }

         print("\(indentation)]\n", terminator: "")
     }
 }

 extension Array {
     func display(_ indent: Int = 0, type: DisplayType = .primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         switch type {
         case .primary, .key:
             print("\(indentation)[\n", terminator: "")
         case .value:
             print("[\n", terminator: "")
         }

         for idx in 0..<count {
             print("\(indentation)  \(idx) => ", terminator: "")
             displayPlist(self[idx], indent: indent + 1, type: .value)
         }

         print("\(indentation)]\n", terminator: "")
     }
 }

 extension String {
     func display(_ indent: Int = 0, type: DisplayType = .primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         switch type {
         case .primary:
             print("\(indentation)\"\(self)\"\n", terminator: "")
         case .key:
             print("\(indentation)\"\(self)\"", terminator: "")
         case .value:
             print("\"\(self)\"\n", terminator: "")
         }
     }
 }

 extension Bool {
     func display(_ indent: Int = 0, type: DisplayType = .primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         switch type {
         case .primary:
             print("\(indentation)\"\(self ? "1" : "0")\"\n", terminator: "")
         case .key:
             print("\(indentation)\"\(self ? "1" : "0")\"", terminator: "")
         case .value:
             print("\"\(self ? "1" : "0")\"\n", terminator: "")
         }
     }
 }

 extension NSNumber {
     func display(_ indent: Int = 0, type: DisplayType = .primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         switch type {
         case .primary:
             print("\(indentation)\"\(self)\"\n", terminator: "")
         case .key:
             print("\(indentation)\"\(self)\"", terminator: "")
         case .value:
             print("\"\(self)\"\n", terminator: "")
         }
     }
 }

 extension NSData {
     func display(_ indent: Int = 0, type: DisplayType = .primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         switch type {
         case .primary:
             print("\(indentation)\"\(self)\"\n", terminator: "")
         case .key:
             print("\(indentation)\"\(self)\"", terminator: "")
         case .value:
             print("\"\(self)\"\n", terminator: "")
         }
     }
 }

 func displayPlist(_ plist: Any, indent: Int = 0, type: DisplayType = .primary) {
     switch plist {
     case let val as [String : Any]:
         val.display(indent, type: type)
     case let val as [Any]:
         val.display(indent, type: type)
     case let val as String:
         val.display(indent, type: type)
     case let val as Bool:
         val.display(indent, type: type)
     case let val as NSNumber:
         val.display(indent, type: type)
     case let val as NSData:
         val.display(indent, type: type)
     default:
         fatalError("unhandled type \(type(of: plist))")
     }
 }

 func display(_ options: Options) -> Int32 {
     if options.inputs.count < 1 {
         print("No files specified.")
         let _ = help()
         return EXIT_FAILURE
     }

     var doError = false
     for file in options.inputs {
         let data : Data?
         if file == "-" {
             // stdin
             data = FileHandle.standardInput.readDataToEndOfFile()
         } else {
             data = try? Data(contentsOf: URL(fileURLWithPath: file))
         }

         if let d = data {
             do {
                 let plist = try PropertyListSerialization.propertyList(from: d, options: [], format: nil)
                 displayPlist(plist)
             } catch {
                 print("\(file): \(error)")
             }

         } else {
             print("\(file) does not exists or is not readable or is not a regular file")
             doError = true
             continue
         }
     }

     if doError {
         return EXIT_FAILURE
     } else {
         return EXIT_SUCCESS
     }
 }

 func main() -> Int32 {
     var args = ProcessInfo.processInfo.arguments

     if args.count < 2 {
         print("No files specified.")
         return EXIT_FAILURE
     }

     // Throw away process path
     args.removeFirst()
     do {
         let opts = try parseArguments(args)
         switch opts.mode {
             case .lint:
                 return lint(opts)
             case .convert:
                 return convert(opts)
             case .print:
                 return display(opts)
             case .help:
                 return help()
         }
     } catch let err {
         switch err as! OptionParseError {
             case .unrecognizedArgument(let arg):
                 print("unrecognized option: \(arg)")
                 let _ = help()
             case .invalidFormat(let format):
                 print("unrecognized format \(format)\nformat should be one of: xml1 binary1 json")
             case .missingArgument(let errorStr):
                 print(errorStr)
         }
         return EXIT_FAILURE
     }
 }

 exit(main())
	// This source file is part of the Swift.org open source project
	//
	// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
	// Licensed under Apache License v2.0 with Runtime Library Exception
	//
	// See http://swift.org/LICENSE.txt for license information
	// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
	//
	#if os(OSX) \|\| os(iOS)
	import Darwin
	import SwiftFoundation
	#elseif os(Linux)
	import Foundation
	import Glibc
	#endif

	func help() -> Int32 {
	print("plutil: [command_option] [other_options] file...\n" +
	"The file '-' means stdin\n" +
	"Command options are (-lint is the default):\n" +
	" -help show this message and exit\n" +
	" -lint check the property list files for syntax errors\n" +
	" -convert fmt rewrite property list files in format\n" +
	" fmt is one of: xml1 binary1 json\n" +
	" -p print property list in a human-readable fashion\n" +
	" (not for machine parsing! this 'format' is not stable)\n" +
	"There are some additional optional arguments that apply to -convert\n" +
	" -s be silent on success\n" +
	" -o path specify alternate file path name for result;\n" +
	" the -o option is used with -convert, and is only\n" +
	" useful with one file argument (last file overwrites);\n" +
	" the path '-' means stdout\n" +
	" -e extension specify alternate extension for converted files\n" +
	" -r if writing JSON, output in human-readable form\n" +
	" -- specifies that all further arguments are file names\n")
	return EXIT_SUCCESS
	}

	enum ExecutionMode {
	case help
	case lint
	case convert
	case print
	}

	enum ConversionFormat {
	case xml1
	case binary1
	case json
	}

	struct Options {
	var mode: ExecutionMode = .lint
	var silent: Bool = false
	var output: String?
	var fileExtension: String?
	var humanReadable: Bool?
	var conversionFormat: ConversionFormat?
	var inputs = [String]()
	}

	enum OptionParseError : Swift.Error {
	case unrecognizedArgument(String)
	case missingArgument(String)
	case invalidFormat(String)
	}

	func parseArguments(_ args: [String]) throws -> Options {
	var opts = Options()
	var iterator = args.makeIterator()
	while let arg = iterator.next() {
	switch arg {
	case "--":
	while let path = iterator.next() {
	opts.inputs.append(path)
	}
	case "-s":
	opts.silent = true
	case "-o":
	if let path = iterator.next() {
	opts.output = path
	} else {
	throw OptionParseError.missingArgument("-o requires a path argument")
	}
	case "-convert":
	opts.mode = .convert
	if let format = iterator.next() {
	switch format {
	case "xml1":
	opts.conversionFormat = .xml1
	case "binary1":
	opts.conversionFormat = .binary1
	case "json":
	opts.conversionFormat = .json
	default:
	throw OptionParseError.invalidFormat(format)
	}
	} else {
	throw OptionParseError.missingArgument("-convert requires a format argument of xml1 binary1 json")
	}
	case "-e":
	if let ext = iterator.next() {
	opts.fileExtension = ext
	} else {
	throw OptionParseError.missingArgument("-e requires an extension argument")
	}
	case "-help":
	opts.mode = .help
	case "-lint":
	opts.mode = .lint
	case "-p":
	opts.mode = .print
	default:
	if arg.hasPrefix("-") && arg.utf8.count > 1 {
	throw OptionParseError.unrecognizedArgument(arg)
	}
	}
	}

	return opts
	}


	func lint(_ options: Options) -> Int32 {
	if options.output != nil {
	print("-o is not used with -lint")
	let _ = help()
	return EXIT_FAILURE
	}

	if options.fileExtension != nil {
	print("-e is not used with -lint")
	let _ = help()
	return EXIT_FAILURE
	}

	if options.inputs.count < 1 {
	print("No files specified.")
	let _ = help()
	return EXIT_FAILURE
	}

	let silent = options.silent

	var doError = false
	for file in options.inputs {
	let data : Data?
	if file == "-" {
	// stdin
	data = FileHandle.standardInput.readDataToEndOfFile()
	} else {
	data = try? Data(contentsOf: URL(fileURLWithPath: file))
	}

	if let d = data {
	do {
	let _ = try PropertyListSerialization.propertyList(from: d, options: [], format: nil)
	if !silent {
	print("\(file): OK")
	}
	} catch {
	print("\(file): \(error)")

	}

	} else {
	print("\(file) does not exists or is not readable or is not a regular file")
	doError = true
	continue
	}
	}

	if doError {
	return EXIT_FAILURE
	} else {
	return EXIT_SUCCESS
	}
	}

	func convert(_ options: Options) -> Int32 {
	print("Unimplemented")
	return EXIT_FAILURE
	}

	enum DisplayType {
	case primary
	case key
	case value
	}

	extension Dictionary {
	func display(_ indent: Int = 0, type: DisplayType = .primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	switch type {
	case .primary, .key:
	print("\(indentation)[\n", terminator: "")
	case .value:
	print("[\n", terminator: "")
	}

	forEach() {
	if let key = $0.0 as? String {
	key.display(indent + 1, type: .key)
	} else {
	fatalError("plists should have strings as keys but got a \(type(of: $0.0))")
	}
	print(" => ", terminator: "")
	displayPlist($0.1, indent: indent + 1, type: .value)
	}

	print("\(indentation)]\n", terminator: "")
	}
	}

	extension Array {
	func display(_ indent: Int = 0, type: DisplayType = .primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	switch type {
	case .primary, .key:
	print("\(indentation)[\n", terminator: "")
	case .value:
	print("[\n", terminator: "")
	}

	for idx in 0..<count {
	print("\(indentation) \(idx) => ", terminator: "")
	displayPlist(self[idx], indent: indent + 1, type: .value)
	}

	print("\(indentation)]\n", terminator: "")
	}
	}

	extension String {
	func display(_ indent: Int = 0, type: DisplayType = .primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	switch type {
	case .primary:
	print("\(indentation)\"\(self)\"\n", terminator: "")
	case .key:
	print("\(indentation)\"\(self)\"", terminator: "")
	case .value:
	print("\"\(self)\"\n", terminator: "")
	}
	}
	}

	extension Bool {
	func display(_ indent: Int = 0, type: DisplayType = .primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	switch type {
	case .primary:
	print("\(indentation)\"\(self ? "1" : "0")\"\n", terminator: "")
	case .key:
	print("\(indentation)\"\(self ? "1" : "0")\"", terminator: "")
	case .value:
	print("\"\(self ? "1" : "0")\"\n", terminator: "")
	}
	}
	}

	extension NSNumber {
	func display(_ indent: Int = 0, type: DisplayType = .primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	switch type {
	case .primary:
	print("\(indentation)\"\(self)\"\n", terminator: "")
	case .key:
	print("\(indentation)\"\(self)\"", terminator: "")
	case .value:
	print("\"\(self)\"\n", terminator: "")
	}
	}
	}

	extension NSData {
	func display(_ indent: Int = 0, type: DisplayType = .primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	switch type {
	case .primary:
	print("\(indentation)\"\(self)\"\n", terminator: "")
	case .key:
	print("\(indentation)\"\(self)\"", terminator: "")
	case .value:
	print("\"\(self)\"\n", terminator: "")
	}
	}
	}

	func displayPlist(_ plist: Any, indent: Int = 0, type: DisplayType = .primary) {
	switch plist {
	case let val as [String : Any]:
	val.display(indent, type: type)
	case let val as [Any]:
	val.display(indent, type: type)
	case let val as String:
	val.display(indent, type: type)
	case let val as Bool:
	val.display(indent, type: type)
	case let val as NSNumber:
	val.display(indent, type: type)
	case let val as NSData:
	val.display(indent, type: type)
	default:
	fatalError("unhandled type \(type(of: plist))")
	}
	}

	func display(_ options: Options) -> Int32 {
	if options.inputs.count < 1 {
	print("No files specified.")
	let _ = help()
	return EXIT_FAILURE
	}

	var doError = false
	for file in options.inputs {
	let data : Data?
	if file == "-" {
	// stdin
	data = FileHandle.standardInput.readDataToEndOfFile()
	} else {
	data = try? Data(contentsOf: URL(fileURLWithPath: file))
	}

	if let d = data {
	do {
	let plist = try PropertyListSerialization.propertyList(from: d, options: [], format: nil)
	displayPlist(plist)
	} catch {
	print("\(file): \(error)")
	}

	} else {
	print("\(file) does not exists or is not readable or is not a regular file")
	doError = true
	continue
	}
	}

	if doError {
	return EXIT_FAILURE
	} else {
	return EXIT_SUCCESS
	}
	}

	func main() -> Int32 {
	var args = ProcessInfo.processInfo.arguments

	if args.count < 2 {
	print("No files specified.")
	return EXIT_FAILURE
	}

	// Throw away process path
	args.removeFirst()
	do {
	let opts = try parseArguments(args)
	switch opts.mode {
	case .lint:
	return lint(opts)
	case .convert:
	return convert(opts)
	case .print:
	return display(opts)
	case .help:
	return help()
	}
	} catch let err {
	switch err as! OptionParseError {
	case .unrecognizedArgument(let arg):
	print("unrecognized option: \(arg)")
	let _ = help()
	case .invalidFormat(let format):
	print("unrecognized format \(format)\nformat should be one of: xml1 binary1 json")
	case .missingArgument(let errorStr):
	print(errorStr)
	}
	return EXIT_FAILURE
	}
	}

	exit(main())