{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE TemplateHaskell    #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Text.BlogLiterately.Options
-- Copyright   :  (c) 2008-2010 Robert Greayer, 2012 Brent Yorgey
-- License     :  GPL (see LICENSE)
-- Maintainer  :  Brent Yorgey <byorgey@gmail.com>
--
-- Configuation and command-line options.
--
-----------------------------------------------------------------------------

module Text.BlogLiterately.Options
    (
      -- * BlogLiterately options record
      BlogLiterately(..), blOpts

      -- ** Lenses
      -- $lenses

    , style
    , hsHighlight
    , otherHighlight
    , litHaskell
    , toc
    , rawlatex
    , wplatex
    , math
    , ghci
    , uploadImages
    , categories
    , tags
    , blogid
    , profile
    , blog
    , user
    , password
    , title
    , file
    , format
    , postid
    , page
    , publish
    , htmlOnly
    , citations
    , xtra

    -- ** Default accessors
    -- $defaccess

    , style'
    , hsHighlight'
    , otherHighlight'
    , litHaskell'
    , toc'
    , rawlatex'
    , wplatex'
    , math'
    , ghci'
    , uploadImages'
    , blogid'
    , profile'
    , blog'
    , user'
    , password'
    , title'
    , file'
    , format'
    , postid'
    , page'
    , publish'
    , htmlOnly'
    , citations'
    )
    where

import           Control.Lens                  (makeLenses, view)
import           Control.Monad                 (mplus)
import           Data.Maybe                    (fromMaybe)
import qualified Data.Semigroup                as Semi
import           Data.Version
import           Paths_BlogLiterately          (version)

import           System.Console.CmdArgs

import           Text.BlogLiterately.Highlight

-- | Configuration record (and command-line options) for @BlogLiterately@.
data BlogLiterately = BlogLiterately
  { BlogLiterately -> Maybe String
_style          :: Maybe String        -- ^ Name of a style file
  , BlogLiterately -> Maybe HsHighlight
_hsHighlight    :: Maybe HsHighlight   -- ^ Haskell highlighting mode
  , BlogLiterately -> Maybe Bool
_otherHighlight :: Maybe Bool          -- ^ Use highlighting-kate for
                                           --   non-Haskell?
  , BlogLiterately -> Maybe Bool
_litHaskell     :: Maybe Bool          -- ^ Parse as literate Haskell?
  , BlogLiterately -> Maybe Bool
_toc            :: Maybe Bool          -- ^ Generate a table of contents?
  , BlogLiterately -> Maybe Bool
_rawlatex       :: Maybe Bool          -- ^ Pass LaTeX through unchanged?
  , BlogLiterately -> Maybe Bool
_wplatex        :: Maybe Bool          -- ^ Format LaTeX for WordPress?
  , BlogLiterately -> Maybe String
_math           :: Maybe String        -- ^ Indicate how to format math
  , BlogLiterately -> Maybe Bool
_ghci           :: Maybe Bool          -- ^ Automatically process ghci sessions?
  , BlogLiterately -> Maybe Bool
_uploadImages   :: Maybe Bool          -- ^ Automatically upload images?
  , BlogLiterately -> [String]
_categories     :: [String]            -- ^ Categories for the post
  , BlogLiterately -> [String]
_tags           :: [String]            -- ^ Tags for the post
  , BlogLiterately -> Maybe String
_blogid         :: Maybe String        -- ^ Blog-specific identifier
                                           --   (e.g. for blogging software
                                           --   handling multiple blogs)
  , BlogLiterately -> Maybe String
_profile        :: Maybe String        -- ^ Name of profile to use.
  , BlogLiterately -> Maybe String
_blog           :: Maybe String        -- ^ Blog xmlrpc URL
  , BlogLiterately -> Maybe String
_user           :: Maybe String        -- ^ Blog user name
  , BlogLiterately -> Maybe String
_password       :: Maybe String        -- ^ Blog password (omit to be interactively prompted)
  , BlogLiterately -> Maybe String
_title          :: Maybe String        -- ^ Post title
  , BlogLiterately -> Maybe String
_file           :: Maybe String        -- ^ File to post
  , BlogLiterately -> Maybe String
_format         :: Maybe String        -- ^ Format of the file
                                           --   (currently supported:
                                           --   markdown, rst)
  , BlogLiterately -> Maybe String
_postid         :: Maybe String        -- ^ ID of a post to update
  , BlogLiterately -> Maybe Bool
_page           :: Maybe Bool          -- ^ Create a \"page\" instead of a post
  , BlogLiterately -> Maybe Bool
_publish        :: Maybe Bool          -- ^ Should the post be published?
                                           --   (Otherwise it is uploaded as a draft.)
  , BlogLiterately -> Maybe Bool
_htmlOnly       :: Maybe Bool          -- ^ Don't upload anything;
                                           --   just output HTML to
                                           --   stdout.
  , BlogLiterately -> Maybe Bool
_citations      :: Maybe Bool          -- ^ Process citations? (default: true)
  , BlogLiterately -> [String]
_xtra           :: [String]            -- ^ Extension arguments, for use e.g. by
                                           --   custom transforms
  }
  deriving (Int -> BlogLiterately -> ShowS
[BlogLiterately] -> ShowS
BlogLiterately -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlogLiterately] -> ShowS
$cshowList :: [BlogLiterately] -> ShowS
show :: BlogLiterately -> String
$cshow :: BlogLiterately -> String
showsPrec :: Int -> BlogLiterately -> ShowS
$cshowsPrec :: Int -> BlogLiterately -> ShowS
Show,Typeable BlogLiterately
BlogLiterately -> DataType
BlogLiterately -> Constr
(forall b. Data b => b -> b) -> BlogLiterately -> BlogLiterately
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> BlogLiterately -> u
forall u. (forall d. Data d => d -> u) -> BlogLiterately -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlogLiterately -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlogLiterately -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlogLiterately
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlogLiterately -> c BlogLiterately
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlogLiterately)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BlogLiterately)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BlogLiterately -> m BlogLiterately
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BlogLiterately -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BlogLiterately -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BlogLiterately -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BlogLiterately -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlogLiterately -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlogLiterately -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlogLiterately -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlogLiterately -> r
gmapT :: (forall b. Data b => b -> b) -> BlogLiterately -> BlogLiterately
$cgmapT :: (forall b. Data b => b -> b) -> BlogLiterately -> BlogLiterately
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BlogLiterately)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BlogLiterately)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlogLiterately)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlogLiterately)
dataTypeOf :: BlogLiterately -> DataType
$cdataTypeOf :: BlogLiterately -> DataType
toConstr :: BlogLiterately -> Constr
$ctoConstr :: BlogLiterately -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlogLiterately
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlogLiterately
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlogLiterately -> c BlogLiterately
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlogLiterately -> c BlogLiterately
Data,Typeable)

