comboy-autumn 3.1

data/skel/config/global.yml

@@ -0,0 +1,2 @@
+---
+season: testing

data/skel/config/seasons/testing/database.yml

@@ -0,0 +1,7 @@
+--- 
+Example: 
+  username: root
+  adapter: mysql
+  host: localhost
+  database: example_database
+  password: ""

data/skel/config/seasons/testing/leaves.yml

@@ -0,0 +1,7 @@
+--- 
+Administrator: 
+  authentication: 
+    type: op
+  class: Administrator
+Insulter: 
+  class: Insulter

data/skel/config/seasons/testing/season.yml

@@ -0,0 +1,2 @@
+--- 
+logging: debug

data/skel/config/seasons/testing/stems.yml

@@ -0,0 +1,9 @@
+--- 
+Example: 
+  nick: MyIRCBot
+  leaves: 
+  - Administrator
+  - Insulter
+  rejoin: true
+  channel: "#yourchannel"
+  server: irc.yourircserver.com

data/skel/leaves/administrator/README

@@ -0,0 +1,20 @@
+= Administrator: An Autumn Leaf
+
+<b>Version 1.0 (Jul 8, 2008)</b>
+
+Author::    Tim Morgan (mailto:riscfuture@gmail.com)
+Copyright:: Copyright (c)2008 Tim Morgan
+License::   Distributed under the same terms as Ruby.
+
+This leaf allows the owner of the IRC bot to perform administrative commands on
+the bot, such as quitting or reloading it. In order to protect such commands
+from abuse, this bot uses the Authenticator module. The Authenticator method
+that is used is specified by the +authentication+ option. For more information,
+see the *Authentication* section of the README.
+
+== Usage
+
+!autumn:: Displays information about the version of Autumn that is running this
+          leaf (unprotected command).
+!quit:: Terminates the stem on which the message was received.
+!reload:: Reloads all source files of all leaves, and all their view files.

data/skel/leaves/administrator/controller.rb

@@ -0,0 +1,67 @@
+# Controller for the Administrator leaf.
+
+class Controller < Autumn::Leaf
+  
+  # Typing this command reloads all source code for all leaves and support
+  # files, allowing you to make "on-the-fly" changes without restarting the
+  # process. It does this by reloading the source files defining the classes.
+  #
+  # If you supply the configuration name of a leaf, only that leaf is reloaded.
+  #
+  # This command does not reload the YAML configuration files, only the source
+  # code.
+  
+  def reload_command(stem, sender, reply_to, msg)
+    var :leaves => Hash.new
+    if msg then
+      if Foliater.instance.leaves.include?(msg) then
+        begin
+          Foliater.instance.hot_reload Foliater.instance.leaves[msg]
+        rescue
+          logger.error "Error when reloading #{msg}:"
+          logger.error $!
+          var(:leaves)[msg] = $!.to_s
+        else
+          var(:leaves)[msg] = false
+        end
+        logger.info "#{msg}: Reloaded"
+      else
+        var :not_found => msg
+      end
+    else
+      Foliater.instance.leaves.each do |name, leaf|
+        begin
+          Foliater.instance.hot_reload leaf
+        rescue
+          logger.error "Error when reloading #{name}:"
+          logger.error $!
+          var(:leaves)[name] = $!.to_s
+        else
+          var(:leaves)[name] = false
+        end
+        logger.info "#{name}: Reloaded"
+      end
+    end
+  end
+  ann :reload_command, :protected => true
+  
+  # Typing this command will cause the Stem to exit.
+  
+  def quit_command(stem, sender, reply_to, msg)
+    stem.quit
+  end
+  ann :quit_command, :protected => true
+  
+  # Typing this command will display information about the version of Autumn
+  # that is running this leaf.
+  
+  def autumn_command(stem, sender, reply_to, msg)
+    var :version => AUTUMN_VERSION
+  end
+  
+  # Suppress the !commands command; don't want to publicize the administrative
+  # features.
+  
+  def commands_command(stem, sender, reply_to, msg)
+  end
+end

data/skel/leaves/administrator/views/autumn.txt.erb

