{- |
Module      :  ./CommonLogic/ExpandCurie.hs
Description :  Expansion of abbreviated IRI to full IRI
Copyright   :  (c) Eugen Kuksa, Uni Bremen 2012
License     :  GPLv2 or higher, see LICENSE.txt

Maintainer  :  eugenk@informatik.uni-bremen.de
Stability   :  experimental
Portability :  portable

Provides a function to expand each abbreviated IRI to a full IRI
in a basic spec.
-}

module CommonLogic.ExpandCurie
  ( expandCurieBS
  ) where

import qualified Common.AS_Annotation as Anno
import Common.Id
import Common.IRI
import CommonLogic.AS_CommonLogic
import CommonLogic.Lexer_CLIF (clLetters)

import qualified Data.Map as Map

{- | Expands each abbreviated IRI to a full IRI in the basic spec according to
the supplemented map @gpm@. An IRI is stored in a name (quoted string). If
the prefix of an abbreviated IRI is not in the map, the IRI won't be expanded.
-}
expandCurieBS :: Map.Map String IRI -> BASIC_SPEC -> BASIC_SPEC
expandCurieBS :: Map String IRI -> BASIC_SPEC -> BASIC_SPEC
expandCurieBS gpm :: Map String IRI
gpm (Basic_spec abis :: [Annoted BASIC_ITEMS]
abis) = [Annoted BASIC_ITEMS] -> BASIC_SPEC
Basic_spec ([Annoted BASIC_ITEMS] -> BASIC_SPEC)
-> [Annoted BASIC_ITEMS] -> BASIC_SPEC
forall a b. (a -> b) -> a -> b
$ (Annoted BASIC_ITEMS -> Annoted BASIC_ITEMS)
-> [Annoted BASIC_ITEMS] -> [Annoted BASIC_ITEMS]
forall a b. (a -> b) -> [a] -> [b]
map
    (\ abi :: Annoted BASIC_ITEMS
abi@Anno.Annoted {item :: forall a. Annoted a -> a
Anno.item = BASIC_ITEMS
bi} -> Annoted BASIC_ITEMS
abi {item :: BASIC_ITEMS
Anno.item = Map String IRI -> BASIC_ITEMS -> BASIC_ITEMS
expBI Map String IRI
gpm BASIC_ITEMS
bi})
    [Annoted BASIC_ITEMS]
abis

expBI :: Map.Map String IRI -> BASIC_ITEMS -> BASIC_ITEMS
expBI :: Map String IRI -> BASIC_ITEMS -> BASIC_ITEMS
expBI gpm :: Map String IRI
gpm (Axiom_items atms :: [Annoted TEXT_META]
atms) =
  [Annoted TEXT_META] -> BASIC_ITEMS
Axiom_items ([Annoted TEXT_META] -> BASIC_ITEMS)
-> [Annoted TEXT_META] -> BASIC_ITEMS
forall a b. (a -> b) -> a -> b
$ (Annoted TEXT_META -> Annoted TEXT_META)
-> [Annoted TEXT_META] -> [Annoted TEXT_META]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> Annoted TEXT_META -> Annoted TEXT_META
expAnTextMeta Map String IRI
gpm) [Annoted TEXT_META]
atms

expAnTextMeta :: Map.Map String IRI
  -> Anno.Annoted TEXT_META -> Anno.Annoted TEXT_META
expAnTextMeta :: Map String IRI -> Annoted TEXT_META -> Annoted TEXT_META
expAnTextMeta gpm :: Map String IRI
gpm an :: Annoted TEXT_META
an@Anno.Annoted {item :: forall a. Annoted a -> a
Anno.item = TEXT_META
tm} =
  Annoted TEXT_META
an {item :: TEXT_META
Anno.item = Map String IRI -> TEXT_META -> TEXT_META
expTextMeta Map String IRI
gpm TEXT_META
tm}

expTextMeta :: Map.Map String IRI -> TEXT_META -> TEXT_META
expTextMeta :: Map String IRI -> TEXT_META -> TEXT_META
expTextMeta gpm :: Map String IRI
gpm tm :: TEXT_META
tm =
  TEXT_META
