cinch 0.3.5 → 1.0.0

data/lib/cinch/names.rb

@@ -1,54 +0,0 @@
-module Cinch
-  module Names
-    attr_reader :channel_names
-    
-    def tracking_names?
-      !!@tracking_names
-    end
-    
-    def track_names
-      return if tracking_names?
-      
-      @tracking_names = true
-      
-      @channel_names = {}
-      
-      on(:join) do |m|
-        if m.nick == nick
-          names(m.channel)
-        else
-          channel_names[m.channel] ||= []
-          channel_names[m.channel].push m.nick
-        end
-      end
-      
-      on(353) do |m|
-        channel = m.params.detect { |c|  c.match(/^#/) }
-        names   = m.text.split.collect { |n|  n.sub(/^@/, '') }
-        channel_names[channel] ||= []
-        channel_names[channel] += names
-      end
-      
-      on(:part) do |m|
-        if m.nick == nick
-          channel_names.delete(m.channel)
-        else
-          channel_names[m.channel] ||= []
-          channel_names[m.channel].delete m.nick
-        end
-      end
-      
-      on(:quit, :kill) do |m|
-        channel_names.each_value { |names|  names.delete m.nick }
-      end
-      
-      on(:nick) do |m|
-        channel_names.each_value { |names|  names.push m.recipient if names.delete m.nick }
-      end
-    end
-  end
-end
-
-class Cinch::Base
-  include Cinch::Names
-end

data/lib/cinch/rules.rb

@@ -1,171 +0,0 @@
-module Cinch
-
-  # == Description
-  # Every rule defined through the Cinch::Base#plugin method becomes an instance 
-  # of this class. Each rule consists of keys used for named parameters, a hash
-  # of options, and an Array of callbacks. 
-  #
-  # When a rule matches an IRC message, all options with be checked, then all
-  # callbacks will be invoked.
-  #
-  # == Author
-  # * Lee Jarvis - ljjarvis@gmail.com
-  class Rule < Struct.new(:rule, :keys, :options, :callbacks)
-    def initialize(rule, keys, options, callback)
-      callbacks = [callback]
-      super(rule, keys, options, callbacks)
-    end
-
-    # Execute all callbacks, passing a Cinch::IRC::Message to them
-    def execute(message)
-      options.keys.each do |key|
-        case key
-        when :nick, :nicks
-          return unless validate(options[:nick] || options[:nicks], message.nick)
-        when :host, :hosts
-          return unless validate(options[:host] || options[:hosts], message.host)
-        when :user, :users
-          return unless validate(options[:user] || options[:users], message.user)
-        when :channel, :channels
-          if message.channel
-            return unless validate(options[:channel] || options[:channels], message.channel)
-          end
-        end
-      end
-
-      callbacks.each do |blk|
-        blk.call(message)
-      end
-    end
-
-    # Validate rule attributes
-    def validate(option, attr)
-      if option.is_a?(Array)
-        return unless option.any?{|o| o == attr }
-      else
-        return unless option.to_s == attr
-      end
-      true
-    end
-
-    # The rule as a String
-    def to_s
-      rule
-    end
-  end
-
-  # == Description
-  # This class provides an interface to manage rules. A rule should only ever be
-  # added using the Rules#add_rule method and retrieved using the Rules#get_rule 
-  # method, or an alias of these. 
-  #
-  # This class provides an easy way to add options or callbacks to an existing
-  # rule.
-  #
-  # Essentially the add_callback, add_option, and merge_options methods are just sugar
-  # so you don't have to edit Rule attributes directly
-  #
-  # == Example
-  #  rules = Cinch::Rules.new
-  #
-  #  rules.add('foo', [], {}, Proc.new{})
-  #
-  #  rules.add_callback('foo', Proc.new{})
-  #  rules['foo'].callbacks #=> [#<Proc:0x9f1e110@(main):100>, #<Proc:0x9f1e0f4@(main):150>]
-  #
-  #  # Or assign directly
-  #  rules.get('foo').callbacks << Proc.new {} 
-  #
-  #  rules['foo'].options #=> {}
-  #  rules.add_option('foo', :nick, 'injekt')
-  #  rules['foo'].options #=> {:nick => 'injekt'}
-  #
-  #  # Or retrieve the rule first and assign directly
-  #  rules.get_rule('foo')
-  #  rules.options = {:foo => 'bar'}
-  #  rules.options[:bar] = 'baz'
-  #
-  # == Author
-  # * Lee Jarvis - ljjarvis@gmail.com
-  class Rules
-    def initialize
-      @rules = {}
-    end
-
-    # Add a new rule, overwrites an already existing rule
-    def add_rule(rule, keys, options, callback)
-      @rules[rule] = Rule.new(rule, keys, options, callback) 
-    end
-    alias :add :add_rule
-
-    # Return a Cinch::Rule by its rule, or nil it one does not exist
-    def get_rule(rule)
-      @rules[rule]
-    end
-    alias :get :get_rule
-    alias :[] :get_rule
-
-    # Remove a rule
-    def remove_rule(rule)
-      @rules.delete(rule)
-    end
-    alias :remove :remove_rule
-
-    # Check if a rule exists
-    def include?(rule)
-      @rules.key?(rule)
-    end
-    alias :has_rule? :include?
-
-    # Add a callback for an already existing rule
-    def add_callback(rule, blk)
-      return unless include?(rule)
-      @rules[rule].callbacks << blk
-    end
-
-    # Add an option for an already existing rule
-    def add_option(rule, key, value)
-      return unless include?(rule)
-      @rules[rule].options[key] = value
-    end
-
-    # Merge rule options
-    def merge_options(rule, ops={})
-      return unless include?(rule)
-      @rules[rule].options.merge!(ops)
-    end
-
-    # Iterate over the rules
-    def each
-      @rules.each {|rule, obj| yield obj }
-    end
-
-    # Remove all rules
-    def clear
-      @rules.clear
-    end
-
-    # Check if any rules exist
-    def empty?
-      @rules.empty?
-    end
-
-    # Return how many rules exist
-    def count
-      @rules.size
-    end
-    alias :size :count
-
-    # Return the hash of rules
-    def all
-      @rules
-    end
-
-    # Return an Array of rules
-    def to_a
-      @rules.keys
-    end
-  end
-
-end
-

data/spec/base_spec.rb

@@ -1,94 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-describe "Cinch::Base" do
-  before do
-    @base = Cinch::Base.new
-
-    @full = Cinch::Base.new(
-      :server => 'irc.freenode.org',
-      :nick => 'CinchBot',
-      :channels => ['#cinch']
-    )
-  end
-
-  describe "::new" do     
-    it "should add a ctcp version listener" do 
-      @base.listeners.should include :ctcp
-      @base.listeners[:ctcp].should include :version
-    end
-  end
-
-  describe "#plugin" do 
-    it "should compile and add a rule" do
-      @base.plugin('foo')
-      @base.rules.include?("^foo$").should == true
-    end
-
-    it "should add options to an existing rule" do
-      @base.plugin('foo') { }
-      @base.plugin('foo', :bar => 'baz') { }
-      rule = @base.rules.get('^foo$')
-      rule.options.should include :bar
-    end 
-
-    it "should add its block to an existing rule" do
-      @base.plugin('foo') { }
-      @base.plugin('foo') { }
-      rule = @base.rules.get_rule('^foo$')
-      rule.callbacks.size.should == 2
-    end
-  end
-
-  describe "#on" do
-    it "should save a listener" do
-      @base.on(:foo) {}
-      @base.listeners.should include :foo
-    end
-
-    it "should store listener blocks in an Array" do
-      @base.listeners[:ping].should be_kind_of Array
-    end
-  end
-
-  describe "#compile" do
-    it "should return an Array of 2 values" do
-      ret = @base.compile("foo")
-      ret.should be_kind_of(Array)
-      ret.size.should == 2
-    end
-    
-    it "should return an empty set of keys if no named parameters are labeled" do
-      rule, keys = @base.compile("foo")
-      keys.should be_empty
-    end
-
-    it "should return a key for each named parameter labeled" do
-      rule, keys = @base.compile("foo :bar :baz")
-      keys.size.should == 2
-      keys.should include "bar"
-      keys.should include "baz"
-    end
-
-    it "should return a rule of type String, unless Regexp is given" do
-      rule, keys = @base.compile(:foo)
-      rule.should be_kind_of(String)
-
-      rule, keys = @base.compile(/foo/)
-      rule.should be_kind_of(Regexp)
-      keys.should be_empty
-    end
-
-    it "should convert a custom pattern" do
-      @base.add_custom_pattern(:people, "foo|bar|baz")
-      rule, keys = @base.compile(":foo-people")
-      rule.should == "^(foo|bar|baz)$"    
-    end
-
-    it "should automatically add start and end anchors" do
-      rule, keys = @base.compile("foo bar baz")
-      rule[0].chr.should == "^"
-      rule[-1].chr.should == "$"
-    end
-  end
-end
-

data/spec/irc/helper.rb

@@ -1,8 +0,0 @@
-spec = File.dirname(__FILE__)
-$LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
-
-lib = File.dirname(__FILE__) + '../../lib/'
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'cinch/irc'
-

data/spec/irc/message_spec.rb

@@ -1,61 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-describe "IRC::Message" do
-  before do
-    @message = Cinch::IRC::Message.new('rawline', 'prefix', 'COMMAND', ['#chan', 'hello world'])
-  end
-
-  describe "#add, #[]=" do
-    it "should add an attribute" do
-      @message.add(:custom, 'something')
-      @message.data.should include :custom
-      @message.data[:custom].should == "something"
-    end
-  end
-
-  describe "#delete" do
-    it "should remove an attribute" do
-      @message.add(:custom, 'something')
-      @message.delete(:custom)
-      @message.data.should_not include :custom
-    end
-  end
-
-  describe "#to_s" do
-    it "should return the raw IRC message" do
-      @message.to_s.should == @message.raw
-    end
-  end
-
-  describe "#method_missing" do
-    it "should return an attribute if it exists" do
-      @message.add(:custom, 'something')
-      @message.custom.should == 'something'
-    end
-
-    it "should return nil if no attribute exists" do
-      @message.foobar.should == nil
-    end
-  end
-
-  describe "default attributes" do
-    it "should contain a prefix" do
-      @message.prefix.should == 'prefix'
-    end
-
-    it "should contain a command" do
-      @message.command.should == "COMMAND"
-    end
-
-    it "should contain params" do
-      @message.params.should be_kind_of(Array)
-      @message.params.size.should == 2
-    end
-
-    it "should contain a symbolized command" do
-      @message.symbol.should == :command
-    end
-  end
-
-end
-

data/spec/irc/parser_spec.rb

@@ -1,103 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-# Common commands
-commands = {
-  :ping => "PING :foobar",
-  :nick => ":foo!~baz@host.com NICK Baz",
-  :join => ":foo!~bar@host.com JOIN #baz",
-  :ctcp => ":foo!~bar@host.com PRIVMSG Baz :\001VERSION\001",
-
-  :privmsg => {
-    "to a channel" => ":foo!~bar@host.com PRIVMSG #baz :hello world",
-    "to a user" => ":foo!~bar@host.com PRIVMSG Baz :hello world",
-  },
-
-  :notice => {
-    "to a channel" => ":foo!~bar@host.com NOTICE #baz :hello world",
-    "to a user" => ":foo!~bar@host.com NOTICE Baz :hello world",
-  },
-
-  :part => {
-    "without a message" => ":foo!~bar@host.com PART #baz",
-    "with a message" => ":foo!~bar@host.com PART #baz :beer",
-  },
-
-  :quit => {
-    "without a message" => ":foo!~bar@host.com QUIT",
-    "with a message" => ":foo!~bar@host.com QUIT :baz"
-  }
-}
-
-describe "IRC::Parser" do
-  before do
-    @parser = Cinch::IRC::Parser.new
-  end
-
-  describe "#add_pattern" do
-    it "should add a pattern" do
-      @parser.add_pattern(:custom, /foo/)
-      @parser.patterns.key?(:custom)
-    end
-  end
-
-  describe "#remove_pattern" do
-    it "should remove a pattern" do
-      @parser.add_pattern(:custom, /foo/)
-      @parser.remove_pattern(:custom)
-      @parser.patterns.keys.should_not include(:custom)
-    end
-
-    it "should return nil if a pattern doesn't exist" do
-      @parser.remove_pattern(:foo).should be nil
-    end
-  end
-
-  describe "#parse" do
-    it "should return an IRC::Message" do
-      @parser.parse("foo :bar").should be_kind_of(Cinch::IRC::Message)
-    end
-
-    it "should raise if given an invalid message" do 
-      lambda { @parser.parse("#") }.should raise_error(ArgumentError)
-    end
-
-    commands.each do |cmd, passes|
-      if passes.is_a?(Hash)
-        passes.each do |extra, pass|
-          it "should parse a #{cmd.to_s.upcase} command #{extra}" do
-            m = @parser.parse(pass)
-            m.symbol.should == cmd
-          end
-        end
-      else
-        it "should parse a #{cmd.to_s.upcase} command" do
-          m = @parser.parse(passes)
-          m.symbol.should == cmd
-        end
-      end
-    end
-
-  end
-
-  describe "#parse_userhost" do
-    it "should return an Array" do
-      @parser.parse_userhost(":foo!bar@baz").should be_kind_of(Array)
-    end
-
-    it "should return 3 values" do
-      @parser.parse_userhost(":foo!bar@baz").size.should be 3
-    end
-  end
-
-  describe "#valid_channel?" do
-    it "should return true with a valid channel name" do
-      @parser.valid_channel?("#foo").should be true
-    end
-
-    it "should return false with an invalid channel name" do
-      @parser.valid_channel?("foo").should be false
-    end
-  end
-
-end
-