mod_spox 0.2.0 → 0.3.0

data/lib/mod_spox/models/Models.rb

@@ -1,4 +1,4 @@
 # Quick loader for all models
-Dir.new(File.dirname(__FILE__)).each do |f| 
+Dir.new(File.dirname(__FILE__)).each do |f|
     require File.dirname(__FILE__) + '/' + f if f =~ /\.rb$/
 end

data/lib/mod_spox/models/Nick.rb

@@ -1,4 +1,10 @@
 require 'socket'
+require 'mod_spox/models/Auth'
+require 'mod_spox/models/Channel'
+require 'mod_spox/models/NickMode'
+require 'mod_spox/models/AuthMask'
+
+
 
 module ModSpox
     module Models
@@ -15,13 +21,29 @@ 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
-
+        
         class Nick < Sequel::Model
 
-            set_cache Database.cache, :ttl => 3600 unless Database.cache.nil?
+            one_to_many :auths, :one_to_one => true, :class => 'ModSpox::Models::Auth'
+            many_to_many :channels, :join_table => :nick_channels, :class => 'ModSpox::Models::Channel'
+            one_to_many :modes, :class => 'ModSpox::Models::NickMode'
+            many_to_many :auth_masks, :join_table => :auth_masks_nicks, :class => 'ModSpox::Models::AuthMask'
 
+            # nick_name:: nick of user
+            # override to downcase nick
             def nick=(nick_name)
-                values[:nick] = nick_name.downcase
+                nick_name.downcase!
+                super(nick_name)
+            end
+
+            def Nick.find_or_create(args)
+                args[:nick].downcase! if args[:nick]
+                super(args)
+            end
+
+            def Nick.filter(args)
+                args[:nick].downcase! if args[:nick]
+                super(args)
             end
 
             def Nick.locate(string, create = true)
@@ -33,169 +55,139 @@ module ModSpox
                 end
                 return nick
             end
-            
-            def address=(address)
-                return if (!values[:address].nil? && !values[:host].nil?) && (values[:address] == address || values[:host] == address)
+
+            # addr: users address
+            # make sure everything is set properly
+            # when the address is set
+            def address=(addr)
+                return if (!values[:address].nil? && !values[:host].nil?) && (values[:address] == addr || values[:host] == addr)
                 oldaddress = values[:address]
                 begin
                     info =  Object::Socket.getaddrinfo(address, nil)
-                    update_values :address => info[0][3]
-                    update_values :host => info[0][2]
+                    addr = info[0][3]
+                    update :host => info[0][2]
+                    super(addr)
                 rescue Object => boom
-                    update_values :address => address
-                    update_values :host => address
+                    super(addr)
+                    update :host => address
                 ensure
                     if values[:address] != oldaddress
-                        clear_auth 
+                        auth.update(:authed => false)
                     end
                 end
             end
 
+            # val:: bool
+            # sets if nick is currently visible. if
+            # not all relating information is cleared
             def visible=(val)
                 unless(val)
-                    update_with_params :username => nil
-                    update_with_params :real_name => nil
-                    update_with_params :address => nil
-                    update_with_params :source => nil
-                    update_with_params :connected_at => nil
-                    update_with_params :connected_to => nil
-                    update_with_params :seconds_idle => nil
-                    update_with_params :away => false
+                    update :username => nil
+                    update :real_name => nil
+                    update :address => nil
+                    update :source => nil
+                    update :connected_at => nil
+                    update :connected_to => nil
+                    update :seconds_idle => nil
+                    update :away => false
+                    remove_all_channels
+                    auth.update(:authed => false)
                 end
-                update_values :visible => val
-            end
-
-            def source=(mask)
-                super
+                super(val)
             end
 
             # Auth model associated with nick
             def auth
-                Auth.find_or_create(:nick_id => pk)
+                if(auths.empty?)
+                    a = Auth.find_or_create(:nick_id => pk)
+                    add_auth(a)
+                end
+                auths[0].refresh
+                return auths[0]
             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
+                g = (auth.groups.empty? || !auth.authed) ? [] : auth.groups
+                unless(auth_masks.empty?)
+                    auth_masks.each{|am| g += am.groups}
                 end
-                return groups
+                return g
             end
 
