spox-mod_spox 0.3.1

data/lib/mod_spox/models/Auth.rb

@@ -0,0 +1,65 @@
+require 'digest/sha1'
+require 'mod_spox/models/Group'
+require 'mod_spox/models/Nick'
+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
+
+            many_to_many :groups, :join_table => :auth_groups, :class => 'ModSpox::Models::Group'
+            many_to_one :nick, :class => 'ModSpox::Models::Nick'
+            
+            # Clear relations before destroying
+            def before_destroy
+                remove_all_groups
+            end
+
+            # Is nick authed using services
+            def services
+                s = values[:services]
+                if(s == 0 || s == '0' || !s)
+                    return false
+                else
+                    return true
+                end
+            end
+
+            # Set services (nickserv) identification
+            def services_identified=(val)
+                if(val && services)
+                    update(:authed => true)
+                else
+                    update(:authed => false)
+                end
+            end
+
+            # pass:: password to compare
+            # Check and authenticate against password
+            def check_password(pass)
+                if(Digest::SHA1.hexdigest(pass) == password)
+                    update(:authed => true)
+                    return true
+                else
+                    return false
+                end
+            end
+
+            def password=(pass)
+                pass = pass.nil? ? nil : Digest::SHA1.hexdigest(pass)
+                super(pass)
+            end
+
+            # source:: source to apply mask to
+            # Check and authenticate by mask against source
+            def check_mask(source)
+                authed = true if source =~ /^#{mask}$/
+            end
+
+        end
+
+    end
+end

data/lib/mod_spox/models/AuthMask.rb

@@ -0,0 +1,13 @@
+require 'mod_spox/models/Nick'
+require 'mod_spox/models/Group'
+module ModSpox
+    module Models
+
+        class AuthMask < Sequel::Model
+
+            many_to_many :nicks, :join_table => :auth_masks_nicks, :class => 'ModSpox::Models::Nick'
+            many_to_many :groups, :join_table => :auth_masks_groups, :class => 'ModSpox::Models::Group'
+            
+        end
+    end
+end

data/lib/mod_spox/models/Channel.rb

@@ -0,0 +1,89 @@
+require 'mod_spox/models/Nick'
+require 'mod_spox/models/NickMode'
+
+module ModSpox
+    module Models
+
+        # Attributes provided by model:
+        # name:: Channel name
+        # password:: Channel password
+        # autojoin:: Set bot to autojoin this channel
+        # topic:: Channel topic
+        # quiet:: Silence the bot in this channel
+        # parked:: Bot is currently in this channel
+        class Channel < Sequel::Model
+
+            many_to_many :nicks, :join_table => :nick_channels, :class => 'ModSpox::Models::Nick'
+            one_to_many :nick_modes, :class => 'ModSpox::Models::NickMode'
+
+            # chan_name:: string
+            # set channel name after downcase
+            def name=(chan_name)
+                chan_name.downcase!
+                super(chan_name)
+            end
+
+            def Channel.find_or_create(args)
+                args[:name].downcase! if args[:name]
+                super(args)
+            end
+
+            def Channel.filter(args)
+                args[:name].downcase! if args[:name]
+                super(args)
+            end
+
+            def Channel.locate(string, create = true)
+                string.downcase!
+                chan = Channel.filter(:name => string).first
+                if(!chan && create)
+                    chan = Channel.find_or_create(:name => string)
+                end
+                return chan
+            end
+
+            # m:: single character mode
+            # returns if mode is currently set for
+            # channel
+            def set?(m)
+                return mode.nil? ? false : !mode.index(m).nil?
+            end
+
+            # m:: single character mode
+            # set a mode for the channel
+            # TODO: add some type checks
+            def set_mode(m)
+                update(:mode => "#{values[:mode]}#{m}") if values[:mode].nil? || values[:mode].index(m).nil?
+            end
+
+            # m:: single character mode
+            # unset a mode for the channel
+            def unset_mode(m)
+                update(:mode => values[:mode].gsub(m, ''))
+            end
+
+            def clear_modes
+                update(:mode => '')
+            end
+
+            # Removes all nicks from this channel
+            def clear_nicks
+                remove_all_nicks
+            end
+
+            def add_nick(n)
+                unless(nicks_dataset.filter(:nick_id => n.pk).count > 0)
+                    super(n)
+                end
+            end
+
+            def remove_nick(n)
+                if(nicks_dataset.filter(:nick_id => n.pk).count > 0)
+                    super(n)
+                end
+            end
+
+        end
+
+    end
+end

data/lib/mod_spox/models/Config.rb

@@ -0,0 +1,30 @@
+module ModSpox
+    module Models
+        # 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.
+        # TODO: find and remove any [] usage
+        class Config < Sequel::Model
+
+            def name=(config_name)
+                config_name.downcase!
+                super(config_name)
+            end
+
+            def Config.val(sym)
+                s = Config.filter(:name => "#{sym}").first
+                return s ? s.value : nil
+            end
+
+            def Config.set(sym, value)
+                s = Config.find_or_create(:name => "#{sym}")
+                s.value = value
+                s.save
+            end
+        end
+    end
+end

