├── .github
    └── workflows
    │   └── swift.yml
├── .gitignore
├── .swiftpm
    └── xcode
    │   └── package.xcworkspace
    │       └── contents.xcworkspacedata
├── LICENSE
├── Package.resolved
├── Package.swift
├── README.md
├── Sources
    └── SwiftyOpenGraph
    │   ├── Internal
    │       ├── _KeyValuePair.swift
    │       ├── _getDate.swift
    │       └── _getDuration.swift
    │   ├── OpenGraph.Determiner.swift
    │   ├── OpenGraph.swift
    │   ├── OpenGraphAudio.swift
    │   ├── OpenGraphImage.swift
    │   ├── OpenGraphType.swift
    │   ├── OpenGraphType
    │       ├── ArticleAttributes.swift
    │       ├── BookAttributes.swift
    │       ├── Music
    │       │   ├── AlbumAttributes.swift
    │       │   ├── PlaylistAttributes.swift
    │       │   ├── RadioStationAttributes.swift
    │       │   └── SongAttributes.swift
    │       ├── ProfileAttributes.swift
    │       ├── Video
    │       │   ├── Actor.swift
    │       │   └── SubKind.swift
    │       └── VideoAttributes.swift
    │   └── OpenGraphVideo.swift
└── Tests
    └── SwiftyOpenGraphTests
        ├── Examples
            ├── audio-array.html
            ├── audio-url.html
            ├── image-array.html
            ├── image-url.html
            ├── min.html
            ├── optional.html
            ├── required.html
            └── video-movie.html
        └── OpenGraphTests.swift


/.github/workflows/swift.yml:
--------------------------------------------------------------------------------
 1 | name: Swift
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | jobs:
10 |   build:
11 |     runs-on: macos-13
12 |     strategy:
13 |       matrix:
14 |         swift: ["5.5"]
15 |     steps:
16 |     - uses: maxim-lobanov/setup-xcode@v1
17 |       with:
18 |         xcode-version: 15
19 |     - uses: actions/checkout@v3
20 |     - name: Build
21 |       run: swift build -v
22 |     - name: Run tests
23 |       run: swift test -v
24 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # OS X
2 | .DS_Store
3 | 
4 | # Xcode user settings
5 | xcuserdata/