-            def populate_groups
-                auth_ids = []
-                group_ids = []
-                auth = Auth.filter('nick_id = ?', pk).filter('authed = ?', true).first
-                if(auth)
-                    auth.groups.each do |group|
-                        NickGroup.find_or_create(:nick_id => pk, :group_id => group.pk)
-                    end
+            # Checks nick's source against available
+            # authentication masks
+            def check_masks
+                AuthMask.all.each do |am|
+                    add_auth_mask(am) if source =~ /#{am.mask}/ && !auth_masks.include?(am)
                 end
-                Auth.where('mask is not null').each do |a|
-                    [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.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
 
+            # group:: Models::Group
+            # Return if nick is member of given group
             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
+                modes
             end
 
             # Remove all channels
             def clear_channels
-                NickChannel.filter(:nick_id => pk).destroy
+                remove_all_channels
                 visible = false
-                clear_auth
-            end
-
-            # Channels nick is currently in
-            def channels
-                chans = []
-                NickChannel.filter(:nick_id => pk).each do |nc|
-                    chans << nc.channel
-                end
-                return chans
             end
 
             # channel:: Models::Channel
             # Return if nick is operator in given channel
             def is_op?(channel)
-                NickMode.filter(:channel_id => channel.pk, :nick_id => pk).each do |mode|
-                    return true if mode.mode == 'o'
-                end
-                return false
+                raise Exceptions::NotInChannel.new(channel) unless channels_dataset.filter(:channel_id => channel.pk).count > 0
+                m = NickMode.filter(:nick_id => pk, :channel_id => channel.pk).first
+                return m ? m.set?('o') : false
             end
 
             # channel:: Models::Channel
             # Return if nick is voiced in given channel
             def is_voice?(channel)
-                NickMode.filter(:channel_id => channel.pk, :nick_id => pk).each do |mode|
-                    return true if mode.mode == 'v'
+                raise Exceptions::NotInChannel.new(channel) unless channels_dataset.filter(:channel_id => channel.pk).count > 0
+                m = NickMode.filter(:nick_id => pk, :channel_id => channel.pk).first
+                return m ? m.set?('v') : false
+            end
+            
+            def set_mode(m)
+                m.each_char do |c|
+                    update(:mode => "#{mode}#{c}") if mode.index(c).nil?
+                end
+            end
+            
+            def unset_mode(m)
+                m.each_char do |c|
+                    update(:mode => mode.gsub(c,'')) unless mode.index(c).nil?
+                end
+            end
+            
+            def mode_set?(m)
+                return !mode.index(m).nil?
+            end
+
+            def add_channel(c)
+                unless(channels_dataset.filter(:channel_id => c.pk).count > 0)
+                    super(c)
+                end
+            end
+
+            def remove_channel(c)
+                if(channels_dataset.filter(:channel_id => c.pk).count > 0)
+                    super(c)
                 end
-                return false
             end
 
+            # TODO: rewrite this to work
             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)
+                # do nothing
             end
 
         end

data/lib/mod_spox/models/NickMode.rb

@@ -1,17 +1,31 @@
+require 'mod_spox/models/Nick'
+require 'mod_spox/models/Channel'
 module ModSpox
     module Models
-        # Attributes provided by model:
-        # mode:: Mode that is set
-        class NickMode < Sequel::Model
 
-            # Nick mode is associated with
-            def nick
-                return Nick[nick_id]
+        class NickMode < Sequel::Model
+            many_to_one :nick, :class => 'ModSpox::Models::Nick'
+            many_to_one :channel, :class => 'ModSpox::Models::Channel'
+            
+            # m:: mode character
+            # add a mode for a nick channel combo
+            def set_mode(m)
+                update(:mode => "#{values[:mode]}#{m}") if values[:mode].nil? || values[:mode].index(m).nil?
+            end
+            
+            # m:: mode character
+            # remove a mode for a nick channel combo
+            def unset_mode(m)
+                update(:mode => values[:mode].gsub(m, ''))
             end
 
-            # Channel mode is associated with
-            def channel
-                return Channel[channel_id]
+            def set?(m)
+                return mode.nil? ? false : !mode.index(m).nil?
+            end
+            
+            # clear all modes for a nick channel combo
+            def clear_modes
+                update(:mode => '')
             end
         end
     end