-- $lenses
-- We derive lenses for all the @BlogLiterately@ fields using the
-- @lens@ library.

makeLenses ''BlogLiterately

instance Semi.Semigroup BlogLiterately where
  BlogLiterately
bl1 <> :: BlogLiterately -> BlogLiterately -> BlogLiterately
<> BlogLiterately
bl2 =
    BlogLiterately
    { _style :: Maybe String
_style          = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_style
    , _hsHighlight :: Maybe HsHighlight
_hsHighlight    = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe HsHighlight
_hsHighlight
    , _otherHighlight :: Maybe Bool
_otherHighlight = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_otherHighlight
    , _litHaskell :: Maybe Bool
_litHaskell     = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_litHaskell
    , _toc :: Maybe Bool
_toc            = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_toc
    , _rawlatex :: Maybe Bool
_rawlatex       = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_rawlatex
    , _wplatex :: Maybe Bool
_wplatex        = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_wplatex
    , _math :: Maybe String
_math           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_math
    , _ghci :: Maybe Bool
_ghci           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_ghci
    , _uploadImages :: Maybe Bool
_uploadImages   = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_uploadImages
    , _categories :: [String]
_categories     = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> [String]
_categories
    , _tags :: [String]
_tags           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> [String]
_tags
    , _blogid :: Maybe String
_blogid         = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_blogid
    , _profile :: Maybe String
_profile        = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_profile
    , _blog :: Maybe String
_blog           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_blog
    , _user :: Maybe String
_user           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_user
    , _password :: Maybe String
_password       = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_password
    , _title :: Maybe String
_title          = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_title
    , _file :: Maybe String
_file           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_file
    , _format :: Maybe String
_format         = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_format
    , _postid :: Maybe String
_postid         = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe String
_postid
    , _page :: Maybe Bool
_page           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_page
    , _publish :: Maybe Bool
_publish        = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_publish
    , _htmlOnly :: Maybe Bool
_htmlOnly       = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_htmlOnly
    , _citations :: Maybe Bool
_citations      = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> Maybe Bool
_citations
    , _xtra :: [String]
_xtra           = forall {m :: * -> *} {a}.
MonadPlus m =>
(BlogLiterately -> m a) -> m a
combine BlogLiterately -> [String]
_xtra
    }
    where combine :: (BlogLiterately -> m a) -> m a
