ceiling_cat 0.0.1

data/bin/ceiling_cat

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'ceiling_cat'
+
+if ARGV[0] == "setup"
+   cc=`gem which ceiling_cat`
+  `mkdir ./plugins` unless File.exists?('./plugins')
+  if File.exists?(File.join(cc.split("/")[0..-3], "setup", "Rakefile")) && !File.exists?('Rakefile')
+    `cp #{File.join(cc.split("/")[0..-3], "setup", "Rakefile")} Rakefile`
+    puts "Rakefile created."
+  end
+  if File.exists?(File.join(cc.split("/")[0..-3], "setup", "Chatfile")) && !File.exists?('Chatfile')
+    `cp #{File.join(cc.split("/")[0..-3], "setup", "Chatfile")} Chatfile`
+    puts "Chatfile created."
+  end
+  puts "To create your own plugin, run `rake plugin:create name=[plugin_name]` to get started."
+else
+  file = ARGV[0] || './Chatfile'
+
+  if File.exists?(file)
+    load file
+    CeilingCat::Setup.new.connect
+  else
+    puts "Couldn't find a Chatfile at #{file}! Create one at `./Chatfile`, provide a path to one, or run `ceiling_cat setup`"
+  end
+end

data/lib/ceiling_cat.rb

@@ -0,0 +1,4 @@
+# General
+%w{version setup connection errors event user room plugins/base services/campfire storage/base storage/yaml}.each do |file|
+  require "ceiling_cat/#{file}"
+end

data/lib/ceiling_cat/connection.rb

@@ -0,0 +1,19 @@
+module CeilingCat
+  class Connection
+    attr_accessor :config
+    
+    def initialize(config)
+      @config=config
+      @config.storage ||= CeilingCat::Storage::Hash
+    end
+    
+    def plugins
+      self.config.plugins
+    end
+    
+    def storage
+      self.config.storage
+    end
+    
+  end
+end

data/lib/ceiling_cat/errors.rb

@@ -0,0 +1,17 @@
+module CeilingCat
+  class Error < StandardError
+
+    def initialize(message)
+      super message
+    end
+  end
+  
+  # Gem Specific Errors
+  class CeilingCatError < StandardError; end
+  
+  class UnsupportedChatServiceError < CeilingCatError; end
+  
+  class NotImplementedError < CeilingCatError; end
+  
+  class ReloadException < CeilingCatError; end
+end

data/lib/ceiling_cat/event.rb

@@ -0,0 +1,29 @@
+module CeilingCat
+  class Event
+    attr_accessor :room, :body, :user, :type, :time
+
+    def initialize(room, body,user,opts={})
+      @room = room
+      @body = body.to_s.strip
+      @user = user
+      @type = opts[:type]
+      @time = opts[:time] || Time.now
+    end
+    
+    def handle 
+      @room.plugins.each do |plugin|
+        puts "running #{plugin}"
+        begin
+          response = plugin.new(self).handle
+          break if response.present?
+        rescue => e
+          @room.say("Whoops - there was a problem with #{plugin}: #{e}")
+        end
+      end
+    end
+    
+    def type # assume that all messages are just text unless the specific room type overrides it.
+      :chat
+    end
+  end
+end

data/lib/ceiling_cat/plugins/about.rb

@@ -0,0 +1,44 @@
+module CeilingCat
+  module Plugin
+    class About < CeilingCat::Plugin::Base
+      def self.commands
+        [{:command => "plugins", :description => "List of installed plugins.", :method => "list_plugins"},
+         {:command => "commands", :description => "List of available commands.", :method => "list_commands", :public => true},
+         {:command => "users", :description => "List of registered in the room.", :method => "list_users", :public => true},
+         {:command => "guests", :description => "List of guests in the room.", :method => "list_guests", :public => true}]
+      end
+
+      def self.description
+        "About the currently running Ceiling Cat"
+      end
+
+      def self.name
+        "About"
+      end
+
+      def self.public?
+        true
+      end
+
+      def list_plugins
+        reply room.plugin_descriptions(user.is_registered?)
+      end
+
+      def list_commands
+        messages = room.available_commands(user.is_registered?) # Show all commands if the user is registered, otherwise only show private commands
+        messages << "Run commands with '![command]' or '#{room.me.name}: [command]'"
+        reply messages
+      end
+      
+      def list_users
+        members = room.list_of_users_in_room(:type => "member")
+        reply "#{members} #{pluralize(members.size, "is a", "are")} #{pluralize(members.size, "registered user")}."
+      end
+      
+      def list_guests
+        guests = room.list_of_users_in_room(:type => "guest")
+        reply "#{guests} #{pluralize(members.size, "is a", "are")} #{pluralize(members.size, "guest")}."
+      end
+    end
+  end
+end