tm { getText :: TEXT
getText = Map String IRI -> TEXT -> TEXT
expTxt ((IRI -> IRI -> IRI)
-> Map String IRI -> Map String IRI -> Map String IRI
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (\ _ p2 :: IRI
p2 -> IRI
p2) Map String IRI
gpm (Map String IRI -> Map String IRI)
-> Map String IRI -> Map String IRI
forall a b. (a -> b) -> a -> b
$
                            [(String, IRI)] -> Map String IRI
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(String, IRI)] -> Map String IRI)
-> [(String, IRI)] -> Map String IRI
forall a b. (a -> b) -> a -> b
$ TEXT_META -> [(String, IRI)]
prefix_map TEXT_META
tm) (TEXT_META -> TEXT
getText TEXT_META
tm) }

expTxt :: Map.Map String IRI -> TEXT -> TEXT
expTxt :: Map String IRI -> TEXT -> TEXT
expTxt pm :: Map String IRI
pm t :: TEXT
t = case TEXT
t of
  Text phrs :: [PHRASE]
phrs rn :: Range
rn -> [PHRASE] -> Range -> TEXT
Text ((PHRASE -> PHRASE) -> [PHRASE] -> [PHRASE]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> PHRASE -> PHRASE
expPhr Map String IRI
pm) [PHRASE]
phrs) Range
rn
  Named_text n :: NAME
n txt :: TEXT
txt rn :: Range
rn -> NAME -> TEXT -> Range -> TEXT
Named_text (Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
n) (Map String IRI -> TEXT -> TEXT
expTxt Map String IRI
pm TEXT
txt) Range
rn

expPhr :: Map.Map String IRI -> PHRASE -> PHRASE
expPhr :: Map String IRI -> PHRASE -> PHRASE
expPhr pm :: Map String IRI
pm p :: PHRASE
p = case PHRASE
p of
  Module m :: MODULE
m -> MODULE -> PHRASE
Module (Map String IRI -> MODULE -> MODULE
expMod Map String IRI
pm MODULE
m)
  Sentence s :: SENTENCE
s -> SENTENCE -> PHRASE
Sentence (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
s)
  Importation i :: IMPORTATION
i -> IMPORTATION -> PHRASE
Importation (Map String IRI -> IMPORTATION -> IMPORTATION
expImp Map String IRI
pm IMPORTATION
i)
  Comment_text c :: COMMENT
c t :: TEXT
t rn :: Range
rn -> COMMENT -> TEXT -> Range -> PHRASE
Comment_text COMMENT
c (Map String IRI -> TEXT -> TEXT
expTxt Map String IRI
pm TEXT
t) Range
rn

expMod :: Map.Map String IRI -> MODULE -> MODULE
expMod :: Map String IRI -> MODULE -> MODULE
expMod pm :: Map String IRI
pm m :: MODULE
m = case MODULE
m of
  Mod n :: NAME
n t :: TEXT
t rn :: Range
rn -> NAME -> TEXT -> Range -> MODULE
Mod (Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
n) (Map String IRI -> TEXT -> TEXT
expTxt Map String IRI
pm TEXT
t) Range
rn
  Mod_ex n :: NAME
n ns :: [NAME]
ns t :: TEXT
t rn :: Range
rn ->
      NAME -> [NAME] -> TEXT -> Range -> MODULE
Mod_ex (Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
n) ((NAME -> NAME) -> [NAME] -> [NAME]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> NAME -> NAME
expName Map String IRI
pm) [NAME]
ns) (Map String IRI -> TEXT -> TEXT
expTxt Map String IRI
pm TEXT
t) Range
rn

expImp :: Map.Map String IRI -> IMPORTATION -> IMPORTATION
expImp :: Map String IRI -> IMPORTATION -> IMPORTATION
expImp pm :: Map String IRI
pm (Imp_name n :: NAME
n) = NAME -> IMPORTATION
Imp_name (NAME -> IMPORTATION) -> NAME -> IMPORTATION
forall a b. (a -> b) -> a -> b
$ Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
n

expSen :: Map.Map String IRI -> SENTENCE -> SENTENCE
expSen :: Map String IRI -> SENTENCE -> SENTENCE
expSen pm :: Map String IRI
pm s :: SENTENCE
s = case SENTENCE
s of
  Quant_sent q :: QUANT
