completion.xyzsh

def xyzsh_quote (
    | sub -global ' |\\|"|\$|\*|\?|\[|\]|\{|\}|\&|\;|\(|\)|'\' ( | add -number 0 \\ )
)

def xyzsh_dequote (
    | sub -global '(?<!\\)\\' ''
)

def program_completion (
    export PATH | split : | ary -local dirs

    dirs | each (
        | if(| rows -2 | = /) ( |print) else ( | add -number -2 / ) | var -local path

        sys::ls $path | each (
            | var -local program

            print "$path$program" | if(| -x) (
                program
            )
        )
    )

    print "" | var el::non_append_space_characters
)

def file_completion (
    ary ARGV -index 0 | var -local inputing

    | if(| rows -2..-1 | =~ '[^\\] ') ( print "" | var -local inputing )

    if(inputing | index -quiet /) (
        sys::dirname $(inputing |chomp| if (|rows -1 | = /) ( |add aaa ) else ( | print ) )  | chomp | if(|rows -1 | = /) ( | print ) ( | add /) | var -local DIR
        eval "print $DIR" | xyzsh_dequote| expand_tilda | var -local DIR2

        sys::ls -a $DIR2 | egrep -v '^\.$|^\.\.$' | if(uname |= Darwin\n && (export LANG LC_ALL) | index -quiet -ignore-case utf-8) ( | sys::iconv -f UTF-8-MAC -t UTF-8) else ( | print ) | each (
            | if (|chomp | add -number 0 $DIR2 | -d) (
                |chomp | xyzsh_quote | add -number 0 $DIR | add / | pomch
            ) else (
                |chomp | xyzsh_quote | add -number 0 $DIR | pomch
            )
        ) 

        print $DIR | length -byte | var rl::omit_head_of_completion_display_matches
    ) else (
        if(inputing | rows 0 | = \~) (
            cat /etc/passwd | each ( 
                | split : | ary -local Field

                if(ary Field -size | -ge 7) (
                    print \~
                    ary Field -index 0 | chomp
                    print /\n
                )
            )
        ) else (
            sys::ls -a | egrep -v '^\.$|^\.\.$' | if(uname |= Darwin\n && (export LANG LC_ALL) | index -quiet -ignore-case utf-8) ( | sys::iconv -f UTF-8-MAC -t UTF-8 ) else ( | print ) | each (
                | if (|chomp| -d) (
                    | chomp | xyzsh_quote | add / | pomch
                ) else (
                    |chomp| xyzsh_quote | pomch
                )
            )
        )
    )

    print "/" | var el::non_append_space_characters
)

class object_completion (
    ary ARGV -index 0 | var -local Kind
    ary ARGV -index 1 | var -local inputing

    if(inputing | index -quiet ::) (
        inputing | strip | split :: | lines 0..-2 | join :: | var -local PREFIX
        
        if(Kind | = all\n) (
            eval "${PREFIX}::show" | each ( | if(|=~ ': object$') (| sub '(.+):' '\1:::' ) else (|print) ) | scan '(.+?:?:?):' | each ( | add -number 0 ${PREFIX}:: )
        ) else (
            eval "${PREFIX}::show" | egrep ": $Kind\$|: object\$" | each ( | if(|=~ ': object$') (| sub '(.+):' '\1:::' ) else (|print) ) | scan '(.+?:?:?):' | each ( | add -number 0 ${PREFIX}:: )
        )
    ) else (
        pwo  | var -local current
        while(true) (
            if(Kind | = all\n) (
                eval "${current}::show" | each ( | if(|=~ ': object$') (| sub '(.+):' '\1:::' ) else (|print) ) | ::scan '(^.+?:?:?):' 
            ) else (
                eval "${current}::show" | egrep ": $Kind\$|: object\$" | each ( | if(|=~ ': object$') (| sub '(.+):' '\1:::'  ) else (|print) ) | ::scan '(^.+?:?:?):' 
            )
            if(current | = root\n) ( break )
            current | strip | split :: | lines 0..-2| join :: | var -local current
        )
    )

    print ":" | var el::non_append_space_characters
)

root | egrep ': native function$' | egrep -v '^run: native function$|^show: native function$' | scan '(^.+):' | add sub\nsplit\nscan\n | each (
        | var -local command

        help $command | lines 1..-1 | scan '^-[a-zA-Z0-9-]+' |chomp| add -number 0 $command\a | hash -append -La COMPLETION_OPTIONS

        print <<<EOS
    completion "$command" (
        hash COMPLETION_OPTIONS -key "$command"
    )
EOS | eval
)

completion var (
    | object_completion var $ARGV[1]
    hash COMPLETION_OPTIONS -key var
)

