Feed.hs

--------------------------------------------------------------------
-- |
-- Module    : Text.Atom.Feed
-- Copyright : (c) Galois, Inc. 2008,
--             (c) Sigbjorn Finne 2009-
-- License   : BSD3
--
-- Maintainer: Sigbjorn Finne <sof@forkIO.com>
-- Stability : provisional
-- Portability: portable
--
--------------------------------------------------------------------
module Text.Atom.Feed
  ( URI
  , NCName
  , Date
  , MediaType
  , Attr
  , Feed(..)
  , Entry(..)
  , EntryContent(..)
  , Category(..)
  , Generator(..)
  , Link(..)
  , TextContent(..)
  , txtToString
  , Source(..)
  , Person(..)
  , InReplyTo(..)
  , InReplyTotal(..)
  , newCategory
  , nullFeed
  , nullEntry
  , nullGenerator
  , nullLink
  , nullSource
  , nullPerson
  ) where

import Prelude.Compat

import Data.Text (Text, unpack)
import Data.XML.Compat
import Data.XML.Types as XML

-- *Core types
-- NOTE: In the future we may want to have more structured
-- types for these.
type URI = Text

type NCName = Text

type Date = Text

type MediaType = Text

data Feed =
  Feed
    { feedId :: URI
    , feedTitle :: TextContent
    , feedUpdated :: Date
    , feedAuthors :: [Person]
    , feedCategories :: [Category]
    , feedContributors :: [Person]
    , feedGenerator :: Maybe Generator
    , feedIcon :: Maybe URI
    , feedLinks :: [Link]
    , feedLogo :: Maybe URI
    , feedRights :: Maybe TextContent
    , feedSubtitle :: Maybe TextContent
    , feedEntries :: [Entry]
    , feedAttrs :: [Attr]
    , feedOther :: [XML.Element]
    }
  deriving (Show)

data Entry =
  Entry
    { entryId :: URI
    , entryTitle :: TextContent
    , entryUpdated :: Date
    , entryAuthors :: [Person]
    , entryCategories :: [Category]
    , entryContent :: Maybe EntryContent
    , entryContributor :: [Person]
    , entryLinks :: [Link]
    , entryPublished :: Maybe Date
    , entryRights :: Maybe TextContent
    , entrySource :: Maybe Source
    , entrySummary :: Maybe TextContent
    , entryInReplyTo :: Maybe InReplyTo
    , entryInReplyTotal :: Maybe InReplyTotal
    , entryAttrs :: [Attr]
    , entryOther :: [XML.Element]
    }
  deriving (Show)

data EntryContent
  = TextContent Text
  | HTMLContent Text
  | XHTMLContent XML.Element
  | MixedContent (Maybe Text) [XML.Node]
  | ExternalContent (Maybe MediaType) URI
  deriving (Show)

data Category =
  Category
    { catTerm :: Text -- ^ the tag\/term of the category.
    , catScheme :: Maybe URI -- ^ optional URL for identifying the categorization scheme.
    , catLabel :: Maybe Text -- ^ human-readable label of the category
    , catOther :: [XML.Element] -- ^ unknown elements, for extensibility.
    }
  deriving (Show)

data Generator =
  Generator
    { genURI :: Maybe URI
    , genVersion :: Maybe Text
    , genText :: Text
    }
  deriving (Eq, Show)

data Link =
  Link
    { linkHref :: URI
         -- ToDo: make the switch over to using the Atom.Feed.Link relation type.
    , linkRel :: Maybe (Either NCName URI)
    , linkType :: Maybe MediaType
    , linkHrefLang :: Maybe Text
    , linkTitle :: Maybe Text
    , linkLength :: Maybe Text
    , linkAttrs :: [Attr]
    , linkOther :: [XML.Element]
    }
  deriving (Show)

data TextContent
  = TextString Text
  | HTMLString Text
  | XHTMLString XML.Element
  deriving (Show)

