comboy-autumn 3.1

data/autumn.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name = 'autumn'
+  s.version = '3.1'
+  s.date = '2009-04-04'
+ 
+  s.summary = "A Ruby IRC Bot Framework"
+  #s.description = ""
+ 
+  s.authors = ['Tim Morgan','Kacper Cieśla']
+  s.email = ''
+  s.homepage = ''
+
+  s.bindir = 'bin'
+  s.executables << 'autumn'
+
+  s.has_rdoc = true
+  s.rdoc_options = ['--main', 'README.textile']
+  s.rdoc_options << '--inline-source' << '--charset=UTF-8'
+  s.extra_rdoc_files = ['README.textile']
+ 
+  # Does not look very cool but github need static lest to build a gem
+  s.files = %w{shared README.textile lib lib/autumn.rb lib/autumn lib/autumn/console_boot.rb lib/autumn/log_facade.rb lib/autumn/channel_leaf.rb lib/autumn/datamapper_hacks.rb lib/autumn/authentication.rb lib/autumn/daemon.rb lib/autumn/stem.rb lib/autumn/generator.rb lib/autumn/leaf.rb lib/autumn/coder.rb lib/autumn/misc.rb lib/autumn/ctcp.rb lib/autumn/formatting.rb lib/autumn/foliater.rb lib/autumn/stem_facade.rb lib/autumn/genesis.rb lib/autumn/script.rb lib/autumn/inheritable_attributes.rb lib/autumn/speciator.rb bin bin/autumn README skel skel/tmp skel/log skel/leaves skel/leaves/administrator skel/leaves/administrator/data skel/leaves/administrator/models skel/leaves/administrator/tasks skel/leaves/administrator/README skel/leaves/administrator/controller.rb skel/leaves/administrator/helpers skel/leaves/administrator/views skel/leaves/administrator/views/reload.txt.erb skel/leaves/administrator/views/autumn.txt.erb skel/leaves/insulter skel/leaves/insulter/data skel/leaves/insulter/models skel/leaves/insulter/tasks skel/leaves/insulter/README skel/leaves/insulter/controller.rb skel/leaves/insulter/helpers skel/leaves/insulter/views skel/leaves/insulter/views/help.txt.erb skel/leaves/insulter/views/about.txt.erb skel/leaves/insulter/views/insult.txt.erb skel/leaves/scorekeeper skel/leaves/scorekeeper/data skel/leaves/scorekeeper/models skel/leaves/scorekeeper/models/person.rb skel/leaves/scorekeeper/models/channel.rb skel/leaves/scorekeeper/models/pseudonym.rb skel/leaves/scorekeeper/models/score.rb skel/leaves/scorekeeper/tasks skel/leaves/scorekeeper/tasks/stats.rake skel/leaves/scorekeeper/README skel/leaves/scorekeeper/controller.rb skel/leaves/scorekeeper/helpers skel/leaves/scorekeeper/helpers/general.rb skel/leaves/scorekeeper/config.yml skel/leaves/scorekeeper/views skel/leaves/scorekeeper/views/about.txt.erb skel/leaves/scorekeeper/views/change.txt.erb skel/leaves/scorekeeper/views/history.txt.erb skel/leaves/scorekeeper/views/points.txt.erb skel/leaves/scorekeeper/views/usage.txt.erb skel/config skel/config/seasons skel/config/seasons/testing skel/config/seasons/testing/stems.yml skel/config/seasons/testing/database.yml skel/config/seasons/testing/leaves.yml skel/config/seasons/testing/season.yml skel/config/global.yml skel/Rakefile skel/script skel/script/server skel/script/console skel/script/destroy skel/script/generate skel/script/daemon autumn.gemspec doc resources resources/daemons resources/daemons/tr-ircd.yml resources/daemons/Dancer.yml resources/daemons/_Other.yml resources/daemons/Undernet.yml resources/daemons/QuakeNet.yml resources/daemons/aircd.yml resources/daemons/IRCnet.yml resources/daemons/KineIRCd.yml resources/daemons/RFC2811.yml resources/daemons/Ultimate.yml resources/daemons/hybrid.yml resources/daemons/GameSurge.yml resources/daemons/AustHex.yml resources/daemons/Unreal.yml resources/daemons/Ithildin.yml resources/daemons/bdq-ircd.yml resources/daemons/RFC1459.yml resources/daemons/RFC2812.yml resources/daemons/Anothernet.yml resources/daemons/Bahamut.yml resources/daemons/ircu.yml resources/daemons/RatBox.yml resources/daemons/PTlink.yml}
+
+end
+ 

