cinch 2.0.12 → 2.1.0

data/README.md

@@ -24,33 +24,39 @@ Installation
 
 You can install the latest Cinch gem using RubyGems
 
-    gem install cinch
+```
+gem install cinch
+```
 
 ### GitHub
 
 Alternatively you can check out the latest code directly from Github
 
-    git clone http://github.com/cinchrb/cinch.git
+```
+git clone http://github.com/cinchrb/cinch.git
+```
 
 Example
 -------
 
 Your typical Hello, World application in Cinch would go something like this:
 
-    require 'cinch'
+```ruby
+require 'cinch'
 
-    bot = Cinch::Bot.new do
-      configure do |c|
-        c.server = "irc.freenode.org"
-        c.channels = ["#cinch-bots"]
-      end
+bot = Cinch::Bot.new do
+  configure do |c|
+    c.server = "irc.freenode.org"
+    c.channels = ["#cinch-bots"]
+  end
 
-      on :message, "hello" do |m|
-        m.reply "Hello, #{m.user.nick}"
-      end
-    end
+  on :message, "hello" do |m|
+    m.reply "Hello, #{m.user.nick}"
+  end
+end
 
-    bot.start
+bot.start
+```
 
 More examples can be found in the `examples` directory.
 
@@ -98,27 +104,31 @@ your own plugins for others to use
 
 Want to see the same Hello, World application in plugin form? Sure you do!
 
-    require 'cinch'
+```ruby
+require 'cinch'
 
-    class Hello
-      include Cinch::Plugin
+class Hello
+  include Cinch::Plugin
 
-      match "hello"
+  match "hello"
 
-      def execute(m)
-        m.reply "Hello, #{m.user.nick}"
-      end
-    end
+  def execute(m)
+    m.reply "Hello, #{m.user.nick}"
+  end
+end
 
-    bot = Cinch::Bot.new do
-      configure do |c|
-        c.server = "irc.freenode.org"
-        c.channels = ["#cinch-bots"]
-        c.plugins.plugins = [Hello]
-      end
-    end
+bot = Cinch::Bot.new do
+  configure do |c|
+    c.server = "irc.freenode.org"
+    c.channels = ["#cinch-bots"]
+    c.plugins.plugins = [Hello]
+  end
+end
 
-    bot.start
+bot.start
+```
+
+Note: Plugins take a default prefix of `/^!/` which means the actual match is `!hello`.
 
 More information can be found in the {Cinch::Plugin} documentation.
 
@@ -140,9 +150,11 @@ terminal, meaning you get some pretty damn awesome readable coloured
 text. Cinch also provides a way for your plugins to log custom
 messages:
 
-    on :message, /hello/ do |m|
-      debug "Someone said hello"
-    end
+```ruby
+on :message, /hello/ do |m|
+  debug "Someone said hello"
+end
+```
 
 Authors
 -------

data/docs/changes.md

@@ -1,6 +1,67 @@
 # @title What has changed?
 # @markup kramdown
 
