mod_spox 0.1.0.1 → 0.2.0

data/lib/mod_spox/messages/outgoing/Privmsg.rb

@@ -6,20 +6,36 @@ module ModSpox
                 attr_reader :target
                 # the message
                 attr_reader :message
-                # message is an action
-                attr_reader :action
+                # type of CTCP message
+                attr_reader :ctcp_type
                 # target:: target for the message
                 # message:: message to be sent
-                # Send a message to user or channel
-                def initialize(target, message, action=false)
+                # Send a message to user or channel. Setting action to true
+                # is a shortcut to setting ctcp parameters. The action parameter
+                # will override the ctcp parameters if all are set
+                def initialize(target, message, action=false, ctcp=false, ctcp_type=nil)
                     @target = target
                     @message = message
                     @action = action
+                    @ctcp = ctcp
+                    @ctcp_type = ctcp_type.upcase unless ctcp_type.nil?
+                    if(@action)
+                        @ctcp = true
+                        @ctcp_type = 'ACTION'
+                    end
+                    if(!@action && !@ctcp_type.nil?)
+                        @action = true if @ctcp_type == 'ACTION'
+                    end
                 end
                 
                 # is message an action
                 def is_action?
-                    return action
+                    return @action
+                end
+                
+                # is message CTCP
+                def is_ctcp?
+                    return @ctcp
                 end
             end
         end

data/lib/mod_spox/migrations/001_initialize_models.rb

@@ -0,0 +1,115 @@
+module ModSpox
+    module Migrations
+        class InitializeModels < Sequel::Migration
+
+            def up
+                Database.db << "SET FOREIGN_KEY_CHECKS = 0" if Database.type == :mysql
+                Database.db.create_table(:nicks) do
+                    primary_key :id, :null => false
+                    varchar :nick, :null => false, :unique => true
+                    varchar :username
+                    varchar :real_name
+                    varchar :address
+                    varchar :host
+                    varchar :source
+                    timestamp :connected_at
+                    varchar :connected_to
+                    integer :seconds_idle
+                    boolean :visible, :null => false, :default => false
+                    boolean :away, :null => false, :default => false
+                    boolean :botnick, :null => false, :default => false
+                end unless Database.db.table_exists?(:nicks)
+                Database.db.create_table(:channels) do
+                    primary_key :id, :null => false
+                    varchar :name, :null => false, :unique => true
+                    varchar :password
+                    boolean :autojoin, :null => false, :default => false
+                    varchar :topic
+                    boolean :quiet, :null => false, :default => false
+                    boolean :parked, :null => false, :default => false
+                end unless Database.db.table_exists?(:channels)
+                Database.db.create_table(:auths) do
+                    primary_key :id, :null => false
+                    varchar :password
+                    boolean :services, :null => false, :default => false
+                    varchar :mask, :unique => true, :default => nil
+                    boolean :authed, :null => false, :default => false
+                    foreign_key :nick_id, :table => :nicks, :unique => true, :null => false, :key => :id
+                end unless Database.db.table_exists?(:auths)
+                Database.db.create_table(:groups) do
+                    primary_key :id, :null => false
+                    varchar :name, :null => false, :unique => true
+                end unless Database.db.table_exists?(:groups)
+                Database.db.create_table(:configs) do
+                    primary_key :id, :null => false
+                    varchar :name, :null => false, :unique => true
+                    varchar :value
+                end unless Database.db.table_exists?(:configs)
+                Database.db.create_table(:servers) do
+                    primary_key :id, :null => false
+                    varchar :host, :null => false
+                    integer :port, :null => false, :default => 6667
+                    integer :priority, :null => false, :default => 0
+                    boolean :connected, :null => false, :default => false
+                    index [:host, :port], :unique => true
+                end unless Database.db.table_exists?(:servers)
+                Database.db.create_table(:settings) do
+                    primary_key :id, :null => false
+                    varchar :name, :null => false, :unique => true
+                    text :value
+                end unless Database.db.table_exists?(:settings)
+                Database.db.create_table(:signatures) do
+                    primary_key :id, :null => false
+                    varchar :signature, :null => false
+                    varchar :params
+                    foreign_key :group_id, :table => :groups, :default => nil, :key => :id
+                    varchar :method, :null => false
+                    varchar :plugin, :null => false
+                    varchar :description
+                    varchar :requirement, :null => false, :default => 'both'
+                end unless Database.db.table_exists?(:signatures)
+                Database.db.create_table(:triggers) do
+                    primary_key :id, :null => false
+                    varchar :trigger, :unique => true, :null => false
+                    boolean :active, :null => false, :default => false
+                end unless Database.db.table_exists?(:triggers)
+                Database.db.create_table(:auth_groups) do
+                    foreign_key :group_id, :table => :groups, :null => false, :key => :id
+                    foreign_key :auth_id, :table => :auths, :null => false, :key => :id
+                    primary_key [:group_id, :auth_id]
+                end unless Database.db.table_exists?(:auth_groups)
+                Database.db.create_table(:channel_modes) do
+                    primary_key :id, :null => false
+                    varchar :mode, :null => false
+                    foreign_key :channel_id, :table => :channels, :unique => true, :null => false, :key => :id
+                end unless Database.db.table_exists?(:channel_modes)
+                Database.db.create_table(:nick_channels) do
+                    foreign_key :nick_id, :table => :nicks, :null => false, :key => :id
+                    foreign_key :channel_id, :table => :channels, :null => false, :key => :id
+                    primary_key [:nick_id, :channel_id]
+                end unless Database.db.table_exists?(:nick_channels)
+                Database.db.create_table(:nick_groups) do
+                    foreign_key :group_id, :table => :groups, :null => false, :key => :id
+                    foreign_key :nick_id, :table => :nicks, :null => false, :key => :id
+                    primary_key [:nick_id, :group_id]
+                end unless Database.db.table_exists?(:nick_groups)
+                Database.db.create_table(:nick_modes) do
+                    primary_key :id, :null => false
+                    varchar :mode, :null => false
+                    foreign_key :nick_id, :table => :nicks, :null => false, :key => :id
+                    foreign_key :channel_id, :table => :channels, :key => :id
+                    index [:nick_id, :channel_id]
+                end unless Database.db.table_exists?(:nick_modes)
+                Database.db << "SET FOREIGN_KEY_CHECKS = 1" if Database.type == :mysql
+            end
+
+            def down
+                [:nick_modes, :nick_groups, :nick_channels, :channel_modes, :auth_groups,
+                 :triggers, :signatures, :settings, :servers, :configs, :groups, :auths,
+                 :channels, :nicks].each do |table|
+                    Database.db.drop_table(table) if Database.db.table_exists?(table)
+                end
+            end
+        end
+    end
+end