data/lib/mod_spox/models/Group.rb

@@ -0,0 +1,30 @@
+require 'mod_spox/models/Auth'
+require 'mod_spox/models/Signature'
+
+module ModSpox
+    module Models
+
+        class Group < Sequel::Model
+
+            many_to_many :auth_masks, :join_table => :auth_masks_groups, :class => 'ModSpox::Models::AuthMask'
+            many_to_many :auths, :join_table => :auth_groups, :class => 'ModSpox::Models::Auth'
+            one_to_many :signature, :class => 'ModSpox::Models::Signature'
+
+            def Group.filter(args={})
+                args[:name].downcase! if args.has_key?(:name)
+                super(args)
+            end
+            
+            def Group.find_or_create(args={})
+                args[:name].downcase! if args.has_key?(:name)
+                super(args)
+            end
+
+            def name=(group_name)
+                group_name.downcase!
+                super(group_name)
+            end
+            
+        end
+    end
+end

data/lib/mod_spox/models/Models.rb

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

data/lib/mod_spox/models/Nick.rb

@@ -0,0 +1,195 @@
+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
+        # Attributes provided by model:
+        # nick:: nick string
+        # username:: username of the user
+        # real_name:: real name 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
+        # seconds_idle:: seconds user has been idle
+        # 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
+
+            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)
+                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)
+                nick = nil
+                string.downcase!
+                nick = Nick.filter(:nick => string).first
+                if(!nick && create)
+                    nick = Nick.find_or_create(:nick => string)
+                end
+                return nick
+            end
+
+            # 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)
+                    addr = info[0][3]
+                    update :host => info[0][2]
+                    super(addr)
+                rescue Object => boom
+                    super(addr)
+                    update :host => address
+                ensure
+                    if values[:address] != oldaddress
+                        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 :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
+                super(val)
+            end
+
+            # Auth model associated with nick
+            def auth
+                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
+                g = (auth.groups.empty? || !auth.authed) ? [] : auth.groups
+                unless(auth_masks.empty?)
+                    auth_masks.each{|am| g += am.groups}
+                end
+                return g
+            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
+            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
+
+            # Modes associated with this nick
+            def nick_modes
+                modes
+            end
+
+            # Remove all channels
+            def clear_channels
+                remove_all_channels
+                visible = false
+            end
+
+            # channel:: Models::Channel
+            # Return if nick is operator in given channel
+            def is_op?(channel)
+                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)
+                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
+            end
+
+            # TODO: rewrite this to work
+            def Nick.transfer_groups(old_nick, new_nick)
+                # do nothing
+            end
+
+        end
+    end
+end

data/lib/mod_spox/models/NickMode.rb

@@ -0,0 +1,32 @@
+require 'mod_spox/models/Nick'
+require 'mod_spox/models/Channel'
+module ModSpox
+    module Models
+
+        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
+
+            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
+end

data/lib/mod_spox/models/Server.rb

@@ -0,0 +1,27 @@
+module ModSpox
+    module Models
+        # Attributes provided by model:
+        # host:: hostname of server
+        # port:: port to connect to
+        # priority:: priority of this entry (higher number == greater priority)
+        # 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)
+                host_name.downcase!
+                super(host_name)
+            end
+
+        end
+    end
+end

data/lib/mod_spox/models/Setting.rb

@@ -0,0 +1,52 @@
+module ModSpox
+    module Models
+        # Attributes provided by model:
+        # name:: name of the setting
+        # value:: value of the setting
+        #
+        # 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 find_or_create(args)
+                args[:name].downcase! if args[:name]
+                super(args)
+            end
+
+            def filter(args)
+                args[:name].downcase! if args[:name]
+                super(args)
+            end
+
+            def name=(setting_name)
+                setting_name.downcase!
+                super(setting_name)
+            end
+
+            def value=(val)
+                val = [Marshal.dump(val.dup)].pack('m')
+                super(val)
+            end
+
+            def value
+                return values[:value] ? Marshal.load(values[:value].unpack('m')[0]) : nil
+            end
+
+            def Setting.set(sym, value)
+                sym = sym.to_s.downcase
+                s = Setting.find_or_create(:name => "#{sym}")
+                s.value = value
+                s.save
+            end
+
+            def Setting.val(sym)
+                sym = sym.to_s.downcase
+                s = Setting.filter(:name => "#{sym}").first
+                return s ? s.value : nil
+            end
+        end
+    end
+end

data/lib/mod_spox/models/Signature.rb

@@ -0,0 +1,52 @@
+require 'mod_spox/models/Group'
+
+module ModSpox
+    module Models
+        # Attributes provided by model:
+        # signature:: regex signature
+        # params:: Array of parameters to match in signature
+        # method:: method to call when matched
+        # plugin:: plugin to call when matched
+        # description:: description of trigger
+        class Signature < Sequel::Model
+
+            many_to_one :group, :class => 'ModSpox::Models::Group'
+
+            def params=(prms)
+                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 signature=(v)
+                v = [Marshal.dump(v)].pack('m')
+                super(v)
+            end
+            
+            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
+    end
+end