--------------------------------------------------------------------------------
/.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <Workspace
3 |    version = "1.0">
4 |    <FileRef
5 |       location = "self:">
6 |    </FileRef>
7 | </Workspace>
8 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Creative Commons Legal Code
  2 | 
  3 | CC0 1.0 Universal
  4 | 
  5 |     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
  6 |     LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
  7 |     ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
  8 |     INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
  9 |     REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
 10 |     PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
 11 |     THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
 12 |     HEREUNDER.
 13 | 
 14 | Statement of Purpose
 15 | 
 16 | The laws of most jurisdictions throughout the world automatically confer
 17 | exclusive Copyright and Related Rights (defined below) upon the creator
 18 | and subsequent owner(s) (each and all, an "owner") of an original work of
 19 | authorship and/or a database (each, a "Work").
 20 | 
 21 | Certain owners wish to permanently relinquish those rights to a Work for
 22 | the purpose of contributing to a commons of creative, cultural and
 23 | scientific works ("Commons") that the public can reliably and without fear
 24 | of later claims of infringement build upon, modify, incorporate in other
 25 | works, reuse and redistribute as freely as possible in any form whatsoever
 26 | and for any purposes, including without limitation commercial purposes.
 27 | These owners may contribute to the Commons to promote the ideal of a free
 28 | culture and the further production of creative, cultural and scientific
 29 | works, or to gain reputation or greater distribution for their Work in
 30 | part through the use and efforts of others.
 31 | 
 32 | For these and/or other purposes and motivations, and without any
 33 | expectation of additional consideration or compensation, the person
 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she
 35 | is an owner of Copyright and Related Rights in the Work, voluntarily
 36 | elects to apply CC0 to the Work and publicly distribute the Work under its
 37 | terms, with knowledge of his or her Copyright and Related Rights in the
 38 | Work and the meaning and intended legal effect of CC0 on those rights.
 39 | 
 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be
 41 | protected by copyright and related or neighboring rights ("Copyright and
 42 | Related Rights"). Copyright and Related Rights include, but are not
 43 | limited to, the following:
 44 | 
 45 |   i. the right to reproduce, adapt, distribute, perform, display,
 46 |      communicate, and translate a Work;
 47 |  ii. moral rights retained by the original author(s) and/or performer(s);
 48 | iii. publicity and privacy rights pertaining to a person's image or
 49 |      likeness depicted in a Work;
 50 |  iv. rights protecting against unfair competition in regards to a Work,
 51 |      subject to the limitations in paragraph 4(a), below;
 52 |   v. rights protecting the extraction, dissemination, use and reuse of data
 53 |      in a Work;
 54 |  vi. database rights (such as those arising under Directive 96/9/EC of the
 55 |      European Parliament and of the Council of 11 March 1996 on the legal
 56 |      protection of databases, and under any national implementation
 57 |      thereof, including any amended or successor version of such
 58 |      directive); and
 59 | vii. other similar, equivalent or corresponding rights throughout the
 60 |      world based on applicable law or treaty, and any national
 61 |      implementations thereof.
 62 | 
 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention
 64 | of, applicable law, Affirmer hereby overtly, fully, permanently,
 65 | irrevocably and unconditionally waives, abandons, and surrenders all of
 66 | Affirmer's Copyright and Related Rights and associated claims and causes
 67 | of action, whether now known or unknown (including existing as well as
 68 | future claims and causes of action), in the Work (i) in all territories
 69 | worldwide, (ii) for the maximum duration provided by applicable law or
 70 | treaty (including future time extensions), (iii) in any current or future
 71 | medium and for any number of copies, and (iv) for any purpose whatsoever,
 72 | including without limitation commercial, advertising or promotional
 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
 74 | member of the public at large and to the detriment of Affirmer's heirs and
 75 | successors, fully intending that such Waiver shall not be subject to
 76 | revocation, rescission, cancellation, termination, or any other legal or
 77 | equitable action to disrupt the quiet enjoyment of the Work by the public
 78 | as contemplated by Affirmer's express Statement of Purpose.
 79 | 
 80 | 3. Public License Fallback. Should any part of the Waiver for any reason
 81 | be judged legally invalid or ineffective under applicable law, then the
 82 | Waiver shall be preserved to the maximum extent permitted taking into
 83 | account Affirmer's express Statement of Purpose. In addition, to the
 84 | extent the Waiver is so judged Affirmer hereby grants to each affected
 85 | person a royalty-free, non transferable, non sublicensable, non exclusive,
 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and
 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the
 88 | maximum duration provided by applicable law or treaty (including future
 89 | time extensions), (iii) in any current or future medium and for any number
 90 | of copies, and (iv) for any purpose whatsoever, including without
 91 | limitation commercial, advertising or promotional purposes (the
 92 | "License"). The License shall be deemed effective as of the date CC0 was
 93 | applied by Affirmer to the Work. Should any part of the License for any
 94 | reason be judged legally invalid or ineffective under applicable law, such
 95 | partial invalidity or ineffectiveness shall not invalidate the remainder
 96 | of the License, and in such case Affirmer hereby affirms that he or she
 97 | will not (i) exercise any of his or her remaining Copyright and Related
 98 | Rights in the Work or (ii) assert any associated claims and causes of
 99 | action with respect to the Work, in either case contrary to Affirmer's
100 | express Statement of Purpose.
101 | 
102 | 4. Limitations and Disclaimers.
103 | 
104 |  a. No trademark or patent rights held by Affirmer are waived, abandoned,
105 |     surrendered, licensed or otherwise affected by this document.
106 |  b. Affirmer offers the Work as-is and makes no representations or
107 |     warranties of any kind concerning the Work, express, implied,
108 |     statutory or otherwise, including without limitation warranties of
109 |     title, merchantability, fitness for a particular purpose, non
110 |     infringement, or the absence of latent or other defects, accuracy, or
111 |     the present or absence of errors, whether or not discoverable, all to
112 |     the greatest extent permissible under applicable law.
113 |  c. Affirmer disclaims responsibility for clearing rights of other persons
114 |     that may apply to the Work or any use thereof, including without
115 |     limitation any person's Copyright and Related Rights in the Work.
116 |     Further, Affirmer disclaims responsibility for obtaining any necessary
117 |     consents, permissions or other rights required for any use of the
118 |     Work.
119 |  d. Affirmer understands and acknowledges that Creative Commons is not a
120 |     party to this document and has no duty or obligation with respect to
121 |     this CC0 or use of the Work.
122 | 


--------------------------------------------------------------------------------
/Package.resolved:
--------------------------------------------------------------------------------
 1 | {
 2 |   "object": {
 3 |     "pins": [
 4 |       {
 5 |         "package": "SchafKit",
 6 |         "repositoryURL": "https://github.com/FiveSheepCo/SchafKit.git",
 7 |         "state": {
 8 |           "branch": "master",
 9 |           "revision": "8567f948567e4d6fccb80cca1402e1044a4b01e0",
10 |           "version": null
11 |         }
12 |       },
13 |       {
14 |         "package": "SwiftSoup",
15 |         "repositoryURL": "https://github.com/scinfu/SwiftSoup",
16 |         "state": {
17 |           "branch": "master",
18 |           "revision": "3fa09f4d79e5172b14cb50e02f1d5f115a2bbaef",
19 |           "version": null
20 |         }
21 |       }
22 |     ]
23 |   },
24 |   "version": 1
25 | }
26 | 


--------------------------------------------------------------------------------
/Package.swift:
--------------------------------------------------------------------------------
 1 | // swift-tools-version:5.5
 2 | // The swift-tools-version declares the minimum version of Swift required to build this package.
 3 | 
 4 | import PackageDescription
 5 | 
 6 | let package = Package(
 7 |     name: "SwiftyOpenGraph",
 8 |     platforms: [
 9 |         .macOS(.v10_15),
10 |         .iOS(.v13),
11 |         .watchOS(.v6),
12 |         .tvOS(.v13)
13 |     ],
14 |     products: [
15 |         // Products define the executables and libraries a package produces, and make them visible to other packages.
16 |         .library(
17 |             name: "SwiftyOpenGraph",
18 |             targets: ["SwiftyOpenGraph"]
19 |         ),
20 |     ],
21 |     dependencies: [
22 |         .package(url: "https://github.com/FiveSheepCo/SchafKit.git", .branch("master")),
23 |         .package(url: "https://github.com/scinfu/SwiftSoup", .branch("master")),
24 |     ],
25 |     targets: [
26 |         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
27 |         // Targets can depend on other targets in this package, and on products in packages this package depends on.
28 |         .target(
29 |             name: "SwiftyOpenGraph",
30 |             dependencies: ["SwiftSoup", "SchafKit"]
31 |         ),
32 |         .testTarget(
33 |             name: "SwiftyOpenGraphTests",
34 |             dependencies: ["SwiftyOpenGraph"],
35 |             resources: [.copy("Examples")]
36 |         ),
37 |     ]
38 | )
39 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # SwiftyOpenGraph
  2 | 
  3 | [![GithubCI_Status]][GithubCI_URL] [![LICENSE_BADGE]][LICENSE_URL] ![Platform](https://img.shields.io/badge/platforms-iOS%2013.0%20%7C%20macOS%2010.15%20%7C%20tvOS%2013.0%20%7C%20watchOS%206.0-F28D00.svg)
  4 | 
  5 | -  [Usage](#usage)
  6 |     - [Initialization](#initialization)
  7 |     - [Base Properties](#base-properties)
  8 |     - [Types](#types)
  9 | -  [Installation](#installation)
 10 | -  [License](#license)
 11 | 
 12 | # Usage
 13 | 
 14 | ## Initialization
 15 | 
 16 | You use SwiftyOpenGraph by initializing `OpenGraph`, the root object of SwiftyOpenGraph. There are two initializers of `OpenGraph`:
 17 | 
 18 | ### HTML String
 19 | ```swift
 20 | let graph = OpenGraph(html: htmlString)
 21 | ```
 22 | 
 23 | ### URL
 24 | ```swift
 25 | let graph = try await OpenGraph(url: "https://quintschaf.com/#/app/mykeyboard")
 26 | ```
 27 | 
 28 | Both of these initializers are optional, only returning when the html contains at least the required OpenGraph properties.
 29 | 
 30 | ## Base Properties
 31 | 
 32 | Every valid open graph enabled webpage has four properties, which an `OpenGraph` object exposes as non-optional constants: `title`, `type`, `image` and `url`. It can also contain `additionalImages`, `audios`, `videos`, `description`, `determiner`, `locale`, `alternateLocales` and `siteName`. These are either optional constants of an `OpenGraph` object or they contain the default value as defined by the OpenGraph protocol.
 33 | 
 34 | Images, Audios, Videos and the Determiner are represented by `OpenGraphImage`, `OpenGraphAudio`, `OpenGraphVideo` and `Determiner`. All of them are structs that may contain additional data, e.g. the width of an image, represented by the `"og:image:width"` meta tag.
 35 | 
 36 | Example:
 37 | ```swift
 38 | print(graph.title)  // "MyKeyboard"
 39 | print(graph.type)   // OpenGraphType.website
 40 | print(graph.image)  // OpenGraphImage(url: "...", width: ...)
 41 | print(graph.url)    // "https://quintschaf.com/#/app/mykeyboard"
 42 | 
 43 | print(graph.additionalImages)   // []
 44 | print(graph.audios)             // []
 45 | print(graph.videos)             // []
 46 | print(graph.description)        // Optional("The fully customizable Keyboard.")
 47 | print(graph.determiner)         // Determiner.blank
 48 | print(graph.locale)             // "en_US"
 49 | print(graph.alternateLocales)   // []
 50 | print(graph.siteName)           // nil
 51 | ```
 52 | 
 53 | ## Types
 54 | 
 55 | The type (`"og:type"`) is represented by the `OpenGraphType` enum, which has the following cases (as specified by the OpenGraph spec):
 56 | - `song(SongAttributes)`
 57 | - `album(AlbumAttributes)`
 58 | - `playlist(PlaylistAttributes)`
 59 | - `radioStation(RadioStationAttributes)`
 60 | - `video(VideoAttributes)`
 61 | - `article(ArticleAttributes)`
 62 | - `book(BookAttributes)`
 63 | - `profile(ProfileAttributes)`
 64 | - `website`
 65 | 
 66 | All of these (with the exception of the default type `website`) have a struct as an associated value. These structs hold the values that are specific to the type. Due to their differences in properties, there are seperate cases for `song`, `album`, `playlist` and `radioStation`. Due to them having almost the same properties, there is only one `video` case for all video types. The `VideoAttributes` therefor contains a `kind` property that is an enumeration containing all the video types.
 67 | 
 68 | Example:
 69 | ```swift
 70 | switch graph.type {
 71 | case .video(let attributes):
 72 |     print(attributes.kind)          // VideoAttributes.SubKind.movie
 73 |     print(attributes.actors)        // []
 74 |     print(attributes.directors)     // []
 75 |     print(attributes.writers)       // []
 76 |     print(attributes.duration)      // Optional(200)
 77 |     print(attributes.releaseDate)   // Optional(Date(...))
 78 |     print(attributes.tags)          // ["some", "words", "as", "tags"]
 79 |     print(attributes.series)        // nil
 80 | default:
 81 |     break
 82 | }
 83 | ```
 84 | 
 85 | # Installation
 86 | 
 87 | ### Swift Package Manager
 88 | 
 89 | SwiftyOpenGraph relies on Swift Package Manager and is installed by adding it as a dependency.
 90 | 
 91 | # License
 92 | 
 93 | We have chosen to use the CC0 1.0 Universal license for SwiftyOpenGraph. The following short explanation has no legal implication whatsoever and does not override the license in any way: CC0 1.0 Universal license gives you the right to use or modify all of SwiftyOpenGraphs code in any (commercial or non-commercial) product without mentioning, licensing or other headaches of any kind.
 94 | 
 95 | # Background
 96 | 
 97 | When we were trying to find an OpenGraph implementation in Swift there was only one result. That result was using Regular Expressions to parse the meta tags, which we find unacceptable. So we set out to create one that uses `SwiftSoup` to properly parse the html of a webpage. We also wanted to make sure this project is a perfect 1:1 abstraction of the OpenGraph protocol into Swift. If there are any additions or changes made to the protocol, we will adopt them as fast as possible.
 98 | 
 99 | <!-- References -->
100 | 
101 | [GithubCI_Status]: https://github.com/Quintschaf/SwiftyOpenGraph/actions/workflows/swift.yml/badge.svg?branch=main
102 | [GithubCI_URL]: https://github.com/Quintschaf/SwiftyOpenGraph/actions/workflows/swift.yml
103 | [LICENSE_BADGE]: https://badgen.net/github/license/quintschaf/SwiftyOpenGraph
104 | [LICENSE_URL]: https://github.com/Quintschaf/SwiftyOpenGraph/blob/master/LICENSE
105 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/Internal/_KeyValuePair.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 | 
3 | struct _KeyValuePair {
4 |     let key: String
5 |     let value: String
6 | }
7 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/Internal/_getDate.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | func _getDate(from string: String?) -> Date? {
 4 |     string.flatMap { (dateString: String) in
 5 |         let optionSets: [ISO8601DateFormatter.Options] = [
 6 |             [.withFullDate, .withDashSeparatorInDate],
 7 |             [.withInternetDateTime],
 8 |             [.withFullDate, .withFullTime, .withSpaceBetweenDateAndTime],
 9 |             [.withYear, .withWeekOfYear, .withDashSeparatorInDate],
10 |             [.withYear, .withWeekOfYear, .withDay, .withDashSeparatorInDate],
11 |             [.withYear, .withDay, .withDashSeparatorInDate]
12 |         ]
13 |         
14 |         for options in optionSets {
15 |             let formatter = ISO8601DateFormatter()
16 |             formatter.formatOptions = options
17 |             if let date = formatter.date(from: dateString) {
18 |                 return date
19 |             }
20 |         }
21 |     
22 |         return nil
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/Internal/_getDuration.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | func _getDuration(from string: String?) -> Int? {
 4 |     string.flatMap { (durationString: String) in
 5 |         if let duration = Int(durationString) {
 6 |             return duration
 7 |         } else if let match = durationString.regexMatches(with: "PT(\\d+)M(\\d+)S")?.first,
 8 |                   let minutes = match.captureGroups[0]?.toInt,
 9 |                   let seconds = match.captureGroups[1]?.toInt {
10 |             return minutes * 60 + seconds
11 |         } else {
12 |             return nil
13 |         }
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraph.Determiner.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraph {
 4 |     
 5 |     /// An enum of (`a`, `an`, `the`, "", `auto`). If `auto` is chosen, the consumer of your data should chose between `a` or `an`.
 6 |     public enum Determiner: String {
 7 |         case a, an, the, blank = "", auto
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraph.swift:
--------------------------------------------------------------------------------
  1 | import Foundation
  2 | import SwiftSoup
  3 | import SchafKit
  4 | 
  5 | public struct OpenGraph {
  6 |     /// The title of your object as it should appear within the graph, e.g., "The Rock".
  7 |     public let title: String
  8 |     /// The type of your object, e.g., "video.movie". Depending on the type you specify, other properties may also be required.
  9 |     public let type: OpenGraphType
 10 |     /// An image URL which should represent your object within the graph.
 11 |     public let image: OpenGraphImage
 12 |     /// The canonical URL of your object that will be used as its permanent ID in the graph, e.g., "https://www.imdb.com/title/tt0117500/".
 13 |     public let url: String
 14 |     
 15 |     /// Other images included.
 16 |     public let additionalImages: [OpenGraphImage]
 17 |     
 18 |     /// Audio files to accompany this object.
 19 |     public let audios: [OpenGraphAudio]
 20 |     /// Video files that complement this object.
 21 |     public let videos: [OpenGraphVideo]
 22 |     /// A one to two sentence description of your object.
 23 |     public let description: String?
 24 |     /// The word that appears before this object's title in a sentence. Default is "" (blank).
 25 |     public let determiner : Determiner
 26 |     /// The locale these tags are marked up in. Of the format `language_TERRITORY`. Default is `en_US`.
 27 |     public let locale: String
 28 |     /// An array of other locales this page is available in.
 29 |     public let alternateLocales: [String]
 30 |     /// If your object is part of a larger web site, the name which should be displayed for the overall site. e.g., "IMDb".
 31 |     public let siteName: String?
 32 |     
 33 |     internal enum Constants {
 34 |         static let metaTag = "meta"
 35 |         
 36 |         static let propertyAttribute = "property"
 37 |         static let contentAttribute = "content"
 38 |         
 39 |         static let titleProperty = "og:title"
 40 |         static let urlProperty = "og:url"
 41 |         
 42 |         // TODO: Implement these
 43 |         // Optional properties
 44 |         static let audioProperty = "og:audio"
 45 |         static let descriptionProperty = "og:description"
 46 |         static let determinerProperty = "og:determiner"
 47 |         static let localeProperty = "og:locale"
 48 |         static let alternateLocaleProperty = "og:locale:alternate"
 49 |         static let siteNameProperty = "og:site_name"
 50 |         static let videoProperty = "og:video"
 51 |         
 52 |         // Default values
 53 |         static let defaultLocale = "en_US"
 54 |         static let defaultDeterminer = Determiner.blank
 55 |     }
 56 |     
 57 |     public init?(url: String) async throws {
 58 |         guard
 59 |             let html =
 60 |                 try await SKNetworking
 61 |                 .request(
 62 |                     url: url,
 63 |                     options: [
 64 |                         .headerFields(value: [.userAgent: "Googlebot"]) // Some websites require this to return the open graph values
 65 |                     ]
 66 |                 )
 67 |                 .stringValue else {
 68 |                     return nil
 69 |                 }
 70 |         
 71 |         self.init(html: html)
 72 |     }
 73 |     
 74 |     public init?(html: String)  {
 75 |         do {
 76 |             let doc: Document = try SwiftSoup.parse(html)
 77 |             
 78 |             // Put all meta properties into a key-value pair array
 79 |             let parsed = try doc.select(Constants.metaTag).map({ element in
 80 |                 _KeyValuePair(
 81 |                     key: try element.attr(Constants.propertyAttribute),
 82 |                     value: try element.attr(Constants.contentAttribute)
 83 |                 )
 84 |             })
 85 |             
 86 |             func getFirstValue(for key: String) -> String? {
 87 |                 parsed.first(where: { $0.key == key })?.value
 88 |             }
 89 |             
 90 |             // Find required single values title and url
 91 |             guard
 92 |                 let title = getFirstValue(for: Constants.titleProperty),
 93 |                 let url = getFirstValue(for: Constants.urlProperty) else {
 94 |                     return nil
 95 |                 }
 96 |             
 97 |             // Find images
 98 |             var images: [OpenGraphImage] = []
 99 |             var audios: [OpenGraphAudio] = []
100 |             var videos: [OpenGraphVideo] = []
101 |             for (index, kVP) in parsed.enumerated() {
102 |                 
103 |                 func getRemainingKVPs() -> [_KeyValuePair] {
104 |                     Array(parsed[index+1..<parsed.count])
105 |                 }
106 |                 
107 |                 if OpenGraphImage.Constants.urlProperties.contains(kVP.key) {
108 |                     images.append(
109 |                         .init(
110 |                             url: kVP.value,
111 |                             followingProperties: getRemainingKVPs()
112 |                         )
113 |                     )
114 |                 }
115 |                 
116 |                 if OpenGraphAudio.Constants.urlProperties.contains(kVP.key) {
117 |                     audios.append(.init(
118 |                         url: kVP.value,
119 |                         followingProperties: getRemainingKVPs()
120 |                     ))
121 |                 }
122 |                 
123 |                 if OpenGraphVideo.Constants.urlProperties.contains(kVP.key) {
124 |                     videos.append(.init(
125 |                         url: kVP.value,
126 |                         followingProperties: getRemainingKVPs()
127 |                     ))
128 |                 }
129 |             }
130 |             
131 |             // Make sure the first image exists
132 |             guard let firstImage = images.removeFirstIfExists() else { return nil }
133 |             
134 |             // Decode the type from the given properties
135 |             let type = OpenGraphType(kVPs: parsed)
136 |             
137 |             // Set properties
138 |             self.title = title
139 |             self.image = firstImage
140 |             self.type = type
141 |             self.url = url
142 |             
143 |             self.audios = audios
144 |             self.videos = videos
145 |             self.description = getFirstValue(for: Constants.descriptionProperty)
146 |             self.determiner = Determiner(rawValue: getFirstValue(for: Constants.determinerProperty) ?? Constants.defaultDeterminer.rawValue) ?? Constants.defaultDeterminer
147 |             self.siteName = getFirstValue(for: Constants.siteNameProperty)
148 |             
149 |             self.locale = getFirstValue(for: Constants.localeProperty) ?? Constants.defaultLocale
150 |             self.alternateLocales = parsed.filter({ $0.key == Constants.alternateLocaleProperty }).map(\.value)
151 |             
152 |             self.additionalImages = images
153 |         } catch let err {
154 |             assertionFailure(err.localizedDescription)
155 |             return nil
156 |         }
157 |     }
158 | }
159 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphAudio.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | public struct OpenGraphAudio {
 4 |     public let url: String
 5 |     public let secureUrl: String?
 6 |     public let mimeType: String?
 7 |     public let alt: String?
 8 |     
 9 |     internal enum Constants {
10 |         static let urlProperties = ["og:audio", "og:audio:url"]
11 |         static let secureUrlProperty = "og:audio:secure_url"
12 |         static let mimeTypeProperty = "og:audio:type"
13 |         static let altProperty = "og:audio:alt"
14 |     }
15 |     
16 |     init(url: String, followingProperties: [_KeyValuePair]) {
17 |         var secureUrl: String? = nil
18 |         var mimeType: String? = nil
19 |         var alt: String? = nil
20 |         
21 |         loop: for property in followingProperties {
22 |             switch property.key {
23 |             case Constants.secureUrlProperty:
24 |                 secureUrl = property.value
25 |             case Constants.mimeTypeProperty:
26 |                 mimeType = property.value
27 |             case Constants.altProperty:
28 |                 alt = property.value
29 |             default:
30 |                 // Break the for loop the first time a non-image property is found
31 |                 if !property.key.starts(with: Constants.urlProperties[0]) || property.key == Constants.urlProperties[0] {
32 |                     break loop
33 |                 }
34 |             }
35 |         }
36 |         
37 |         self.url = url
38 |         self.secureUrl = secureUrl
39 |         self.mimeType = mimeType
40 |         self.alt = alt
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphImage.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | public struct OpenGraphImage {
 4 |     
 5 |     public let url: String
 6 |     public let secureUrl: String?
 7 |     public let mimeType: String?
 8 |     public let width: Int?
 9 |     public let height: Int?
10 |     public let alt: String?
11 |     
12 |     internal enum Constants {
13 |         static let urlProperties = ["og:image", "og:image:url"]
14 |         static let secureUrlProperty = "og:image:secure_url"
15 |         static let mimeTypeProperty = "og:image:type"
16 |         static let widthProperty = "og:image:width"
17 |         static let heightProperty = "og:image:height"
18 |         static let altProperty = "og:image:alt"
19 |     }
20 |     
21 |     init(url: String, followingProperties: [_KeyValuePair]) {
22 |         var secureUrl: String? = nil
23 |         var mimeType: String? = nil
24 |         var width: Int? = nil
25 |         var height: Int? = nil
26 |         var alt: String? = nil
27 |         
28 |         loop: for property in followingProperties {
29 |             switch property.key {
30 |             case Constants.secureUrlProperty:
31 |                 secureUrl = property.value
32 |             case Constants.mimeTypeProperty:
33 |                 mimeType = property.value
34 |             case Constants.widthProperty:
35 |                 width = Int(property.value)
36 |             case Constants.heightProperty:
37 |                 height = Int(property.value)
38 |             case Constants.altProperty:
39 |                 alt = property.value
40 |             default:
41 |                 // Break the for loop the first time a non-image property is found
42 |                 if !property.key.starts(with: Constants.urlProperties[0]) || property.key == Constants.urlProperties[0] {
43 |                     break loop
44 |                 }
45 |             }
46 |         }
47 |         
48 |         self.url = url
49 |         self.secureUrl = secureUrl
50 |         self.mimeType = mimeType
51 |         self.width = width
52 |         self.height = height
53 |         self.alt = alt
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | public enum OpenGraphType {
 4 |     
 5 |     internal enum Constants {
 6 |         static let typeProperty = "og:type"
 7 |     }
 8 |     
 9 |     case song(SongAttributes)
10 |     case album(AlbumAttributes)
11 |     case playlist(PlaylistAttributes)
12 |     case radioStation(RadioStationAttributes)
13 |     case video(VideoAttributes)
14 |     case article(ArticleAttributes)
15 |     case book(BookAttributes)
16 |     case profile(ProfileAttributes)
17 |     case website
18 |     
19 |     init(kVPs: [_KeyValuePair]) {
20 |         let type = kVPs.first(where: { $0.key == Constants.typeProperty })?.value
21 |         
22 |         switch type {
23 |         case SongAttributes.Constants.type:
24 |             self = .song(.init(properties: kVPs))
25 |         case AlbumAttributes.Constants.type:
26 |             self = .album(.init(properties: kVPs))
27 |         case PlaylistAttributes.Constants.type:
28 |             self = .playlist(.init(properties: kVPs))
29 |         case RadioStationAttributes.Constants.type:
30 |             self = .radioStation(.init(properties: kVPs))
31 |         default:
32 |             if let type = type, let videoSubKind = VideoAttributes.SubKind(rawValue: type) {
33 |                 self = .video(.init(subKind: videoSubKind, properties: kVPs))
34 |             } else {
35 |                 self = .website
36 |             }
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/ArticleAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct ArticleAttributes {
 6 |         /// When the article was first published.
 7 |         public let publishedTime: Date?
 8 |         /// When the article was last changed.
 9 |         public let modifiedTime: Date?
10 |         /// When the article is out of date after.
11 |         public let expirationTime: Date?
12 |         /// Writers of the article.
13 |         public let authors: [String]
14 |         /// A high-level section name. E.g. Technology.
15 |         public let section: String?
16 |         /// Tag words associated with this article.
17 |         public let tags: [String]
18 |         
19 |         internal enum Constants {
20 |             static let type = "article"
21 |             
22 |             static let publishedTimeProperty = "article:published_time"
23 |             static let modifiedTimeProperty = "article:modified_time"
24 |             static let expirationTimeProperty = "article:expiration_time"
25 |             static let authorProperty = "article:author"
26 |             static let sectionProperty = "article:section"
27 |             static let tagProperty = "article:tag"
28 |         }
29 |         
30 |         init(properties: [_KeyValuePair]) {
31 |             var publishedTimeString: String?
32 |             var modifiedTimeString: String?
33 |             var expirationTimeString: String?
34 |             var authors: [String] = []
35 |             var section: String?
36 |             var tags: [String] = []
37 |             
38 |             for property in properties {
39 |                 switch property.key {
40 |                 case Constants.publishedTimeProperty:
41 |                     publishedTimeString = property.value
42 |                 case Constants.modifiedTimeProperty:
43 |                     modifiedTimeString = property.value
44 |                 case Constants.expirationTimeProperty:
45 |                     expirationTimeString = property.value
46 |                 case Constants.authorProperty:
47 |                     authors.append(property.value)
48 |                 case Constants.sectionProperty:
49 |                     section = property.value
50 |                 case Constants.tagProperty:
51 |                     tags.append(property.value)
52 |                 default:
53 |                     break
54 |                 }
55 |             }
56 |             
57 |             self.publishedTime = _getDate(from: publishedTimeString)
58 |             self.modifiedTime = _getDate(from: modifiedTimeString)
59 |             self.expirationTime = _getDate(from: expirationTimeString)
60 |             self.authors = authors
61 |             self.section = section
62 |             self.tags = tags
63 |         }
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/BookAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct BookAttributes {
 6 |         /// Who wrote this book.
 7 |         public let authors: [String]
 8 |         /// The ISBN.
 9 |         public let isbn: String?
10 |         /// The date the book was released.
11 |         public let releaseDate: Date?
12 |         /// Tag words associated with this book.
13 |         public let tags: [String]
14 |         
15 |         internal enum Constants {
16 |             static let type = "book"
17 |             
18 |             static let authorProperty = "book:author"
19 |             static let isbnProperty = "book:isbn"
20 |             static let releaseDateProperty = "book:release_date"
21 |             static let tagProperty = "book:tag"
22 |         }
23 |         
24 |         init(properties: [_KeyValuePair]) {
25 |             var authors: [String] = []
26 |             var isbn: String?
27 |             var releaseDateString: String?
28 |             var tags: [String] = []
29 |             
30 |             for property in properties {
31 |                 switch property.key {
32 |                 case Constants.authorProperty:
33 |                     authors.append(property.value)
34 |                 case Constants.isbnProperty:
35 |                     isbn = property.value
36 |                 case Constants.releaseDateProperty:
37 |                     releaseDateString = property.value
38 |                 case Constants.tagProperty:
39 |                     tags.append(property.value)
40 |                 default:
41 |                     break
42 |                 }
43 |             }
44 |             
45 |             self.authors = authors
46 |             self.isbn = isbn
47 |             self.releaseDate = _getDate(from: releaseDateString)
48 |             self.tags = tags
49 |         }
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/Music/AlbumAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct AlbumAttributes {
 6 |         /// The song on this album.
 7 |         public let songs: [SongAttributes]
 8 |         /// The musician that made this album.
 9 |         public let musician: String?
10 |         /// The date the album was released.
11 |         public let releaseDate: Date?
12 |         
13 |         enum Constants {
14 |             static let type = "music.album"
15 |             
16 |             static let urlProperty = "music:album"
17 |             static let musicianProperty = "music:musician"
18 |             static let releaseDateProperty = "music:release_date"
19 |         }
20 |         
21 |         init(properties: [_KeyValuePair]) {
22 |             var songs: [SongAttributes] = []
23 |             var musician: String?
24 |             var releaseDateString: String?
25 |             
26 |             for (index, property) in properties.enumerated() {
27 |                 switch property.key {
28 |                 case SongAttributes.Constants.urlProperty:
29 |                     songs.append(
30 |                         .init(
31 |                             url: property.value,
32 |                             properties: Array(properties[index+1..<properties.count]),
33 |                             isInAlbumOrPlaylist: true
34 |                         )
35 |                     )
36 |                 case Constants.musicianProperty:
37 |                     musician = property.value
38 |                 case Constants.releaseDateProperty:
39 |                     releaseDateString = property.value
40 |                 default:
41 |                     break
42 |                 }
43 |             }
44 |             
45 |             self.songs = songs
46 |             self.musician = musician
47 |             self.releaseDate = _getDate(from: releaseDateString)
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/Music/PlaylistAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct PlaylistAttributes {
 6 |         /// The songs on this playlist.
 7 |         public let songs: [SongAttributes]
 8 |         /// The creator of this playlist.
 9 |         public let creator: String?
10 |         
11 |         enum Constants {
12 |             static let type = "music.playlist"
13 |             
14 |             static let creatorProperty = "music:creator"
15 |         }
16 |         
17 |         init(properties: [_KeyValuePair]) {
18 |             var songs: [SongAttributes] = []
19 |             var creator: String?
20 |             
21 |             for (index, property) in properties.enumerated() {
22 |                 switch property.key {
23 |                 case SongAttributes.Constants.urlProperty:
24 |                     songs.append(
25 |                         .init(
26 |                             url: property.value,
27 |                             properties: Array(properties[index+1..<properties.count]),
28 |                             isInAlbumOrPlaylist: true
29 |                         )
30 |                     )
31 |                 case Constants.creatorProperty:
32 |                     creator = property.value
33 |                 default:
34 |                     break
35 |                 }
36 |             }
37 |             
38 |             self.songs = songs
39 |             self.creator = creator
40 |         }
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/Music/RadioStationAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct RadioStationAttributes {
 6 |         /// The creator of this station.
 7 |         public let creator: String?
 8 |         
 9 |         enum Constants {
10 |             static let type = "music.radio_station"
11 |             
12 |             static let creatorProperty = "music:creator"
13 |         }
14 |         
15 |         init(properties: [_KeyValuePair]) {
16 |             var creator: String?
17 |             
18 |             for property in properties {
19 |                 switch property.key {
20 |                 case Constants.creatorProperty:
21 |                     creator = property.value
22 |                 default:
23 |                     break
24 |                 }
25 |             }
26 |             
27 |             self.creator = creator
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/Music/SongAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct SongAttributes {
 6 |         /// The url of the song. Only set if the song is included as a subtype (in an album or a playlist).
 7 |         public let url: String?
 8 |         
 9 |         /// The song's length in seconds.
10 |         public let duration: Int?
11 |         /// The album this song is from.
12 |         public let albumUrl: String?
13 |         /// Which disc of the album this song is on.
14 |         public let disc: Int?
15 |         /// Which track this song is.
16 |         public let track: Int?
17 |         /// The musician that made this song.
18 |         public let musician: String?
19 |         
20 |         internal enum Constants {
21 |             static let type = "music.song"
22 |             
23 |             static let urlProperty = "music:song"
24 |             static let durationProperty = "music:duration"
25 |             static let albumDiscProperty = "music:album:disc"
26 |             static let albumTrackProperty = "music:album:track"
27 |             static let songDiscProperty = "music:song:disc"
28 |             static let songTrackProperty = "music:song:track"
29 |             static let songDurationProperty = "music:song:duration"
30 |             static let musicianProperty = "music:musician"
31 |         }
32 |         
33 |         init(url: String? = nil, properties: [_KeyValuePair], isInAlbumOrPlaylist: Bool = false) {
34 |             var durationString: String?
35 |             var albumUrl: String?
36 |             var disc: Int?
37 |             var track: Int?
38 |             var musician: String?
39 |             
40 |             if isInAlbumOrPlaylist {
41 |                 loop: for property in properties {
42 |                     switch property.key {
43 |                     case Constants.songDurationProperty:
44 |                         durationString = property.value
45 |                     case Constants.songDiscProperty:
46 |                         disc = Int(property.value)
47 |                     case Constants.songTrackProperty:
48 |                         track = Int(property.value)
49 |                     default:
50 |                         // Break the for loop the first time a non-image property is found
51 |                         if !property.key.starts(with: Constants.urlProperty) || property.key == Constants.urlProperty {
52 |                             break loop
53 |                         }
54 |                     }
55 |                 }
56 |             } else {
57 |                 for property in properties {
58 |                     switch property.key {
59 |                     case Constants.durationProperty:
60 |                         durationString = property.value
61 |                     case AlbumAttributes.Constants.urlProperty:
62 |                         albumUrl = property.value
63 |                     case Constants.albumDiscProperty:
64 |                         disc = Int(property.value)
65 |                     case Constants.albumTrackProperty:
66 |                         track = Int(property.value)
67 |                     case Constants.musicianProperty:
68 |                         musician = property.value
69 |                     default:
70 |                         break
71 |                     }
72 |                 }
73 |             }
74 |             
75 |             self.url = url
76 |             self.duration = _getDuration(from: durationString)
77 |             self.albumUrl = albumUrl
78 |             self.disc = disc
79 |             self.track = track
80 |             self.musician = musician
81 |         }
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/ProfileAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct ProfileAttributes {
 6 |         /// A name normally given to an individual by a parent or self-chosen.
 7 |         public let firstName: String?
 8 |         /// A name inherited from a family or marriage and by which the individual is commonly known.
 9 |         public let lastName: String?
10 |         /// A short unique string to identify them.
11 |         public let username: String?
12 |         /// Their gender.
13 |         public let gender: Gender?
14 |         
15 |         internal enum Constants {
16 |             static let type = "article"
17 |             
18 |             static let firstNameProperty = "article:first_name"
19 |             static let lastNameProperty = "article:last_name"
20 |             static let usernameProperty = "article:username"
21 |             static let genderProperty = "article:gender"
22 |         }
23 |         
24 |         public enum Gender: String {
25 |             case male, female
26 |         }
27 |         
28 |         init(properties: [_KeyValuePair]) {
29 |             var firstName: String?
30 |             var lastName: String?
31 |             var username: String?
32 |             var gender: Gender?
33 |             
34 |             for property in properties {
35 |                 switch property.key {
36 |                 case Constants.firstNameProperty:
37 |                     firstName = property.value
38 |                 case Constants.lastNameProperty:
39 |                     lastName = property.value
40 |                 case Constants.usernameProperty:
41 |                     username = property.value
42 |                 case Constants.genderProperty:
43 |                     gender = Gender(rawValue: property.value)
44 |                 default:
45 |                     break
46 |                 }
47 |             }
48 |             
49 |             self.firstName = firstName
50 |             self.lastName = lastName
51 |             self.username = username
52 |             self.gender = gender
53 |         }
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/Video/Actor.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType.VideoAttributes {
 4 |     
 5 |     public struct Actor {
 6 |         public let url: String
 7 |         public let role: String?
 8 |         
 9 |         internal enum Constants {
10 |             static let urlProperty = "video:actor"
11 |             static let roleProperty = "video:actor:role"
12 |         }
13 |         
14 |         init(url: String, followingProperties: [_KeyValuePair]) {
15 |             var role: String? = nil
16 |             
17 |             loop: for property in followingProperties {
18 |                 switch property.key {
19 |                 case Constants.roleProperty:
20 |                     role = property.value
21 |                 default:
22 |                     // Break the for loop the first time a non-image property is found
23 |                     if !property.key.starts(with: Constants.urlProperty) || property.key == Constants.urlProperty {
24 |                         break loop
25 |                     }
26 |                 }
27 |             }
28 |             
29 |             self.url = url
30 |             self.role = role
31 |         }
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/Video/SubKind.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType.VideoAttributes {
 4 |     
 5 |     public enum SubKind: String, CaseIterable {
 6 |         case movie = "video.movie"
 7 |         case episode = "video.episode"
 8 |         case tvShow = "video.tv_show"
 9 |         case other = "video.other"
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphType/VideoAttributes.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | extension OpenGraphType {
 4 |     
 5 |     public struct VideoAttributes {
 6 |         
 7 |         /// The kind of the video.
 8 |         public let kind: SubKind
 9 |         /// Actors in the movie.
10 |         public let actors: [Actor]
11 |         /// Directors of the movie.
12 |         public let directors: [String]
13 |         /// Writers of the movie.
14 |         public let writers: [String]
15 |         /// The movie's length in seconds.
16 |         public let duration: Int?
17 |         /// The date the movie was released.
18 |         public let releaseDate: Date?
19 |         /// Tag words associated with this movie.
20 |         public let tags: [String]
21 |         /// Which series a tv episode belongs to.
22 |         public let series: String?
23 |         
24 |         internal enum Constants {
25 |             static let directorProperty = "video:director"
26 |             static let writerProperty = "video:writer"
27 |             static let durationProperty = "video:duration"
28 |             static let releaseDateProperty = "video:release_date"
29 |             static let tagProperty = "video:tag"
30 |             static let seriesProperty = "video:series"
31 |         }
32 |         
33 |         init(subKind: SubKind, properties: [_KeyValuePair]) {
34 |             self.kind = subKind
35 |             
36 |             var actors: [Actor] = []
37 |             var directors: [String] = []
38 |             var writers: [String] = []
39 |             var durationString: String?
40 |             var releaseDateString: String?
41 |             var tags: [String] = []
42 |             var series: String?
43 |             
44 |             for (index, property) in properties.enumerated() {
45 |                 switch property.key {
46 |                 case Actor.Constants.urlProperty:
47 |                     actors.append(
48 |                         .init(
49 |                             url: property.value,
50 |                             followingProperties: Array(properties[index+1..<properties.count])
51 |                         )
52 |                     )
53 |                 case Constants.durationProperty:
54 |                     durationString = property.value
55 |                 case Constants.directorProperty:
56 |                     directors.append(property.value)
57 |                 case Constants.writerProperty:
58 |                     writers.append(property.value)
59 |                 case Constants.tagProperty:
60 |                     tags.append(property.value)
61 |                 case Constants.releaseDateProperty:
62 |                     releaseDateString = property.value
63 |                 case Constants.seriesProperty:
64 |                     series = property.value
65 |                 default:
66 |                     break
67 |                 }
68 |             }
69 |             
70 |             self.actors = actors
71 |             self.directors = directors
72 |             self.writers = writers
73 |             self.duration = _getDuration(from: durationString)
74 |             self.releaseDate = _getDate(from: releaseDateString)
75 |             self.tags = tags
76 |             self.series = series
77 |         }
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/Sources/SwiftyOpenGraph/OpenGraphVideo.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | public struct OpenGraphVideo {
 4 |     public let url: String
 5 |     public let secureUrl: String?
 6 |     public let mimeType: String?
 7 |     public let width: Int?
 8 |     public let height: Int?
 9 |     public let alt: String?
10 |     
11 |     internal enum Constants {
12 |         static let urlProperties = ["og:video", "og:video:url"]
13 |         static let secureUrlProperty = "og:video:secure_url"
14 |         static let mimeTypeProperty = "og:video:type"
15 |         static let widthProperty = "og:video:width"
16 |         static let heightProperty = "og:video:height"
17 |         static let altProperty = "og:video:alt"
18 |     }
19 |     
20 |     init(url: String, followingProperties: [_KeyValuePair]) {
21 |         var secureUrl: String? = nil
22 |         var mimeType: String? = nil
23 |         var width: Int? = nil
24 |         var height: Int? = nil
25 |         var alt: String? = nil
26 |         
27 |         loop: for property in followingProperties {
28 |             switch property.key {
29 |             case Constants.secureUrlProperty:
30 |                 secureUrl = property.value
31 |             case Constants.mimeTypeProperty:
32 |                 mimeType = property.value
33 |             case Constants.widthProperty:
34 |                 width = Int(property.value)
35 |             case Constants.heightProperty:
36 |                 height = Int(property.value)
37 |             case Constants.altProperty:
38 |                 alt = property.value
39 |             default:
40 |                 // Break the for loop the first time a non-image property is found
41 |                 if !property.key.starts(with: Constants.urlProperties[0]) || property.key == Constants.urlProperties[0] {
42 |                     break loop
43 |                 }
44 |             }
45 |         }
46 |         
47 |         self.url = url
48 |         self.secureUrl = secureUrl
49 |         self.mimeType = mimeType
50 |         self.width = width
51 |         self.height = height
52 |         self.alt = alt
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/audio-array.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns#">
 4 | <meta charset="utf-8">
 5 | <title>Two structured audio properties</title>
 6 | <meta property="og:title" content="Two structured audio properties">
 7 | <meta property="og:site_name" content="Open Graph protocol examples">
 8 | <meta property="og:type" content="website">
 9 | <meta property="og:locale" content="en_US">
10 | <link rel="canonical" href="http://examples.opengraphprotocol.us/audio-array.html">
11 | <meta property="og:url" content="http://examples.opengraphprotocol.us/audio-array.html">
12 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/50.png">
13 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png">
14 | <meta property="og:image:width" content="50">
15 | <meta property="og:image:height" content="50">
16 | <meta property="og:image:type" content="image/png">
17 | <meta property="og:audio" content="http://examples.opengraphprotocol.us/media/audio/1khz.mp3">
18 | <meta property="og:audio:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/audio/1khz.mp3">
19 | <meta property="og:audio:type" content="audio/mpeg">
20 | <meta property="og:audio" content="http://examples.opengraphprotocol.us/media/audio/250hz.mp3">
21 | <meta property="og:audio:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/audio/250hz.mp3">
22 | <meta property="og:audio:type" content="audio/mpeg">
23 | <meta property="og:audio:alt" content="The second audio, at 250hz.">
24 | </head>
25 | <body>
26 | <p>Audio property with type declaration as structured property.</p>
27 | </body>
28 | </html>
29 | 


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/audio-url.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns#">
 4 | <meta charset="utf-8">
 5 | <title>Structured audio property</title>
 6 | <meta property="og:title" content="Structured audio property">
 7 | <meta property="og:site_name" content="Open Graph protocol examples">
 8 | <meta property="og:type" content="website">
 9 | <meta property="og:locale" content="en_US">
10 | <link rel="canonical" href="http://examples.opengraphprotocol.us/audio-url.html">
11 | <meta property="og:url" content="http://examples.opengraphprotocol.us/audio-url.html">
12 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/50.png">
13 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png">
14 | <meta property="og:image:width" content="50">
15 | <meta property="og:image:height" content="50">
16 | <meta property="og:image:type" content="image/png">
17 | <meta property="og:audio:url" content="http://examples.opengraphprotocol.us/media/audio/250hz.mp3">
18 | <meta property="og:audio:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/audio/250hz.mp3">
19 | <meta property="og:audio:type" content="audio/mpeg">
20 | </head>
21 | <body>
22 | <p>Audio defined as structured properties.</p>
23 | <p>Compare to <a href="/audio.html">og:audio alias</a> for parser support of og:audio:url vs. og:audio.</p>
24 | </body>
25 | </html>


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/image-array.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns#">
 4 | <meta charset="utf-8">
 5 | <title>Two structured image properties</title>
 6 | <meta property="og:title" content="Two structured image properties">
 7 | <meta property="og:site_name" content="Open Graph protocol examples">
 8 | <meta property="og:type" content="website">
 9 | <meta property="og:locale" content="en_US">
10 | <link rel="canonical" href="http://examples.opengraphprotocol.us/image-array.html">
11 | <meta property="og:url" content="http://examples.opengraphprotocol.us/image-array.html">
12 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/75.png">
13 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/75.png">
14 | <meta property="og:image:width" content="75">
15 | <meta property="og:image:height" content="75">
16 | <meta property="og:image:type" content="image/png">
17 | <meta property="og:image:alt" content="The first image, at 75x75px.">
18 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/50.png">
19 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png">
20 | <meta property="og:image:width" content="50">
21 | <meta property="og:image:height" content="50">
22 | <meta property="og:image:type" content="image/png">
23 | </head>
24 | <body>
25 | <p>Two images declared as an <a href="http://ogp.me/#array">array</a>.</p>
26 | </body>
27 | </html>
28 | 


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/image-url.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns#">
 4 | <meta charset="utf-8">
 5 | <title>Full structured image property</title>
 6 | <meta property="og:title" content="Full structured image property">
 7 | <meta property="og:site_name" content="Open Graph protocol examples">
 8 | <meta property="og:type" content="website">
 9 | <meta property="og:locale" content="en_US">
10 | <link rel="canonical" href="http://examples.opengraphprotocol.us/image-url.html">
11 | <meta property="og:url" content="http://examples.opengraphprotocol.us/image-url.html">
12 | <meta property="og:image:url" content="http://examples.opengraphprotocol.us/media/images/50.png">
13 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png">
14 | <meta property="og:image:width" content="50">
15 | <meta property="og:image:height" content="50">
16 | <meta property="og:image:type" content="image/png">
17 | </head>
18 | <body>
19 | <p>Example of basic properties with a <a href="http://ogp.me/#structured">structured</a> image including og:image:url.</p>
20 | <p>Compare to <a href="/image.html">og:image alias</a> for parser support of og:image:url vs. og:image.</p>
21 | </body>
22 | </html>


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/min.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 | <meta charset="utf-8">
 5 | <title>Minimal HTML</title>
 6 | <meta property="og:site_name" content="Open Graph protocol examples">
 7 | <meta property="og:description" content="Content not on page">
 8 | </head>
 9 | <body>
10 | <img alt="logo" src="http://examples.opengraphprotocol.us/media/images/logo.png" width="300" height="300">
11 | <p>An example of an HTML document lacking <a href="http://ogp.me/#metadata">required</a> properties.</p>
12 | <p>Contains optional properties and HTML fallback content.</p>
13 | </body>
14 | </html>


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/optional.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns#">
 4 | <meta charset="utf-8">
 5 | <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
 6 | <title>Open Graph protocol examples</title>
 7 | <meta name="description" content="Example HTML documents marked up with Open Graph protocol.">
 8 | <meta property="og:description" content="Example HTML documents marked up with Open Graph protocol.">
 9 | <meta property="og:type" content="website">
10 | <meta property="og:locale" content="de_DE">
11 | <meta property="og:locale:alternate" content="en_US">
12 | <meta property="og:locale:alternate" content="fr_FR">
13 | <meta property="og:title" content="Open Graph protocol examples">
14 | <meta property="og:site_name" content="Open Graph protocol examples">
15 | <meta property="og:determiner" content="the">
16 | <link rel="canonical" href="http://examples.opengraphprotocol.us/">
17 | <meta property="og:url" content="http://examples.opengraphprotocol.us/">
18 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/logo.png">
19 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/logo.png">
20 | <meta property="og:image:type" content="image/png">
21 | <meta property="og:image:width" content="300">
22 | <meta property="og:image:height" content="300">
23 | </head>
24 | <body>
25 | </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/required.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns#">
 4 | <meta charset="utf-8">
 5 | <title>Minimum required properties</title>
 6 | <meta property="og:title" content="Minimum required properties">
 7 | <link rel="canonical" href="http://examples.opengraphprotocol.us/required.html">
 8 | <meta property="og:url" content="http://examples.opengraphprotocol.us/required.html">
 9 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/50.png">
10 | </head>
11 | <body>
12 | </body>
13 | </html>


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/Examples/video-movie.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head prefix="og: http://ogp.me/ns# video: http://ogp.me/ns/video#">
 4 | <meta charset="utf-8">
 5 | <title>Arrival of a Train at La Ciotat</title>
 6 | <meta property="og:title" content="Arrival of a Train at La Ciotat">
 7 | <meta property="og:description" content="L'arrivée d'un train en gare de La Ciotat is an 1895 French short black-and-white silent documentary film directed and produced by Auguste and Louis Lumière. Its first public showing took place in January 1896.">
 8 | <meta property="og:site_name" content="Open Graph protocol examples">
 9 | <meta property="og:type" content="video.movie">
10 | <meta property="og:locale" content="en_US">
11 | <link rel="canonical" href="http://examples.opengraphprotocol.us/video-movie.html">
12 | <meta property="og:url" content="http://examples.opengraphprotocol.us/video-movie.html">
13 | <meta property="og:image" content="http://examples.opengraphprotocol.us/media/images/train.jpg">
14 | <meta property="og:image:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/images/train.jpg">
15 | <meta property="og:image:width" content="500">
16 | <meta property="og:image:height" content="328">
17 | <meta property="og:image:type" content="image/jpeg">
18 | <meta property="og:video" content="http://fpdownload.adobe.com/strobe/FlashMediaPlayback.swf?src=http%3A%2F%2Fexamples.opengraphprotocol.us%2Fmedia%2Fvideo%2Ftrain.mp4">
19 | <meta property="og:video:secure_url" content="https://fpdownload.adobe.com/strobe/FlashMediaPlayback.swf?src=https%3A%2F%2Fd72cgtgi6hvvl.cloudfront.net%2Fmedia%2Fvideo%2Ftrain.mp4">
20 | <meta property="og:video:type" content="application/x-shockwave-flash">
21 | <meta property="og:video:width" content="472">
22 | <meta property="og:video:height" content="296">
23 | <meta property="og:video" content="http://examples.opengraphprotocol.us/media/video/train.mp4">
24 | <meta property="og:video:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/video/train.mp4">
25 | <meta property="og:video:type" content="video/mp4">
26 | <meta property="og:video:width" content="472">
27 | <meta property="og:video:height" content="296">
28 | <meta property="og:video" content="http://examples.opengraphprotocol.us/media/video/train.webm">
29 | <meta property="og:video:secure_url" content="https://d72cgtgi6hvvl.cloudfront.net/media/video/train.webm">
30 | <meta property="og:video:type" content="video/webm">
31 | <meta property="og:video:width" content="480">
32 | <meta property="og:video:height" content="320">
33 | <meta property="video:release_date" content="1895-12-28">
34 | <meta property="video:director" content="http://examples.opengraphprotocol.us/profile.html">
35 | <meta property="video:duration" content="50">
36 | <meta property="video:tag" content="La Ciotat">
37 | <meta property="video:tag" content="train">
38 | </head>
39 | <body>
40 | <p>A <a href="http://ogp.me/#type_video.movie">video.movie</a> object.</p>
41 | </body>
42 | </html>


--------------------------------------------------------------------------------
/Tests/SwiftyOpenGraphTests/OpenGraphTests.swift:
--------------------------------------------------------------------------------
  1 | import XCTest
  2 | import SchafKit
  3 | @testable import SwiftyOpenGraph
  4 | 
  5 | final class OpenGraphTests: XCTestCase {
  6 |     
  7 |     func getHtml(for url: String) async -> String {
  8 |         let result = try! await SKNetworking.request(url: url)
  9 |         
 10 |         return .init(data: result.data, encoding: .utf8)!
 11 |     }
 12 |     
 13 |     func test(date: Date?, shortUSString: String) {
 14 |         XCTAssertNotNil(date)
 15 |         
 16 |         let formatter = DateFormatter(dateStyle: .short)
 17 |         formatter.locale = .init(identifier: "en_US")
 18 |         XCTAssertEqual(formatter.string(from: date!), shortUSString)
 19 |     }
 20 |     
 21 |     func getGraph(filename: String) -> OpenGraph? {
 22 |         do {
 23 |             let thisSourceFile = URL(fileURLWithPath: #file)
 24 |             let thisDirectory = thisSourceFile.deletingLastPathComponent().absoluteString
 25 |             let html = try String(contentsOf: URL(string: "\(thisDirectory)Examples/\(filename).html")!)
 26 |             
 27 |             return OpenGraph(html: html)
 28 |         }
 29 |         catch let err {
 30 |             XCTFail("File retrieval failed with error: \(err)")
 31 |         }
 32 |         return nil
 33 |     }
 34 |     
 35 |     func testRequired() {
 36 |         guard let graph = getGraph(filename: "required") else {
 37 |             XCTFail("No graph object found.")
 38 |             return
 39 |         }
 40 |         
 41 |         XCTAssertEqual(graph.title, "Minimum required properties")
 42 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/required.html")
 43 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/50.png")
 44 |         XCTAssertNil(graph.image.mimeType)
 45 |         XCTAssertEqual(graph.determiner, .blank)
 46 |         
 47 |         XCTAssertTrue(graph.additionalImages.isEmpty)
 48 |     }
 49 |     
 50 |     func testOptional() {
 51 |         guard let graph = getGraph(filename: "optional") else {
 52 |             XCTFail("No graph object found.")
 53 |             return
 54 |         }
 55 |         
 56 |         XCTAssertEqual(graph.title, "Open Graph protocol examples")
 57 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/")
 58 |         XCTAssertEqual(graph.determiner, .the)
 59 |         XCTAssertEqual(graph.locale, "de_DE")
 60 |         XCTAssertEqual(graph.alternateLocales, ["en_US", "fr_FR"])
 61 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/logo.png")
 62 |         XCTAssertEqual(graph.image.width, 300)
 63 |         XCTAssertEqual(graph.image.height, 300)
 64 |         XCTAssertEqual(graph.image.mimeType, "image/png")
 65 |         
 66 |         XCTAssertTrue(graph.additionalImages.isEmpty)
 67 |     }
 68 |     
 69 |     func testImageArray() {
 70 |         guard let graph = getGraph(filename: "image-array") else {
 71 |             XCTFail("No graph object found.")
 72 |             return
 73 |         }
 74 |         
 75 |         XCTAssertEqual(graph.title, "Two structured image properties")
 76 |         XCTAssertEqual(graph.siteName, "Open Graph protocol examples")
 77 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/image-array.html")
 78 |         
 79 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/75.png")
 80 |         XCTAssertEqual(graph.image.secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/images/75.png")
 81 |         XCTAssertEqual(graph.image.width, 75)
 82 |         XCTAssertEqual(graph.image.height, 75)
 83 |         XCTAssertEqual(graph.image.mimeType, "image/png")
 84 |         XCTAssertEqual(graph.image.alt, "The first image, at 75x75px.")
 85 |         
 86 |         XCTAssertEqual(graph.additionalImages.count, 1)
 87 |         
 88 |         XCTAssertEqual(graph.additionalImages[0].url, "http://examples.opengraphprotocol.us/media/images/50.png")
 89 |         XCTAssertEqual(graph.additionalImages[0].secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png")
 90 |         XCTAssertEqual(graph.additionalImages[0].width, 50)
 91 |         XCTAssertEqual(graph.additionalImages[0].height, 50)
 92 |         XCTAssertEqual(graph.additionalImages[0].mimeType, "image/png")
 93 |         XCTAssertNil(graph.additionalImages[0].alt)
 94 |         
 95 |         switch graph.type {
 96 |         case .website:
 97 |             break
 98 |         default:
 99 |             XCTFail("Graph type was not album.")
100 |             return
101 |         }
102 |     }
103 |     
104 |     func testImageURL() {
105 |         guard let graph = getGraph(filename: "image-url") else {
106 |             XCTFail("No graph object found.")
107 |             return
108 |         }
109 |         
110 |         XCTAssertEqual(graph.title, "Full structured image property")
111 |         XCTAssertEqual(graph.siteName, "Open Graph protocol examples")
112 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/image-url.html")
113 |         
114 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/50.png")
115 |         XCTAssertEqual(graph.image.secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png")
116 |         XCTAssertEqual(graph.image.width, 50)
117 |         XCTAssertEqual(graph.image.height, 50)
118 |         XCTAssertEqual(graph.image.mimeType, "image/png")
119 |         
120 |         XCTAssertTrue(graph.additionalImages.isEmpty)
121 |         
122 |         switch graph.type {
123 |         case .website:
124 |             break
125 |         default:
126 |             XCTFail("Graph type was not album.")
127 |             return
128 |         }
129 |     }
130 |     
131 |     func testAudioArray() {
132 |         guard let graph = getGraph(filename: "audio-array") else {
133 |             XCTFail("No graph object found.")
134 |             return
135 |         }
136 |         
137 |         XCTAssertEqual(graph.title, "Two structured audio properties")
138 |         XCTAssertEqual(graph.siteName, "Open Graph protocol examples")
139 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/audio-array.html")
140 |         
141 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/50.png")
142 |         XCTAssertEqual(graph.image.secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png")
143 |         XCTAssertEqual(graph.image.width, 50)
144 |         XCTAssertEqual(graph.image.height, 50)
145 |         XCTAssertEqual(graph.image.mimeType, "image/png")
146 |         
147 |         XCTAssertEqual(graph.audios.count, 2)
148 |         
149 |         XCTAssertEqual(graph.audios[0].url, "http://examples.opengraphprotocol.us/media/audio/1khz.mp3")
150 |         XCTAssertEqual(graph.audios[0].secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/audio/1khz.mp3")
151 |         XCTAssertEqual(graph.audios[0].mimeType, "audio/mpeg")
152 |         XCTAssertNil(graph.audios[0].alt)
153 |         
154 |         XCTAssertEqual(graph.audios[1].url, "http://examples.opengraphprotocol.us/media/audio/250hz.mp3")
155 |         XCTAssertEqual(graph.audios[1].secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/audio/250hz.mp3")
156 |         XCTAssertEqual(graph.audios[1].mimeType, "audio/mpeg")
157 |         XCTAssertEqual(graph.audios[1].alt, "The second audio, at 250hz.")
158 |         
159 |         switch graph.type {
160 |         case .website:
161 |             break
162 |         default:
163 |             XCTFail("Graph type was not album.")
164 |             return
165 |         }
166 |     }
167 |     
168 |     func testAudioURL() {
169 |         guard let graph = getGraph(filename: "audio-url") else {
170 |             XCTFail("No graph object found.")
171 |             return
172 |         }
173 |         
174 |         XCTAssertEqual(graph.title, "Structured audio property")
175 |         XCTAssertEqual(graph.siteName, "Open Graph protocol examples")
176 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/audio-url.html")
177 |         
178 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/50.png")
179 |         XCTAssertEqual(graph.image.secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/images/50.png")
180 |         XCTAssertEqual(graph.image.width, 50)
181 |         XCTAssertEqual(graph.image.height, 50)
182 |         XCTAssertEqual(graph.image.mimeType, "image/png")
183 |         
184 |         XCTAssertEqual(graph.audios.count, 1)
185 |         
186 |         XCTAssertEqual(graph.audios[0].url, "http://examples.opengraphprotocol.us/media/audio/250hz.mp3")
187 |         XCTAssertEqual(graph.audios[0].secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/audio/250hz.mp3")
188 |         XCTAssertEqual(graph.audios[0].mimeType, "audio/mpeg")
189 |         XCTAssertNil(graph.audios[0].alt)
190 |         
191 |         switch graph.type {
192 |         case .website:
193 |             break
194 |         default:
195 |             XCTFail("Graph type was not album.")
196 |             return
197 |         }
198 |     }
199 |     
200 |     func testVideoMovie() {
201 |         guard let graph = getGraph(filename: "video-movie") else {
202 |             XCTFail("No graph object found.")
203 |             return
204 |         }
205 |         
206 |         XCTAssertEqual(graph.title, "Arrival of a Train at La Ciotat")
207 |         XCTAssertEqual(graph.description, "L'arrivée d'un train en gare de La Ciotat is an 1895 French short black-and-white silent documentary film directed and produced by Auguste and Louis Lumière. Its first public showing took place in January 1896.")
208 |         XCTAssertEqual(graph.locale, "en_US")
209 |         XCTAssertEqual(graph.url, "http://examples.opengraphprotocol.us/video-movie.html")
210 |         
211 |         XCTAssertEqual(graph.image.url, "http://examples.opengraphprotocol.us/media/images/train.jpg")
212 |         XCTAssertEqual(graph.image.secureUrl, "https://d72cgtgi6hvvl.cloudfront.net/media/images/train.jpg")
213 |         XCTAssertEqual(graph.image.width, 500)
214 |         XCTAssertEqual(graph.image.height, 328)
215 |         XCTAssertEqual(graph.image.mimeType, "image/jpeg")
216 |         
217 |         XCTAssertTrue(graph.audios.isEmpty)
218 |         
219 |         XCTAssertEqual(graph.videos.count, 3)
220 |         
221 |         XCTAssertEqual(graph.videos[0].url, "http://fpdownload.adobe.com/strobe/FlashMediaPlayback.swf?src=http%3A%2F%2Fexamples.opengraphprotocol.us%2Fmedia%2Fvideo%2Ftrain.mp4")
222 |         XCTAssertEqual(graph.videos[0].secureUrl, "https://fpdownload.adobe.com/strobe/FlashMediaPlayback.swf?src=https%3A%2F%2Fd72cgtgi6hvvl.cloudfront.net%2Fmedia%2Fvideo%2Ftrain.mp4")
223 |         XCTAssertEqual(graph.videos[0].mimeType, "application/x-shockwave-flash")
224 |         XCTAssertEqual(graph.videos[0].width, 472)
225 |         XCTAssertEqual(graph.videos[0].height, 296)
226 |         XCTAssertNil(graph.videos[0].alt)
227 |         
228 |         XCTAssertEqual(graph.videos[1].mimeType, "video/mp4")
229 |         XCTAssertEqual(graph.videos[1].width, 472)
230 |         XCTAssertEqual(graph.videos[1].height, 296)
231 |         XCTAssertNil(graph.videos[1].alt)
232 |         
233 |         XCTAssertEqual(graph.videos[2].mimeType, "video/webm")
234 |         XCTAssertEqual(graph.videos[2].width, 480)
235 |         XCTAssertEqual(graph.videos[2].height, 320)
236 |         XCTAssertNil(graph.videos[2].alt)
237 |         
238 |         switch graph.type {
239 |         case .video(let attributes):
240 |             XCTAssertEqual(attributes.kind, .movie)
241 |             let formatter = DateFormatter(dateStyle: .short)
242 |             formatter.locale = .init(identifier: "en_US")
243 |             XCTAssertEqual(formatter.string(from: attributes.releaseDate!), "12/28/95")
244 |             XCTAssertEqual(attributes.directors, ["http://examples.opengraphprotocol.us/profile.html"])
245 |             XCTAssertEqual(attributes.duration, 50)
246 |             XCTAssertEqual(attributes.tags, ["La Ciotat", "train"])
247 |             break
248 |         default:
249 |             XCTFail("Graph type was not album.")
250 |             return
251 |         }
252 |     }
253 |     
254 |     func testMin() {
255 |         XCTAssertNil(getGraph(filename: "min"))
256 |     }
257 |     
258 |     func testMusicAlbum() async throws {
259 |         let url = "https://music.apple.com/us/album/fallen-embers-deluxe-version/1591091543"
260 |         let html = await getHtml(for: url)
261 |         
262 |         guard let graph = OpenGraph(html: html) else {
263 |             XCTFail("No graph object found.")
264 |             return
265 |         }
266 |         
267 |         XCTAssertEqual(graph.title, "Fallen Embers (Deluxe Version) by ILLENIUM on Apple Music")
268 |         XCTAssertEqual(graph.url, url)
269 |         
270 |         XCTAssertEqual(graph.image.url, "https://is1-ssl.mzstatic.com/image/thumb/Music122/v4/94/c2/14/94c21487-8703-4ae5-9386-17335d5e9f5d/093624874690.jpg/1200x1200bf-60.jpg")
271 |         XCTAssertEqual(graph.image.secureUrl, "https://is1-ssl.mzstatic.com/image/thumb/Music122/v4/94/c2/14/94c21487-8703-4ae5-9386-17335d5e9f5d/093624874690.jpg/1200x1200bf-60.jpg")
272 |         XCTAssertEqual(graph.image.alt, "Fallen Embers (Deluxe Version) by ILLENIUM on Apple Music")
273 |         XCTAssertEqual(graph.image.width, 1200)
274 |         XCTAssertEqual(graph.image.height, 1200)
275 |         XCTAssertEqual(graph.image.mimeType, "image/jpg")
276 |         
277 |         switch graph.type {
278 |         case .album(let album):
279 |             XCTAssertEqual(album.songs.count, 19)
280 |             XCTAssertEqual(album.songs[0].url, "https://music.apple.com/us/song/wouldnt-change-a-thing/1591091768")
281 |             XCTAssertEqual(album.songs[0].disc, 1)
282 |             XCTAssertEqual(album.songs[0].track, 1)
283 |             XCTAssertEqual(album.songs[0].duration, 187)
284 |             
285 |             XCTAssertEqual(album.musician, "https://music.apple.com/us/artist/illenium/645420096")
286 |             test(date: album.releaseDate, shortUSString: "10/22/21")
287 |         
288 |         default:
289 |             XCTFail("Graph type was not album.")
290 |             return
291 |         }
292 |     }
293 | }
294 | 


--------------------------------------------------------------------------------