data/lib/mod_spox/models/Auth.rb

@@ -1,26 +1,26 @@
 require 'digest/sha1'
 module ModSpox
     module Models
-    
+
             # Attributes provided by model:
             # password:: Password to autenticate against
             # services:: Authentication by nickserv
             # mask:: Mask to authenticate source against
             # authed:: Nick has authenticated
-        class Auth < Sequel::Model(:auths)
-        
+        class Auth < Sequel::Model
+
             before_destroy :clear_auth_groups
-            
+
             # Clear relations before destroying
             def clear_auth_groups
                 AuthGroup.filter(:auth_id => pk).destroy
             end
-            
+
             # Nick associated with this Auth
             def nick
                 Nick[nick_id]
             end
-            
+
             # Is nick identified with services
             def services
                 s = values[:services]
@@ -30,7 +30,11 @@ module ModSpox
                     return true
                 end
             end
-            
+
+            def authenticated(bool=true)
+                update_values :authed => bool
+            end
+
             # Groups this auth is a member of
             def groups
                 # we grab IDs, then the object. Otherwise we get sync problems
@@ -42,22 +46,22 @@ module ModSpox
                 group_id.each{|id| group << Group[id]}
                 return group
             end
-            
+
             # Add group to this auth's list
             def group=(group)
                 AuthGroup.find_or_create(:auth_id => pk, :group_id => group.pk)
             end
-            
+
             # Remove given group from auth
             def remove_group(group)
                 AuthGroup.filter(:auth_id => pk, :group_id => group.pk).each{|g|g.destroy}
             end
