thea-owl-i

/* -*- Mode: Prolog -*- */

:- use_module(library('thea2/owl2_model')).
:- use_module(library('thea2/owl2_util')).
:- use_module(library('thea2/swrl_rdf_hooks')).
:- use_module(library('thea2/swrl')).
:- use_module(library('thea2/owl2_reasoner')).
:- use_module(library('thea2/owl2_io')).
:- use_module(library('thea2/owl2_catalog')).
:- use_module(library('thea2/owl2_plsyn')).

:- multifile user:parse_arg_hook/3.

main :-
        current_prolog_flag(argv, Args),
        parse_args(Args,Opts_1),
        flatten(Opts_1,Opts),
        findall(X,
                member(loadopt(X),Opts),
                LoadOpts),
        (   member(format(Fmt),LoadOpts)
        ->  true
        ;   true),
        forall(member(ensure_loaded(M),Opts),
               ensure_loaded(M)),
        forall(member(settings(X),Opts),
               assert(owl2_settings:X)),
        get_time(T1),
	% set of ontologies explicitly to convert
        forall(member(convert(F),Opts),
               load_axioms(F,Fmt,LoadOpts)),
	(   setof(Ont,A^ontologyAxiom(Ont,A),ConvertOnts)
	->  true
	;   ConvertOnts=[]),
	% any other ontologies
        forall(member(rest(F),Opts),
               load_axioms(F,Fmt,LoadOpts)),
        get_time(T2),
        LoadTime is T2-T1,
        debug(bench,'load_time: ~w',[LoadTime]),
        (   member(reasonername(RN),Opts)
        ->  ensure_loaded(library(thea2/owl2_reasoner)),
            initialize_reasoner(RN,Reasoner),
            nb_setval(reasoner,Reasoner),
            (   member(check_consistency,Opts)
            ->  (   reasoner_check_consistency(Reasoner)
                ->  print_message(informational,reasoner(consistent))
                ;   print_message(error,reasoner(inconsistent)))
            ;   true)
        ;   true),

        % GOALS AND TRANSFORMATIONS
        forall(member(goal(G),Opts),
               G),
        findall(PoplOpt,
                member(popl_opt(PoplOpt),Opts),
                PoplOpts),
        forall(member(popl_file(F),Opts),
               execute_popl_file(F,[syntax(plsyn)|PoplOpts])),
        forall(member(popl(G),Opts),
               popl_translate(G,[syntax(plsyn)|PoplOpts])),
        (   member(statistics(true),Opts)
        ->  statistics
        ;   true),
        get_time(T3),
        GoalTime is T3-T2,
        debug(bench,'goal_time: ~w',[GoalTime]),

        /*
        forall(diff(F1,F2),
               (   owl2_diff_files(F1,F2,Diffs),
                   maplist(writeln(Diffs)))),
          */

	% QUERIES
        forall(member(reasonerquery(T,G),Opts),
               forall(reasoner_ask(Reasoner,G),
                      show_term(T,Opts))),
        forall(member(reasonerquery(T,G,IsDirect),Opts),
               forall(reasoner_ask(Reasoner,G,IsDirect),
                      show_term(T,Opts))),
        forall(member(reasonercache(G,F),Opts),
               reasoner_cache_to_file(Reasoner,G,F)),
        forall(member(query(T,G),Opts),
               forall(G,show_term(T,Opts))),

        % SAVE
        findall(X,
                (   member(saveopt(X),Opts)
		;   member(Ont,ConvertOnts),
		    X=ontology(Ont)), % save this ontology specifically
                SaveOpts),
        (   member(output_format(OutFmt),Opts)
        ->  (   member(output_file(OutFile),Opts)
            ->  save_axioms(OutFile,OutFmt,SaveOpts)
            ;   save_axioms(_,OutFmt,SaveOpts))
        ;   true),

        % SHELL
        (   member(prolog(true),Opts)
        ->  set_prolog_flag(verbose, normal),
            set_prolog_flag(toplevel_goal, prolog)
        ;   true).

% ----------------------------------------
% DISPLAY
% ----------------------------------------