q noss :: [NAME_OR_SEQMARK]
noss s2 :: SENTENCE
s2 rn :: Range
rn ->
    QUANT -> [NAME_OR_SEQMARK] -> SENTENCE -> Range -> SENTENCE
Quant_sent QUANT
q ((NAME_OR_SEQMARK -> NAME_OR_SEQMARK)
-> [NAME_OR_SEQMARK] -> [NAME_OR_SEQMARK]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> NAME_OR_SEQMARK -> NAME_OR_SEQMARK
expNos Map String IRI
pm) [NAME_OR_SEQMARK]
noss) (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
s2) Range
rn
  Bool_sent bs :: BOOL_SENT
bs rn :: Range
rn -> BOOL_SENT -> Range -> SENTENCE
Bool_sent (case BOOL_SENT
bs of
      Junction j :: AndOr
j ss :: [SENTENCE]
ss -> AndOr -> [SENTENCE] -> BOOL_SENT
Junction AndOr
j ([SENTENCE] -> BOOL_SENT) -> [SENTENCE] -> BOOL_SENT
forall a b. (a -> b) -> a -> b
$ (SENTENCE -> SENTENCE) -> [SENTENCE] -> [SENTENCE]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm) [SENTENCE]
ss
      Negation s2 :: SENTENCE
s2 -> SENTENCE -> BOOL_SENT
Negation (SENTENCE -> BOOL_SENT) -> SENTENCE -> BOOL_SENT
forall a b. (a -> b) -> a -> b
$ Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
s2
      BinOp op :: ImplEq
op s1 :: SENTENCE
s1 s2 :: SENTENCE
s2 -> ImplEq -> SENTENCE -> SENTENCE -> BOOL_SENT
BinOp ImplEq
op (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
s1) (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
s2)
    ) Range
rn
  Atom_sent as :: ATOM
as rn :: Range
rn -> ATOM -> Range -> SENTENCE
Atom_sent (case ATOM
as of
      Equation t1 :: TERM
t1 t2 :: TERM
t2 -> TERM -> TERM -> ATOM
Equation (Map String IRI -> TERM -> TERM
expTrm Map String IRI
pm TERM
t1) (Map String IRI -> TERM -> TERM
expTrm Map String IRI
pm TERM
t2)
      Atom t :: TERM
t tseqs :: [TERM_SEQ]
tseqs -> TERM -> [TERM_SEQ] -> ATOM
Atom (Map String IRI -> TERM -> TERM
expTrm Map String IRI
pm TERM
t) ([TERM_SEQ] -> ATOM) -> [TERM_SEQ] -> ATOM
forall a b. (a -> b) -> a -> b
$ (TERM_SEQ -> TERM_SEQ) -> [TERM_SEQ] -> [TERM_SEQ]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> TERM_SEQ -> TERM_SEQ
expTseq Map String IRI
pm) [TERM_SEQ]
tseqs
    ) Range
rn
  Comment_sent c :: COMMENT
c cs :: SENTENCE
cs rn :: Range
rn -> COMMENT -> SENTENCE -> Range -> SENTENCE
Comment_sent COMMENT
c (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
cs) Range
rn
  Irregular_sent is :: SENTENCE
is rn :: Range
rn -> SENTENCE -> Range -> SENTENCE
Irregular_sent (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
is) Range
rn

expNos :: Map.Map String IRI -> NAME_OR_SEQMARK -> NAME_OR_SEQMARK
expNos :: Map String IRI -> NAME_OR_SEQMARK -> NAME_OR_SEQMARK
expNos pm :: Map String IRI
pm nos :: NAME_OR_SEQMARK
nos = case NAME_OR_SEQMARK
nos of
  Name n :: NAME
n -> NAME -> NAME_OR_SEQMARK
Name (NAME -> NAME_OR_SEQMARK) -> NAME -> NAME_OR_SEQMARK
forall a b. (a -> b) -> a -> b
$ Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
n
  SeqMark s :: NAME