-            
+
             # Set services (nickserv) identification
             def services_identified=(val)
                 update_with_params :authed => true if val && services
             end
-            
+
             # pass:: password to compare
             # Check and authenticate against password
             def check_password(pass)
@@ -68,11 +72,15 @@ module ModSpox
                     return false
                 end
             end
-            
+
             def password=(pass)
-                update_values :password => Digest::SHA1.hexdigest(pass)
+                unless(pass.nil?)
+                    update_values :password => Digest::SHA1.hexdigest(pass)
+                else
+                    update_values :password => nil
+                end
             end
-            
+
             # source:: source to apply mask to
             # Check and authenticate by mask against source
             def check_mask(source)
@@ -80,8 +88,8 @@ module ModSpox
                     update_with_params :authed => true
                 end
             end
-            
+
         end
-        
+
     end
 end

data/lib/mod_spox/models/AuthGroup.rb

@@ -1,12 +1,13 @@
 module ModSpox
     module Models
-        class AuthGroup < Sequel::Model(:auth_groups)
+        class AuthGroup < Sequel::Model
+
             set_primary_key [:group_id, :auth_id]
-            
+
             def auth
                 Auth[auth_id]
             end
-            
+
             def group
                 Group[group_id]
             end

data/lib/mod_spox/models/Channel.rb

@@ -8,24 +8,28 @@ module ModSpox
         # topic:: Channel topic
         # quiet:: Silence the bot in this channel
         # parked:: Bot is currently in this channel
-        class Channel < Sequel::Model(:channels)
-            
+        class Channel < Sequel::Model
+
             set_cache Database.cache, :ttl => 3600 unless Database.cache.nil?
-            
+
+            def name=(chan_name)
+                update_values :name => chan_name.downcase
+            end
+
             def Channel.locate(string, create = true)
-                chan = nil
-                if(Database.type == :pgsql)
-                    chan = Channel.filter('name = lower(?)', string).first
+                string.downcase!
+                chan = Channel.filter(:name => string).first
+                if(!chan && create)
+                    chan = Channel.find_or_create(:name => string)
                 end
-                chan = Channel.find_or_create(:name => string) if !chan && create
                 return chan
             end
-            
+
             # Modes for this channel
             def channel_modes
                 ChannelMode.filter(:channel_id => pk)
             end
-            
+
             # Nicks residing within this channel
             def nicks
                 all_nicks = []
@@ -34,20 +38,24 @@ module ModSpox
                 end
                 return all_nicks
             end
-            
+
             # Adds a nick to this channel
             def nick_add(nick)
                 NickChannel.find_or_create(:channel_id => pk, :nick_id => nick.pk)
             end
-            
+
             # Removes a nick from this channel
             def nick_remove(nick)
                 NickChannel.filter(:channel_id => pk, :nick_id => nick.pk).first.destroy
+                if(NickChannel.filter(:channel_id => pk).count < 1)
+                    update_values :parked => false
+                end
             end
-            
+
             # Removes all nicks from this channel
             def clear_nicks
                 NickChannel.filter(:channel_id => pk, :nick_id => nick.pk).each{|o| o.destroy}
+                update_values :parked => false
             end
 
             # Purges all channel information

data/lib/mod_spox/models/ChannelMode.rb

@@ -2,8 +2,8 @@ module ModSpox
     module Models
         # Attribute provided by model:
         # mode:: mode that is set
-        class ChannelMode < Sequel::Model(:channel_modes)
-        
+        class ChannelMode < Sequel::Model
+
             # Channel this mode is associated to
             def channel
                 Channel[channel_id]

data/lib/mod_spox/models/Config.rb

@@ -3,11 +3,19 @@ module ModSpox
         # Attributes provided by model:
         # name:: name of the config item
         # value:: value of the config item
-        # 
+        #
         # It is important to note this model is for storing configuration
         # values only. It will only store strings, not complex objects. If
         # you need to store an object, use the Setting model.
-        class Config < Sequel::Model(:configs)
+        class Config < Sequel::Model
+
+            def name=(config_name)
+                values[:name] = config_name.downcase
+            end
+            
+            def value=(val)
+                values[:value] = val
+            end
 
             # key:: name of the config item
             # Returns the value of config item named the given key