+# What has changed in 2.1?
+1. Color stripping
+1. Per group hooks
+1. API improvements
+   1. New methods
+   1. Changed methods
+   1. New aliases
+
+## Color stripping
+
+The new method {Cinch::Utilities::String.strip_colors} allows removal
+of mIRC color codes from messages.
+
+Additionally, a new match option called `strip_colors` makes it
+possible to automatically and temporarily strip color codes before
+attemping to match a message.
+
+## Per group hooks
+
+A new option `group` for hooks allows registering hooks for specific
+groups.
+
+## API improvements
+
+### New methods
+
+#### {Cinch::Bot}
+
+- {Cinch::Bot#oper}
+
+#### {Cinch::User}
+
+- {Cinch::User#oper?}
+
+#### {Cinch::Message}
+
+- {Cinch::Message#action_reply}
+- {Cinch::Message#safe_action_reply}
+
+### Changed methods
+
+#### {Cinch::Handler}
+
+- {Cinch::Handler#call} now returns the started thread.
+
+#### {Cinch::HandlerList}
+
+- {Cinch::HandlerList#dispatch} now returns the started threads.
+
+### New aliases
+
+Due to some unfortunate naming mistakes in Cinch 2.0, Cinch 2.1 adds
+several aliases. All of the new aliases deprecate the original method
+names, which will be removed in Cinch 3.0.
+
+#### {Cinch::User}
+- {Cinch::User#monitored?} for {Cinch::User#monitored}
+- {Cinch::User#synced?} for {Cinch::User#synced}
+
+
+
 # What has changed in 2.0?
 1. Added support for SASL
 1. Added support for DCC SEND
@@ -181,7 +242,6 @@ moved from {Cinch} to {Cinch::Constants}
 - {Cinch::Bot#modes}
 - {Cinch::Bot#modes=}
 - {Cinch::Bot#set_mode}
-- {Cinch::Bot#stop}
 - {Cinch::Bot#unset_mode}
 - {Cinch::Bot#user_list}
 

data/docs/common_mistakes.md

@@ -34,3 +34,27 @@ The following is not possible:
         # ...
       end
     end
+
+# My handlers won't run, even though the Regexp matches.
+
+Cinch plugins have a default prefix (`/^!/`). This allows for flexible prefixes
+across the whole bot. The default prefix can be changed in `Bot#configure`:
+
+    x = Cinch::Bot.new do
+      configure do |c|
+        # ...
+        c.plugins.prefix = /^%/
+      end
+    end
+
+Alternatively, you can set the prefix for specific plugins only, by calling `set`:
+
+    class MyPlygin
+      include Cinch::Plugin
+
+      set :prefix, /^%/
+    end
+
+You can also choose to not use a prefix for specific matchers:
+
+    match /hi/, use_prefix: false

data/docs/common_tasks.md

@@ -46,3 +46,12 @@ example:
         @bot.loggers.info "I miss my master :("
       end
     end
+
+# Sending messages to users and channels beside `m.user` and `m.channel`
+
+Cinch provides {Cinch::Helpers helper methods} to get instances of Channel
+and User objects that you can work with:
+
+    User('user').send("Hello!")        # Sends a message to user 'user'
+    Channel('#channel').send("Hello!") # Sends a message to channel '#channel'
+

data/docs/logging.md

@@ -41,7 +41,7 @@ The level can be changed for single loggers or all loggers at once, by either us
 Example:
 
     bot = Cinch::Bot.new { }
-    bot.loggers << Cinch::Loggers::FormattedLogger.new(File.open("/tmp/log.log", "a"))
+    bot.loggers << Cinch::Logger::FormattedLogger.new(File.open("/tmp/log.log", "a"))
     bot.loggers.level = :debug
     bot.loggers.first.level  = :info
 

data/examples/plugins/own_events.rb

@@ -8,7 +8,7 @@ class RandomNumberGenerator
   def start
     while true
       sleep 5 # pretend that we are waiting for some kind of entropy
-      @bot.dispatch(:random_number, nil, Kernel.rand)
+      @bot.handlers.dispatch(:random_number, nil, Kernel.rand)
     end
   end
 end

data/lib/cinch/bot.rb

@@ -177,10 +177,10 @@ module Cinch
     #   right event will be checked against this argument and the event
     #   will only be called if it matches
     #
-    # @param [Array<Object>] *args Arguments that should be passed to
+    # @param [Array<Object>] args Arguments that should be passed to
     #   the block, additionally to capture groups of the regexp.
     #
-    # @yieldparam [String] *args each capture group of the regex will
+    # @yieldparam [Array<String>] args each capture group of the regex will
     #   be one argument to the block.
     #
     # @return [Handler] The handlers that have been registered
@@ -266,6 +266,8 @@ module Cinch
           }
         end
 
+        @modes = []
+
         @loggers.info "Connecting to #{@config.server}:#{@config.port}"
         @irc = IRC.new(self)
         @irc.start
@@ -424,6 +426,18 @@ module Cinch
       @irc.send "NICK #{new_nick}"
     end
 
+    # Gain oper privileges.
+    #
+    # @param [String] password
+    # @param [String] user The username to use. Defaults to the bot's
+    #   nickname
+    # @since 2.1.0
+    # @return [void]
+    def oper(password, user = nil)
+      user ||= self.nick
+      @irc.send "OPER #{user} #{password}"
+    end
+
     # Try to create a free nick, first by cycling through all
     # available alternatives and then by appending underscores.
     #

data/lib/cinch/callback.rb

@@ -13,8 +13,8 @@ module Cinch
     end
 
     # (see Bot#synchronize)
-    def synchronize(*args, &block)
-      @bot.synchronize(*args, &block)
+    def synchronize(name, &block)
+      @bot.synchronize(name, &block)
     end
   end
 end

data/lib/cinch/channel.rb

@@ -59,7 +59,7 @@ module Cinch
 
       @synced_attributes  = Set.new
       @when_requesting_synced_attribute = lambda {|attr|
-        if @in_channel && attr == :topic && !synced?(:topic)
+        if @in_channel && attr == :topic && !attribute_synced?(:topic)
           # Even if we are in the channel, if there's no topic set,
           # the attribute won't be synchronised yet. Explicitly
           # request the topic.
@@ -321,7 +321,7 @@ module Cinch
     # Kicks a user from the channel.
     #
     # @param [String, User] user the user to kick
-    # @param [String] a reason for the kick
+    # @param [String] reason a reason for the kick
     # @raise [Exceptions::KickReasonTooLong]
     # @return [void]
     def kick(user, reason = nil)

data/lib/cinch/formatting.rb

@@ -70,7 +70,7 @@ module Cinch
       :reset      => 15.chr,
     }
 
-    # @param [Array<Symbol>] *settings The colors and attributes to apply.
+    # @param [Array<Symbol>] settings The colors and attributes to apply.
     #   When supplying two colors, the first will be used for the
     #   foreground and the second for the background.
     # @param [String] string The string to format.

data/lib/cinch/handler.rb

@@ -19,6 +19,9 @@ module Cinch
     # @return [Symbol]
     attr_reader :group
 
+    # @return [Boolean]
+    attr_reader :strip_colors
+
     # @return [ThreadGroup]
     # @api private
     attr_reader :thread_group
@@ -31,15 +34,23 @@ module Cinch
     #   to.
     # @option options [Boolean] :execute_in_callback (false) Whether
     #   to execute the handler in an instance of {Callback}
+    # @option options [Boolean] :strip_colors (false) Strip colors
+    #   from message before attemping match
     # @option options [Array] :args ([]) Additional arguments to pass
     #   to the block
     def initialize(bot, event, pattern, options = {}, &block)
-      options              = {:group => nil, :execute_in_callback => false, :args => []}.merge(options)
+      options              = {
+        :group => nil,
+        :execute_in_callback => false,
+        :strip_colors => false,
+        :args => []
+      }.merge(options)
       @bot                 = bot
       @event               = event
       @pattern             = pattern
       @group               = options[:group]
       @execute_in_callback = options[:execute_in_callback]
+      @strip_colors        = options[:strip_colors]
       @args                = options[:args]
       @block               = block
 
@@ -74,11 +85,11 @@ module Cinch
     # @param [Message] message Message that caused the invocation
     # @param [Array] captures Capture groups of the pattern that are
     #   being passed as arguments
-    # @return [void]
+    # @return [Thread]
     def call(message, captures, arguments)
       bargs = captures + arguments
 
-      @thread_group.add Thread.new {
+      thread = Thread.new {
         @bot.loggers.debug "[New thread] For #{self}: #{Thread.current} -- #{@thread_group.list.size} in total."
 
         begin
@@ -93,6 +104,9 @@ module Cinch
           @bot.loggers.debug "[Thread done] For #{self}: #{Thread.current} -- #{@thread_group.list.size - 1} remaining."
         end
       }
+
+      @thread_group.add(thread)
+      thread
     end
 
     # @return [String]

data/lib/cinch/handler_list.rb

@@ -19,7 +19,7 @@ module Cinch
       end
     end
 
-    # @param [Handler, Array<Handler>] *handlers The handlers to unregister
+    # @param [Handler, Array<Handler>] handlers The handlers to unregister
     # @return [void]
     # @see Handler#unregister
     def unregister(*handlers)
@@ -39,7 +39,7 @@ module Cinch
         end
 
         handlers = handlers.select { |handler|
-          msg.match(handler.pattern.to_r(msg), type)
+          msg.match(handler.pattern.to_r(msg), type, handler.strip_colors)
         }.group_by {|handler| handler.group}
 
         handlers.values_at(*(handlers.keys - [nil])).map(&:first) + (handlers[nil] || [])
@@ -49,10 +49,12 @@ module Cinch
     # @param [Symbol] event The event type
     # @param [Message, nil] msg The message which is responsible for
     #   and attached to the event, or nil.
-    # @param [Array] *arguments A list of additional arguments to pass
+    # @param [Array] arguments A list of additional arguments to pass
     #   to event handlers
-    # @return [void]
+    # @return [Array<Thread>]
     def dispatch(event, msg = nil, *arguments)
+      threads = []
+
       if handlers = find(event, msg)
         already_run = Set.new
         handlers.each do |handler|
@@ -61,14 +63,16 @@ module Cinch
           # calling Message#match multiple times is not a problem
           # because we cache the result
           if msg
-            captures = msg.match(handler.pattern.to_r(msg), event).captures
+            captures = msg.match(handler.pattern.to_r(msg), event, handler.strip_colors).captures
           else
             captures = []
           end
 
-          handler.call(msg, captures, arguments)
+          threads << handler.call(msg, captures, arguments)
         end
       end
+
+      threads
     end
 
     # @yield [handler] Yields all registered handlers

data/lib/cinch/helpers.rb

@@ -179,8 +179,8 @@ module Cinch
     # @group Formatting
 
     # (see Formatting.format)
-    def Format(*args)
-      Formatting.format(*args)
+    def Format(*settings, string)
+      Formatting.format(*settings, string)
     end
     alias_method :Color, :Format
 

data/lib/cinch/irc.rb

@@ -493,7 +493,7 @@ module Cinch
         modes = ModeParser.parse_modes(msg.params[1], msg.params[2..-1])
         modes.each do |direction, mode, _|
           if direction == :add
-            @bot.modes << mode
+            @bot.modes << mode unless @bot.modes.include?(mode)
           else
             @bot.modes.delete(mode)
           end
@@ -629,6 +629,12 @@ module Cinch
                    })
     end
 
+    def on_313(msg, events)
+      # RPL_WHOISOPERATOR
+      user = User(msg.params[1])
+      @whois_updates[user].merge!({:oper? => true})
+    end
+
     def on_317(msg, events)
       # RPL_WHOISIDLE
       user = User(msg.params[1])

data/lib/cinch/logger_list.rb

@@ -55,8 +55,8 @@ module Cinch
     end
 
     # (see Logger#exception)
-    def exception(message)
-      each {|l| l.exception(message)}
+    def exception(e)
+      each {|l| l.exception(e)}
     end
   end
 end

data/lib/cinch/mask.rb

@@ -50,7 +50,7 @@ module Cinch
       @mask.dup
     end
 
-    # @param [String, #mask]
+    # @param [String, #mask] target
     # @return [target] if already a Mask
     # @return [Mask]
     # @version 2.0.0

data/lib/cinch/message.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 require "time"
+require "cinch/utilities/string"
 
 module Cinch
   # This class serves two purposes. For one, it simply
@@ -135,14 +136,23 @@ module Cinch
 
     # @api private
     # @return [MatchData]
-    def match(regexp, type)
-      if type == :ctcp
-        @matches[:ctcp][regexp] ||= ctcp_message.match(regexp)
-      elsif type == :action
-        @matches[:action][regexp] ||= action_message.match(regexp)
+    def match(regexp, type, strip_colors)
+      text = ""
+      case type
+      when :ctcp
+        text = ctcp_message
+      when :action
+        text = action_message
       else
-        @matches[:other][regexp] ||= message.to_s.match(regexp)
+        text = message.to_s
+        type = :other
       end
+
+      if strip_colors
+        text = Cinch::Utilities::String.strip_colors(text)
+      end
+
+      @matches[type][regexp] ||= text.match(regexp)
     end
 
     # @group Replying
@@ -176,6 +186,24 @@ module Cinch
       @target.safe_send(text)
     end
 
+    # Reply to a message with an action.
+    #
+    # @param [String] text the action message
+    # @return [void]
+    def action_reply(text)
+      text = text.to_s
+      @target.action(text)
+    end
+
+    # Like #action_reply, but using {Target#safe_action} instead
+    #
+    # @param (see #action_reply)
+    # @return (see #action_reply)
+    def safe_action_reply(text)
+      text = text.to_s
+      @target.safe_action(text)
+    end
+
     # Reply to a CTCP message
     #
     # @return [void]

data/lib/cinch/plugin.rb

@@ -1,3 +1,5 @@
+require "cinch/helpers"
+
 # TODO more details in "message dropped" debug output
 module Cinch
   # This class represents the core of the plugin functionality of
@@ -79,7 +81,15 @@ module Cinch
       # @attr [Boolean] use_suffix
       # @attr [Symbol] method
       # @attr [Symbol] group
-      Matcher = Struct.new(:pattern, :use_prefix, :use_suffix, :method, :group, :prefix, :suffix, :react_on)
+      Matcher = Struct.new(:pattern,
+                           :use_prefix,
+                           :use_suffix,
+                           :method,
+                           :group,
+                           :prefix,
+                           :suffix,
+                           :react_on,
+                           :strip_colors)
 
       # Represents a Listener as created by {#listen_to}.
       #
@@ -105,7 +115,7 @@ module Cinch
       # @attr [Symbol] type
       # @attr [Array<Symbol>] for
       # @attr [Symbol] method
-      Hook = Struct.new(:type, :for, :method)
+      Hook = Struct.new(:type, :for, :method, :group)
 
       # @api private
       def self.extended(by)
@@ -179,14 +189,32 @@ module Cinch
       # @option options [Symbol, Fixnum] react_on (:message) The
       #   {file:docs/events.md event} to react on.
       # @option options [Symbol] :group (nil) The group the match belongs to.
+      # @option options [Boolean] :strip_colors (false) Strip colors
+      #   from message before attempting match
       # @return [Matcher]
       # @todo Document match/listener grouping
       def match(pattern, options = {})
-        options = {:use_prefix => true, :use_suffix => true, :method => :execute, :group => nil, :prefix => nil, :suffix => nil, :react_on => nil}.merge(options)
+        options = {
+          :use_prefix => true,
+          :use_suffix => true,
+          :method => :execute,
+          :group => nil,
+          :prefix => nil,
+          :suffix => nil,
+          :react_on => nil,
+          :strip_colors => false,
+        }.merge(options)
         if options[:react_on]
           options[:react_on] = options[:react_on].to_s.to_sym
         end
-        matcher = Matcher.new(pattern, *options.values_at(:use_prefix, :use_suffix, :method, :group, :prefix, :suffix, :react_on))
+        matcher = Matcher.new(pattern, *options.values_at(:use_prefix,
+                                                          :use_suffix,
+                                                          :method,
+                                                          :group,
+                                                          :prefix,
+                                                          :suffix,
+                                                          :react_on,
+                                                          :strip_colors))
         @matchers << matcher
 
         matcher
@@ -253,12 +281,15 @@ module Cinch
       #   a handler?
       # @option options [Array<:match, :listen_to, :ctcp>] :for ([:match, :listen_to, :ctcp])
       #   Which kinds of events to run the hook for.
-      # @option options [Symbol] :method (true) The method to execute.
+      # @option options [Symbol] :method (:hook) The method to execute.
+      # @option options [Symbol] :group (nil) The match group to
+      #   execute the hook for. Hooks belonging to the `nil` group
+      #   will execute for all matches.
       # @return [Hook]
       # @since 1.1.0
       def hook(type, options = {})
-        options = {:for => [:match, :listen_to, :ctcp], :method => :hook}.merge(options)
-        hook = Hook.new(type, options[:for], options[:method])
+        options = {:for => [:match, :listen_to, :ctcp], :method => :hook, :group => nil}.merge(options)
+        hook = Hook.new(type, options[:for], options[:method], options[:group])
         __hooks(type) << hook
 
         hook
@@ -266,7 +297,7 @@ module Cinch
 
       # @return [Hash]
       # @api private
-      def __hooks(type = nil, events = nil)
+      def __hooks(type = nil, events = nil, group = nil)
         if type.nil?
           hooks = @hooks
         else
@@ -280,14 +311,16 @@ module Cinch
           if hooks.is_a?(Hash)
             hooks = hooks.map { |k, v| v }
           end
-          return hooks.select { |hook| (events & hook.for).size > 0 }
+          hooks.select! { |hook| (events & hook.for).size > 0 }
         end
+
+        return hooks.select { |hook| hook.group.nil? || hook.group == group }
       end
 
       # @return [Boolean] True if processing should continue
       # @api private
-      def call_hooks(type, event, instance, args)
-        stop = __hooks(type, event).find { |hook|
+      def call_hooks(type, event, group, instance, args)
+        stop = __hooks(type, event, group).find { |hook|
           # stop after the first hook that returns false
           if hook.method.respond_to?(:call)
             instance.instance_exec(*args, &hook.method) == false
@@ -314,9 +347,9 @@ module Cinch
       self.class.listeners.each do |listener|
         @bot.loggers.debug "[plugin] #{self.class.plugin_name}: Registering listener for type `#{listener.event}`"
         new_handler = Handler.new(@bot, listener.event, Pattern.new(nil, //, nil)) do |message, *args|
-          if self.class.call_hooks(:pre, :listen_to, self, [message])
+          if self.class.call_hooks(:pre, :listen_to, nil, self, [message])
             __send__(listener.method, message, *args)
-            self.class.call_hooks(:post, :listen_to, self, [message])
+            self.class.call_hooks(:post, :listen_to, nil, self, [message])
           else
             @bot.loggers.debug "[plugin] #{self.class.plugin_name}: Dropping message due to hook"
           end
@@ -332,9 +365,9 @@ module Cinch
       self.class.ctcps.each do |ctcp|
         @bot.loggers.debug "[plugin] #{self.class.plugin_name}: Registering CTCP `#{ctcp}`"
         new_handler = Handler.new(@bot, :ctcp, Pattern.generate(:ctcp, ctcp)) do |message, *args|
-          if self.class.call_hooks(:pre, :ctcp, self, [message])
+          if self.class.call_hooks(:pre, :ctcp, nil, self, [message])
             __send__("ctcp_#{ctcp.downcase}", message, *args)
-            self.class.call_hooks(:post, :ctcp, self, [message])
+            self.class.call_hooks(:post, :ctcp, nil, self, [message])
           else
             @bot.loggers.debug "[plugin] #{self.class.plugin_name}: Dropping message due to hook"
           end
@@ -370,7 +403,11 @@ module Cinch
 
         @bot.loggers.debug "[plugin] #{self.class.plugin_name}: Registering executor with pattern `#{pattern_to_register.inspect}`, reacting on `#{react_on}`"
 
-        new_handler = Handler.new(@bot, react_on, pattern_to_register, group: matcher.group) do |message, *args|
+        new_handler = Handler.new(@bot,
+                                  react_on,
+                                  pattern_to_register,
+                                  group: matcher.group,
+                                  strip_colors: matcher.strip_colors) do |message, *args|
           method = method(matcher.method)
           arity = method.arity - 1
           if arity > 0
@@ -378,9 +415,9 @@ module Cinch
           elsif arity == 0
             args = []
           end
-          if self.class.call_hooks(:pre, :match, self, [message])
+          if self.class.call_hooks(:pre, :match, matcher.group, self, [message])
             method.call(message, *args)
-            self.class.call_hooks(:post, :match, self, [message])
+            self.class.call_hooks(:post, :match, matcher.group, self, [message])
           else
             @bot.loggers.debug "[plugin] #{self.class.plugin_name}: Dropping message due to hook"
           end
@@ -454,8 +491,8 @@ module Cinch
     end
 
     # (see Bot#synchronize)
-    def synchronize(*args, &block)
-      @bot.synchronize(*args, &block)
+    def synchronize(name, &block)
+      @bot.synchronize(name, &block)
     end
 
     # Provides access to plugin-specific options.

data/lib/cinch/sasl/dh_blowfish.rb

@@ -55,18 +55,12 @@ module Cinch
           password << "." * (8 - (password.size % 8))
 
           crypted = ""
-          cipher = OpenSSL::Cipher.new("BF")
+          cipher = OpenSSL::Cipher.new("BF-ECB")
+          cipher.key_len = 32 # OpenSSL's default of 16 doesn't work
+          cipher.encrypt
+          cipher.key = secret
 
-          while password.size > 0 do
-            # We have to reinitialize this every time because for OpenSSL, "BF" is synonynmous with "BF-CBC", and we do not want CBC
-            cipher.reset
-            cipher.key_len = 32 # OpenSSL's default of 16 doesn't work
-            cipher.encrypt
-            cipher.key = secret
-
-            clear = password.slice!(0, 8)
-            crypted << cipher.update(clear) # we do not want the content of cipher.final
-          end
+          crypted = cipher.update(password) # we do not want the content of cipher.final
 
           answer = [public.bytesize, public, user, crypted].pack("na*Z*a*")
           Base64.strict_encode64(answer)

data/lib/cinch/syncable.rb

@@ -9,7 +9,7 @@ module Cinch
       attr = attr.to_sym
       waited = 0
       while true
-        return if synced?(attr)
+        return if attribute_synced?(attr)
         waited += 1
 
         if waited % 100 == 0
@@ -38,7 +38,7 @@ module Cinch
 
     # @return [Boolean]
     # @api private
-    def synced?(attribute)
+    def attribute_synced?(attribute)
       @synced_attributes.include?(attribute)
     end
 

data/lib/cinch/target.rb

@@ -134,7 +134,7 @@ module Cinch
       self == other
     end
 
-    # @param [Target, String]
+    # @param [Target, String] other
     # @return [-1, 0, 1, nil]
     def <=>(other)
       casemapping = @bot.irc.isupport["CASEMAPPING"]

data/lib/cinch/user.rb

@@ -3,22 +3,32 @@ require "cinch/target"
 require "timeout"
 
 module Cinch
-  # @attr_reader [String] user
-  # @attr_reader [String] host
-  # @attr_reader [String] realname
   # @attr_reader [String] authname
+  # @attr_reader [String, nil] away The user's away message, or
+  #   `nil` if not away.
+  # @attr_reader [Array<Channel>] channels All channels the user is
+  #   in.
+  # @attr_reader [String] host
   # @attr_reader [Integer] idle How long this user has been idle, in seconds.
   #   This is a snapshot of the last WHOIS.
+  # @attr_reader [String] nick The user's nickname
+  # @attr_reader [Boolean] online True if the user is online.
+  # @attr_reader [Boolean] oper True if the user is an IRC operator.
+  # @attr_reader [String] realname
+  # @attr_reader [Boolean] secure True if the user is using a secure
+  #   connection, i.e. SSL.
   # @attr_reader [Time] signed_on_at
-  # @attr_reader [Array<Channel>] channels All channels the user is in.
-  # @attr_reader [String, nil] away The user's away message, or
-  #   `nil` if not away.
+  # @attr_reader [Boolean] unknown True if the instance references an user who
+  #   cannot be found on the server.
+  # @attr_reader [String] user
   #
   # @version 2.0.0
   class User < Target
     include Syncable
 
-    alias_method :nick, :name
+    def nick
+      name
+    end
 
     # @return [String]
     # @since 1.1.0
@@ -26,45 +36,126 @@ module Cinch
 
     # @return [Boolean]
     attr_reader :synced
+    # @since 2.1.0
+    alias_method :synced?, :synced
 
     # @return [Boolean]
-    attr_reader :in_whois
-
     # @api private
-    attr_writer :in_whois
+    attr_accessor :in_whois
+
+    def user
+      attr(:user, true, false)
+    end
+
+    def host
+      attr(:host, true, false)
+    end
+
+    def realname
+      attr(:realname, true, false)
+    end
+
+    def authname
+      attr(:authname, true, false)
+    end
+
+    def idle
+      attr(:idle, true, false)
+    end
+
+    def signed_on_at
+      attr(:signed_on_at, true, false)
+    end
 
-    # @return [Boolean] True if the instance references an user who
-    #   cannot be found on the server.
-    attr_reader :unknown
-    alias_method :unknown?, :unknown
-    undef_method "unknown?"
-    undef_method "unknown"
     def unknown
-      self.unknown?
+      attr(:unknown?, true, false)
     end
+    alias_method :unknown?, :unknown
 
-    # @return [Boolean] True if the user is online.
     # @note This attribute will be updated by various events, but
     # unless {#monitor} is being used, this information cannot be
     # ensured to be always correct.
-    attr_reader :online
-    alias_method :online?, :online
-    undef_method "online?"
-    undef_method "online"
     def online
-      self.online?
+      attr(:online?, true, false)
+    end
+    alias_method :online?, :online
+
+    def channels
+      attr(:channels, true, false)
     end
 
-    # @return [Boolean] True if the user is using a secure connection, i.e. SSL.
-    attr_reader :secure
-    alias_method :secure?, :secure
-    undef_method "secure?"
-    undef_method "secure"
     def secure
-      self.secure?
+      attr(:secure?, true, false)
+    end
+    alias_method :secure?, :secure
+
+    # @since 2.1.0
+    def oper
+      attr(:oper?, true, false)
+    end
+    alias_method :oper?, :oper
+
+    # @private
+    def user_unsynced
+      attr(:user, true, true)
+    end
+
+    # @private
+    def host_unsynced
+      attr(:host, true, true)
+    end
+
+    # @private
+    def realname_unsynced
+      attr(:realname, true, true)
+    end
+
+    # @private
+    def authname_unynced
+      attr(:authname, true, true)
+    end
+
+    # @private
+    def idle_unsynced
+      attr(:idle, true, true)
+    end
+
+    # @private
+    def signed_on_at_unsynced
+      attr(:signed_on_at, true, true)
+    end
+
+    # @private
+    def unknown_unsynced
+      attr(:unknown?, true, true)
+    end
+    alias_method "unknown?_unsynced", "unknown_unsynced"
+
+    # @private
+    def online_unsynced
+      attr(:online?, true, true)
     end
+    alias_method "online?_unsynced", "online_unsynced"
 
-    # By default, you can use methods like User#user, User#host and
+    # @private
+    def channels_unsynced
+      attr(:channels, true, true)
+    end
+
+    # @private
+    def secure_unsynced
+      attr(:secure?, true, true)
+    end
+    alias_method "secure?_unsynced", "secure_unsynced"
+
+    # @private
+    # @since 2.1.0
+    def oper_unsynced
+      attr(:oper?, true, true)
+    end
+    alias_method "oper?_unsynced", "oper_unsynced"
+
+    # By default, you can use methods like {#user}, {#host} and
     # alike – If you however fear that another thread might change
     # data while you're using it and if this means a critical issue to
     # your code, you can store a clone of the result of this method
@@ -82,7 +173,10 @@ module Cinch
     # @return [Boolean] True if the user is being monitored
     # @see #monitor
     # @see #unmonitor
+    # @note The attribute writer is in fact part of the private API
     attr_reader :monitored
+    # @since 2.1.0
+    alias_method :monitored?, :monitored
 
     # @api private
     attr_writer :monitored
@@ -101,6 +195,7 @@ module Cinch
         :channels     => [],
         :secure?      => false,
         :away         => nil,
+        :oper?        => false,
       }
       case args.size
       when 2
@@ -114,7 +209,7 @@ module Cinch
       @synced_attributes  = Set.new
 
       @when_requesting_synced_attribute = lambda {|attr|
-        unless synced?(attr)
+        unless attribute_synced?(attr)
           @data[:unknown?] = false
           unsync :unknown?
 
@@ -197,8 +292,9 @@ module Cinch
 
       {
         :authname => nil,
-        :idle => 0,
-        :secure? => false,
+        :idle     => 0,
+        :secure?  => false,
+        :oper?    => false,
         :channels => [],
       }.merge(values).each do |attr, value|
         sync(attr, value, true)
@@ -371,28 +467,5 @@ module Cinch
       unsync(:authname)
       @bot.user_list.update_nick(self)
     end
-
-    # Provides synced access to user attributes.
-    def method_missing(m, *args)
-      if m.to_s =~ /^(.+)_unsynced$/
-        m = $1.to_sym
-        unsync = true
-      end
-
-      if @data.has_key?(m)
-        attr(m, true, unsync)
-      else
-        super
-      end
-    end
-
-    # @since 1.1.2
-    def respond_to?(m, include_all = false)
-      if m.to_s =~ /^(.+)_unsynced$/
-        m = $1.to_sym
-      end
-
-      return @data.has_key?(m) || super
-    end
   end
 end

data/lib/cinch/utilities/string.rb

@@ -8,6 +8,10 @@ module Cinch
       def self.filter_string(string)
         string.gsub(/[\x00-\x1f]/, '')
       end
+
+      def self.strip_colors(string)
+        string.gsub(/[\x02\x0f\x16\x1f\x12]|\x03(\d{1,2}(,\d{1,2})?)?/, '')
+      end
     end
   end
 end

data/lib/cinch/version.rb

@@ -1,4 +1,4 @@
 module Cinch
   # Version of the library
-  VERSION = '2.0.12'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cinch
 version: !ruby/object:Gem::Version
-  version: 2.0.12
+  version: 2.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2014-02-27 00:00:00.000000000 Z
 dependencies: []
 description: A simple, friendly DSL for creating IRC bots
 email:
@@ -103,7 +103,6 @@ files:
 - examples/plugins/own_events.rb
 - examples/plugins/seen.rb
 - examples/plugins/last_nick.rb
-- examples/plugins/urban_dict.rb
 - examples/plugins/hooks.rb
 - examples/plugins/hello.rb
 - examples/plugins/custom_prefix.rb
@@ -142,3 +141,4 @@ signing_key:
 specification_version: 3
 summary: An IRC Bot Building Framework
 test_files: []
+has_rdoc: yard

data/examples/plugins/urban_dict.rb

@@ -1,30 +0,0 @@
-require 'cinch'
-require 'open-uri'
-require 'nokogiri'
-require 'cgi'
-
-class UrbanDictionary
-  include Cinch::Plugin
-
-  match /urban (.+)/
-  def lookup(word)
-    url = "http://www.urbandictionary.com/define.php?term=#{CGI.escape(word)}"
-    CGI.unescape_html Nokogiri::HTML(open(url)).at("div.definition").text.gsub(/\s+/, ' ') rescue nil
-  end
-
-  def execute(m, word)
-    m.reply(lookup(word) || "No results found", true)
-  end
-end
-
-bot = Cinch::Bot.new do
-  configure do |c|
-    c.server = "irc.freenode.net"
-    c.nick   = "MrCinch"
-    c.channels = ["#cinch-bots"]
-    c.plugins.plugins = [UrbanDictionary]
-  end
-end
-
-bot.start
-