s -> NAME -> NAME_OR_SEQMARK
SeqMark (NAME -> NAME_OR_SEQMARK) -> NAME -> NAME_OR_SEQMARK
forall a b. (a -> b) -> a -> b
$ Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
s

expTrm :: Map.Map String IRI -> TERM -> TERM
expTrm :: Map String IRI -> TERM -> TERM
expTrm pm :: Map String IRI
pm trm :: TERM
trm = case TERM
trm of
  Name_term n :: NAME
n -> NAME -> TERM
Name_term (NAME -> TERM) -> NAME -> TERM
forall a b. (a -> b) -> a -> b
$ Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
n
  Funct_term t :: TERM
t tseqs :: [TERM_SEQ]
tseqs rn :: Range
rn ->
      TERM -> [TERM_SEQ] -> Range -> TERM
Funct_term (Map String IRI -> TERM -> TERM
expTrm Map String IRI
pm TERM
t) ((TERM_SEQ -> TERM_SEQ) -> [TERM_SEQ] -> [TERM_SEQ]
forall a b. (a -> b) -> [a] -> [b]
map (Map String IRI -> TERM_SEQ -> TERM_SEQ
expTseq Map String IRI
pm) [TERM_SEQ]
tseqs) Range
rn
  Comment_term t :: TERM
t c :: COMMENT
c rn :: Range
rn -> TERM -> COMMENT -> Range -> TERM
Comment_term (Map String IRI -> TERM -> TERM
expTrm Map String IRI
pm TERM
t) COMMENT
c Range
rn
  That_term s :: SENTENCE
s rn :: Range
rn -> SENTENCE -> Range -> TERM
That_term (Map String IRI -> SENTENCE -> SENTENCE
expSen Map String IRI
pm SENTENCE
s) Range
rn

expTseq :: Map.Map String IRI -> TERM_SEQ -> TERM_SEQ
expTseq :: Map String IRI -> TERM_SEQ -> TERM_SEQ
expTseq pm :: Map String IRI
pm nos :: TERM_SEQ
nos = case TERM_SEQ
nos of
  Term_seq t :: TERM
t -> TERM -> TERM_SEQ
Term_seq (TERM -> TERM_SEQ) -> TERM -> TERM_SEQ
forall a b. (a -> b) -> a -> b
$ Map String IRI -> TERM -> TERM
expTrm Map String IRI
pm TERM
t
  Seq_marks s :: NAME
s -> NAME -> TERM_SEQ
Seq_marks (NAME -> TERM_SEQ) -> NAME -> TERM_SEQ
forall a b. (a -> b) -> a -> b
$ Map String IRI -> NAME -> NAME
expName Map String IRI
pm NAME
s

expName :: Map.Map String IRI -> NAME -> NAME
expName :: Map String IRI -> NAME -> NAME
expName pm :: Map String IRI
pm n :: NAME
n = case (IRI -> Maybe IRI) -> Maybe IRI -> Maybe (Maybe IRI)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Map String IRI -> IRI -> Maybe IRI
expandCurie Map String IRI
pm) (Maybe IRI -> Maybe (Maybe IRI)) -> Maybe IRI -> Maybe (Maybe IRI)
forall a b. (a -> b) -> a -> b
$ String -> Maybe IRI
parseCurie (NAME -> String
strippedQuotesStr NAME
n) of
  Just (Just x :: IRI
x) -> let s :: String
s = IRI -> String
iriToStringShortUnsecure IRI
x
                   in String -> Range -> NAME
Token (if Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
clLetters String
s
                              then "\"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ "\""
                              else String
s) (Range -> NAME) -> Range -> NAME
forall a b. (a -> b) -> a -> b
$ NAME -> Range
tokPos NAME
n
  _ -> NAME
n

strippedQuotesStr :: NAME -> String
strippedQuotesStr :: NAME -> String
strippedQuotesStr n :: NAME
n =
  let str :: String
str = NAME -> String
tokStr NAME
n
      middleStr :: String
middleStr = String -> String
forall a. [a] -> [a]
init (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ String -> String
forall a. [a] -> [a]
tail String
str
  in case String
str of
        '\"' : _ : _ -> String
middleStr
        '\'' : _ : _ -> String
middleStr
        _ -> String
str