data/bin/autumn

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+if ARGV.empty?
+   puts "Usage: autumn /path/to/app"
+   puts "\nDescription:"
+   puts "    Creates new autumn app skeleton in the given directory."
+else
+   begin
+      dir = ARGV[0]
+      print "Preparing application skeleton in directory #{dir}... "; STDOUT.flush
+      Dir.mkdir dir
+      my_dir = File.expand_path(File.dirname(__FILE__))
+      FileUtils.cp_r Dir.glob(File.join(my_dir,'..','skel','*')), dir
+      
+      # There's a small problem with packaging empty dirs into a gem
+      FileUtils.mkdir_p File.join(dir,'tmp')
+      FileUtils.mkdir_p File.join(dir,'log')
+      puts "DONE"
+
+   rescue Errno::EEXIST => e
+      puts "Directory already exists."
+      exit 1
+   end
+    
+end

data/lib/autumn.rb

@@ -0,0 +1,2 @@
+AUTUMN_LIB_DIR = File.expand_path(File.dirname(__FILE__))
+$: << AUTUMN_LIB_DIR

data/lib/autumn/authentication.rb

@@ -0,0 +1,290 @@
+# Defines the Autumn::Authentication class, which includes different
+# authentication strategies available to leaves.
+
+module Autumn
+  
+  # Defines classes which each encapsulate a different strategy for
+  # authentication. When the +authentication+ option is specified (see the
+  # Autumn::Leaf class), the options given are used to choose the correct class
+  # within this module to serve as the authenticator for that leaf.
+  #
+  # These authentication strategies are used to ensure only authorized users
+  # have access to protected commands. Leaf authors can designate certain
+  # commands as protected.
+  #
+  # = Writing Your Own Authenticators
+  #
+  # When the Autumn::Leaf#authenticate method is called, it converts the symbol
+  # from snake_case to CamelCase, and looks for a class in this model. Thus, a
+  # call to <tt>authenticate :hostname</tt> would look for a class
+  # Autumn::Authentication::Hostname.
+  #
+  # To define your own authenticator, subclass Autumn::Authentication::Base as a
+  # new class in the Autumn::Authentication module. Implement the methods
+  # defined in the Autumn::Authentication::Base class docs, then adjust your
+  # configuration to use your new authenticator.
+  
+  module Authentication
+    
+    # The basic subclass for all authenticators. If you wish to write your own
+    # authenticator, you must subclass this class. You must at a minimum
+    # override the authenticate method. You should also override the initialize
+    # method if you need to store any options or other data for later use.
+    #
+    # The authentication module will become a stem listener, so see
+    # Autumn::Stem#add_listener for information on other methods you can
+    # implement.
+    
+    class Base
+      
+      # Stores the options for this authenticator and configures it for use.
+      
+      def initialize(options={})
+        raise "You can only instantiate subclasses of this class."
+      end
+      
+      # Returns true if the user is authorized, false if not. +sender+ is a
+      # sender hash as defined in the Autumn::Stem docs.
+      
+      def authenticate(stem, channel, sender, leaf)
+        raise "Subclasses must override the Autumn::Authentication::Base#authenticate method."
+      end
+      
+      # Returns a string to be displayed to a user who is not authorized to
+      # perform a command. Override this method to provide more specific hints
+      # to a user on what he can do to authorize himself (e.g., "Tell me your
+      # password").
+      
+      def unauthorized
+        "You must be an administrator for this bot to do that."
+      end
+    end
+    
+    # Authenticates users by their privilege level in the channel they ran the
+    # command in.
+    # 
+    # This is a quick, configuration-free way of protecting your leaf, so long
+    # as you trust the ops in your channel.
+    
+    class Op < Base
+      
+      # Creates a new authenticator. Pass a list of allowed privileges (as
+      # symbols) for the +privileges+ option. By default this class accepts ops,
+      # admins, and channel owners/founders as authorized.
+      
+      def initialize(options={})
+        @privileges = options[:privileges]
+        @privileges ||= [ :operator, :oper, :op, :admin, :founder, :channel_owner ]
+      end
+            
+      def authenticate(stem, channel, sender, leaf) # :nodoc:
+        # Returns true if the sender has any of the privileges listed below
+        not (@privileges & [ stem.privilege(channel, sender) ].flatten).empty?
+      end
+      
+      def unauthorized # :nodoc:
+        "You must be an op to do that."
+      end
+    end
+    
+    # Authenticates by IRC nick. A list of allowed nicks is built on
+    # initialization, and anyone with that nick is allowed to use restricted
+    # commands.
+    # 
+    # This is the most obvious approach to authentication, but it is hardly
+    # secure. Anyone can change their nick to an admin's nick once that admin
+    # logs out.
+    
+    class Nick < Base
+      
+      # Creates a new authenticator. Pass a single nick for the +nick+ option or
+      # an array of allowed nicks for the +nicks+ option. If neither option is
+      # set, an exception is raised.
+      
+      def initialize(options={})
+        @nicks = options[:nick]
+        @nicks ||= options[:nicks]
+        raise "You must give the nick of an administrator to use nick-based authentication." if @nicks.nil?
+        @nicks = [ @nicks ] if @nicks.kind_of? String
+      end
+            
+      def authenticate(stem, channel, sender, leaf) # :nodoc:
+        @nicks.include? sender[:nick]
+      end
+    end
+
+    # Works just like nick authentication, the only difference is that one has
+    # to be identified to the nickserver.
+    #
+    # This currently will only work on ircd, dancer and dalnet servers.
+
+    class RegisteredNick < Base
+
+      def initialize(options={})
+        puts "RegisterNick initialization"
+        @nicks = options[:nick]
+        @nicks ||= options[:nicks]
+        raise "You must must the nick of an administrator to use nick-based authentication." if @nicks.nil?
+        @nicks = [ @nicks ] if @nicks.kind_of? String
+        @identified = {}
+        @whois_lock = Mutex.new
+        @identification_lock = Mutex.new
+      end
+
+      def authenticate(stem, channel, sender, leaf) # :nodoc:
+        nick = sender[:nick]
+        @nicks.include?(nick) && is_identified?(stem,nick)
+      end
+
+      # Respnse code that comes at the end of whois message
+      def irc_rpl_endofwhois_response(stem, sender, recipient, arguments, msg)
+        @whois_lock.unlock
+      end
+
+      # Dancer and ircd response code including line with identification information
+      def irc_rpl_whois_hidden_response(stem, sender, recipient, arguments, msg)
+        @identified[arguments.first] = true if msg.strip == "is identified to services"
+      end
+
+      # DALnet response code including line with identification information
+      def irc_rpl_whoisregnick_response(stem, sender, recipient, arguments, msg)
+        @identified[arguments.first] = true if msg.strip == "has identified for this nick"
+      end
+
+      private
+
+      def is_identified?(stem,nick)
+        @identification_lock.synchronize do
+          @whois_lock.lock
+          @identified[nick] = false
+          stem.whois nick
+          @whois_lock.synchronize {}
+          @identified[nick]
+        end
+      end
+
+    end
+    
+    # Authenticates by the host portion of an IRC message. A hostmask is used to
+    # match the relevant portion of the address with a whitelist of accepted
+    # host addresses.
+    # 
+    # This method can be a secure way of preventing unauthorized access if you
+    # choose an appropriately narrow hostmask. However, you must configure in
+    # advance the computers you may want to administrate your leaves from.
+    
+    class Hostname < Base
+      
+      # Creates a new authenticator. You provide a hostmask via the +hostmask+
+      # option -- either a Regexp with one capture (that captures the portion of
+      # the hostmask you are interested in), or a Proc, which takes a host as an
+      # argument and returns true if the host is authorized, false if not. If
+      # the +hostmask+ option is not provided, a standard hostmask regexp will
+      # be used. This regexp strips everything left of the first period; for the
+      # example hostmask "wsd1.ca.widgetcom.net", it would return
+      # "ca.widgetcom.net" to be used for comparison.
+      # 
+      # You also provide an authorized host with the +host+ option, or a list of
+      # such hosts with the +hosts+ option. If neither is given, an exception is
+      # raised.
+      
+      def initialize(options={})
+        @hostmask = options[:hostmask]
+        @hostmask ||= /^.+?\.(.+)$/
+        @hostmask = @hostmask.to_rx(false) if @hostmask.kind_of? String
+        if @hostmask.kind_of? Regexp then
+          mask = @hostmask
+          @hostmask = lambda do |host|
+            if matches = host.match(mask) then matches[1] else nil end
+          end
+        end
+                
+        @hosts = options[:host]
+        @hosts ||= options[:hosts]
+        raise "You must give the host address of an administrator to use nick-based authentication." unless @hosts
+        @hosts = [ @hosts ] unless @hosts.kind_of? Array
+      end
+      
+      def authenticate(stem, channel, sender, leaf) # :nodoc:
+        @hosts.include? @hostmask.call(sender[:host])
+      end
+    end
+    
+    # Authenticates by a password provided in secret. When a user PRIVMSG's the
+    # leaf the correct password, the leaf adds that user's nick to a list of
+    # authorized nicks. These credentials expire when the person changes his
+    # nick, logs out, leaves the channel, etc. They also expire if a certain
+    # amount of time passes without running any protected commands.
+    
+    class Password < Base
+      # The default period of time that must occur with no use of protected
+      # commands after which a user's credentials expire.
+      DEFAULT_EXPIRE_TIME = 5*60
+      
+      # Creates a new authenticator. You provide a valid password with the
+      # +password+ option. If that option is not provided, an exception is
+      # raised. You can pass a number of seconds to the +expire_time+ option;
+      # this is the amount of time that must pass with no protected commands for
+      # a nick's authorization to expire. If the +expire_time+ option is not
+      # given, a default value of five minutes is used.
+      
+      def initialize(options={})
+        @password = options[:password]
+        @expire_time = options[:expire_time]
+        @expire_time ||= DEFAULT_EXPIRE_TIME
+        raise "You must provide a password to use password-based authentication" unless @password
+        @authorized_nicks = Hash.new { |hsh, key| hsh[key] = Set.new }
+        @last_protected_action = Hash.new { |hsh, key| hsh[key] = Hash.new(Time.at(0)) }
+        @an_lock = Mutex.new
+      end
+      
+      def irc_privmsg_event(stem, sender, arguments) # :nodoc:
+        if arguments[:recipient] and arguments[:message] == @password then
+          @an_lock.synchronize do
+            @authorized_nicks[stem] << sender[:nick]
+            @last_protected_action[stem][sender[:nick]] = Time.now
+            #TODO values are not always deleted; this hash has the possibility to slowly grow and consume more memory
+          end
+          stem.message "Your password has been accepted, and you are now authorized.", sender[:nick]
+        end
+      end
+      
+      def irc_nick_event(stem, sender, arguments) # :nodoc:
+        @an_lock.synchronize do
+          revoke stem, sender[:nick]
+          revoke stem, arguments[:nick]
+        end
+      end
+      
+      def irc_kick_event(stem, sender, arguments) # :nodoc:
+        @an_lock.synchronize { revoke stem, arguments[:nick] }
+      end
+      
+      def irc_quit_event(stem, sender, arguments) # :nodoc:
+        @an_lock.synchronize { revoke stem, sender[:nick] }
+      end
+      
+      def authenticate(stem, channel, sender, leaf) # :nodoc:
+        @an_lock.synchronize do
+          if Time.now - @last_protected_action[stem][sender[:nick]] > @expire_time then
+            revoke stem, sender[:nick]
+          else
+            @last_protected_action[stem][sender[:nick]] = Time.now
+          end
+          @authorized_nicks[stem].include? sender[:nick]
+        end
+      end
+      
+      def unauthorized # :nodoc:
+        "You must authenticate with an administrator password to do that."
+      end
+      
+      private
+      
+      def revoke(stem, nick)
+        @authorized_nicks[stem].delete nick
+        @last_protected_action[stem].delete nick
+      end
+    end
+  end
+end