show_term(T,Opts) :-
        select(saveopt(combined),Opts,Opts2),
        !,
        write('% '),
        show_term(T,Opts2),
        format('~q.~n',[T]).
show_term(T,Opts) :-
        member(saveopt(tr(T,TG,Ont,Ax)),Opts),
        !,
        forall(TG,
               assert_axiom(Ax,Ont)).
show_term(T,Opts) :-
        member(saveopt(tabular),Opts),
        !,
        T=..L,
        show_subterms(L,'\t',Opts),
        nl.
show_term(T,Opts) :-
        member(saveopt(prolog),Opts),
        !,
        format('~q.~n',[T]).
show_term(T,Opts) :-
        member(saveopt(plsyn),Opts),
        member(saveopt(labels),Opts),
        !,
        map_IRIs(use_label_as_IRI,T,T2),
        plsyn_owl(X,T2),
        (   member(saveopt(show_orig),Opts)
        ->  format('~q.~n',[T])
        ;   true),
        (   member(saveopt(no_plquote),Opts)
        ->  format('~w~n',[X])
        ;   format('~q.~n',[X])).
show_term(T,Opts) :-
        member(saveopt(plsyn),Opts),
        !,
        plsyn_owl(X,T),
        format('~q.~n',[X]).
show_term(T,Opts) :-
        member(saveopt(labels),Opts),
        !,
        map_IRIs(use_label_as_IRI,T,X),
        writeln(X).
show_term(T,_) :-
        writeln(T).

show_subterms([],_,_).
show_subterms([T|L],Sep,Opts) :-
        !,
        show_subterm(T,Sep,Opts),
        (   L=[]
        ->  true
        ;   format(Sep,[]),
            show_subterms(L,Sep,Opts)).

show_subterm(T,Sep,Opts) :-
        member(saveopt(labels),Opts),
        member(saveopt(plsyn),Opts),
        !,
        map_IRIs(use_label_as_IRI,T,T2),
        plsyn_owl(X,T2),
        write(T),
        format(Sep),
        write(X).
show_subterm(T,_Sep,Opts) :-
        member(saveopt(plsyn),Opts),
        !,
        plsyn_owl(X,T),
        write(X).
show_subterm(T,Sep,Opts) :-
        member(saveopt(labels),Opts),
        !,
        write(T),
        format(Sep),
        (   labelAnnotation_value(T,N)
        ->  write(N)
        ;   true).
show_subterm(T,_,_) :-
        write(T).

comma_term_to_list((A,B),[A|L]) :-
        !,
        comma_term_to_list(B,L).
comma_term_to_list(A,[A]).


% ----------------------------------------
% LOOKUP
% ----------------------------------------

lookup(X,X) :- entity(X),!.
lookup(N,X) :- labelAnnotation_value(N,X),!.
lookup(N,X) :-
        % URI suffix
        entity(X),
        sub_atom(X,_,_,0,N),
        !.
lookup(N,_) :-
        throw(error(cannot_find(N))).



% ----------------------------------------
% OPTION PROCESSING
% ----------------------------------------


parse_args([],[]).
parse_args(Args,[Opt|Opts]) :-
        parse_arg(Args,Rest,Opt),
        !,
        parse_args(Rest,Opts).
parse_args([A|Args],[rest(A)|Opts]) :-
        parse_args(Args,Opts).

:- discontiguous parse_arg/3.
:- discontiguous arg_info/3.

parse_arg(['--debug',D|L],L,null) :- debug(D), set_prolog_flag(verbose,normal).
arg_info(debug,atom,'(developers) debug target').

parse_arg(['--prolog'|L],L,prolog(true)).
arg_info(prolog,-,'start prolog shell after loading owl files').
parse_arg(['--shell'|L],L,prolog(true)) :- ensure_loaded(library(thea2/owl2_shell)).

parse_arg(['--no_uri_expansion'|L],L,settings(uri_translation(none))).

parse_arg(['--uri_translation',X|L],L,settings(uri_translation(X))).

parse_arg(['--contract',X|L],L,settings(uri_translation(contract(X)))).
arg_info(contract,-,'perform URI contraction').