data/lib/mod_spox/models/Trigger.rb

@@ -0,0 +1,9 @@
+module ModSpox
+    module Models
+        # Attributes provided by model:
+        # trigger:: trigger to match
+        # active:: trigger is active
+        class Trigger < Sequel::Model
+        end
+    end
+end

data/lib/mod_spox/rfc2812.rb

@@ -0,0 +1,49 @@
+module ModSpox
+    
+    RFC = {
+        # basic
+        :INVITE => {:value => :INVITE, :handlers => ['Invite']},
+        :JOIN => {:value => :JOIN, :handlers => ['Join']},
+        :KICK => {:value => :KICK, :handlers => ['Kick']},
+        :MODE => {:value => :MODE, :handlers => ['Mode']},
+        :NICK => {:value => :NICK, :handlers => ['Nick']},
+        :NOTICE => {:value => :NOTICE, :handlers => ['Notice']},
+        :PART => {:value => :PART, :handlers => ['Part']},
+        :PING => {:value => :PING, :handlers => ['Ping']},
+        :PONG => {:value => :PONG, :handlers => ['Pong']},
+        :PRIVMSG => {:value => :PRIVMSG, :handlers => ['Privmsg']},
+        :QUIT => {:value => :QUIT, :handlers => ['Quit']},
+        #client server messages#
+        :RPL_WELCOME => {:value => '001', :handlers => ['Welcome']},
+        :RPL_YOURHOST => {:value => '002'},
+        :RPL_CREATED => {:value => '003', :handlers => ['Created']},
+        :RPL_MYINFO => {:value => '004', :handlers => ['MyInfo']},
+        :RPL_BOUNCE => {:value => '005', :handlers => ['Bounce']},
+        #response replies#
+        :RPL_WHOISIDENTIFIED => {:value => '307', :handlers => ['Whois']},
+        :RPL_WHOISUSER => {:value => '311', :handlers => ['Whois']},
+        :RPL_WHOISSERVER => {:value => '312', :handlers => ['Whois']},
+        :RPL_WHOISOPERATOR => {:value => '313', :handlers => ['Whois']},
+        :RPL_WHOISIDLE => {:value => '317', :handlers => ['Whois']},
+        :RPL_ENDOFWHOIS => {:value => '318', :handlers => ['Whois']},
+        :RPL_WHOISCHANNELS => {:value => '319', :handlers => ['Whois']},
+        :RPL_NOTOPIC => {:value => '331', :handlers => ['Topic']},
+        :RPL_TOPIC => {:value => '332', :handlers => ['Topic']},
+        :RPL_TOPICINFO => {:value => '333', :handlers => ['Topic']},
+        :RPL_WHOREPLY => {:value => '352', :handlers => ['Who']},
+        :RPL_ENDOFWHO => {:value => '315', :handlers => ['Who']},
+        :RPL_NAMREPLY => {:value => '353', :handlers => ['Names']},
+        :RPL_ENDOFNAMES => {:value => '366', :handlers => ['Names']},
+        :RPL_MOTDSTART => {:value => '375', :handlers => ['Motd']},
+        :RPL_MOTD => {:value => '372', :handlers => ['Motd']},
+        :RPL_ENDOFMOTD => {:value => '376', :handlers => ['Motd']},
+        :RPL_LUSERCLIENT => {:value => '251', :handlers => ['LuserClient']},
+        :RPL_LUSEROP => {:value => '252', :handlers => ['LuserOp']},
+        :RPL_LUSERUNKNOWN => {:value => '253', :handlers => ['LuserUnknown']},
+        :RPL_LUSERCHANNELS => {:value => '254', :handlers => ['LuserChannels']},
+        :RPL_LUSERME => {:value => '255', :handlers => ['LuserMe']},
+        :ERR_ERRONEOUSNICKNAME => {:value => '432', :handlers => ['BadNick']},
+        :ERR_NICKNAMEINUSE => {:value => '433', :handlers => ['NickInUse']}
+    }
+    # i feel kinda dirty after that, but hey, lets keep things interesting!
+end

data/populate_gemspec.rb

@@ -0,0 +1,15 @@
+skip = %w(gemspec$ gem$ Rakefile populate_gemspec.rb)
+files = `git ls-files`.split("\n").sort
+files.each{|f| skip.each{|s| if(f =~ /#{s}/);files.delete(f);next;end;}}
+
+spec = File.open('mod_spox.gemspec', 'r')
+contents = spec.readlines
+spec.close
+contents.each do |line|
+    if(line =~ /^\s+s\.files\s+=\s(.+)$/)
+        line.gsub!($1, files.to_s)
+    end
+end
+spec = File.open('mod_spox.gemspec', 'w')
+spec.write(contents.join)
+spec.close