txtToString :: TextContent -> String
txtToString (TextString s) = unpack s
txtToString (HTMLString s) = unpack s
txtToString (XHTMLString x) = show x

data Source =
  Source
    { sourceAuthors :: [Person]
    , sourceCategories :: [Category]
    , sourceGenerator :: Maybe Generator
    , sourceIcon :: Maybe URI
    , sourceId :: Maybe URI
    , sourceLinks :: [Link]
    , sourceLogo :: Maybe URI
    , sourceRights :: Maybe TextContent
    , sourceSubtitle :: Maybe TextContent
    , sourceTitle :: Maybe TextContent
    , sourceUpdated :: Maybe Date
    , sourceOther :: [XML.Element]
    }
  deriving (Show)

data Person =
  Person
    { personName :: Text
    , personURI :: Maybe URI
    , personEmail :: Maybe Text
    , personOther :: [XML.Element]
    }
  deriving (Show)

data InReplyTo =
  InReplyTo
    { replyToRef :: URI
    , replyToHRef :: Maybe URI
    , replyToType :: Maybe MediaType
    , replyToSource :: Maybe URI
    , replyToOther :: [Attr]
    , replyToContent :: [Node]
    }
  deriving (Show)

data InReplyTotal =
  InReplyTotal
    { replyToTotal :: Integer -- non-negative :)
    , replyToTotalOther :: [Attr]
    }
  deriving (Show)

-- *Smart Constructors
newCategory ::
     Text -- ^catTerm
  -> Category
newCategory t = Category {catTerm = t, catScheme = Nothing, catLabel = Just t, catOther = []}

nullFeed ::
     URI -- ^feedId
  -> TextContent -- ^feedTitle
  -> Date -- ^feedUpdated
  -> Feed
nullFeed i t u =
  Feed
    { feedId = i
    , feedTitle = t
    , feedUpdated = u
    , feedAuthors = []
    , feedCategories = []
    , feedContributors = []
    , feedGenerator = Nothing
    , feedIcon = Nothing
    , feedLinks = []
    , feedLogo = Nothing
    , feedRights = Nothing
    , feedSubtitle = Nothing
    , feedEntries = []
    , feedAttrs = []
    , feedOther = []
    }

nullEntry ::
     URI -- ^entryId
  -> TextContent -- ^entryTitle
  -> Date -- ^entryUpdated
  -> Entry
nullEntry i t u =
  Entry
    { entryId = i
    , entryTitle = t
    , entryUpdated = u
    , entryAuthors = []
    , entryCategories = []
    , entryContent = Nothing
    , entryContributor = []
    , entryLinks = []
    , entryPublished = Nothing
    , entryRights = Nothing
    , entrySource = Nothing
    , entrySummary = Nothing
    , entryInReplyTo = Nothing
    , entryInReplyTotal = Nothing
    , entryAttrs = []
    , entryOther = []
    }

nullGenerator ::
     Text -- ^genText
  -> Generator
nullGenerator t = Generator {genURI = Nothing, genVersion = Nothing, genText = t}

nullLink ::
     URI -- ^linkHref
  -> Link
nullLink uri =
  Link
    { linkHref = uri
    , linkRel = Nothing
    , linkType = Nothing
    , linkHrefLang = Nothing
    , linkTitle = Nothing
    , linkLength = Nothing
    , linkAttrs = []
    , linkOther = []
    }

nullSource :: Source
nullSource =
  Source
    { sourceAuthors = []
    , sourceCategories = []
    , sourceGenerator = Nothing
    , sourceIcon = Nothing
    , sourceId = Nothing
    , sourceLinks = []
    , sourceLogo = Nothing
    , sourceRights = Nothing
    , sourceSubtitle = Nothing
    , sourceTitle = Nothing
    , sourceUpdated = Nothing
    , sourceOther = []
    }

nullPerson :: Person
nullPerson = Person {personName = "", personURI = Nothing, personEmail = Nothing, personOther = []}