parse_arg(['--statistics'|L],L,statistics(true)).
arg_info(statistics,-,'show statistics').

parse_arg(['--import'|L],L,loadopt(imports(true))).
arg_info(import,-,'follow import closure (default is to only load the selected file)').

parse_arg(['--save-opt',A|L],L,saveopt(O)) :- atom_to_term(A,O,_).
arg_info(save-opt,term,'format dependent: prolog term that is passed to the Options argument for the relevant writer').

parse_arg(['--save-opts',A|L],L,Opts) :-
        atom_to_term(A,T,_),
        comma_term_to_list(T,OL),
        findall(saveopt(O),member(O,OL),Opts).


parse_arg(['--save-ontology',X|L],L,saveopt(ontology(X))).
arg_info(save-ontology,atom,'save selected ontology').

parse_arg(['--format',A|L],L,loadopt(format(Fmt)))  :- atom_to_term(A,Fmt,_).
arg_info(format,atom,'input format: one of {owl,owlpl,owlx,...}').

parse_arg(['--ensure_loaded',MA|L],L,ensure_loaded(M)) :- atom_to_term(MA,M,_).
parse_arg(['--ensure-loaded',MA|L],L,ensure_loaded(M)) :- atom_to_term(MA,M,_).
parse_arg(['--load-app',MA|L],L,ensure_loaded(library(thea2/apps/M))) :- atom_to_term(MA,M,_).
%parse_arg(['--load-mod',MA|L],L,ensure_loaded(library(thea2/M))) :- atom_to_term(MA,M,_).
parse_arg(['--load-mod',MA|L],L,null) :- atom_to_term(MA,M,_),ensure_loaded(library(thea2/M)).

parse_arg(['--jvm-opt',A|L],L,null) :-
        (   jpl_set_default_jvm_opts([A])
        ->  true
        ;   throw(error(jvm('Cannot set jvm opts (must be called BEFORE jpl is loaded)')))).


parse_arg(['--convert',X|L],L,convert(X)).

parse_arg(['--to',A|L],L,output_format(Fmt)) :- atom_to_term(A,Fmt,_).
arg_info(to,atom,'output format: one of {owl,owlpl,owlx,...}').

parse_arg(['--out',File|L],L,output_file(File)).
arg_info(out,filepath,'saves to file (default is standard_output)').

parse_arg(['--rewrite-with-labels'|L],L,goal(use_labels_for_IRIs)).
arg_info(use-labels,-,'rewrite ontology to switch out all URIs and use labels instead').

parse_arg(['--assume-entity-declarations'|L],L,goal(assume_entity_declarations)).


parse_arg(['--use-labels'|L],L,saveopt(labels)).
arg_info(use-labels,-,'use labels when writing axioms in reporting').
parse_arg(['--use-labels-and-IRIs'|L],L,saveopt(labels_and_IRIs)).
arg_info(use-labels,-,'use labels and IRIs when writing axioms in reporting').

parse_arg(['--use-safe-labels'|L],L,goal(use_safe_labels_for_IRIs)).

parse_arg(['--iri-map',A,in,O|L],L,goal(translate_IRIs(T,O))) :- atom_to_term(A,T,_).

parse_arg(['--goal',GA|L],L,goal(G)) :- atom_to_term(GA,G,_).
arg_info(goal,goal,'execute prolog goal after loading ontologies').

parse_arg(['--diff',F1,F2|L],L,diff(F1,F2)) :- ensure_loaded(library(thea2/owl2_diff)).
arg_info(diff,files,'diff two owl files').

parse_arg(['--popl',GA|L],L,popl(G)) :-
        ensure_loaded(library(thea2/owl2_popl)),
        ensure_loaded(library(thea2/owl2_plsyn)),
        atom_to_term(GA,G,_).
arg_info(popl,term,'process using POPL directive. Example: --popl EXPR ').

parse_arg(['--popl-opt',GA|L],L,popl_opt(G)) :-
        atom_to_term(GA,G,_).

