Changeset 71

Show
Ignore:
Timestamp:
05/05/04 21:23:12 (5 years ago)
Author:
jajcus
Message:

- code reformated so 4 spaces are used for indenting

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/jjigw.py

    r66 r71  
    3636    sys.exit(1) 
    3737 
    38 # vi: sw=4 ts=8 sts=4 
     38# vi: sts=4 et sw=4 

  • trunk/jjigw/__init__.py

    • Property svn:eol-style deleted
    • Property svn:keywords deleted
    r66 r71  
     1 
     2# vi: sts=4 et sw=4 

  • trunk/jjigw/channel.py

    • Property svn:eol-style deleted
    • Property svn:keywords deleted
    r66 r71  
    3232    multiarg_modes="OovbeI" 
    3333    def __init__(self,session,name): 
    34        if not channel_re.match(name): 
    35            raise ValueError,"Bad channel name" 
    36        self.name=name 
    37        self.session=session 
    38        self.state=None 
    39        self.room_jid=None 
    40        self.config=session.network.get_channel_config(name) 
    41        if self.config and self.config.encoding: 
    42            self.encoding=self.config.encoding 
    43        else: 
    44            self.encoding=session.default_encoding 
    45        self.modes={} 
    46        self.users=[] 
    47        self.muc=0 
    48        self.requests=RequestQueue(10) 
     34        if not channel_re.match(name): 
     35            raise ValueError,"Bad channel name" 
     36        self.name=name 
     37        self.session=session 
     38        self.state=None 
     39        self.room_jid=None 
     40        self.config=session.network.get_channel_config(name) 
     41        if self.config and self.config.encoding: 
     42            self.encoding=self.config.encoding 
     43        else: 
     44            self.encoding=session.default_encoding 
     45        self.modes={} 
     46        self.users=[] 
     47        self.muc=0 
     48        self.requests=RequestQueue(10) 
    4949 
    5050    def sync_user(self,user,status=None): 
    51        if user.channels.has_key(normalize(self.name)): 
    52            if user not in self.users: 
    53                self.users.append(user) 
    54        else: 
    55            for m in self.multiarg_modes: 
    56                ul=self.modes.get(m,[]) 
    57                if user in ul: 
    58                    ul.remove(user) 
    59            if user in self.users: 
    60                self.users.remove(user) 
    61                 self.send_notice_message(u"%s has quit"  
    62                        % (unicode(user.nick,self.encoding,"replace"),)) 
    63        if self.state: 
    64            p=self.get_user_presence(user,status=status) 
    65            self.session.component.send(p) 
     51        if user.channels.has_key(normalize(self.name)): 
     52            if user not in self.users: 
     53                self.users.append(user) 
     54        else: 
     55            for m in self.multiarg_modes: 
     56                ul=self.modes.get(m,[]) 
     57                if user in ul: 
     58                    ul.remove(user) 
     59            if user in self.users: 
     60                self.users.remove(user) 
     61                self.send_notice_message(u"%s has quit" 
     62                        % (unicode(user.nick,self.encoding,"replace"),)) 
     63        if self.state: 
     64            p=self.get_user_presence(user,status=status) 
     65            self.session.component.send(p) 
    6666 
    6767    def send_notice_message(self,msg,not_in_muc=1): 
    68        if not self.state or (self.muc and not_in_muc): 
    69            return 
    70        m=Message(fr=self.room_jid.bare(),to=self.session.jid,type="groupchat",body=msg) 
    71        self.session.component.send(m) 
     68        if not self.state or (self.muc and not_in_muc): 
     69            return 
     70        m=Message(fr=self.room_jid.bare(),to=self.session.jid,type="groupchat",body=msg) 
     71        self.session.component.send(m) 
    7272 
    7373    def join(self,stanza): 
    74        if self.state: 
    75            self.debug("Channel %r not in the initial state, not joining!" % (self.name,)) 
    76            p=stanza.make_error_response(stanza,"bad-request") 
    77            self.session.component.send(p) 
    78            return 
    79        self.room_jid=stanza.get_to() 
    80        self.debug("Joining channel %r" % (self.name,)) 
    81        self.session.send("JOIN %s" % (self.name,)) 
    82        self.requests.add("JOIN",stanza) 
    83        self.state="join" 
    84        if stanza.get_join_info(): 
    85            self.muc=1 
     74        if self.state: 
     75            self.debug("Channel %r not in the initial state, not joining!" % (self.name,)) 
     76            p=stanza.make_error_response(stanza,"bad-request") 
     77            self.session.component.send(p) 
     78            return 
     79        self.room_jid=stanza.get_to() 
     80        self.debug("Joining channel %r" % (self.name,)) 
     81        self.session.send("JOIN %s" % (self.name,)) 
     82        self.requests.add("JOIN",stanza) 
     83        self.state="join" 
     84        if stanza.get_join_info(): 
     85            self.muc=1 
    8686 
    8787    def leave(self,stanza): 
    88        status=stanza.get_status() 
    89        if not self.state: 
    90            self.debug("Channel %r in the initial state - nothing to do." % (self.name,)) 
    91        else: 
    92            if status: 
    93                self.session.send("PART %s" % (self.name,)) 
    94            else: 
    95                self.session.send("PART %s :%s" % (self.name, 
    96                        status.encode(self.encoding,"replace"))) 
    97            self.state=None 
    98        p=MucPresence(type="unavailable",fr=stanza.get_to(),to=stanza.get_from(),status=status) 
    99        self.session.component.send(p) 
    100        for u in self.users: 
    101            u.leave_room(self) 
    102        self.state=None 
     88        status=stanza.get_status() 
     89        if not self.state: 
     90            self.debug("Channel %r in the initial state - nothing to do." % (self.name,)) 
     91        else: 
     92            if status: 
     93                self.session.send("PART %s" % (self.name,)) 
     94            else: 
     95                self.session.send("PART %s :%s" % (self.name, 
     96                        status.encode(self.encoding,"replace"))) 
     97            self.state=None 
     98        p=MucPresence(type="unavailable",fr=stanza.get_to(),to=stanza.get_from(),status=status) 
     99        self.session.component.send(p) 
     100        for u in self.users: 
     101            u.leave_room(self) 
     102        self.state=None 
    103103 
    104104    def prefix_to_jid(self,prefix): 
    105        if "!" in prefix: 
    106            return self.nick_to_jid(prefix.split("!")[0]) 
    107        return self.nick_to_jid(prefix) 
     105        if "!" in prefix: 
     106            return self.nick_to_jid(prefix.split("!")[0]) 
     107        return self.nick_to_jid(prefix) 
    108108 
    109109    def nick_to_jid(self,nick): 
    110        return JID(self.room_jid.node,self.room_jid.domain, 
    111                unicode(nick,self.encoding,"replace")) 
     110        return JID(self.room_jid.node,self.room_jid.domain, 
     111                unicode(nick,self.encoding,"replace")) 
    112112 
    113113    def get_user_presence(self,user,nick=None,actor=None,reason=None,status=None): 
    114        if self.state and user in self.users: 
    115            p=MucPresence(fr=self.nick_to_jid(user.nick),to=self.session.jid) 
    116        else: 
    117            p=MucPresence(type="unavailable",fr=self.nick_to_jid(user.nick),to=self.session.jid) 
    118        if self.muc: 
    119            if user in self.modes.get("o",[]): 
    120                aff="admin" 
    121                role="moderator" 
    122            elif user in self.modes.get("v",[]): 
    123                aff="member" 
    124                role="participant" 
    125            elif self.modes.get("m"): 
    126                aff="none" 
    127                role="visitor" 
    128            elif user in self.users: 
    129                aff="none" 
    130                role="participant" 
    131            else: 
    132                aff="none" 
    133                role="none" 
    134            ui=p.make_muc_userinfo() 
    135            if nick: 
    136                nick=unicode(user.nick,self.encoding,"replace") 
    137            it=MucItem(aff,role,user.jid(),nick=nick,actor=actor,reason=reason) 
    138            ui.add_item(it) 
    139            if status: 
    140                ui.add_item(MucStatus(status)) 
    141        return p 
     114        if self.state and user in self.users: 
     115            p=MucPresence(fr=self.nick_to_jid(user.nick),to=self.session.jid) 
     116        else: 
     117            p=MucPresence(type="unavailable",fr=self.nick_to_jid(user.nick),to=self.session.jid) 
     118        if self.muc: 
     119            if user in self.modes.get("o",[]): 
     120                aff="admin" 
     121                role="moderator" 
     122            elif user in self.modes.get("v",[]): 
     123                aff="member" 
     124                role="participant" 
     125            elif self.modes.get("m"): 
     126                aff="none" 
     127                role="visitor" 
     128            elif user in self.users: 
     129                aff="none" 
     130                role="participant" 
     131            else: 
     132                aff="none" 
     133                role="none" 
     134            ui=p.make_muc_userinfo() 
     135            if nick: 
     136                nick=unicode(user.nick,self.encoding,"replace") 
     137            it=MucItem(aff,role,user.jid(),nick=nick,actor=actor,reason=reason) 
     138            ui.add_item(it) 
     139            if status: 
     140                ui.add_item(MucStatus(status)) 
     141        return p 
    142142 
    143143    def nick_changed(self,oldnick,user): 
    144        p_unaval=self.get_user_presence(user,nick=user.nick,status=303) 
    145        p_unaval.set_type("unavailable") 
    146        p_unaval.set_show(None) 
    147        p_unaval.set_status(None) 
    148        p_unaval.set_from(self.nick_to_jid(oldnick)) 
    149        p_aval=self.get_user_presence(user,status=303) 
    150        self.session.component.send(p_unaval) 
    151        self.session.component.send(p_aval) 
    152         self.send_notice_message(u"%s is now known as %s"  
    153                % (unicode(oldnick,self.encoding,"replace"), 
    154                    unicode(user.nick,self.encoding,"replace"))) 
    155          
     144        p_unaval=self.get_user_presence(user,nick=user.nick,status=303) 
     145        p_unaval.set_type("unavailable") 
     146        p_unaval.set_show(None) 
     147        p_unaval.set_status(None) 
     148        p_unaval.set_from(self.nick_to_jid(oldnick)) 
     149        p_aval=self.get_user_presence(user,status=303) 
     150        self.session.component.send(p_unaval) 
     151        self.session.component.send(p_aval) 
     152        self.send_notice_message(u"%s is now known as %s" 
     153                % (unicode(oldnick,self.encoding,"replace"), 
     154                    unicode(user.nick,self.encoding,"replace"))) 
     155 
    156156    def set_mode(self,mode,arg): 
    157        if mode in self.toggle_modes: 
    158            self.modes[mode]=1 
    159        elif mode in self.arg_modes: 
    160            self.modes[mode]=arg 
    161        elif mode in self.multiarg_modes: 
    162            if self.modes.has_key(mode): 
    163                self.modes[mode].append(arg) 
    164            else: 
    165                self.modes[mode]=[arg] 
     157        if mode in self.toggle_modes: 
     158            self.modes[mode]=1 
     159        elif mode in self.arg_modes: 
     160            self.modes[mode]=arg 
     161        elif mode in self.multiarg_modes: 
     162            if self.modes.has_key(mode): 
     163                self.modes[mode].append(arg) 
     164            else: 
     165                self.modes[mode]=[arg] 
    166166 
    167167    def reset_mode(self,mode,arg): 
    168        try: 
    169            if mode in self.toggle_modes: 
    170                del self.modes[mode] 
    171            elif mode in self.arg_modes: 
    172                del self.modes[mode] 
    173            elif mode in self.multiarg_modes: 
    174                if self.modes.has_key(mode): 
    175                    self.modes[mode].remove(arg) 
    176                    if not self.modes[mode]: 
    177                        del self.modes[mode] 
    178        except (KeyError,ValueError): 
    179            pass 
     168        try: 
     169            if mode in self.toggle_modes: 
     170                del self.modes[mode] 
     171            elif mode in self.arg_modes: 
     172                del self.modes[mode] 
     173            elif mode in self.multiarg_modes: 
     174                if self.modes.has_key(mode): 
     175                    self.modes[mode].remove(arg) 
     176                    if not self.modes[mode]: 
     177                        del self.modes[mode] 
     178        except (KeyError,ValueError): 
     179            pass 
    180180 
    181181    def irc_cmd_324(self,prefix,command,params): # RPL_CHANNELMODEIS 
    182        for m in self.toggle_modes: 
    183            try: 
    184                del self.modes[m] 
    185            except KeyError: 
    186                pass 
    187        self.irc_mode_changed(prefix,command,params) 
    188          
     182        for m in self.toggle_modes: 
     183            try: 
     184                del self.modes[m] 
     185            except KeyError: 
     186                pass 
     187        self.irc_mode_changed(prefix,command,params) 
     188 
    189189    def irc_cmd_482(self,prefix,command,params): # ERR_CHANOPRIVSNEEDED 
    190        self.irc_error_response(prefix,command,params,["TOPIC","KICK","MODE"],"forbidden") 
     190        self.irc_error_response(prefix,command,params,["TOPIC","KICK","MODE"],"forbidden") 
    191191 
    192192    def irc_cmd_461(self,prefix,command,params): # ERR_NEEDMOREPARAMS 
    193        self.irc_error_response(prefix,command,params,["TOPIC","KICK","MODE"],"bad-request") 
     193        self.irc_error_response(prefix,command,params,["TOPIC","KICK","MODE"],"bad-request") 
    194194 
    195195    def irc_cmd_403(self,prefix,command,params): # ERR_NOSUCHCHANNEL 
    196        self.irc_error_response(prefix,command,params,["KICK"],"recipient-unavailable") 
    197      
     196        self.irc_error_response(prefix,command,params,["KICK"],"recipient-unavailable") 
     197 
    198198    def irc_cmd_476(self,prefix,command,params): # ERR_BADCHANMASK 
    199        self.irc_error_response(prefix,command,params,["KICK"],"bad-request") 
    200      
     199        self.irc_error_response(prefix,command,params,["KICK"],"bad-request") 
     200 
    201201    def irc_cmd_441(self,prefix,command,params): # ERR_USERNOTINCHANNEL 
    202        self.irc_error_response(prefix,command,params,["KICK","MODE"],"item-not-found") 
    203          
     202        self.irc_error_response(prefix,command,params,["KICK","MODE"],"item-not-found") 
     203 
    204204    def irc_cmd_442(self,prefix,command,params): # ERR_NOTONCHANNEL 
    205        self.irc_error_response(prefix,command,params,["TOPIC","KICK"],"forbidden") 
     205        self.irc_error_response(prefix,command,params,["TOPIC","KICK"],"forbidden") 
    206206 
    207207    def irc_cmd_472(self,prefix,command,params): # ERR_UNKNOWNMODE 
    208        self.irc_error_response(prefix,command,params,["MODE"],"feature-not-implemented") 
     208        self.irc_error_response(prefix,command,params,["MODE"],"feature-not-implemented") 
    209209 
    210210    def irc_cmd_477(self,prefix,command,params): # ERR_NOCHANMODES 
    211        self.irc_error_response(prefix,command,params,["TOPIC","MODE"],"not-acceptable") 
     211        self.irc_error_response(prefix,command,params,["TOPIC","MODE"],"not-acceptable") 
    212212 
    213213    def irc_error_response(self,prefix,command,params,requests,condition): 
    214        r=self.requests.get(requests) 
    215        if r: 
    216            m=r.stanza.make_error_response(condition) 
    217        else: 
    218            m=Message(fr=self.room_jid.bare(),to=self.session.jid, 
    219                    type="error", error_cond=condition) 
    220        self.session.component.send(m) 
     214        r=self.requests.get(requests) 
     215        if r: 
     216            m=r.stanza.make_error_response(condition) 
     217        else: 
     218            m=Message(fr=self.room_jid.bare(),to=self.session.jid, 
     219                    type="error", error_cond=condition) 
     220        self.session.component.send(m) 
    221221 
    222222    def irc_cmd_331(self,prefix,command,params): # RPL_NOTOPIC 
    223        m=Message(fr=self.room_jid.bare(),to=self.session.jid, type="groupchat", subject=u"") 
    224        self.session.component.send(m) 
    225          
     223        m=Message(fr=self.room_jid.bare(),to=self.session.jid, type="groupchat", subject=u"") 
     224        self.session.component.send(m) 
     225 
    226226    def irc_cmd_332(self,prefix,command,params): # RPL_TOPIC 
    227        topic=remove_evil_characters(params[1]) 
    228        m=Message(fr=self.room_jid.bare(),to=self.session.jid, 
    229                type="groupchat", subject=unicode(topic,self.encoding,"replace")) 
    230        self.session.component.send(m) 
     227        topic=remove_evil_characters(params[1]) 
     228        m=Message(fr=self.room_jid.bare(),to=self.session.jid, 
     229                type="groupchat", subject=unicode(topic,self.encoding,"replace")) 
     230        self.session.component.send(m) 
    231231 
    232232    def irc_cmd_TOPIC(self,prefix,command,params): 
    233        self.requests.get("TOPIC") 
    234        topic=remove_evil_characters(params[1]) 
    235        m=Message(fr=self.prefix_to_jid(prefix),to=self.session.jid, 
    236                type="groupchat", subject=unicode(topic,self.encoding,"replace")) 
    237        self.session.component.send(m) 
    238          
     233        self.requests.get("TOPIC") 
     234        topic=remove_evil_characters(params[1]) 
     235        m=Message(fr=self.prefix_to_jid(prefix),to=self.session.jid, 
     236                type="groupchat", subject=unicode(topic,self.encoding,"replace")) 
     237        self.session.component.send(m) 
     238 
    239239    def irc_cmd_MODE(self,prefix,command,params): 
    240        if len(params)<2: 
    241            self.debug("No parameters in received MODE") 
    242            return 
    243        params_str=string.join(params[2:]," ").strip() 
    244        if params_str: 
    245            params_str=" "+params_str 
    246        if "!" in prefix: 
    247            nick,iuser=prefix.split("!",1) 
    248            iuser="(%s)" % (iuser,) 
    249        else: 
    250            nick,iuser=prefix,"" 
    251         self.send_notice_message(u"Mode change: [%s%s] by %s%s"  
    252                % (unicode(params[1],self.encoding,"replace"), 
    253                        unicode(params_str,self.encoding,"replace"), 
    254                        unicode(nick,self.encoding,"replace"), 
    255                        unicode(iuser,self.encoding,"replace")), 
    256                0) 
    257        if self.session.check_prefix(prefix) and len(params)>=3: 
    258            r=self.requests.get("MODE",string.join(params[1:]," ")) 
    259            if r: 
    260                reply=r.stanza.make_result_response() 
    261                self.session.component.send(reply) 
    262        self.irc_mode_changed(prefix,command,params) 
     240        if len(params)<2: 
     241            self.debug("No parameters in received MODE") 
     242            return 
     243        params_str=string.join(params[2:]," ").strip() 
     244        if params_str: 
     245            params_str=" "+params_str 
     246        if "!" in prefix: 
     247            nick,iuser=prefix.split("!",1) 
     248            iuser="(%s)" % (iuser,) 
     249        else: 
     250            nick,iuser=prefix,"" 
     251        self.send_notice_message(u"Mode change: [%s%s] by %s%s" 
     252                % (unicode(params[1],self.encoding,"replace"), 
     253                        unicode(params_str,self.encoding,"replace"), 
     254                        unicode(nick,self.encoding,"replace"), 
     255                        unicode(iuser,self.encoding,"replace")), 
     256                0) 
     257        if self.session.check_prefix(prefix) and len(params)>=3: 
     258            r=self.requests.get("MODE",string.join(params[1:]," ")) 
     259            if r: 
     260                reply=r.stanza.make_result_response() 
     261                self.session.component.send(reply) 
     262        self.irc_mode_changed(prefix,command,params) 
    263263 
    264264    def irc_mode_changed(self,prefix,command,params): 
    265        actor=self.session.get_user(prefix) 
    266        modes=params[1] 
    267        params=params[2:] 
    268        pm=None 
    269        for m in modes: 
    270            if m in "+-": 
    271                pm=m 
    272                continue 
    273            elif not pm: 
    274                self.debug("Not '+' or '-' before '%s' in received MODE" % (m,)) 
    275                continue 
    276            elif m in self.arg_modes or m in self.multiarg_modes: 
    277                if not len(params): 
    278                    self.debug("No argument for mode '%s' in received MODE" % (m,)) 
    279                    continue 
    280                arg=params.pop(0) 
    281            elif m in self.toggle_modes: 
    282                arg=None 
    283            else: 
    284                self.debug("Unknown mode '%s' in received MODE" % (m,)) 
    285                continue 
    286            if m in "oOv": 
    287                arg=self.session.get_user(arg) 
    288                if not arg: 
    289                    continue 
    290            if pm=="+": 
    291                self.set_mode(m,arg) 
    292            else: 
    293                self.reset_mode(m,arg) 
    294            if m in "oOv": 
    295                self.user_mode_changed(arg,actor,m) 
    296            elif m=="m": 
    297                for u in self.users: 
    298                    self.sync_user(u) 
     265        actor=self.session.get_user(prefix) 
     266        modes=params[1] 
     267        params=params[2:] 
     268        pm=None 
     269        for m in modes: 
     270            if m in "+-": 
     271                pm=m 
     272                continue 
     273            elif not pm: 
     274                self.debug("Not '+' or '-' before '%s' in received MODE" % (m,)) 
     275                continue 
     276            elif m in self.arg_modes or m in self.multiarg_modes: 
     277                if not len(params): 
     278                    self.debug("No argument for mode '%s' in received MODE" % (m,)) 
     279                    continue 
     280                arg=params.pop(0) 
     281            elif m in self.toggle_modes: 
     282                arg=None 
     283            else: 
     284                self.debug("Unknown mode '%s' in received MODE" % (m,)) 
     285                continue 
     286            if m in "oOv": 
     287                arg=self.session.get_user(arg) 
     288                if not arg: 
     289                    continue 
     290            if pm=="+": 
     291                self.set_mode(m,arg) 
     292            else: 
     293                self.reset_mode(m,arg) 
     294            if m in "oOv": 
     295                self.user_mode_changed(arg,actor,m) 
     296            elif m=="m": 
     297                for u in self.users: 
     298                    self.sync_user(u) 
    299299 
    300300    def user_mode_changed(self,user,actor,mode): 
    301        if actor: 
    302            actor_jid=self.nick_to_jid(actor.nick) 
    303        else: 
    304            actor_jid=None 
    305        p=self.get_user_presence(user,actor_jid) 
    306        if actor: 
    307            by=u" by %s" % (unicode(actor.nick,self.encoding,"replace"),) 
    308        else: 
    309            by=u"" 
    310        self.session.component.send(p) 
    311        if mode=="v": 
    312             self.send_notice_message(u"%s was granted voice%s"  
    313                    % (unicode(user.nick,self.encoding,"replace"),by)) 
    314        elif mode=="o": 
    315             self.send_notice_message(u"%s was granted operator status%s"  
    316                    % (unicode(user.nick,self.encoding,"replace"),by)) 
    317        elif mode=="O": 
    318             self.send_notice_message(u"%s was granted got owner status%s"  
    319                    % (unicode(user.nick,self.encoding,"replace"),by)) 
     301        if actor: 
     302            actor_jid=self.nick_to_jid(actor.nick) 
     303        else: 
     304            actor_jid=None 
     305        p=self.get_user_presence(user,actor_jid) 
     306        if actor: 
     307            by=u" by %s" % (unicode(actor.nick,self.encoding,"replace"),) 
     308        else: 
     309            by=u"" 
     310        self.session.component.send(p) 
     311        if mode=="v": 
     312            self.send_notice_message(u"%s was granted voice%s" 
     313                    % (unicode(user.nick,self.encoding,"replace"),by)) 
     314        elif mode=="o": 
     315            self.send_notice_message(u"%s was granted operator status%s" 
     316                    % (unicode(user.nick,self.encoding,"replace"),by)) 
     317        elif mode=="O": 
     318            self.send_notice_message(u"%s was granted got owner status%s" 
     319                    % (unicode(user.nick,self.encoding,"replace"),by)) 
    320320 
    321321    def irc_cmd_JOIN(self,prefix,command,params): 
    322        nprefix=normalize(prefix) 
    323        nnick=normalize(self.session.nick) 
    324        if nprefix==nnick or nprefix.startswith(nnick+"!"): 
    325            if self.state=="join": 
    326                self.debug("Channel %r joined!" % (self.name,)) 
    327                self.session.user.sync_delay+=1 
    328                try: 
    329                    self.session.user.join_channel(self) 
    330                finally: 
    331                    self.session.user.sync_delay-=1 
    332                self.state="joined" 
    333                self.requests.get("JOIN") 
    334                self.session.send("MODE %s" % (self.name,)) 
    335                self.session.send("WHO %s" % (self.name,)) 
    336        else: 
    337            user=self.session.get_user(prefix) 
    338            user.join_channel(self) 
    339             self.send_notice_message(u"%s has joined"  
    340                    % (unicode(user.nick,self.encoding,"replace"),)) 
    341            self.session.send("WHO %s" % (user.nick,)) 
     322        nprefix=normalize(prefix) 
     323        nnick=normalize(self.session.nick) 
     324        if nprefix==nnick or nprefix.startswith(nnick+"!"): 
     325            if self.state=="join": 
     326                self.debug("Channel %r joined!" % (self.name,)) 
     327                self.session.user.sync_delay+=1 
     328                try: 
     329                    self.session.user.join_channel(self) 
     330                finally: 
     331                    self.session.user.sync_delay-=1 
     332                self.state="joined" 
     333                self.requests.get("JOIN") 
     334                self.session.send("MODE %s" % (self.name,)) 
     335                self.session.send("WHO %s" % (self.name,)) 
     336        else: 
     337            user=self.session.get_user(prefix) 
     338            user.join_channel(self) 
     339            self.send_notice_message(u"%s has joined" 
     340                    % (unicode(user.nick,self.encoding,"replace"),)) 
     341            self.session.send("WHO %s" % (user.nick,)) 
    342342 
    343343    def irc_cmd_PART(self,prefix,command,params): 
    344344        user=self.session.get_user(prefix) 
    345        try: 
    346            self.users.remove(user) 
    347        except ValueError: 
    348            pass 
    349        user.leave_channel(self) 
    350         self.send_notice_message(u"%s has left"  
    351                % (unicode(user.nick,self.encoding,"replace"),)) 
     345        try: 
     346            self.users.remove(user) 
     347        except ValueError: 
     348            pass 
     349        user.leave_channel(self) 
     350        self.send_notice_message(u"%s has left" 
     351                % (unicode(user.nick,self.encoding,"replace"),)) 
    352352 
    353353    def irc_cmd_KICK(self,prefix,command,params): 
    354354        actor=self.session.get_user(prefix) 
    355355        user=self.session.get_user(params[1]) 
    356        try: 
    357            self.users.remove(user) 
    358        except ValueError: 
    359            pass 
    360         self.send_notice_message(u"%s was kicked by %s"  
    361                % (unicode(user.descr(),self.encoding,"replace"), 
    362                    unicode(actor.descr(),self.encoding,"replace")), 
    363                0) 
    364        user.leave_channel(self,status=307) 
    365        if user and self.session.check_prefix(prefix): 
    366            r=self.requests.get("KICK",user.nick) 
    367            if r: 
    368                iq=r.stanza.make_result_response() 
    369                self.session.component.send(iq) 
     356        try: 
     357            self.users.remove(user) 
     358        except ValueError: 
     359            pass 
     360        self.send_notice_message(u"%s was kicked by %s" 
     361                % (unicode(user.descr(),self.encoding,"replace"), 
     362                    unicode(actor.descr(),self.encoding,"replace")), 
     363                0) 
     364        user.leave_channel(self,status=307) 
     365        if user and self.session.check_prefix(prefix): 
     366            r=self.requests.get("KICK",user.nick) 
     367            if r: 
     368                iq=r.stanza.make_result_response() 
     369                self.session.component.send(iq) 
    370370 
    371371    def irc_cmd_PRIVMSG(self,prefix,command,params): 
    372        self.irc_message(prefix,command,params) 
     372        self.irc_message(prefix,command,params) 
    373373 
    374374    def irc_cmd_NOTICE(self,prefix,command,params): 
    375        self.irc_message(prefix,command,params) 
     375        self.irc_message(prefix,command,params) 
    376376 
    377377    def irc_message(self,prefix,command,params): 
    378        if not self.state or len(params)<2: 
    379            self.debug("ignoring it") 
    380            return 
    381        body=unicode(params[1],self.encoding,"replace") 
    382        if body[0]=="\001" and body[-1]=="\001": 
    383            self.CTCP(prefix,body[1:-1]) 
    384        else: 
    385            m=Message(type="groupchat",fr=self.prefix_to_jid(prefix),to=self.session.jid, 
    386                    body=remove_evil_characters(strip_colors(body))) 
    387            self.session.component.send(m) 
    388      
     378        if not self.state or len(params)<2: 
     379            self.debug("ignoring it") 
     380            return 
     381        body=unicode(params[1],self.encoding,"replace") 
     382        if body[0]=="\001" and body[-1]=="\001": 
     383            self.CTCP(prefix,body[1:-1]) 
     384        else: 
     385            m=Message(type="groupchat",fr=self.prefix_to_jid(prefix),to=self.session.jid, 
     386                    body=remove_evil_characters(strip_colors(body))) 
     387            self.session.component.send(m) 
     388 
    389389    def CTCP(self,prefix,command): 
    390        if " " in command: 
    391            command,arg=command.split(" ",1) 
    392        else: 
    393            arg=None 
    394        if command=="ACTION": 
    395            m=Message(type="groupchat",fr=self.prefix_to_jid(prefix),to=self.session.jid, 
    396                    body="/me "+remove_evil_characters(strip_colors(arg))) 
    397            self.session.component.send(m) 
    398        else: 
    399            self.debug("Unknown CTCP command: %r %r" % (command,arg)) 
     390        if " " in command: 
     391            command,arg=command.split(" ",1) 
     392        else: 
     393            arg=None 
     394        if command=="ACTION": 
     395            m=Message(type="groupchat",fr=self.prefix_to_jid(prefix),to=self.session.jid, 
     396                    body="/me "+remove_evil_characters(strip_colors(arg))) 
     397            self.session.component.send(m) 
     398        else: 
     399            self.debug("Unknown CTCP command: %r %r" % (command,arg)) 
    400400 
    401401    def change_topic(self,topic,stanza): 
    402        topic=topic.encode(self.encoding,"replace") 
    403        topic=topic.replace("\n"," ").replace("\r"," ") 
    404        self.session.send("TOPIC %s :%s" % (self.name,topic)) 
    405        self.requests.add("TOPIC",stanza) 
     402        topic=topic.encode(self.encoding,"replace") 
     403        topic=topic.replace("\n"," ").replace("\r"," ") 
     404        self.session.send("TOPIC %s :%s" % (self.name,topic)) 
     405        self.requests.add("TOPIC",stanza) 
    406406 
    407407    def kick_user(self,nick,reason,stanza): 
    408        nick=nick.encode(self.encoding,"strict") 
    409        self.session.send("KICK %s %s :%s" % (self.name,nick,reason)) 
    410        self.requests.add("KICK",stanza,nick) 
    411   
     408        nick=nick.encode(self.encoding,"strict") 
     409        self.session.send("KICK %s %s :%s" % (self.name,nick,reason)) 
     410        self.requests.add("KICK",stanza,nick) 
     411 
    412412    def op_user(self,nick,stanza): 
    413        nick=nick.encode(self.encoding,"strict") 
    414        user=self.session.users.get(normalize(nick)) 
    415        if not user in self.users: 
    416           r=stanza.make_error_response("item-not-found") 
    417           self.session.component.send(r) 
    418           return 
    419        if user in self.modes.get("o",[]): 
    420           r=stanza.make_result_response() 
    421           self.session.component.send(r) 
    422           return 
    423        if user in self.modes.get("v",[]): 
    424            change="-v+o %s %s" % (nick,nick) 
    425        else: 
    426            change="+o "+nick 
    427        self.session.send("MODE %s %s" % (self.name,change)) 
    428        self.requests.add("MODE",stanza,change) 
     413        nick=nick.encode(self.encoding,"strict") 
     414        user=self.session.users.get(normalize(nick)) 
     415        if not user in self.users: 
     416           r=stanza.make_error_response("item-not-found") 
     417           self.session.component.send(r) 
     418           return 
     419        if user in self.modes.get("o",[]): 
     420           r=stanza.make_result_response() 
     421           self.session.component.send(r) 
     422           return 
     423        if user in self.modes.get("v",[]): 
     424            change="-v+o %s %s" % (nick,nick) 
     425        else: 
     426            change="+o "+nick 
     427        self.session.send("MODE %s %s" % (self.name,change)) 
     428        self.requests.add("MODE",stanza,change) 
    429429 
    430430    def voice_user(self,nick,stanza): 
    431        nick=nick.encode(self.encoding,"strict") 
    432        user=self.session.users.get(normalize(nick)) 
    433        if not user in self.users: 
    434           r=stanza.make_error_response("item-not-found") 
    435           self.session.component.send(r) 
    436           return 
    437        if user in self.modes.get("v",[]): 
    438           r=stanza.make_result_response() 
    439           self.session.component.send(r) 
    440           return 
    441        if user in self.modes.get("o",[]): 
    442            change="-o+v %s %s" % (nick,nick) 
    443        else: 
    444            change="+v "+nick 
    445        self.session.send("MODE %s %s" % (self.name,change)) 
    446        self.requests.add("MODE",stanza,change) 
     431        nick=nick.encode(self.encoding,"strict") 
     432        user=self.session.users.get(normalize(nick)) 
     433        if not user in self.users: 
     434           r=stanza.make_error_response("item-not-found") 
     435           self.session.component.send(r) 
     436           return 
     437        if user in self.modes.get("v",[]): 
     438           r=stanza.make_result_response() 
     439           self.session.component.send(r) 
     440           return 
     441        if user in self.modes.get("o",[]): 
     442            change="-o+v %s %s" % (nick,nick) 
     443        else: 
     444            change="+v "+nick 
     445        self.session.send("MODE %s %s" % (self.name,change)) 
     446        self.requests.add("MODE",stanza,change) 
    447447 
    448448    def devoice_user(self,nick,stanza): 
    449        nick=nick.encode(self.encoding,"strict") 
    450        user=self.session.users.get(normalize(nick)) 
    451        if not user in self.users: 
    452           r=stanza.make_error_response("item-not-found") 
    453           self.session.component.send(r) 
    454           return 
    455        if user in self.modes.get("v",[]) and user in self.modes.get("o",[]): 
    456           change="-o-v %s %s" % (nick,nick) 
    457        elif user in self.modes.get("o",[]): 
    458            change="-o "+nick 
    459        elif user in self.modes.get("v",[]): 
    460            change="-v "+nick 
    461        else: 
    462           r=stanza.make_result_response() 
    463           self.session.component.send(r) 
    464           return 
    465        self.session.send("MODE %s %s" % (self.name,change)) 
    466        self.requests.add("MODE",stanza,change) 
     449        nick=nick.encode(self.encoding,"strict") 
     450        user=self.session.users.get(normalize(nick)) 
     451        if not user in self.users: 
     452           r=stanza.make_error_response("item-not-found") 
     453           self.session.component.send(r) 
     454           return 
     455        if user in self.modes.get("v",[]) and user in self.modes.get("o",[]): 
     456           change="-o-v %s %s" % (nick,nick) 
     457        elif user in self.modes.get("o",[]): 
     458            change="-o "+nick 
     459        elif user in self.modes.get("v",[]): 
     460            change="-v "+nick 
     461        else: 
     462           r=stanza.make_result_response() 
     463           self.session.component.send(r) 
     464           return 
     465        self.session.send("MODE %s %s" % (self.name,change)) 
     466        self.requests.add("MODE",stanza,change) 
    467467 
    468468    def __repr__(self): 
    469        return "<IRCChannel %r>" % (self.name,) 
     469        return "<IRCChannel %r>" % (self.name,) 
    470470 
    471471    def debug(self,msg): 
    472        return self.session.debug(msg) 
    473  
    474 # vi: sw=4 ts=8 sts=4 
     472        return self.session.debug(msg) 
     473 
     474# vi: sts=4 et sw=4 

  • trunk/jjigw/common.py

    • Property svn:eol-style deleted
    • Property svn:keywords deleted
    r66 r71  
    6363    s=escape_node_string(s) 
    6464    if not channel_re.match(s): 
    65        raise ValueError,"Bad channel name: %r" % (s,) 
     65        raise ValueError,"Bad channel name: %r" % (s,) 
    6666    return s 
    6767 
    …… 
    7575    s=escape_node_string(s) 
    7676    if not network.valid_nick(s): 
    77        raise ValueError,"Bad nick name: %r" % (s,) 
     77        raise ValueError,"Bad nick name: %r" % (s,) 
    7878    return s 
    7979 
    …… 
    8484 
    8585irc_translate_table=string.maketrans( 
    86        string.ascii_uppercase+"[]\\~", 
    87        string.ascii_lowercase+"{}|^") 
     86        string.ascii_uppercase+"[]\\~", 
     87        string.ascii_lowercase+"{}|^") 
    8888 
    8989def normalize(s): 
    …… 
    9292class ConnectionInfo: 
    9393    def __init__(self,socket,user): 
    94        self.localip,self.localport=socket.getsockname() 
    95        self.remoteip,self.remoteport=socket.getpeername() 
    96        self.user=user 
     94        self.localip,self.localport=socket.getsockname() 
     95        self.remoteip,self.remoteport=socket.getpeername() 
     96        self.user=user 
    9797 
    9898 
    99 # vi: sw=4 ts=8 sts=4 
     99# vi: sts=4 et sw=4 

  • trunk/jjigw/component.py

    r68