cinch 0.3.5 → 1.0.0

data/examples/custom_patterns.rb

@@ -1,19 +0,0 @@
-require 'cinch'
-
-bot = Cinch.setup do 
-  server "irc.freenode.org"
-  channels %w{ #cinch }
-end
-
-bot.add_custom_pattern(:friends, /injekt|lee|john|bob/)
-bot.add_custom_pattern(:hex, /[\dA-Fa-f]+/)
-
-bot.plugin("I like :person-friends", :prefix => false) do |m|
-  m.reply "I like #{m.args[:person]} too!"
-end
-
-bot.plugin("checkhex :n-hex") do |m|
-  m.answer "Yes, #{m.args[:n]} is indeed hex."
-end
-
-bot.run

data/examples/custom_prefix.rb

@@ -1,25 +0,0 @@
-require 'cinch'
-
-bot = Cinch.setup do 
-  server "irc.freenode.org"
-  channels %w( #cinch )
-end
-
-bot.plugin "default" do |m|
-  m.reply "default prefix"
-end
-
-bot.plugin "custom", :prefix => '@' do |m|
-  m.reply "custom prefix"
-end
-
-bot.plugin "botnick", :prefix => :botnick do |m|
-  m.reply "botnick prefix"
-end
-
-bot.plugin "botnick2", :prefix => bot.nick do |m|
-  m.reply "another botnick prefix"
-end
-
-bot.run
-

data/examples/google.rb

@@ -1,31 +0,0 @@
-require 'cinch'
-require 'open-uri'
-require 'nokogiri'
-require 'cgi'
-
-bot = Cinch.setup do 
-  server "irc.freenode.net"
-  nick "MrCinch"
-  channels %w/ #cinch /
-end
-
-# Extremely basic method, grabs the first result returned by Google
-# or "No results found" otherwise
-def google(query)
-  url = "http://www.google.com/search?q=#{CGI.escape(query)}"
-  res = Nokogiri::HTML(open(url)).at("h3.r")
-
-  title = res.text
-  link = res.at('a')[:href]
-  desc = res.at("./following::div").children.first.text 
-rescue 
-  "No results found"
-else
-  CGI.unescape_html "#{title} - #{desc} (#{link})"
-end
-
-bot.plugin("google :query") do |m|
-  m.reply google(m.args[:query])
-end
-
-bot.run

data/examples/hello.rb

@@ -1,13 +0,0 @@
-require 'cinch'
-
-bot = Cinch.setup do 
-  server "irc.freenode.org"
-  channels %w( #cinch )
-end
-
-bot.plugin "hello" do |m|
-  m.reply "Hello, #{m.nick}!"
-end
-
-bot.run
-

data/examples/join_part.rb

@@ -1,26 +0,0 @@
-require 'cinch'
-
-bot = Cinch.setup do 
-  server "irc.freenode.org"
-  nick "CinchBot"
-  channels %w( #cinch )
-end
-
-# Who should be able to access these plugins
-admin = 'injekt'
-
-bot.plugin "join :channel", :nick => admin do |m|
-  bot.join m.args[:channel]
-end
-
-bot.plugin "part :channel", :nick => admin do |m|
-  bot.part m.args[:channel]
-end
-
-# Part current channel if none is given
-bot.plugin "part", :nick => admin do |m|
-  bot.part m.channel
-end
-
-bot.run
-

data/examples/memo.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'cinch'
-
-bot = Cinch.setup do
-  server "irc.freenode.org"
-  channels %w( #cinch )
-end
-
-class Memo < Struct.new(:nick, :channel, :text, :time)
-  def to_s
-    "[#{time.asctime}] <#{channel}/#{nick}> #{text}"
-  end
-end
-
-@memos = {}
-
-bot.on :privmsg do |m|
-  if @memos.has_key?(m.nick)
-    bot.privmsg m.nick, @memos[m.nick].to_s
-    @memos.delete(m.nick)
-  end
-end
-
-bot.plugin("memo :nick-string :memo") do |m|
-  nick = m.args[:nick]
-
-  if @memos.key?(nick)
-    m.reply "There's already a memo #{nick}. You can only store one right now"
-  elsif nick == m.nick
-    m.reply "You can't leave memos for yourself.."
-  elsif nick == bot.options.nick
-    m.reply "You can't leave memos for me.."
-  else
-    @memos[nick] = Memo.new(m.nick, m.channel, m.args[:memo], Time.new)
-    m.reply "Added memo for #{nick}"
-  end
-end
-
-bot.run

data/examples/msg.rb

@@ -1,14 +0,0 @@
-require 'cinch'
-
-bot = Cinch.setup do 
-  server "irc.freenode.org"
-  nick "CinchBot"
-  channels %w/ #cinch /
-end
-
-bot.plugin("msg :who :text") do |m|
-  bot.privmsg m.args[:who], m.args[:text]
-end
-
-bot.run
-

data/examples/named-param-types.rb

@@ -1,19 +0,0 @@
-require 'cinch'
-
-bot = Cinch.setup do
-  server "irc.freenode.org"
-  channels %w( #cinch )
-end
-
-bot.plugin("say :n-digit :text") do |m|
-  m.args[:n].to_i.times {
-    m.reply m.args[:text]
-  }
-end
-
-bot.plugin("say :text-word :rest") do |m|
-  stuff = [m.args[:text], m.args[:rest]].join(' ')
-  m.reply stuff
-end
-
-bot.run

data/examples/seen.rb

@@ -1,41 +0,0 @@
-require 'cinch'
-
-users = {}
-
-class Seen < Struct.new(:who, :where, :what, :time)
-  def to_s
-    "[#{time.asctime}] #{who} was seen in #{where} saying #{what}"
-  end
-end
-
-bot = Cinch.setup(
-  :server => 'irc.freenode.org',
-  :channels => ['#cinch'],
-  :prefix => '!',
-  :verbose => true,
-)
-
-# Only log a PRIVMSG
-bot.on :privmsg do |m|
-  # Dont record a private message
-  unless m.private?
-    users[m.nick] = Seen.new(m.nick, m.channel, m.text, Time.new)
-  end
-end
-
-bot.plugin("seen :nick") do |m|
-  nick = m.args[:nick]
-
-  if nick == bot.nick
-    m.reply "That's me!"
-  elsif nick == m.nick
-    m.reply "That's you!"
-  elsif users.key?(nick)
-    m.reply users[nick].to_s
-  else
-    m.reply "I haven't seen #{nick}"
-  end
-end
-
-bot.run
-

data/examples/urban_dict.rb

@@ -1,31 +0,0 @@
-require 'cinch'
-require 'open-uri'
-require 'nokogiri'
-require 'cgi'
-
-# This bot connects to urban dictionary and returns the first result
-# for a given query, replying with the result directly to the sender
-
-bot = Cinch.setup do 
-  server "irc.freenode.net"
-  nick "MrCinch"
-  channels %w/ #cinch /
-end
-
-# This method assumes everything will go ok, it's not the best method
-# of doing this *by far* and is simply a helper method to show how it
-# can be done.. it works!
-def urban_dict(query)
-  url = "http://www.urbandictionary.com/define.php?term=#{CGI.escape(query)}"
-  CGI.unescape_html Nokogiri::HTML(open(url)).at("div.definition").text.gsub(/\s+/, ' ') rescue nil
-end
-
-bot.plugin("urban :query") do |m|
-  m.answer urban_dict(m.args[:query]) || "No results found"
-end
-
-bot.run
-
-# injekt> !urban cinch
-# MrCinch> injekt: describing an action that's extremely easy.
-

data/examples/url_shorten.rb

@@ -1,34 +0,0 @@
-require 'open-uri'
-require 'cinch'
-
-# Automatically shorten URL's found in messages
-# Using the tinyURL API
-
-bot = Cinch.configure do
-  server "irc.freenode.org"
-  verbose true
-  channels %w/#cinch/
-end
-
-def shorten(url)
-  url = open("http://tinyurl.com/api-create.php?url=#{URI.escape(url)}").read
-  url == "Error" ? nil : url
-rescue OpenURI::HTTPError
-  nil
-end
-
-bot.on :privmsg do |m|
-  unless m.private?
-    urls = URI.extract(m.text, "http")
-
-    unless urls.empty?
-      short_urls = urls.map {|url| shorten(url) }.compact
-
-      unless short_urls.empty?
-        m.reply short_urls.join(", ")
-      end
-    end
-  end
-end
-
-bot.start

data/lib/cinch/base.rb

@@ -1,368 +0,0 @@
-module Cinch
-
-  # == Description
-  # The base for an IRC connection
-  # TODO: More documentation
-  #
-  # == Example
-  #  bot = Cinch::Base.new :server => 'irc.freenode.org'
-  #
-  #  bot.on :join do |m|
-  #    m.reply "Welcome to #{m.channel}, #{m.nick}!" unless m.nick == bot.nick
-  #  end
-  #
-  #  bot.plugin "say :text" do |m|
-  #    m.reply m.args[:text]
-  #  end
-  #
-  # == Author
-  # * Lee Jarvis - ljjarvis@gmail.com
-  class Base
-
-    # A Hash holding rules and attributes
-    attr_reader :rules
-
-    # A Hash holding listeners and reply Procs
-    attr_reader :listeners
-
-    # An OpenStruct holding all configuration options
-    attr_reader :options
-
-    # Our IRC::Socket instance
-    attr_reader :irc
-
-    # Default options hash
-    DEFAULTS = {
-      :port => 6667,
-      :nick => "Cinch",
-      :nick_suffix => '_',
-      :username => 'cinch',
-      :realname => "Cinch IRC Bot Building Framework",
-      :prefix => '!',
-      :usermode => 0,
-      :password => nil,
-      :ssl => false,
-    }
-
-    # Options can be passed via a hash, a block, or on the instance
-    # independantly. Or of course via the command line
-    #
-    # == Example
-    #  # With a Hash
-    #  bot = Cinch::Base.new(:server => 'irc.freenode.org')
-    #
-    #  # With a block
-    #  bot = Cinch::Base.new do
-    #    server "irc.freenode.org"
-    #  end
-    #
-    #  # After the instance is created
-    #  bot = Cinch::Base.new
-    #  bot.options.server = "irc.freenode.org"
-    #
-    #  # Nothing, but invoked with "ruby foo.rb -s irc.freenode.org"
-    #  bot = Cinch::Base.new
-    def initialize(ops={}, &blk)
-      options = DEFAULTS.merge(ops).merge(Options.new(&blk))
-      @options = OpenStruct.new(options.merge(cli_ops))
-
-      @rules = Rules.new
-      @listeners = {}
-      @listeners[:ctcp] = {}
-
-      @irc = IRC::Socket.new(options[:server], options[:port], options[:ssl])
-      @parser = IRC::Parser.new
-
-      # Default listeners
-      on(:ping) {|m| @irc.pong(m.text) }
-
-      on(:ctcp, :version) {|m| m.ctcp_reply "Cinch IRC Bot Building Framework v#{Cinch::VERSION}"}
-    end
-
-    # Add a new plugin
-    #
-    # == Example
-    #  plugin('hello') do |m|
-    #    m.reply "Hello, #{m.nick}!"
-    #  end
-    def plugin(rule, options={}, &blk)
-      rule, keys = compile(rule)
-
-      if @rules.has_rule?(rule)
-        @rules.add_callback(rule, blk)
-        @rules.merge_options(rule, options)
-      else
-        @rules.add_rule(rule, keys, options, blk)
-      end
-    end
-    alias :rule :plugin
-
-    # Add new listeners
-    #
-    # == Example
-    #  on(376) do |m|
-    #    m.join "#mychan"
-    #  end
-    #
-    # This method also provides an alternative way to define a rule.
-    # The following are equivalent
-    #   plugin("foo bar") do |m|
-    #     m.reply "baz!"
-    #   end
-    #
-    #   on(:message, "foo bar") do |m|
-    #     m.reply "baz!"
-    #   end
-    # 
-    # This also gives us the opportunity to reply to CTCP messages
-    #  on(:ctcp, :time) do |m|
-    #    m.ctcp_reply Time.now.asctime
-    #  end
-    #
-    # Note that when adding listeners for numberic IRC replies which
-    # begin with a 0 (digit), make sure you define the command as a
-    # String and not Integer. This is because 001.to_s == "1" so the
-    # command will not work as expected.
-    def on(*commands, &blk)
-      if commands.first == :message
-        rule, options = commands[1..2]
-        options = {} unless options.is_a?(Hash)
-        plugin(rule, options, &blk)
-      elsif commands.first == :ctcp
-        action = commands[1]
-
-        if @listeners[:ctcp].key?(action)
-          @listeners[:ctcp][action] << blk
-        else
-          @listeners[:ctcp][action] = [blk]
-        end
-      else
-        commands.map {|x| x.to_s.downcase.to_sym }.each do |cmd|
-          if @listeners.key?(cmd)
-            @listeners[cmd] << blk
-          else
-            @listeners[cmd] = [blk]
-          end
-        end
-      end
-    end
-
-    # This method builds a regular expression from your rule
-    # and defines all named parameters, as well as dealing with
-    # patterns.
-    #
-    # All patterns which exist in Cinch::IRC::Parser are supported
-    #
-    # == Examples
-    # === Capturing digits
-    #  bot.plugin("say :text-digit")
-    # * Does match !say 3
-    # * Does not match !say 3 4
-    # * Does not match !say foo
-    #
-    # === Both digit and word
-    #  bot.plugin("say :n-digit :text-word")
-    # * Does match !say 3 foo
-    # * Does not match !say 3 foo bar
-    #
-    # === Capturing until the end of the line
-    #  bot.plugin("say :text")
-    # * Does match !say foo
-    # * Does match !say foo bar
-    #
-    # === Or mix them all
-    #  bot.plugin("say :n-digit :who-word :text")
-    #
-    # Using "!say 3 injekt some text here" would provide
-    # the following attributes
-    # * m.args[:n] => 3
-    # * m.args[:who] => injekt
-    # * m.args[:text] => some text here
-    def compile(rule)
-      return [rule, []] if rule.is_a?(Regexp)
-      keys = []
-      special_chars = %w{. + ( )}
-
-      pattern = rule.to_s.gsub(/((:[\w\-]+)|[\*#{special_chars.join}])/) do |match|
-        case match
-        when *special_chars
-          Regexp.escape(match)
-        else
-          k = $2
-          if k =~ /\-\w+$/
-            key, type = k.split('-')
-            keys << key[1..-1]
-            
-            if @parser.has_pattern?(type)
-              "(#{@parser.pattern(type)})"
-            else
-              "([^\x00\r\n]+?)"
-            end
-          else
-            keys << k[1..-1]
-            "([^\x00\r\n]+?)"
-          end
-        end
-      end
-      ["^#{pattern}$", keys]
-    end
-
-    # Add a custom pattern for rule validation
-    #
-    # == Example
-    #  bot = Cinch.setup do
-    #    server 'irc.freenode.org'
-    #    port 6667
-    #  end
-    #
-    #  bot.add_pattern(:number, /[0-9]/)
-    #
-    #  bot.plugin("getnum :foo-number") do |m|
-    #    m.reply "Your number was: #{m.args[:foo]}"
-    #  end
-    def add_pattern(name, pattern)
-      @parser.add_pattern(name, pattern)
-    end
-    alias :add_custom_pattern :add_pattern
-
-    # Run run run
-    def run
-      # Configure some runtime listeners
-      on(433) do |m|
-        @options.nick += @options.nick_suffix
-        @irc.nick @options.nick
-      end
-
-      if @options.respond_to?(:channels)
-        on("004") { @options.channels.each {|c| @irc.join(c) } }
-      end
-
-      @irc.connect options.server, options.port
-      @irc.pass options.password if options.password
-      @irc.nick options.nick
-      @irc.user options.username, options.usermode, '*', options.realname
-
-      begin
-        process(@irc.read) while @irc.connected?
-      rescue Interrupt
-        @irc.quit("Interrupted")
-        puts "\nInterrupted. Shutting down .."
-        exit
-      end
-    end
-    alias :start :run
-
-    private
-
-    # Process the next line read from the server
-    def process(line)
-      return unless line
-      message = @parser.parse(line)
-      message.irc = @irc unless message.irc
-      puts message if options.verbose
-
-      # runs on any symbol
-      @listeners[:any].each { |l| l.call(message) } if @listeners.key?(:any)
-
-      if @listeners.key?(message.symbol)
-        if message.symbol == :ctcp
-          action = message.ctcp_action.downcase.to_sym
-
-          if @listeners[:ctcp].include?(action)
-            @listeners[:ctcp][action].each {|l| l.call(message) }
-          end
-        else
-          @listeners[message.symbol].each {|l| l.call(message) }
-        end
-      end
-
-      if [:privmsg].include?(message.symbol)
-        rules.each do |rule|
-          pattern = rule.to_s
-          rule.keys.map! {|key| key.to_sym }
-          prefix = nil
-          
-          if options.prefix
-            if rule.options.key?(:prefix)
-              if [:bot, :botnick, options.nick].include? rule.options[:prefix]
-                prefix = options.nick + "[:,] "
-              else              
-                prefix = rule.options[:prefix]
-              end
-            else
-              if [:bot, :botnick, options.nick].include? options.prefix
-                prefix = options.nick + "[:,] "
-              else
-                prefix = options.prefix
-              end
-            end
-          end
-          
-          # insert prefix unless it already exists
-          pattern.insert(1, prefix) unless pattern[1..prefix.size] == prefix
-
-          if rule.options[:ignore_case]
-            regex = Regexp.new(pattern, Regexp::IGNORECASE)
-          else
-            regex = Regexp.new(pattern)
-          end
-
-          if message.text && mdata = message.text.rstrip.match(regex)
-            unless rule.keys.empty? || mdata.captures.empty?
-              args = Hash[rule.keys.zip(mdata.captures)]
-              message.args = args
-            end
-            # execute rule
-            rule.execute(message)
-          end
-        end
-      end
-    end
-
-    # Parse command line options
-    def cli_ops
-      options = {}
-      if ARGV.any?
-        begin
-          OptionParser.new do |op|
-            op.on("-s server") {|v| options[:server] = v }
-            op.on("-p port") {|v| options[:port] = v.to_i }
-            op.on("-n nick") {|v| options[:nick] = v }
-            op.on("-c command_prefix") {|v| options[:prefix] = v }
-            op.on("-v", "--verbose", "Enable verbose mode") {|v| options[:verbose] = true }
-            op.on("--ssl") {|v| options[:ssl] = true }
-            op.on("-C", "--channels x,y,z", Array, "Autojoin channels") {|v|
-              options[:channels] = v.map {|c| %w(# + &).include?(c[0].chr) ? c : c.insert(0, '#') }
-            }
-          end.parse(ARGV)
-        rescue OptionParser::MissingArgument => err
-          warn "Missing values for options: #{err.args.join(', ')}\nFalling back to default"
-        rescue OptionParser::InvalidOption => err
-          warn err.message
-        end
-      end
-      options
-    end
-
-    # Catch methods
-    def method_missing(meth, *args, &blk) # :nodoc:
-      if options.respond_to?(meth)
-        options.send(meth)
-      elsif @irc.respond_to?(meth)
-        @irc.send(meth, *args)
-      else
-        super
-      end
-    end
-
-    # Option management
-    class Options < Hash # :nodoc:
-      def initialize(&blk)
-        instance_eval(&blk) if block_given?
-      end
-      def method_missing(meth, *args, &blk)
-        self[meth] = args.first unless args.empty?
-      end
-    end
-  end
-end