parse_arg(['--popl-file',F|L],L,popl_file(F)) :-
        ensure_loaded(library(thea2/owl2_popl)),
        ensure_loaded(library(thea2/owl2_plsyn)).
arg_info(popl-file,file,'file containing POPL directives').

parse_arg(['--mireot',Ext,into,Local|L],L,mireot(Local,Ext)) :-
        ensure_loaded(library(thea2/apps/mireot)).

parse_arg(['--query',select,TA,where,GA|L],L,query(T,G)) :- sformat(A,'q((~w),(~w))',[TA,GA]),atom_to_term(A,q(T,G),_).
parse_arg(['--query',GA|L],L,query(T,G)) :- atom_to_term(GA,G-T,_).
parse_arg(['--query',GA|L],L,query(G,G)) :- atom_to_term(GA,G,_).
arg_info(query,goal,'execute prolog query').

parse_arg(['--reasoner',A|L],L,reasonername(RN)) :-
        atom_to_term(A,RN,_).

parse_arg(['--consult',F|L],L,null) :- consult(F).
parse_arg(['--prefix-with',X|L],L,goal(prefix_IRIs(X))).


parse_arg(['--check-consistency'|L],L,check_consistency).

parse_arg(['--reasoner-query',select,TA,where,GA|L],L,reasonerquery( T, G)) :- sformat(A,'q((~w),(~w))',[TA,GA]),atom_to_term(A,q(T,G),_).
parse_arg(['--reasoner-ask',GA|L],L,reasonerquery( T, G)) :- atom_to_term(GA,G-T,_).
parse_arg(['--reasoner-ask',GA|L],L,reasonerquery( A, A)) :- atom_to_term(GA,A,_).
parse_arg(['--reasoner-ask-direct',GA|L],L,reasonerquery( A, A, true)) :- atom_to_term(GA,A,_).
parse_arg(['--reasoner-ask-all'|L],L,reasonerquery( A, A)).
parse_arg(['--reasoner-ask-all-direct'|L],L,reasonerquery( A, A, true)).
parse_arg(['--reasoner-get-superclasses',C|L],L,reasonerquery( P, subClassOf(C,P))).
parse_arg(['--reasoner-cache-query-to',GA,F|L],L,reasonercache( A, F)) :- atom_to_term(GA,A,_).
parse_arg(['--reasoner-cache-subclass-to',F|L],L,reasonercache( subClassOf(_,_), F)).

parse_arg(['--sim',A|L],L,
          query(sim(X,Y,LCS),
                (   setof(X,T1^T1,Xs),
                    setof(Y,T2^T2,Ys),
                    member(X,Xs),
                    member(Y,Ys),
                    X@<Y,
                    class_pair_least_common_subsumer(X,Y,LCS,[])) )
         ) :-
        atom_to_term(A,V-T,_),
        copy_term(V-T,X-T1),
        copy_term(V-T,Y-T2),
        ensure_loaded(library(thea2/owl2_lcs)),
        prepare_optimizations(_). % note - do not prepare a second time!
arg_info(sim,term,'Find LCS of pairs based on query. Argument should be Template-Goal. ').

parse_arg(['--sim-pair',XN,YN|L],L,
          query(sim(X,Y,LCS),
                (   lookup(XN,X),
                    lookup(YN,Y),
                    class_pair_least_common_subsumer(X,Y,LCS,[])))) :-
        ensure_loaded(library(thea2/owl2_lcs)),
        prepare_optimizations(_).
parse_arg(['--sim-all'|L],L,
          query(sim(X,Y,LCS),
                (   class(X),
                    class(Y),
                    class_pair_least_common_subsumer(X,Y,LCS,[])))
         ) :-
        ensure_loaded(library(thea2/owl2_lcs)),
        prepare_optimizations(_).

parse_arg(['--load-catalog'|L],L,null) :- load_catalog.

parse_arg(['--qsave',File|L],L,qsave(File)).

parse_arg(L1,L2,X) :- user:parse_arg_hook(L1,L2,X).


% GALAXY:

:- multifile rdf_db:rdf_file_type/3.
rdf_db:rdf_file_type(dat,xml).