combine BlogLiterately -> m a
f = BlogLiterately -> m a
f BlogLiterately
bl1 forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` BlogLiterately -> m a
f BlogLiterately
bl2

instance Monoid BlogLiterately where
  mempty :: BlogLiterately
mempty =
    BlogLiterately
    { _style :: Maybe String
_style          = forall a. Maybe a
Nothing
    , _hsHighlight :: Maybe HsHighlight
_hsHighlight    = forall a. Maybe a
Nothing
    , _otherHighlight :: Maybe Bool
_otherHighlight = forall a. Maybe a
Nothing
    , _litHaskell :: Maybe Bool
_litHaskell     = forall a. Maybe a
Nothing
    , _toc :: Maybe Bool
_toc            = forall a. Maybe a
Nothing
    , _rawlatex :: Maybe Bool
_rawlatex       = forall a. Maybe a
Nothing
    , _wplatex :: Maybe Bool
_wplatex        = forall a. Maybe a
Nothing
    , _math :: Maybe String
_math           = forall a. Maybe a
Nothing
    , _ghci :: Maybe Bool
_ghci           = forall a. Maybe a
Nothing
    , _uploadImages :: Maybe Bool
_uploadImages   = forall a. Maybe a
Nothing
    , _categories :: [String]
_categories     = []
    , _tags :: [String]
_tags           = []
    , _blogid :: Maybe String
_blogid         = forall a. Maybe a
Nothing
    , _profile :: Maybe String
_profile        = forall a. Maybe a
Nothing
    , _blog :: Maybe String
_blog           = forall a. Maybe a
Nothing
    , _user :: Maybe String
_user           = forall a. Maybe a
Nothing
    , _password :: Maybe String
_password       = forall a. Maybe a
Nothing
    , _title :: Maybe String
_title          = forall a. Maybe a
Nothing
    , _file :: Maybe String
_file           = forall a. Maybe a
Nothing
    , _format :: Maybe String
_format         = forall a. Maybe a
Nothing
    , _postid :: Maybe String
_postid         = forall a. Maybe a
Nothing
    , _page :: Maybe Bool
_page           = forall a. Maybe a
Nothing
    , _publish :: Maybe Bool
_publish        = forall a. Maybe a
Nothing
    , _htmlOnly :: Maybe Bool
_htmlOnly       = forall a. Maybe a
Nothing
    , _citations :: Maybe Bool
_citations      = forall a. Maybe a
Nothing
    , _xtra :: [String]
_xtra           = []
    }

  mappend :: BlogLiterately -> BlogLiterately -> BlogLiterately
mappend = forall a. Semigroup a => a -> a -> a
(Semi.<>)

--------------------------------------------------
-- Default accessors
--------------------------------------------------

-- $defaccess
-- Some convenient accessors that strip off the Maybe and return an
-- appropriate default value.

style' :: BlogLiterately -> String
style' :: BlogLiterately -> String
style'          = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
style

hsHighlight' :: BlogLiterately -> HsHighlight
hsHighlight' :: BlogLiterately -> HsHighlight
hsHighlight'    = forall a. a -> Maybe a -> a
fromMaybe (StylePrefs -> HsHighlight
HsColourInline StylePrefs
defaultStylePrefs) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe HsHighlight)
hsHighlight

otherHighlight' :: BlogLiterately -> Bool
otherHighlight' :: BlogLiterately -> Bool
otherHighlight' = forall a. a -> Maybe a -> a
fromMaybe Bool
True  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
otherHighlight

litHaskell' :: BlogLiterately -> Bool
litHaskell' :: BlogLiterately -> Bool
litHaskell' = forall a. a -> Maybe a -> a
fromMaybe Bool
True forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
litHaskell

toc' :: BlogLiterately -> Bool
toc' :: BlogLiterately -> Bool
toc'            = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
toc

rawlatex' :: BlogLiterately -> Bool
rawlatex' :: BlogLiterately -> Bool
rawlatex'        = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
rawlatex

wplatex' :: BlogLiterately -> Bool
wplatex' :: BlogLiterately -> Bool
wplatex'        = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
wplatex

math' :: BlogLiterately -> String
math' :: BlogLiterately -> String
math'           = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
math

ghci' :: BlogLiterately -> Bool
ghci' :: BlogLiterately -> Bool
ghci'           = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
ghci

uploadImages' :: BlogLiterately -> Bool
uploadImages' :: BlogLiterately -> Bool
uploadImages'   = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
uploadImages

blogid' :: BlogLiterately -> String
blogid' :: BlogLiterately -> String
blogid'         = forall a. a -> Maybe a -> a
fromMaybe String
"default" forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
blogid

profile' :: BlogLiterately -> String
profile' :: BlogLiterately -> String
profile'        = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
profile

blog' :: BlogLiterately -> String
blog' :: BlogLiterately -> String
blog'           = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
blog

user' :: BlogLiterately -> String
user' :: BlogLiterately -> String
user'           = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
user

password' :: BlogLiterately -> String
password' :: BlogLiterately -> String
password'       = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
password

title' :: BlogLiterately -> String
title' :: BlogLiterately -> String
title'          = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
title

file' :: BlogLiterately -> String
file' :: BlogLiterately -> String
file'           = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
file

format' :: BlogLiterately -> String
format' :: BlogLiterately -> String
format'         = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
format

postid' :: BlogLiterately -> String
postid' :: BlogLiterately -> String
postid'         = forall a. a -> Maybe a -> a
fromMaybe String
""    forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe String)
postid

page' :: BlogLiterately -> Bool
page' :: BlogLiterately -> Bool
page'           = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
page

publish' :: BlogLiterately -> Bool
publish' :: BlogLiterately -> Bool
publish'        = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
publish

htmlOnly' :: BlogLiterately -> Bool
htmlOnly' :: BlogLiterately -> Bool
htmlOnly'       = forall a. a -> Maybe a -> a
fromMaybe Bool
False forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
htmlOnly

citations' :: BlogLiterately -> Bool
citations' :: BlogLiterately -> Bool
citations' = forall a. a -> Maybe a -> a
fromMaybe Bool
True forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BlogLiterately (Maybe Bool)
citations

-- | Command-line configuration for use with @cmdargs@.
blOpts :: BlogLiterately
blOpts :: BlogLiterately
blOpts = BlogLiterately
     { _style :: Maybe String
_style = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"style specification (for --hscolour-icss)"
                    forall val. Data val => val -> Ann -> val
&= Ann
typFile
                    forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"style" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"s" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _hsHighlight :: Maybe HsHighlight
_hsHighlight = forall val. Data val => [val] -> val
enum
       [ forall a. Maybe a
Nothing
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"hscolour-icss"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"highlight haskell: hscolour, inline style (default)"
       , forall a. a -> Maybe a
Just HsHighlight
HsColourCSS
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"hscolour-css"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"highlight haskell: hscolour, separate stylesheet"
       , forall a. a -> Maybe a
Just HsHighlight
HsNoHighlight
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"hs-nohighlight"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"no haskell highlighting"
       , forall a. a -> Maybe a
Just HsHighlight
HsKate
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"hs-kate"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"highlight haskell with highlighting-kate"
       ]
     , _otherHighlight :: Maybe Bool
_otherHighlight = forall val. Data val => [val] -> val
enum
       [ forall a. Maybe a
Nothing
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"kate"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"highlight non-Haskell code with highlighting-kate (default)"
       , forall a. a -> Maybe a
Just Bool
False
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"no-kate"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"don't highlight non-Haskell code"
       ]
     , _toc :: Maybe Bool
_toc = forall val. Data val => [val] -> val
enum
       [ forall a. Maybe a
Nothing
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"no-toc"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"don't generate a table of contents (default)"
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
       , forall a. a -> Maybe a
Just Bool
True
         forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"toc"
         forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"generate a table of contents"
         forall val. Data val => val -> Ann -> val
&= Ann
explicit
       ]
     , _rawlatex :: Maybe Bool
_rawlatex = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"pass inline/display LaTeX through unchanged"
                       forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"rawlatex" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"r" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _wplatex :: Maybe Bool
_wplatex = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"reformat inline LaTeX the way WordPress expects"
                  forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"wplatex" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"w" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _math :: Maybe String
_math    = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"how to layout math, where --math=<pandoc-option>[=URL]"
                  forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"math" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"m" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _litHaskell :: Maybe Bool
_litHaskell = forall val. Data val => [val] -> val
enum
        [ forall a. Maybe a
Nothing
          forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"parse as literate Haskell (default)"
          forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"lit-haskell"
          forall val. Data val => val -> Ann -> val
&= Ann
explicit
        , forall a. a -> Maybe a
Just Bool
False
          forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"do not parse as literate Haskell"
          forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"no-lit-haskell"
          forall val. Data val => val -> Ann -> val
&= Ann
explicit
        ]
     , _ghci :: Maybe Bool
_ghci    = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"run [ghci] blocks through ghci and include output"
                  forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"ghci" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"g" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _uploadImages :: Maybe Bool
_uploadImages = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"upload-images" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"I" forall val. Data val => val -> Ann -> val
&= Ann
explicit forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"upload local images"
     , _page :: Maybe Bool
_page    = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"create a \"page\" instead of a post (WordPress only)"
                  forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"page" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _publish :: Maybe Bool
_publish = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"publish post (otherwise it's uploaded as a draft)"
                  forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"publish" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _htmlOnly :: Maybe Bool
_htmlOnly = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"don't upload anything; output HTML to stdout"
                  forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"html-only" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"h" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _categories :: [String]
_categories = forall a. Default a => a
def
       forall val. Data val => val -> Ann -> val
&= Ann
explicit
       forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"category" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"C"
       forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"post category (can specify more than one)"
     , _tags :: [String]
_tags = forall a. Default a => a
def
       forall val. Data val => val -> Ann -> val
&= Ann
explicit
       forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"tag" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"T"
       forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"tag (can specify more than one)"

     , _citations :: Maybe Bool
_citations = forall val. Data val => [val] -> val
enum
        [ forall a. Maybe a
Nothing
          forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"process citations (default)"
          forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"citations"
          forall val. Data val => val -> Ann -> val
&= Ann
explicit
        , forall a. a -> Maybe a
Just Bool
False
          forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"do not process citations"
          forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"no-citations"
          forall val. Data val => val -> Ann -> val
&= Ann
explicit
        ]

     , _xtra :: [String]
_xtra     = forall a. Default a => a
def
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"extension arguments, for use with custom extensions"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"xtra" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"x" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _blogid :: Maybe String
_blogid   = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"Blog specific identifier" forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"ID"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"blogid" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _postid :: Maybe String
_postid   = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"Post to replace (if any)" forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"ID"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"postid" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"i" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _profile :: Maybe String
_profile  = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"STRING"   forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"profile to use"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"profile" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"P" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _blog :: Maybe String
_blog     = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"URL"      forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"blog XML-RPC url (if omitted, HTML goes to stdout)"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"blog" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"b" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _user :: Maybe String
_user     = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"USER"     forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"user name"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"user" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"u" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _password :: Maybe String
_password = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"PASSWORD" forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"password"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"password" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"p" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _title :: Maybe String
_title    = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"TITLE"    forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"post title"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"title" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"t" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _format :: Maybe String
_format   = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"FORMAT"   forall val. Data val => val -> Ann -> val
&= String -> Ann
help String
"input format: markdown or rst"
                   forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"format" forall val. Data val => val -> Ann -> val
&= String -> Ann
name String
"f" forall val. Data val => val -> Ann -> val
&= Ann
explicit
     , _file :: Maybe String
_file     = forall a. Default a => a
def forall val. Data val => val -> Ann -> val
&= Int -> Ann
argPos Int
0 forall val. Data val => val -> Ann -> val
&= String -> Ann
typ String
"FILE"
  }
  forall val. Data val => val -> Ann -> val
&= String -> Ann
program String
"BlogLiterately"
  forall val. Data val => val -> Ann -> val
&= String -> Ann
summary (String
"BlogLierately v" forall a. [a] -> [a] -> [a]
++ Version -> String
showVersion Version
version forall a. [a] -> [a] -> [a]
++ String
", (c) Robert Greayer 2008-2010, Brent Yorgey 2012-2013\n" forall a. [a] -> [a] -> [a]
++
              String
"For help, see http://byorgey.wordpress.com/blogliterately/")