autumn 3.1.8

data/Rakefile

@@ -0,0 +1,75 @@
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'time'
+require 'date'
+
+PROJECT_SPECS = FileList[
+  'spec/*.rb',
+  'lib/skel/spec/*.rb'
+]
+
+PROJECT_MODULE = 'Autumn'
+PROJECT_README = 'README.markdown'
+#PROJECT_RUBYFORGE_GROUP_ID = 3034
+PROJECT_COPYRIGHT = [
+  "#          Copyright (c) #{Time.now.year} Tim Morgan riscfuture@gmail.com",
+  "# Distributed under the same terms as the Ruby license.",
+  "# Portions of this code are copyright ©2004 David Heinemeier Hansson; ",
+  "# please see libs/inheritable_attributes.rb for more information.",
+  "# Autumn's package tasks are copyright 2009 Michael Fellinger m.fellinger@gmail.com;",
+  "# Distributed under the terms of the Ramaze license"
+]
+
+# To release the monthly version do:
+# $ PROJECT_VERSION=2009.03 rake release
+IGNORE_FILES = [/\.gitignore/]
+
+GEMSPEC = Gem::Specification.new{|s|
+  s.name         = 'autumn'
+  s.author       = "Tim 'riscfuture' Morgan"
+  s.summary      = "Autumn is a simple and modular irc framework"
+  s.description  = s.summary
+  s.email        = 'bougy.man@gmail.com'
+  s.homepage     = 'http://github.com/bougyman/autumn'
+  s.platform     = Gem::Platform::RUBY
+  s.version      = (ENV['PROJECT_VERSION'] || Date.today.strftime("%Y.%m.%d"))
+  s.files        = `git ls-files`.split("\n").sort.reject { |f| IGNORE_FILES.detect { |exp| f.match(exp)  } }
+  s.has_rdoc     = true
+  s.require_path = 'lib'
+  s.bindir = "bin"
+  s.executables = ["autumn"]
+  s.rubyforge_project = "pastr"
+
+  s.add_dependency('facets')
+  s.add_dependency('anise')
+
+  s.post_install_message = <<MESSAGE.strip
+============================================================
+
+Thank you for installing Autumn!
+You can now create a new bot:
+# autumn create yourbot
+
+============================================================
+MESSAGE
+}
+
+Dir['tasks/*.rake'].each{|f| import(f) }
+
+task :default => [:spec]
+
+CLEAN.include %w[
+  **/.*.sw?
+  *.gem
+  .config
+  **/*~
+  **/{data.db,cache.yaml}
+  *.yaml
+  pkg
+  rdoc
+  ydoc
+  *coverage*
+]