completion ary (
    | object_completion array $ARGV[1]
    hash COMPLETION_OPTIONS -key ary
)

completion hash (
    | object_completion hash $ARGV[1]
    hash COMPLETION_OPTIONS -key hash
)

completion class (
    | object_completion class $ARGV[1]
    hash COMPLETION_OPTIONS -key class
)

completion def (
    | object_completion function $ARGV[1]
    hash COMPLETION_OPTIONS -key def
)

completion completion (
    | object_completion completion $ARGV[1]
    hash COMPLETION_OPTIONS -key completion
)

completion alias (
    | object_completion alias $ARGV[1]
    hash COMPLETION_OPTIONS -key alias
)

completion ref (
    | object_completion all $ARGV[1]
    hash COMPLETION_OPTIONS -key ref
)

completion defined (
    | object_completion all $ARGV[1]
    hash COMPLETION_OPTIONS -key defined
)

completion objinfo (
    | object_completion all $ARGV[1]
    hash COMPLETION_OPTIONS -key defined
)

completion typeof (
    | object_completion all $ARGV[1]
    hash COMPLETION_OPTIONS -key typeof
)

completion export (
    sys::env | scan '(.+?)=' | sys::sort | uniq
)

completion sweep (
    self | egrep -v external\ program\$ | egrep -v native\ function\$ | egrep -v '^root:|^self:|^parent:|^run:'| ::scan '(^.+?):'
    hash COMPLETION_OPTIONS -key sweep
)

completion help (
    ::self | egrep native\ function\$ | ::scan '(^.+?):' | add sub\nsplit\nscan\n | each ( | chomp | quote | pomch )
    hash COMPLETION_OPTIONS -key help
)

completion write (
    hash COMPLETION_OPTIONS -key write
    | file_completion $ARGV[1]
)

completion unset (
    sys::env | scan '(.+?)='
)

completion load (
    | if(| index -quiet "-dynamic-library" ) (
        sys::ls $XYZSH_EXT_PATH | (| print -read-from-error; | print)  | egrep '.so$|.dll$'
        sys::ls ~/.xyzsh/lib | ( | print -read-from-error; | print ) | egrep '.so$|.dll$' 
    ) else (
        | file_completion $ARGV[1]
        hash COMPLETION_OPTIONS -key load
    )
)

completion cd (
    | file_completion $ARGV[1] | each ( | =~ '/$' && | print )
    print ../\n
    hash COMPLETION_OPTIONS -key cd
)

object ::compl::rl
object ::compl::el

completion rl::help (
    rl::self | egrep native\ function\$ | egrep -v 'run|show' | ::scan '(^.+?):' | each ( | chomp | quote | pomch )
)

completion el::help (
    el::self | egrep native\ function\$ | egrep -v 'run|show' | ::scan '(^.+?):' | each ( | chomp | quote | pomch )
)

object ::compl::curses

completion curses::help (
    curses::self | egrep native\ function\$ | egrep -v 'run|show' | ::scan '(^.+?):' | each ( | chomp | quote | pomch )
)

###################################################################################
### external program completoins ##################################################
###################################################################################
object ::compl::sys

completion ./configure (
    ./configure --help | scan '(--[a-zA-Z0-9-]+)' | sys::sort | uniq
)

completion man sys::man (
    program_completion
)

completion sudo sys::sudo (
    | scan 'sudo .*' | chomp | split '(?<!\\) +' | wc -l | var -local input_num
    | scan 'sudo .*' | chomp | split '(?<!\\) +' | lines 1 | var -local program_name

    if(input_num | -eq 2) (
        program_completion
    ) elif(input_num | -ge 3) (
        try (
            completion sys::$program_name
        ) catch (
            | file_completion $ARGV[1]
        )
    )
)

completion make sys::make (
    print Makefile | -e && cat Makefile | scan '(.+?):' | sys::sort | uniq
)

completion git sys::git (
    git | awk '/The most commonly used git commands are:/,p' | lines 1..-2 | scan '^\s+(.+?)\s+'  | sys::sort | uniq
)

completion kill sys::kill (
    ps uwx | ( | print -read-from-error > /dev/null; | print) | each ( | sub '^\s+' '' ) | selector | split | lines 1
    if(uname |= FreeBSD\n) (rl::clear_screen)
)

completion pkill sys::pkill (
    ps wx | ( | print -read-from-error > /dev/null; | print) | lines 1..-1 | each ( | strip | split | lines 4 | strip | split / | lines -1 ) 
)

completion sys::__all__ (
    ARGV | var -local Program inputing

    | file_completion $ARGV[1]
)

completion __all__ (
    ARGV | var -local Program inputing

    | file_completion $ARGV[1]
)