data/lib/mod_spox/models/Server.rb

@@ -7,8 +7,19 @@ module ModSpox
         # connected:: bot is connected to this server
         class Server < Sequel::Model
 
+            def Server.filter(args={})
+                args[:host].downcase! if args.has_key?(:host)
+                super(args)
+            end
+            
+            def Server.find_or_create(args={})
+                args[:host].downcase! if args.has_key?(:host)
+                super(args)
+            end
+
             def host=(host_name)
-                update_values :host => host_name.downcase
+                host_name.downcase!
+                super(host_name)
             end
 
         end

data/lib/mod_spox/models/Setting.rb

@@ -6,38 +6,34 @@ module ModSpox
         #
         # This model can be used to store complex objects. These objects are dumped
         # and stored for later retrieval
+        # TODO: remove [] from any usage
         class Setting < Sequel::Model
 
             #serialize(:value, :format => :marshal)
 
             def name=(setting_name)
-                update_values :name => setting_name.downcase
+                setting_name.downcase!
+                super(setting_name)
             end
 
             def value=(val)
-                update_values(:value => [Marshal.dump(val.dup)].pack('m'))
+                val = [Marshal.dump(val.dup)].pack('m')
+                super(val)
             end
 
             def value
                 return values[:value] ? Marshal.load(values[:value].unpack('m')[0]) : nil
             end
 
-            # key:: name of the setting
-            # Returns the setting with the given name
-            def self.[](key)
-                key = key.to_s if key.is_a?(Symbol)
-                setting = Setting.filter(:name => key).first
-                return setting ? setting.value : nil
+            def Setting.set(sym, value)
+                s = Setting.find_or_create(:name => "#{sym}")
+                s.value = value
+                s.save
             end
 
-            # key:: name of the setting
-            # val:: value of the setting
-            # Stores the val in setting named by the given key
-            # Note: Will fail if attempting to save hashes. Must set value explicitly
-            def self.[]=(key, val)
-                key = key.to_s if key.is_a?(Symbol)
-                model = Setting.find_or_create(:name => key)
-                model.update_with_params(:value => [Marshal.dump(val.dup)].pack('m'))
+            def Setting.val(sym)
+                s = Setting.filter(:name => "#{sym}").first
+                return s ? s.value : nil
             end
         end
     end

data/lib/mod_spox/models/Signature.rb

@@ -1,3 +1,5 @@
+require 'mod_spox/models/Group'
+
 module ModSpox
     module Models
         # Attributes provided by model:
@@ -8,23 +10,41 @@ module ModSpox
         # description:: description of trigger
         class Signature < Sequel::Model
 
-            serialize(:signature, :format => :marshal)
+            many_to_one :group, :class => 'ModSpox::Models::Group'
 
             def params=(prms)
-                raise InvalidType.new('Parameter names must be provided in an array') unless prms.kind_of?(Array)
-                update_values(:params => prms.join('|'))
+                raise Exceptions::InvalidType.new('Parameter names must be provided in an array') unless prms.nil? || prms.kind_of?(Array)
+                prms = prms.join('|') unless prms.nil?
+                super(prms)
             end
 
             def params
                 return values[:params].nil? ? [] : values[:params].split('|')
             end
 
-            def group
-                Group[group_id]
+            def signature=(v)
+                v = [Marshal.dump(v)].pack('m')
+                super(v)
             end
-
-            def group=(group)
-                update_values :group_id => group.pk
+            
+            def signature
+                values[:signature] ? Marshal.load(values[:signature].unpack('m')[0]) : nil
+            end
+            
+            def Signature.find_or_create(args)
+                t = nil
+                if(args.has_key?(:signature) && args.has_key?(:params) && args.has_key?(:method) && args.has_key?(:plugin))
+                    args[:params] = [] if args[:params].nil?
+                    Signature.filter(:method => args[:method], :plugin => args[:plugin], :params => args[:params].join('|')).each do |s|
+                        t = s if s.signature == args[:signature]
+                    end
+                    args[:params] = nil if args[:params].empty?
+                end
+                unless(t)
+                    t = create(args)
+                end
+                t.update(:enabled => true)
+                return t
             end
 
         end