data/autumn.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{autumn}
+  s.version = "3.1.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim 'riscfuture' Morgan"]
+  s.date = %q{2009-05-03}
+  s.default_executable = %q{autumn}
+  s.description = %q{Autumn is a simple and modular irc framework}
+  s.email = %q{bougy.man@gmail.com}
+  s.executables = ["autumn"]
+  s.files = ["AUTHORS", "CHANGELOG", "MANIFEST", "README", "README.textile", "Rakefile", "autumn.gemspec", "bin/autumn", "lib/autumn.rb", "lib/autumn/authentication.rb", "lib/autumn/channel_leaf.rb", "lib/autumn/coder.rb", "lib/autumn/console_boot.rb", "lib/autumn/ctcp.rb", "lib/autumn/daemon.rb", "lib/autumn/datamapper_hacks.rb", "lib/autumn/foliater.rb", "lib/autumn/formatting.rb", "lib/autumn/generator.rb", "lib/autumn/genesis.rb", "lib/autumn/inheritable_attributes.rb", "lib/autumn/leaf.rb", "lib/autumn/log_facade.rb", "lib/autumn/misc.rb", "lib/autumn/resources/daemons/Anothernet.yml", "lib/autumn/resources/daemons/AustHex.yml", "lib/autumn/resources/daemons/Bahamut.yml", "lib/autumn/resources/daemons/Dancer.yml", "lib/autumn/resources/daemons/GameSurge.yml", "lib/autumn/resources/daemons/IRCnet.yml", "lib/autumn/resources/daemons/Ithildin.yml", "lib/autumn/resources/daemons/KineIRCd.yml", "lib/autumn/resources/daemons/PTlink.yml", "lib/autumn/resources/daemons/QuakeNet.yml", "lib/autumn/resources/daemons/RFC1459.yml", "lib/autumn/resources/daemons/RFC2811.yml", "lib/autumn/resources/daemons/RFC2812.yml", "lib/autumn/resources/daemons/RatBox.yml", "lib/autumn/resources/daemons/Ultimate.yml", "lib/autumn/resources/daemons/Undernet.yml", "lib/autumn/resources/daemons/Unreal.yml", "lib/autumn/resources/daemons/_Other.yml", "lib/autumn/resources/daemons/aircd.yml", "lib/autumn/resources/daemons/bdq-ircd.yml", "lib/autumn/resources/daemons/hybrid.yml", "lib/autumn/resources/daemons/ircu.yml", "lib/autumn/resources/daemons/tr-ircd.yml", "lib/autumn/script.rb", "lib/autumn/speciator.rb", "lib/autumn/stem.rb", "lib/autumn/stem_facade.rb", "lib/autumn/tool/bin.rb", "lib/autumn/tool/create.rb", "lib/autumn/tool/project_creator.rb", "lib/autumn/version.rb", "lib/skel/Rakefile", "lib/skel/config/global.yml", "lib/skel/config/seasons/testing/database.yml", "lib/skel/config/seasons/testing/leaves.yml", "lib/skel/config/seasons/testing/season.yml", "lib/skel/config/seasons/testing/stems.yml", "lib/skel/leaves/administrator/README", "lib/skel/leaves/administrator/controller.rb", "lib/skel/leaves/administrator/views/autumn.txt.erb", "lib/skel/leaves/administrator/views/reload.txt.erb", "lib/skel/leaves/insulter/README", "lib/skel/leaves/insulter/controller.rb", "lib/skel/leaves/insulter/views/about.txt.erb", "lib/skel/leaves/insulter/views/help.txt.erb", "lib/skel/leaves/insulter/views/insult.txt.erb", "lib/skel/leaves/scorekeeper/README", "lib/skel/leaves/scorekeeper/config.yml", "lib/skel/leaves/scorekeeper/controller.rb", "lib/skel/leaves/scorekeeper/helpers/general.rb", "lib/skel/leaves/scorekeeper/models/channel.rb", "lib/skel/leaves/scorekeeper/models/person.rb", "lib/skel/leaves/scorekeeper/models/pseudonym.rb", "lib/skel/leaves/scorekeeper/models/score.rb", "lib/skel/leaves/scorekeeper/tasks/stats.rake", "lib/skel/leaves/scorekeeper/views/about.txt.erb", "lib/skel/leaves/scorekeeper/views/change.txt.erb", "lib/skel/leaves/scorekeeper/views/history.txt.erb", "lib/skel/leaves/scorekeeper/views/points.txt.erb", "lib/skel/leaves/scorekeeper/views/usage.txt.erb", "lib/skel/log/README", "lib/skel/script/console", "lib/skel/script/destroy", "lib/skel/script/generate", "lib/skel/shared/README", "lib/skel/tmp/README", "spec/authentication_spec.rb", "spec/channel_leaf_spec.rb", "spec/coder_spec.rb", "spec/ctcp_spec.rb", "spec/daemon_spec.rb", "spec/datamapper_hacks_spec.rb", "tasks/authors.rake", "tasks/changelog.rake", "tasks/copyright.rake", "tasks/doc.rake", "tasks/gem.rake", "tasks/gem_installer.rake", "tasks/install_dependencies.rake", "tasks/manifest.rake", "tasks/rcov.rake", "tasks/release.rake", "tasks/reversion.rake", "tasks/setup.rake", "tasks/spec.rake", "tasks/yard.rake"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/bougyman/autumn}
+  s.post_install_message = %q{============================================================
+
+Thank you for installing Autumn!
+You can now create a new bot:
+# autumn create yourbot
+
+============================================================}
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{pastr}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Autumn is a simple and modular irc framework}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<facets>, [">= 0"])
+      s.add_runtime_dependency(%q<anise>, [">= 0"])
+    else
+      s.add_dependency(%q<facets>, [">= 0"])
+      s.add_dependency(%q<anise>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<facets>, [">= 0"])
+    s.add_dependency(%q<anise>, [">= 0"])
+  end
+end

data/bin/autumn

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+begin
+  require "pathname"
+  require Pathname.new(__FILE__).expand_path.dirname.join("..", "lib", "autumn")
+  require "autumn/tool/bin"
+rescue LoadError
+  require "rubygems"
+  require "autumn"
+  require "autumn/tool/bin"
+end
+Autumn::Tool::Bin::Cmd.run(ARGV)

data/lib/autumn.rb

@@ -0,0 +1,8 @@
+require "pathname"
+module Autumn
+  unless Autumn.const_defined?("ROOT")
+    ROOT = Pathname.new(__FILE__).dirname.expand_path
+  end
+end
+$LOAD_PATH.unshift Autumn::ROOT
+require "autumn/version"

data/lib/autumn/authentication.rb

@@ -0,0 +1,238 @@
+# 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
+    
+    # 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