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)
                 }
                 break
             case "-s":
                 opts.silent = true
                 break
             case "-o":
                 if let path = iterator.next() {
                     opts.output = path
                 } else {
                     throw OptionParseError.MissingArgument("-o requires a path argument")
                 }
                 break
             case "-convert":
                 opts.mode = ExecutionMode.Convert
                 if let format = iterator.next() {
                     switch format {
                         case "xml1":
                             opts.conversionFormat = ConversionFormat.XML1
                             break
                         case "binary1":
                             opts.conversionFormat = ConversionFormat.Binary1
                             break
                         case "json":
                             opts.conversionFormat = ConversionFormat.JSON
                             break
                         default:
                             throw OptionParseError.InvalidFormat(format)
                     }
                 } else {
                     throw OptionParseError.MissingArgument("-convert requires a format argument of xml1 binary1 json")
                 }
                 break
             case "-e":
                 if let ext = iterator.next() {
                     opts.fileExtension = ext
                 } else {
                     throw OptionParseError.MissingArgument("-e requires an extension argument")
                 }
             case "-help":
                 opts.mode = ExecutionMode.Help
                 break
             case "-lint":
                 opts.mode = ExecutionMode.Lint
                 break
             case "-p":
                 opts.mode = ExecutionMode.Print
                 break
             default:
                 if arg.hasPrefix("-") && arg.utf8.count > 1 {
                     throw OptionParseError.UnrecognizedArgument(arg)
                 }
                 break
         }
     }

     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.fileHandleWithStandardInput().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)
         if type == .Primary || type == .Key {
             print("\(indentation)[\n", terminator: "")
         } else {
             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)
         if type == .Primary || type == .Key {
             print("\(indentation)[\n", terminator: "")
         } else {
             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)
         if type == .Primary {
             print("\(indentation)\"\(self)\"\n", terminator: "")
         }
         else if type == .Key {
             print("\(indentation)\"\(self)\"", terminator: "")
         } else {
             print("\"\(self)\"\n", terminator: "")
         }
     }
 }

 extension Bool {
     func display(_ indent: Int = 0, type: DisplayType = .Primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         if type == .Primary {
             print("\(indentation)\"\(self ? "1" : "0")\"\n", terminator: "")
         }
         else if type == .Key {
             print("\(indentation)\"\(self ? "1" : "0")\"", terminator: "")
         } else {
             print("\"\(self ? "1" : "0")\"\n", terminator: "")
         }
     }
 }

 extension NSNumber {
     func display(_ indent: Int = 0, type: DisplayType = .Primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         if type == .Primary {
             print("\(indentation)\"\(self)\"\n", terminator: "")
         }
         else if type == .Key {
             print("\(indentation)\"\(self)\"", terminator: "")
         } else {
             print("\"\(self)\"\n", terminator: "")
         }
     }
 }

 extension NSData {
     func display(_ indent: Int = 0, type: DisplayType = .Primary) {
         let indentation = String(repeating: " ", count: indent * 2)
         if type == .Primary {
             print("\(indentation)\"\(self)\"\n", terminator: "")
         }
         else if type == .Key {
             print("\(indentation)\"\(self)\"", terminator: "")
         } else {
             print("\"\(self)\"\n", terminator: "")
         }
     }
 }

 func displayPlist(_ plist: Any, indent: Int = 0, type: DisplayType = .Primary) {
     if let val = plist as? Dictionary<String, Any> {
         val.display(indent, type: type)
     } else if let val = plist as? Array<Any> {
         val.display(indent, type: type)
     } else if let val = plist as? String {
         val.display(indent, type: type)
     } else if let val = plist as? Bool {
         val.display(indent, type: type)
     } else if let val = plist as? NSNumber {
         val.display(indent, type: type)
     } else if let val = plist as? NSData {
         val.display(indent, type: type)
     } else {
         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.fileHandleWithStandardInput().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()
                 break
             case .InvalidFormat(let format):
                 print("unrecognized format \(format)\nformat should be one of: xml1 binary1 json")
                 break
             case .MissingArgument(let errorStr):
                 print(errorStr)
                 break
         }
         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)
	}
	break
	case "-s":
	opts.silent = true
	break
	case "-o":
	if let path = iterator.next() {
	opts.output = path
	} else {
	throw OptionParseError.MissingArgument("-o requires a path argument")
	}
	break
	case "-convert":
	opts.mode = ExecutionMode.Convert
	if let format = iterator.next() {
	switch format {
	case "xml1":
	opts.conversionFormat = ConversionFormat.XML1
	break
	case "binary1":
	opts.conversionFormat = ConversionFormat.Binary1
	break
	case "json":
	opts.conversionFormat = ConversionFormat.JSON
	break
	default:
	throw OptionParseError.InvalidFormat(format)
	}
	} else {
	throw OptionParseError.MissingArgument("-convert requires a format argument of xml1 binary1 json")
	}
	break
	case "-e":
	if let ext = iterator.next() {
	opts.fileExtension = ext
	} else {
	throw OptionParseError.MissingArgument("-e requires an extension argument")
	}
	case "-help":
	opts.mode = ExecutionMode.Help
	break
	case "-lint":
	opts.mode = ExecutionMode.Lint
	break
	case "-p":
	opts.mode = ExecutionMode.Print
	break
	default:
	if arg.hasPrefix("-") && arg.utf8.count > 1 {
	throw OptionParseError.UnrecognizedArgument(arg)
	}
	break
	}
	}

	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.fileHandleWithStandardInput().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)
	if type == .Primary \|\| type == .Key {
	print("\(indentation)[\n", terminator: "")
	} else {
	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)
	if type == .Primary \|\| type == .Key {
	print("\(indentation)[\n", terminator: "")
	} else {
	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)
	if type == .Primary {
	print("\(indentation)\"\(self)\"\n", terminator: "")
	}
	else if type == .Key {
	print("\(indentation)\"\(self)\"", terminator: "")
	} else {
	print("\"\(self)\"\n", terminator: "")
	}
	}
	}

	extension Bool {
	func display(_ indent: Int = 0, type: DisplayType = .Primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	if type == .Primary {
	print("\(indentation)\"\(self ? "1" : "0")\"\n", terminator: "")
	}
	else if type == .Key {
	print("\(indentation)\"\(self ? "1" : "0")\"", terminator: "")
	} else {
	print("\"\(self ? "1" : "0")\"\n", terminator: "")
	}
	}
	}

	extension NSNumber {
	func display(_ indent: Int = 0, type: DisplayType = .Primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	if type == .Primary {
	print("\(indentation)\"\(self)\"\n", terminator: "")
	}
	else if type == .Key {
	print("\(indentation)\"\(self)\"", terminator: "")
	} else {
	print("\"\(self)\"\n", terminator: "")
	}
	}
	}

	extension NSData {
	func display(_ indent: Int = 0, type: DisplayType = .Primary) {
	let indentation = String(repeating: " ", count: indent * 2)
	if type == .Primary {
	print("\(indentation)\"\(self)\"\n", terminator: "")
	}
	else if type == .Key {
	print("\(indentation)\"\(self)\"", terminator: "")
	} else {
	print("\"\(self)\"\n", terminator: "")
	}
	}
	}

	func displayPlist(_ plist: Any, indent: Int = 0, type: DisplayType = .Primary) {
	if let val = plist as? Dictionary<String, Any> {
	val.display(indent, type: type)
	} else if let val = plist as? Array<Any> {
	val.display(indent, type: type)
	} else if let val = plist as? String {
	val.display(indent, type: type)
	} else if let val = plist as? Bool {
	val.display(indent, type: type)
	} else if let val = plist as? NSNumber {
	val.display(indent, type: type)
	} else if let val = plist as? NSData {
	val.display(indent, type: type)
	} else {
	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.fileHandleWithStandardInput().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()
	break
	case .InvalidFormat(let format):
	print("unrecognized format \(format)\nformat should be one of: xml1 binary1 json")
	break
	case .MissingArgument(let errorStr):
	print(errorStr)
	break
	}
	return EXIT_FAILURE
	}
	}

	exit(main())