@@ -16,7 +24,7 @@ module ModSpox
                 match = Config.filter(:name => key).first
                 return match ? match.value : nil
             end
-            
+
             # key:: name of the config item
             # val:: value of the config item
             # Modifies or creates config item and stores the value

data/lib/mod_spox/models/Group.rb

@@ -1,6 +1,11 @@
 module ModSpox
     module Models
-        class Group < Sequel::Model(:groups)
+        class Group < Sequel::Model
+
+            def name=(group_name)
+                update_values :name => group_name.downcase
+            end
+
             def auths
                 auth = []
                 AuthGroup.filter(:group_id => pk).each do |ag|

data/lib/mod_spox/models/Nick.rb

@@ -1,10 +1,13 @@
+require 'socket'
+
 module ModSpox
     module Models
         # Attributes provided by model:
         # nick:: nick string
         # username:: username of the user
         # real_name:: real name of the user
-        # address:: hostname/ip of the user
+        # address:: ip of the user
+        # host:: hostname/ip of the user
         # source:: full source string of the user
         # connected_at:: time user connected
         # connected_to:: server user connected to
@@ -12,21 +15,42 @@ module ModSpox
         # visible:: can the bot see the user (is in a channel the bot is parked)
         # away:: is nick away
         # botnick:: is the nick of the bot
-         
-        # TODO: for nick field -> "tack a COLLATE NOCASE onto the columns"
-        class Nick < Sequel::Model(:nicks)
-            
+
+        class Nick < Sequel::Model
+
             set_cache Database.cache, :ttl => 3600 unless Database.cache.nil?
-            
+
+            def nick=(nick_name)
+                values[:nick] = nick_name.downcase
+            end
+
             def Nick.locate(string, create = true)
                 nick = nil
-                if(Database.type == :pgsql)
-                    nick = Nick.filter('nick = lower(?)', string).first
+                string.downcase!
+                nick = Nick.filter(:nick => string).first
+                if(!nick && create)
+                    nick = Nick.find_or_create(:nick => string)
                 end
-                nick = Nick.find_or_create(:nick => string) if !nick && create
                 return nick
             end
             
+            def address=(address)
+                return if (!values[:address].nil? && !values[:host].nil?) && (values[:address] == address || values[:host] == address)
+                oldaddress = values[:address]
+                begin
+                    info =  Object::Socket.getaddrinfo(address, nil)
+                    update_values :address => info[0][3]
+                    update_values :host => info[0][2]
+                rescue Object => boom
+                    update_values :address => address
+                    update_values :host => address
+                ensure
+                    if values[:address] != oldaddress
+                        clear_auth 
+                    end
+                end
+            end
+
             def visible=(val)
                 unless(val)
                     update_with_params :username => nil
@@ -40,68 +64,98 @@ module ModSpox
                 end
                 update_values :visible => val
             end
-                    
+
             def source=(mask)
-                update_values :source => mask
-                auth.check_mask(mask)
+                super
             end
-            
+
             # Auth model associated with nick
             def auth
                 Auth.find_or_create(:nick_id => pk)
             end
-            
+
             # AuthGroups nick is authed to
             def auth_groups
+                nickgroups = NickGroup.filter(:nick_id => pk)
+                if(nickgroups.size < 1)
+                    populate_groups
+                    nickgroups = NickGroup.filter(:nick_id => pk)
+                end
                 groups = []
+                NickGroup.filter(:nick_id => pk).each do | nickgroup |
+                    groups << nickgroup.group
+                end
+                return groups
+            end
+
+            def populate_groups
                 auth_ids = []
                 group_ids = []
                 auth = Auth.filter('nick_id = ?', pk).filter('authed = ?', true).first
                 if(auth)
-                    groups = auth.groups
+                    auth.groups.each do |group|
+                        NickGroup.find_or_create(:nick_id => pk, :group_id => group.pk)
+                    end
                 end
                 Auth.where('mask is not null').each do |a|