data/lib/ceiling_cat/plugins/base.rb

@@ -0,0 +1,98 @@
+module CeilingCat
+  module Plugin
+    class Base
+      attr_accessor :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def handle
+        if command = commands.find{|command| body =~ /^(!|#{room.me.name}:?\s*)#{command[:command]}/i}
+          begin
+            if command[:public] || user.is_registered?
+              self.send command[:method]
+            end
+          rescue => e
+            reply "There was an error: #{$!}"
+            raise e
+          end
+        end
+      end
+
+      def self.name
+        self.to_s.gsub("CeilingCat::Plugin::","")
+      end
+
+      def self.description
+        "No description"
+      end
+
+      def self.public?
+        false #assume we don't want people to know a plugin is available.
+      end
+
+      def self.commands
+        []
+      end
+
+      def commands
+        self.class.commands || []
+      end
+
+      def event
+        @event
+      end
+
+      def room
+        event.room
+      end
+      
+      def store
+        self.class.store
+      end
+      
+      def self.store
+        CeilingCat::Setup.config.storage
+      end
+
+      def body
+        event.body
+      end
+
+      def user
+        event.user
+      end
+
+      def reply(message)
+        room.say(message)
+      end
+      
+      def words
+        body.split
+      end
+
+      def body_without_command(command,text=body)
+        text.sub(/^!#{command}:?\s*/i,"").strip
+      end
+
+      def body_without_nick(text=body)
+        text.sub(/^#{room.me.name}:?\s*/i,'').strip
+      end
+      
+      def body_without_nick_or_command(command,text=body)
+        body_without_command(command, body_without_nick(text).sub(/^#{command}/i,"!#{command}"))
+      end
+      
+      def pluralize(n, singular, plural=nil)
+        if n == 1
+            "#{singular}"
+        elsif plural
+            "#{plural}"
+        else
+            "#{singular}s"
+        end
+      end
+    end
+  end
+end

data/lib/ceiling_cat/plugins/calc.rb

@@ -0,0 +1,34 @@
+module CeilingCat
+  module Plugin
+    class Calc < CeilingCat::Plugin::Base      
+      def self.commands
+        [{:command => "calculate", :description => "Performs basic math functions - '!calculate 7*5'", :method => "calculate", :public => true}]
+      end
+      
+      def self.description
+        "A basic calculator, for all your mathin' needs!"
+      end
+      
+      def self.name
+        "Calculator"
+      end
+      
+      def self.public?
+        true
+      end
+      
+      def calculate
+        begin
+          math = body.gsub(/[^\d+-\/*\(\)\.]/,"") # Removing anything but numbers, operators, and parens
+          if math.length > 0 && math =~ /^\d.+\d$/
+            reply "#{math} = #{eval math}"
+          else
+            reply "I don't think that's an equation. Want to try something else?"
+          end
+        rescue => e
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/ceiling_cat/plugins/call_and_response.rb

@@ -0,0 +1,76 @@
+module CeilingCat
+  module Plugin
+    class CallAndResponse < CeilingCat::Plugin::Base
+      def handle
+        if event.type == :chat
+          super
+          if match = self.class.list.find{|car| body =~ Regexp.new(Regexp.escape(car[:call]),true) }
+            reply match[:url]
+            return nil
+          end
+        end
+        
+      end
+
+      def self.commands
+        [{:command => "list calls", :description => "List current calls and their responses", :method => "list"},
+         {:command => "add call", :description => "Add an response to display when a phrase is said, split by a | - '!add call I see what you did there... | You caught me!'", :method => "add"},
+         {:command => "remove call", :description => "Remove an call and response by call '!remove call I see what you did there...'", :method => "remove"}]
+      end
+
+      def self.description
+        "Watches for certain phrases and inserts a relevant image"
+      end
+
+      def self.name
+        "Call and Response"
+      end
+
+      def self.public?
+        false
+      end
+
+      def list
+        messages = []
+        store["call_and_responses"] ||= []
+        if store["call_and_responses"].size > 0
+          messages << "Current Calls and Responses"
+          messages += store["call_and_responses"].collect{|car| "-- #{car[:call]} | #{car[:response]}"}
+        else
+          messages << "There are no call and respones set up yet! You should add one with '!add call When someone says this | I say this'"
+        end
+        reply messages
+      end
+
+      def add
+        message = body_without_nick_or_command("add call").split
+        call, response = message.split("|")
+        if self.class.add(:call => call.strip,:response => response.strip)
+          reply "Call and Response added."
+        else
+          reply "Unable to add that call. A call and a response are required, split by a | - 'When someones says this | I say this'"
+        end
+      end
+
+      def remove
+        self.class.remove(body_without_nick_or_command("remove image phrase"))
+        reply "Call removed."
+      end
+
+      def self.list
+        store["call_and_responses"] ||= []
+      end
+
+      def self.add(opts={})
+        return false unless opts[:call] && opts[:response]
+        store["call_and_responses"] ||= []
+        store["call_and_responses"] = (store["call_and_responses"] + [{:call => opts[:call], :response => opts[:response]}]).uniq
+      end
+
+      def self.remove(phrase)
+        store["call_and_responses"] ||= []
+        store["call_and_responses"] = store["call_and_responses"].reject{|car| car[:call].downcase == call.downcase }
+      end
+    end
+  end
+end

data/lib/ceiling_cat/plugins/campfire_account_monitor.rb

@@ -0,0 +1,46 @@
+module CeilingCat
+  module Plugin
+    class CampfireAccountMonitor < CeilingCat::Plugin::Base
+      # See lib/ceiling_cat/plugins/base.rb for the methods available by default.
+      # Plugins are run in the order they are listed in the Chatfile.
+      # When a plugin returns anything other than nil the plugin execution chain is halted.
+      # If you want your plugin to do something but let the remaining plugins execute, return nil at the end of your method.
+
+      # handle manages a plugin's entire interaction with an event.
+      # If you only want to execute commands - "![command]" - leave handle alone (or remove it and define commands below)
+      def handle
+        if room.connection.config.service.downcase == "campfire" && event.type == :entrance
+          user_count = room.connection.total_user_count
+          max_users = room.connection.config.max_users || 100
+          room.plugin("notifo").new(@event).deliver("#{user_count} of #{max_users} max  connections to Campfire.") if room.plugin_installed?("notifo") && user_count > max_users-2
+        end
+        super
+      end
+
+      # If you want the plugin to run when certain text is sent use commands instead of handle.
+      # Ceiling Cat will watch for "![command]" or "[name]: [command" and execute the method for that command.
+      def self.commands
+        [{:command => "total users", :description => "Gets the total number of current users in chat", :method => "total_users", :public => false}]
+      end
+
+      def self.description
+        "For monitoring Campfire connection limits"
+      end
+
+      def self.name
+        "Campfire account monitor"
+      end
+
+      def self.public?
+        false
+      end
+
+      def total_users
+        if room.connection.config.service.downcase == "campfire"
+          reply "#{room.connection.total_user_count} connections currently used"
+        end
+      end
+    end
+  end
+end
+    

data/lib/ceiling_cat/plugins/days.rb

@@ -0,0 +1,99 @@
+module CeilingCat
+  class NotADateError < CeilingCatError; end
+  
+  module Plugin
+    class Days < CeilingCat::Plugin::Base
+      def self.commands
+        [{:command => "today", :description => "Find out if there's anything special about today.", :method => "about", :public => true},
+         {:command => "add holiday", :description => "Add a holiday - '!add holiday 1/19/2011'", :method => "add_to_holidays"}]
+      end
+      
+      def about(date=Date.today)
+        begin
+          if self.class.is_a_holiday?(date)
+            reply "Today is a holiday!"
+          elsif self.class.is_a_weekend?(date)
+            reply "Today is a weekend!"
+          else
+            reply "Just a normal day today."
+          end
+        rescue NotADateError
+          reply "Sorry, that's not a valid date."
+        end
+      end
+      
+      def self.description
+        "Holidays and times you shouldn't expect to see us in chat."
+      end
+      
+      def add_to_holidays
+        date = body_without_command("add holiday")
+        if date.empty?
+          reply "You need to provide a date to add to the holiday list, like 'add holiday 1/19/2011'"
+        else
+          begin
+            self.class.add_to_holidays(body_without_command("add holiday"))
+            reply "#{date.to_s} has been added to the holiday list."
+          rescue NotADateError
+            reply "Sorry, that's not a valid date."
+          end
+        end
+      end
+      
+      def self.is_a_weekend?(date=Date.today)
+        if is_a_date?(date)
+          date = Date.parse(date.to_s)
+          date.wday == 0 || date.wday == 6
+        else
+          raise NotADateError
+        end
+      end
+      
+      def self.holidays
+        store["holidays"] ||= []
+      end
+      
+      def self.add_to_holidays(days)
+        dates = Array(days).collect do |day|
+          if is_a_date?(day)
+            Date.parse(day.to_s)
+          else
+            raise NotADateError
+          end
+        end
+
+        store["holidays"] ||= []
+        store["holidays"] = (store["holidays"] + dates).uniq
+      end
+
+      def self.remove_from_holidays(days)
+        dates = Array(days).collect do |day|
+          if is_a_date?(day)
+            Date.parse(day.to_s)
+          else
+            raise NotADateError
+          end
+        end
+        
+        store["holidays"] ||= []
+        store["holidays"] = store["holidays"] - dates
+      end
+      
+      def self.is_a_holiday?(date=Date.today)
+        if is_a_date?(date)
+          store["holidays"].include? Date.parse(date.to_s)
+        else
+          raise NotADateError
+        end
+      end
+      
+      def self.is_a_date?(date_string)
+        begin
+          return true if Date.parse(date_string.to_s)
+        rescue ArgumentError => e
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/ceiling_cat/plugins/general.rb

@@ -0,0 +1,56 @@
+module CeilingCat
+  module Plugin
+    class General < CeilingCat::Plugin::Base
+      # See lib/ceiling_cat/plugins/base.rb for the methods available by default.
+      # Plugins are run in the order they are listed in the Chatfile.
+      # When a plugin returns anything other than nil the plugin execution chain is halted.
+      # If you want your plugin to do something but let the remaining plugins execute, return nil at the end of your method.
+
+      # handle manages a plugin's entire interaction with an event.
+      # If you only want to execute commands - "![command]" - leave handle alone (or remove it and define commands below)
+      def handle
+        super
+      end
+
+      # If you want the plugin to run when certain text is sent use commands instead of handle.
+      # Ceiling Cat will watch for "![command]" or "[name]: [command" and execute the method for that command.
+      def self.commands
+        [{:command => "debugger", :description => "Load the debugger", :method => "run_debug", :public => false},
+         {:command => "enable debug", :description => "Enable debuggers", :method => "enable_debug", :public => false},
+         {:command => "disable debug", :description => "Disable debuggers", :method => "disable_debug", :public => false}]
+      end
+
+      def self.description
+        "General tasks for development"
+      end
+
+      def self.name
+        "General"
+      end
+
+      def self.public?
+        false
+      end
+
+      def run_debug
+        if room.debug_mode?
+          reply "Opening debugger in terminal"
+          debugger
+        else
+          reply "Debugging is disabled - !enable debug to activate it."
+        end
+      end
+      
+      def enable_debug
+        store["debug_mode"] ||= "true"
+        reply "debugging enabled"
+      end
+      
+      def disable_debug
+        store["debug_mode"] ||= "false"
+        reply "debugging disabled"
+      end
+    end
+  end
+end
+    

data/lib/ceiling_cat/plugins/greeter.rb

@@ -0,0 +1,30 @@
+module CeilingCat
+  module Plugin
+    class Greeter < CeilingCat::Plugin::Base
+      def handle
+        message = []
+
+        if event.type == :entrance
+          members = room.users_in_room(:type => "member")
+          guests = room.users_in_room(:type => "guest")
+          if user.is_guest?
+            messages << "Hey #{user.name}!"
+          elsif user.is_registered?
+            messages << "Nice to see you again #{user.name}"
+          end
+          reply message unless message.empty?
+        elsif event.type == :chat
+          super
+        end
+      end
+      
+      def self.name
+        "Greeter"
+      end
+      
+      def self.description
+        "Welcomes visitors and memebrs to chat."
+      end
+    end
+  end
+end

data/lib/ceiling_cat/plugins/notifo.rb

@@ -0,0 +1,69 @@
+require 'httparty'
+
+module CeilingCat
+  module Plugin
+    class Notifo < CeilingCat::Plugin::Base
+      def self.commands
+        [{:command => "notifo", :description => "Send a message with Notifo - '!notifo Hey, get in here!'.", :method => "deliver"},
+         {:command => "add notifo users", :description => "Add users to get Notifos - '!add notifo users username1 username2'.", :method => "add_users"},
+         {:command => "remove notifo users", :description => "Add users to get Notifos - '!remove notifo users username1 username2'.", :method => "remove_users"},
+         {:command => "list notifo users", :description => "List users who get Notifos - '!list notifo users'.", :method => "list_users"}]
+      end
+
+      def deliver(message=nil)
+        message ||= body_without_nick_or_command("notifo")
+        if active?
+          Array(store["notifo_users"]).each do |user|
+            HTTParty.post("https://api.notifo.com/v1/send_notification",
+                            :body => { :to => user, :msg => message },
+                            :basic_auth => {:username => store["notifo_credentials"][:username], :password => store["notifo_credentials"][:api_secret]})
+          end
+        else
+          debugger
+          puts "here"
+        end
+      end
+
+      def active?
+        store["notifo_credentials"] && store["notifo_credentials"][:username].present? && store["notifo_credentials"][:api_secret].present? && Array(store["notifo_users"]).size > 0
+      end
+
+      def self.name
+        "Notifo"
+      end
+
+      def self.description
+        "Sends messages to users with Notifo"
+      end
+
+      def self.add_users(users)
+        store["notifo_users"] ||= []
+        store["notifo_users"] = (Array(store["notifo_users"]) + Array(users)).uniq
+      end
+
+      def self.set_credentials(username, api_secret)
+        store["notifo_credentials"] = {:username => username, :api_secret => api_secret}
+      end
+
+      def add_users
+        users = body_without_nick_or_command("add notifo users").split(" ")
+        self.class.add_users(users)
+        reply "#{users.join(" ")} added to notifo alerts."
+      end
+
+      def remove_users
+        users = body_without_nick_or_command("remove notifo users").split(" ")
+        store["notifo_users"] ||= []
+        store["notifo_users"] = store["notifo_users"] - users
+        reply "#{users.join(" ")} removed from notifo alerts."
+      end
+
+      def list_users
+        messages = []
+        messages << "Notifo Users"
+        Array(store["notifo_users"]).each{|user| messages << "-- #{user}"}
+        reply messages
+      end
+    end
+  end
+end

data/lib/ceiling_cat/room.rb

@@ -0,0 +1,81 @@
+module CeilingCat
+  class Room
+    attr_accessor :connection, :room, :users_in_room, :me
+
+    def initialize(opts={})
+      @connection = opts[:connection]
+    end
+
+    def watch
+      raise NotImplementedError, "Implement in chat service files!"
+    end
+
+    def say
+      raise NotImplementedError, "Implement in chat service files!"
+    end
+
+    def me
+      raise NotImplementedError, "Implement in chat service files or define config.nickname!" unless config.nickname
+      @me ||= CeilingCat::User.new(config.nickname)
+    end
+
+    def users_in_room(type=nil)
+      raise NotImplementedError, "Implement in chat service files!"
+    end
+
+    def plugins
+      @connection.plugins
+    end
+
+    def config
+      @connection.config
+    end
+
+    def plugin_installed?(name)
+      !plugin(name).nil?
+    end
+
+    def plugin(name)
+      plugins.find{|plugin| plugin.name.downcase == name.to_s.downcase || plugin.class == name}
+    end
+
+    def store
+      @connection.storage
+    end
+
+    def debug_mode?
+      !store["debug_mode"].nil? && store["debug_mode"] == "true"
+    end
+
+    def plugin_descriptions(show_private=false)
+      messages = []
+      plugins.each do |plugin|
+        messages << "#{plugin.name}: #{plugin.description}" if show_private || plugin.public?
+      end
+      messages
+    end
+
+    def available_commands(show_private=false)
+      messages = []
+      plugins.each do |plugin|
+        if !plugin.commands.empty? && (plugin.public? || show_private)
+          messages << "Commands for #{plugin.name}"
+          plugin.commands.each do |command|
+            messages << "-- #{command[:command]}: #{command[:description]}" if show_private || command[:public]
+          end
+        end
+      end
+      messages
+    end
+
+    def list_of_users_in_room(type=nil)
+      users = users_in_room(type)
+      last_user = users.pop
+      if users.size > 0
+        return users.collect{|user| user["name"] }.join(", ") + " and #{ last_user["name"]}"
+      else
+        return last_user["name"]
+      end
+    end
+  end
+end

data/lib/ceiling_cat/services/campfire.rb

@@ -0,0 +1,3 @@
+%w{connection room event}.each do |file|
+  require "ceiling_cat/services/campfire/#{file}"
+end

data/lib/ceiling_cat/services/campfire/connection.rb

@@ -0,0 +1,24 @@
+require 'tinder'
+
+module CeilingCat
+  module Campfire
+    class Connection < CeilingCat::Connection
+      def initialize(config)
+        @config=config
+        @config.ssl ||= "true"
+      end
+
+      def campfire
+        @campfire = Tinder::Campfire.new(self.config.username, :token => self.config.token, :ssl => self.config.ssl)
+      end
+      
+      def total_user_count
+        users = 0
+        @campfire.rooms.each do |room|
+          users += room.users.size
+        end
+        users
+      end
+    end
+  end
+end

data/lib/ceiling_cat/services/campfire/event.rb

@@ -0,0 +1,18 @@
+module CeilingCat
+  module Campfire
+    class Event < CeilingCat::Event
+      
+      def type
+        case @type
+        when "EnterMessage"
+          :entrance
+        when "TextMessage"
+          :chat
+        when "LeaveMessage", "KickMessage"
+          :exit
+        end
+      end
+      
+    end
+  end
+end

data/lib/ceiling_cat/services/campfire/room.rb

@@ -0,0 +1,110 @@
+module CeilingCat
+  module Campfire
+    class Room < CeilingCat::Room
+
+      def initialize(opts={})
+        super
+        @campfire_room = @connection.campfire.find_room_by_name(opts[:room_name])
+      end
+      
+      def watch
+        puts "Watching room..."
+        setup_interrupts
+        begin
+          loop do
+            begin
+              Timeout::timeout(90) do
+                @campfire_room.listen do |event|
+                  begin
+                    if event[:type] != "TimestampMessage"
+                      user = CeilingCat::User.new(event[:user][:name], :id => event[:user][:id], :role => event[:user][:type])
+                    
+                      unless is_me?(user) # Otherwise CC will talk to itself
+                        event = CeilingCat::Campfire::Event.new(self,event[:body], user, :type => event[:type])
+                        event.handle
+                        users_in_room(:reload => true) if event.type != :chat # If someone comes or goes, reload the list.
+                      end
+                    end
+                  rescue => e
+                    say "An error occurred with Campfire: #{e}" if debug_mode?
+                    raise e
+                  end
+                end
+              end
+            rescue Timeout::Error
+              puts "timeout! trying again..."
+              retry
+            end
+          end
+        rescue Faraday::Error::ParsingError
+          puts "Error parsing response. Campfire may be down."
+          break
+        rescue ReloadException => e
+          retry
+        rescue NoMethodError => e
+          puts "No Method Error"
+          e.backtrace.each do |line|
+            puts "Backtrace: #{line}"
+          end
+          retry
+        rescue StandardError => e
+          puts e.class
+          debugger if debug_mode?
+          e.backtrace.each do |line|
+            puts "Backtrace: #{line}"
+          end
+          retry
+        end
+      end
+      
+      def is_me?(user)
+        user.id == me.id
+      end
+      
+      def me
+        @me ||= CeilingCat::User.new(@connection.campfire.me[:name], :id => @connection.campfire.me[:id], :role => @connection.campfire.me[:type])
+      end
+      
+      def users_in_room(opts={})
+        if opts[:reload] || @users_in_room.nil?
+          puts "Requesting user list"
+          @users_in_room = @campfire_room.users
+        end
+
+        @users_in_room.find_all do |user|
+          unless is_me?(CeilingCat::User.new(user[:name], :id => user[:id], :role => user[:type]))
+            if opts[:type].present?
+              if user[:type].to_s.downcase == opts[:type].downcase
+                CeilingCat::User.new(user[:name], :id => user[:id], :role => user[:type])
+              end
+            else
+              CeilingCat::User.new(user[:name], :id => user[:id], :role => user[:type])
+            end
+          end
+        end
+      end
+            
+      def say(something_to_say)
+        Array(something_to_say).each do |line|
+          @campfire_room.speak(line)
+        end
+      end
+      
+      def setup_interrupts
+        trap('INT') do
+          puts "Leaving room...."
+          @campfire_room.leave if @campfire_room
+          exit 1
+        end
+
+        trap('USR1') do
+          puts "Leaving room"
+          @campfire_room.leave if @campfire_room
+          # logger.info "Reloading config"
+          # config(true)
+          # raise ReloadException.new("Rejoin room please, ceiling cat")
+        end
+      end
+    end
+  end
+end

data/lib/ceiling_cat/setup.rb

@@ -0,0 +1,47 @@
+require 'ostruct'
+
+module CeilingCat
+  class Setup
+    
+    attr_accessor :config
+    
+    class << self
+      # Class-level config. This is set by the +configure+ class method,
+      # and is used if no configuration is passed to the +initialize+
+      # method.
+      attr_accessor :config
+    end
+    
+    # Configures the connection at the class level. When the +ceiling_cat+ bin
+    # file is loaded, it evals the file referenced by the first
+    # command-line parameter. This file can configure the connection
+    # instance later created by +robut+ by setting parameters in the
+    # CeilingCat::Connection.configure block.
+    def self.configure
+      self.config = OpenStruct.new
+      yield config
+    end
+
+    # Sets the instance config to +config+, converting it into an
+    # OpenStruct if necessary.
+    def config=(config)
+      @config = config.kind_of?(Hash) ? OpenStruct.new(config) : config
+    end
+    
+    def initialize(_config = nil)
+      self.config = _config || self.class.config
+    end
+    
+    def connect
+      case self.config.service.downcase
+      when 'campfire'
+        connection = CeilingCat::Campfire::Connection.new(self.config)
+        room = CeilingCat::Campfire::Room.new(:connection => connection, :room_name => self.config.room)
+        room.watch
+      else
+        raise CeilingCat::UnsupportedChatServiceError.new("#{self.config.service} is not a supported chat service.")
+      end
+    end
+    
+  end
+end

data/lib/ceiling_cat/storage/base.rb

@@ -0,0 +1,18 @@
+module CeilingCat
+  module Storage
+    class Base
+      class << self
+
+        # Sets the key +k+ to the value +v+ in the current storage system
+        def []=(k,v)
+          raise NotImplementedError, "Implement in storage type file!"
+        end
+
+        # Returns the value at the key +k+.
+        def [](k)
+          raise NotImplementedError, "Implement in storage type file!"
+        end
+      end
+    end
+  end
+end

data/lib/ceiling_cat/storage/yaml.rb

@@ -0,0 +1,49 @@
+require 'yaml'
+
+module CeilingCat
+  module Storage
+    class Yaml < CeilingCat::Storage::Base
+      class << self
+        attr_reader :file
+
+        # Sets the path to the file this store will persist to, and forces
+        # a reload of all of the data.
+        def file=(f)
+          @file = f
+          @internal = nil # force reload
+          @file
+        end
+
+        # Sets the key +k+ to the value +v+ 
+        def []=(k, v)
+          internal[k] = v
+          persist!
+          v
+        end
+
+        # Returns the value at the key +k+.
+        def [](k)
+          internal[k]
+        end
+
+        private
+
+        # The internal in-memory representation of the yaml file
+        def internal
+          @internal ||= begin
+            YAML.load_file(file) rescue {}
+          end
+        end
+
+        # Persists the data in this store to disk. Throws an exception if
+        # we don't have a file set.
+        def persist!
+          raise "CeilingCat::Storage::Yaml.file must be set" unless file
+          f = File.open(file, "w")
+          f.puts internal.to_yaml
+          f.close
+        end
+      end
+    end
+  end
+end

data/lib/ceiling_cat/user.rb

@@ -0,0 +1,27 @@
+module CeilingCat
+  class User
+    attr_accessor :name, :role, :id
+
+    def initialize(name, opts={})
+      @name = name
+      @id = opts[:id]
+      @role = opts[:role]
+    end
+    
+    def to_s
+      short_name
+    end
+    
+    def short_name
+      @name.to_s.split.compact.first
+    end
+
+    def is_registered?
+      @role.to_s.downcase == 'member'
+    end
+
+    def is_guest?
+      @role.to_s.downcase == 'guest' || @type.to_s.nil?
+    end
+  end
+end

data/lib/ceiling_cat/version.rb

@@ -0,0 +1,3 @@
+module CeilingCat
+  VERSION = "0.0.1"
+end

data/setup/Chatfile

@@ -0,0 +1,20 @@
+# Require your plugins here
+require 'ceiling_cat/plugins/about'
+require 'ceiling_cat/plugins/calc'
+require 'ceiling_cat/plugins/greeter'
+
+CeilingCat::Setup.configure do |config|
+  config.service = 'campfire'
+  config.username = 'username'
+  config.token = '12345abcde'
+  config.room = 'Test Room'
+  config.ssl = true
+  
+  config.plugins = [CeilingCat::Plugin::About,
+                    CeilingCat::Plugin::Greeter,
+                    CeilingCat::Plugin::Calc]
+  
+  # Some plugins require storage
+  CeilingCat::Storage::Yaml.file = "ceilingcat.yml"
+  config.storage = CeilingCat::Storage::Yaml
+end

data/setup/Rakefile

@@ -0,0 +1,65 @@
+namespace :plugin do
+  desc "Create a new plugin"
+  task :create do
+    raise "You need to set a name! `rake plugin:create name=[plugin_name]`" unless ENV["name"]
+    name = ENV["name"].downcase
+    file = File.join("plugins", "#{name}.rb")
+
+    unless File.exists? file
+      contents = plugin_base(name)
+      File.open(file, 'w') {|f| f.write(contents) }
+      puts "Plugin '#{name}' created at #{file}."
+      puts "Make sure you require it in your Chatfile and add it to your config.plugins so it runs."
+    else
+      puts "A plugin named '#{name}' already exists. Try another name."
+    end
+  end
+end
+
+def plugin_base(name)
+%Q{module CeilingCat
+  module Plugin
+    class #{name.camelize} < CeilingCat::Plugin::Base
+      # See lib/ceiling_cat/plugins/base.rb for the methods available by default.
+      # Plugins are run in the order they are listed in the Chatfile.
+      # When a plugin returns anything other than nil the plugin execution chain is halted.
+      # If you want your plugin to do something but let the remaining plugins execute, return nil at the end of your method.
+
+      # handle manages a plugin's entire interaction with an event.
+      # If you only want to execute commands - "![command]" - leave handle alone (or remove it and define commands below)
+      def handle
+        super
+      end
+
+      # If you want the plugin to run when certain text is sent use commands instead of handle.
+      # Ceiling Cat will watch for "![command]" or "[name]: [command" and execute the method for that command.
+      def self.commands
+        [{:command => "#{name}", :description => "Does something", :method => "#{name}", :public => false}]
+      end
+
+      def self.description
+        "A plugin called #{name.capitalize}"
+      end
+
+      def self.name
+        "#{name.gsub("_"," ").capitalize}"
+      end
+
+      def self.public?
+        false
+      end
+
+      def #{name}
+        reply "You've created the '#{name.capitalize}' plugin. Now make it do something awesome!"
+      end
+    end
+  end
+end
+}
+end
+
+class String
+  def camelize
+    self.split("_").each{|z|z.capitalize!}.join("")
+  end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: ceiling_cat
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Warren
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tinder
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 4
+        - 4
+        version: 1.4.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 7
+        - 8
+        version: 0.7.8
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: crack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 1
+        - 8
+        version: 0.1.8
+  type: :runtime
+  version_requirements: *id003
+description: Ceiling Cat is watching you chat. A Campfire chat bot!
+email: 
+- chris@zencoder.com
+executables: 
+- ceiling_cat
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ceiling_cat.rb
+- lib/ceiling_cat/setup.rb
+- lib/ceiling_cat/version.rb
+- lib/ceiling_cat/connection.rb
+- lib/ceiling_cat/errors.rb
+- lib/ceiling_cat/event.rb
+- lib/ceiling_cat/user.rb
+- lib/ceiling_cat/room.rb
+- lib/ceiling_cat/storage/base.rb
+- setup/Chatfile
+- setup/Rakefile
+- lib/ceiling_cat/plugins/base.rb
+- lib/ceiling_cat/plugins/about.rb
+- lib/ceiling_cat/plugins/calc.rb
+- lib/ceiling_cat/plugins/call_and_response.rb
+- lib/ceiling_cat/plugins/campfire_account_monitor.rb
+- lib/ceiling_cat/plugins/days.rb
+- lib/ceiling_cat/plugins/general.rb
+- lib/ceiling_cat/plugins/greeter.rb
+- lib/ceiling_cat/plugins/notifo.rb
+- lib/ceiling_cat/storage/yaml.rb
+- lib/ceiling_cat/services/campfire.rb
+- lib/ceiling_cat/services/campfire/connection.rb
+- lib/ceiling_cat/services/campfire/event.rb
+- lib/ceiling_cat/services/campfire/room.rb
+- bin/ceiling_cat
+homepage: http://zencoder.com
+licenses: []
+
+post_install_message: "  ********************************************************************************\n    Run `ceiling_cat setup` to create a Chatfile and a Rakefile - everything you\n    need to start watching your chats and making ceiling_cat do your bidding!\n  \n    Run `rake plugin:create name=plugin_name` to generate a new plugin.\n\n    Update your Chatfile with your credentials and you'll be ready to go!\n  ********************************************************************************\n"
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Ceiling Cat is watching you chat. A Campfire chat bot.
+test_files: []
+