@@ -0,0 +1 @@
+Autumn version <%= var :version %>, an IRC bot framework for Ruby (http://github.com/RISCfuture/autumn).

data/skel/leaves/administrator/views/reload.txt.erb

@@ -0,0 +1,11 @@
+<% if var(:not_found) %>
+	There is no leaf named <%= var :not_found %>.
+<% else %>
+	<% var(:leaves).each do |leaf, error| %>
+		<% if error %>
+			<%= leaf %> couldn't be reloaded: <%= error %>
+		<% else %>
+			<%= leaf %> was reloaded successfully.
+		<% end %>
+	<% end %>
+<% end %>

data/skel/leaves/insulter/README

@@ -0,0 +1,17 @@
+= Insulter: An Autumn Leaf
+
+<b>Version 1.0 (Jul 4, 2008)</b>
+
+Author::    Tim Morgan (mailto:riscfuture@gmail.com)
+Copyright:: Copyright (c)2008 Tim Morgan
+License::   Distributed under the same terms as Ruby. Portions of this content
+            are copyright (c)1996 Main Strike Telecommunications, Inc.
+
+A simple Autumn Leaf that generates faux-Shakespearean insults. This leaf
+required no database and no additional gems beyond that of a normal Autumn
+install.
+
+== Usage
+
+!insult [name]:: The bot lets fly a barbarous insult against [name], whose very
+                 spirit will thenceforth be crushed into a negligible pulp.

data/skel/leaves/insulter/controller.rb

@@ -0,0 +1,65 @@
+# Controller and model for the Insulter leaf; maintains the list of insult
+# substrings and chooses from them randomly.
+
+class Controller < Autumn::Leaf
+  
+  # Insults the unfortunate argument of this command.
+  
+  def insult_command(stem, sender, reply_to, msg)
+    if msg.nil? then render :help
+    else insult msg.capitalize end
+  end
+  
+  # Displays information about the leaf.
+  
+  def about_command(stem, sender, reply_to, msg)
+  end
+  
+  private
+  
+  ADJECTIVES = [
+    'an artless', 'a bawdy', 'a beslubbering', 'a bootless', 'a churlish',
+    'a clouted', 'a cockered', 'a craven', 'a currish', 'a dankish',
+    'a dissembling', 'a droning', 'an errant', 'a fawning', 'a fobbing',
+    'a frothy', 'a froward', 'a gleeking', 'a goatish', 'a gorbellied',
+    'an impertinent', 'an infectious', 'a jarring', 'a loggerheaded',
+    'a lumpish', 'a mammering', 'a mangled', 'a mewling', 'a paunchy',
+    'a pribbling', 'a puking', 'a puny', 'a qualling', 'a rank', 'a reeky',
+    'a roguish', 'a ruttish', 'a saucy', 'a spleeny', 'a spongy', 'a surly',
+    'a tottering', 'an unmuzzled', 'a vain', 'a venomed', 'a villainous',
+    'a warped', 'a wayward', 'a weedy', 'a yeasty'
+  ]
+  
+  PARTICIPLES = [
+    'base-court', 'bat-fowling', 'beef-witted', 'beetle-headed', 'boil-brained',
+    'clapper-clawed', 'clay-brained', 'common-kissing', 'crook-pated',
+    'dismal-dreaming', 'dizzy-eyed', 'doghearted', 'dread-bolted',
+    'earth-vexing', 'elf-skinned', 'fat-kidneyed', 'fen-sucked', 'flap-mouthed',
+    'fly-bitten', 'folly-fallen', 'fool-born', 'full-gorged', 'guts-griping',
+    'half-faced', 'hasty-witted', 'hedge-born', 'hell-hated', 'idle-headed',
+    'ill-breeding', 'ill-nurtured', 'knotty-pated', 'milk-livered',
+    'motley-minded', 'onion-eyed', 'plume-plucked', 'pottle-deep', 'pox-marked',
+    'reeling-ripe', 'rough-hewn', 'rude-growing', 'rump-fed', 'shard-borne',
+    'sheep-biting', 'spur-galled', 'swag-bellied', 'tardy-gaited',
+    'tickle-brained', 'toad-spotted', 'urchin-snouted', 'weather-bitten'
+  ]
+  
+  NOUNS = [
+    'apple-john', 'baggage', 'barnacle', 'bladder', 'boar-pig', 'bugbear',
+    'bum-bailey', 'canker-blossom', 'clack-dish', 'clotpole', 'codpiece',
+    'coxcomb', 'death-token', 'dewberry', 'flap-dragon', 'flax-wench',
+    'flirt-gill', 'foot-licker', 'fustilarian', 'giglet', 'gudgeon', 'haggard',
+    'harpy', 'hedge-pig', 'horn-beast', 'hugger-mugger', 'joithead', 'lewdster',
+    'lout', 'maggot-pie', 'malt-worm', 'mammet', 'measle', 'minnow',
+    'miscreant', 'moldwarp', 'mumble-news', 'nut-hook', 'pigeon-egg', 'pignut',
+    'pumpion', 'puttock', 'ratsbane', 'scut', 'skainsmate', 'strumpet',
+    'varlet', 'vassal', 'wagtail', 'whey-face'
+  ]
+  
+  def insult(victim)
+    var :adjective => ADJECTIVES.pick
+    var :participle => PARTICIPLES.pick
+    var :noun => NOUNS.pick
+    var :victim => victim
+  end
+end

data/skel/leaves/insulter/views/about.txt.erb

@@ -0,0 +1 @@
+Insulter version 1.0 (7-4-08) by Tim Morgan: An Autumn Leaf. Insults copyright (c)1996 Main Strike Telecommunications, Inc.

data/skel/leaves/insulter/views/help.txt.erb

@@ -0,0 +1 @@
+Type "!insult Ted" to crush Ted's spirit with a devastating insult.

data/skel/leaves/insulter/views/insult.txt.erb

@@ -0,0 +1 @@
+<%= var :victim %>, thou art <%= var :adjective %> <%= var :participle %> <%= var :noun %>!

data/skel/leaves/scorekeeper/README

@@ -0,0 +1,34 @@
+= Scorekeeper: An Autumn Leaf
+
+<b>Version 3.0 (Jul 4, 2008)</b>
+
+Author::    Tim Morgan (mailto:riscfuture@gmail.com)
+Copyright:: Copyright (c)2007-2008 Tim Morgan
+License::   Distributed under the same terms as Ruby.
+
+An Autumn Leaf used for an in-channel scorekeeping system. This can operate both
+as an open or closed score system. (In the former, new members are automatically
+added when they receive points; in the latter, only authorized members can give
+and receive points.)
+
+Scorekeeper is a database-backed leaf. It requires the DataMapper gem
+(http://www.datamapper.org) in order to run. The database stores channels and
+their members, and each member's point history.
+
+Scorekeeper supports pseudonyms. Entries in the +pseudonyms+ table can be used
+to help ensure that the correct person's points are changed even when the sender
+uses a nickname or abbreviation.
+
+Scorekeeper takes one custom configuration option, +scoring+, which can be
+either "open" or "closed". A closed system only allows a specified set of users
+to receive and give points. An open system allows anyone to award points to
+anyone.
+
+== Usage
+
+!points [name]:: Get a person's score
+!points [name] [+|-][number] [reason]:: Change a person's score (you must have a
+                                        "+" or a "-"). A reason is optional.
+!points [name] history:: Return some recent history of that person's score.
+!points [name] history [time period]:: Selects history from a time period.
+!points [name] history [sender]:: Selects point changes from a sender.

data/skel/leaves/scorekeeper/config.yml

@@ -0,0 +1,2 @@
+--- 
+scoring: open

data/skel/leaves/scorekeeper/controller.rb

@@ -0,0 +1,104 @@
+require 'dm-ar-finders'
+
+begin
+  gem 'chronic'
+  require 'chronic'
+rescue Gem::LoadError
+  # Install the "chronic" gem for more robust date parsing
+end
+
+# Controller for the Scorekeeper leaf. This class contains only the methods
+# directly relating to IRC. Other methods are stored in the helper and model
+# classes.
+
+class Controller < Autumn::Leaf
+  
+  # Displays an about message.
+  
+  def about_command(stem, sender, reply_to, msg)
+  end
+  
+  # Displays the current point totals, or modifies someone's score, depending on
+  # the message provided with the command.
+  
+  def points_command(stem, sender, reply_to, msg)
+    if msg.nil? or msg.empty? then
+      var :totals => totals(stem, reply_to)
+    elsif msg =~ /^(\w+)\s+history\s*(.*)$/ then
+      parse_history stem, reply_to, $1, $2
+      render :history
+    elsif msg =~ /^(\w+)\s+([\+\-]\d+)\s*(.*)$/ then
+      parse_change stem, reply_to, sender, $1, $2.to_i, $3
+      render :change
+    else
+      render :usage
+    end
+  end
+  
+  private
+  
+  def points(stem, channel)
+    chan = Channel.find_or_create :server => server_identifier(stem), :name => channel
+    scores = chan.scores.all
+    scores.inject(Hash.new(0)) { |hsh, score| hsh[score.receiver.name] += score.change; hsh }
+  end
+
+  def totals(stem, channel)
+    points(stem, channel).sort { |a,b| b.last <=> a.last }
+  end
+
+  def parse_change(stem, channel, sender, victim, delta, note)
+    giver = find_person(stem, sender[:nick])
+    receiver = find_person(stem, victim)
+    if giver.nil? and options[:scoring] == 'open' then
+      giver ||= Person.create :server => server_identifier(stem), :name => sender[:nick]
+    end
+    if receiver.nil? and options[:scoring] == 'open' then
+      receiver ||= Person.create :server => server_identifier(stem), :name => find_in_channel(stem, channel, victim)
+    end
+    unless authorized?(giver, receiver)
+      var :unauthorized => true
+      var :receiver => receiver.nil? ? victim : receiver.name
+      return
+    end
+    change_points stem, channel, giver, receiver, delta, note
+    var :giver => giver
+    var :receiver => receiver
+    var :delta => delta
+  end
+  
+  def parse_history(stem, channel, subject, argument)
+    date = argument.empty? ? nil : parse_date(argument)
+    scores = Array.new
+    
+    chan = Channel.first(:name => channel)
+    person = find_person(stem, subject)
+    if person.nil? then
+      var :person => subject
+      var :no_history => true
+      return
+    end
+    
+    if date then
+      start, stop = find_range(date)
+      scores = chan.scores.all(:conditions => [ "receiver_id = ? AND created_at >= ? AND created_at < ?", person.id, start, stop ], :order => [ :created_at.desc ], :limit => 5)
+      #TODO is there a way to scope by both channel and receiver?
+    elsif argument.empty? then
+      scores = chan.scores.all(:conditions => [ "receiver_id = ?", person.id ], :order => [ :created_at.desc ], :limit => 5)
+      #TODO is there a way to scope by both channel and receiver?
+    else
+      giver = find_person(stem, argument)
+      if giver.nil? then
+        var :giver => argument
+        var :receiver => person
+        var :no_giver_history => true
+        return
+      end
+      scores = chan.scores.all(:conditions => [ "receiver_id = ? AND giver_id = ?", person.id, giver.id ], :order => [ :created_at.desc ], :limit => 5)
+      #TODO is there a way to scope by channel, receiver, and giver?
+    end
+    var :receiver => person
+    var :giver => giver
+    var :scores => scores
+  end
+end

data/skel/leaves/scorekeeper/helpers/general.rb

@@ -0,0 +1,64 @@
+# Utility methods used by Scorekeeper.
+
+module GeneralHelper
+  def parse_date(str)
+    date = nil
+    begin
+      date = Chronic.parse(str, :context => :past, :guess => false)
+    rescue NameError
+      begin
+        date = Date.parse(str)
+      rescue ArgumentError
+      end
+    end
+    return date
+  end
+  
+  def find_range(date)
+    start = nil
+    stop = nil
+    if date.kind_of? Range then
+      start = date.first
+      stop = date.last
+    elsif date.kind_of? Time then
+      start = date.to_date
+      stop = date.to_date + 1
+    else
+      start = date
+      stop = date + 1
+    end
+    return start, stop
+  end
+  
+  def find_person(stem, nick)
+    Person.all(:server => server_identifier(stem)).each do |person|
+      return person if person.name.downcase == normalize(nick) or person.pseudonyms.collect { |pn| pn.name.downcase }.include? normalize(nick)
+    end
+    return nil
+  end
+  
+  def find_in_channel(stem, channel, victim)
+    stem.channel_members[channel].each do |name, privilege|
+      return normalize(name, false) if normalize(name) == normalize(victim)
+    end
+    return victim
+  end
+
+  def normalize(nick, dc=true)
+    dc ? nick.downcase.split(/\|/)[0] : nick.split(/\|/)[0]
+  end
+  
+  def authorized?(giver, receiver)
+    giver and receiver and giver.authorized? and giver.name != receiver.name
+  end
+  
+  def change_points(stem, channel, giver, receiver, delta, note=nil)
+    return if delta.zero?
+    chan = Channel.find_or_create :server => server_identifier(stem), :name => channel
+    chan.scores.create :giver => giver, :receiver => receiver, :change => delta, :note => note
+  end
+  
+  def server_identifier(stem)
+    "#{stem.server}:#{stem.port}"
+  end
+end