-                    Logger.log("Matching AUTH against #{a.mask}", 30)
-                    if(source =~ /#{a.mask}/)
-                        auth_ids << a.pk
+                    [source, "#{nick}!#{username}@#{host}", "#{nick}!#{username}@#{address}"].each do |chk_src|
+                        Logger.info("Matching AUTH - #{chk_src} against #{a.mask}")
+                        if(chk_src =~ /#{a.mask}/)
+                            auth_ids << a.pk unless auth_ids.include?(a.pk)
+                        end
                     end
                 end
                 auth_ids.each{|id| AuthGroup.filter(:auth_id => id).each{|ag| group_ids << ag.group_id}}
-                group_ids.each{|id| groups << Group[id]}
-                groups.uniq!
-                return groups
+                group_ids.uniq.each{|id| NickGroup.find_or_create(:nick_id => pk, :group_id => id)}
             end
-            
+
             # Set nick as member of given group
             def group=(group)
                 auth.group = group
             end
-            
+
+            def in_group?(group)
+                group = Group.filter(:name => group).first if group.is_a?(String)
+                return group.nil? ? false : auth_groups.include?(group)
+            end
+
             # Remove nick from given group
             def remove_group(group)
                 auth.remove_group(group)
             end
-            
+
+            # Clear this nick's auth status
+            def clear_auth
+                auth.authenticated(false)
+                NickGroup.filter(:nick_id => pk).destroy
+            end
+
             # Modes associated with this nick
             def nick_modes
                 NickMode.filter(:nick_id => pk)
             end
-            
+
             # Add channel nick is found in
             def channel_add(channel)
                 NickChannel.find_or_create(:nick_id => pk, :channel_id => channel.pk)
             end
-            
+
             # Remove channel nick is no longer found in
             def channel_remove(channel)
                 NickChannel.filter(:nick_id => pk, :channel_id => channel.pk).first.destroy
+                if(NickChannel.filter(:nick_id => pk).count < 1)
+                    clear_auth
+                    visible = false
+                end
             end
-            
+
             # Remove all channels
             def clear_channels
-                NickChannel.filter(:nick_id => pk).each{|o|o.destroy}
+                NickChannel.filter(:nick_id => pk).destroy
+                visible = false
+                clear_auth
             end
-            
+
             # Channels nick is currently in
             def channels
                 chans = []
@@ -110,7 +164,7 @@ module ModSpox
                 end
                 return chans
             end
-            
+
             # channel:: Models::Channel
             # Return if nick is operator in given channel
             def is_op?(channel)
@@ -119,7 +173,7 @@ module ModSpox
                 end
                 return false
             end
-            
+
             # channel:: Models::Channel
             # Return if nick is voiced in given channel
             def is_voice?(channel)
@@ -128,16 +182,22 @@ module ModSpox
                 end
                 return false
             end
-            
+
+            def Nick.transfer_groups(old_nick, new_nick)
+                NickGroup.filter(:nick_id => old_nick.pk).update(:nick_id => new_nick.pk)
+            end
+
             # Purge all nick information
             def self.clean
                 Nick.set(:username => nil, :real_name => nil, :address => nil,
                                    :source => nil, :connected_at => nil, :connected_to => nil,
                                    :seconds_idle => nil, :away => false, :visible => false, :botnick => false)
                 NickMode.destroy_all
+                NickChannel.destroy_all
+                NickGroup.destroy_all
                 Auth.set(:authed => false)
             end
-        
+
         end
     end
 end

data/lib/mod_spox/models/NickChannel.rb

@@ -2,10 +2,12 @@ module ModSpox
     module Models
         # This model is for internal use only to provide a
         # proper relation between Nick and Channel
-        class NickChannel < Sequel::Model(:nick_channels)
-            
+        class NickChannel < Sequel::Model
+
+            include Models
+
             set_primary_key [:nick_id, :channel_id]
-            
+
             after_save do
                 c = Channel[channel_id]
                 n = Nick[nick_id]
@@ -14,7 +16,7 @@ module ModSpox
                 c.parked = true
                 c.save
             end
-            
+
             after_destroy do
                 c = Channel[channel_id]
                 n = Nick[nick_id]
@@ -30,11 +32,11 @@ module ModSpox
                     ChannelMode.filter(:channel_id => channel_id).each{|n|n.destroy}
                 end
             end
-            
+
             def nick
                 Nick[nick_id]
             end
-            
+
             def channel
                 Channel[channel_id]
             end