data/lib/autumn/channel_leaf.rb

@@ -0,0 +1,107 @@
+# Defines the Autumn::ChannelLeaf class, a subclass of Autumn::Leaf that
+# selectively ignores channels.
+
+module Autumn
+  
+  # A special kind of leaf that only responds to messages sent to certain
+  # channels. Leaves that subclass ChannelLeaf can, in their config, specify a
+  # +channels+ option that narrows down which channels the leaf listens to. The
+  # leaf will not invoke the hook methods nor the <tt>*_command</tt> methods for
+  # IRC events that are not associated with those channels. It will respond to
+  # global, non-channel-specific events as well.
+  #
+  # You can combine multiple ChannelLeaf subclasses in one Stem to allow you to
+  # run two leaves off of one nick, but have the nick running different leaves
+  # in different channels.
+  #
+  # The +channels+ option should be a list of stems, and for each stem, a valid
+  # channel. For example, if you ran your leaf on two servers, your stems.yml
+  # file might look like:
+  #
+  #  GamingServer:
+  #    channels: fishinggames, games, drivinggames
+  #    [...]
+  #  FishingServer:
+  #    channels: fishinggames, flyfishing
+  #    [...]
+  #
+  # Now let's say you had a trivia leaf that asked questions about fishing
+  # games. You'd want to run that leaf on the "#fishinggames" channel of each
+  # server, and the "#games" channel of the GamingServer, but not the other
+  # channels. (Perhaps your Stem was also running other leaves relevant to those
+  # channels.) You'd set up your leaves.yml file like so:
+  #
+  #  FishingGamesTrivia:
+  #    channels:
+  #      GamingServer:
+  #        - fishinggames
+  #        - games
+  #      FishingServer: fishinggames
+  #    [...]
+  #
+  # Now your leaf will only respond to messages relevant to the specified server
+  # channels (as well as global messages).
+  #
+  # Interception and filtering of messages is done at the _leaf_ level, not the
+  # _stem_ level. Therefore, for instance, if you override
+  # +someone_did_join_channel+, it will only be called for the appropriate
+  # channels; however, if you implement +irc_join_event+, it will still be
+  # called for all channels the stem is in.
+  
+  class ChannelLeaf < Leaf
+    # The IRC channels that this leaf is responding to, mapped to server names.
+    attr :channels
+    
+    # Creates a new instance. (See the Leaf class for more information.)
+    
+    def will_start_up
+      @channels = Hash.new
+      @options[:channels] ||= Hash.new
+      @options[:channels].each do |server, chans|
+        stem = Foliater.instance.stems[server]
+        raise "Unknown stem #{server}" unless stem
+        chans = [ chans ] if chans.kind_of? String
+        @channels[stem] = chans.map { |chan| stem.normalized_channel_name chan }
+      end
+      super
+    end
+    
+    def irc_privmsg_event(stem, sender, arguments) # :nodoc:
+      super if arguments[:channel].nil? or listening?(stem, arguments[:channel])
+    end
+    
+    def irc_join_event(stem, sender, arguments) # :nodoc:
+      super if listening?(stem, arguments[:channel])
+    end
+
+    def irc_part_event(stem, sender, arguments) # :nodoc:
+      super if listening?(stem, arguments[:channel])
+    end
+
+    def irc_mode_event(stem, sender, arguments) # :nodoc:
+      super if arguments[:channel].nil? or listening?(stem, arguments[:channel])
+    end
+
+    def irc_topic_event(stem, sender, arguments) # :nodoc:
+      super if listening?(stem, arguments[:channel])
+    end
+
+    def irc_invite_event(stem, sender, arguments) # :nodoc:
+      super if listening?(stem, arguments[:channel]) or not stem.channels.include? arguments[:channel]
+    end
+
+    def irc_kick_event(stem, sender, arguments) # :nodoc:
+      super if listening?(stem, arguments[:channel])
+    end
+
+    def irc_notice_event(stem, sender, arguments) # :nodoc:
+      super if arguments[:channel].nil? or listening?(stem, arguments[:channel])
+    end
+    
+    private
+    
+    def listening?(stem, channel)
+      @channels.include? stem and @channels[stem].include? channel
+    end
+  end
+end