newton 0.0.1

data/lib/newton/channel.rb

@@ -0,0 +1,362 @@
+# -*- coding: utf-8 -*-
+require "set"
+
+module Newton
+  class Channel
+    include Syncable
+    @channels = {}
+
+    class << self
+      # Finds or creates a channel.
+      #
+      # @param [String] name name of a channel
+      # @param [Bot] bot a bot
+      # @return [Channel]
+      # @see Bot#Channel
+      def find_ensured(name, bot)
+        downcased_name = name.irc_downcase(bot.irc.isupport["CASEMAPPING"])
+        @channels[downcased_name] ||= new(name, bot)
+        @channels[downcased_name]
+      end
+
+      # Finds a channel.
+      #
+      # @param [String] name name of a channel
+      # @return [Channel, nil]
+      def find(name)
+        @channels[name]
+      end
+
+      # @return [Array<Channel>] Returns all channels
+      def all
+        @channels.values
+      end
+    end
+
+    # @return [Bot]
+    attr_reader :bot
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Array<User>]
+    attr_reader :users
+    synced_attr_reader :users
+
+    # @return [String]
+    attr_accessor :topic
+    synced_attr_reader :topic
+
+    # @return [Array<Ban>]
+    attr_reader :bans
+    synced_attr_reader :bans
+
+    # @return [Array<String>]
+    attr_reader :modes
+    synced_attr_reader :modes
+    def initialize(name, bot)
+      @bot   = bot
+      @name  = name
+      @users = {}
+      @bans  = []
+
+      @modes = {}
+      # TODO raise if not a channel
+
+      @topic = nil
+
+      @in_channel = false
+
+      @synced_attributes  = Set.new
+      @when_requesting_synced_attribute = lambda {|attr|
+        unless @in_channel
+          unsync(attr)
+          case attr
+          when :users
+            @bot.raw "NAMES #@name"
+          when :topic
+            @bot.raw "TOPIC #@name"
+          when :bans
+            @bot.raw "MODE #@name +b"
+          when :modes
+            @bot.raw "MODE #@name"
+          end
+        end
+      }
+    end
+
+    attr_accessor :limit
+    # @return [Number]
+    def limit
+      @modes["l"].to_i
+    end
+
+    def limit=(val)
+      if val == -1 or val.nil?
+        mode "-l"
+      else
+        mode "+l #{val}"
+      end
+    end
+
+    attr_accessor :secret
+    # @return [Boolean] true if the channel is secret (+s)
+    def secret
+      @modes["s"]
+    end
+    alias_method :secret?, :secret
+
+    def secret=(bool)
+      if bool
+        mode "+s"
+      else
+        mode "-s"
+      end
+    end
+
+    attr_accessor :moderated # documentation only
+    # @return [Boolean] true if the channel is moderated (only users
+    # with +o and +v are able to send messages)
+    def moderated
+      @modes["m"]
+    end
+    alias_method :moderated?, :moderated
+
+    def moderated=(val)
+      if bool
+        mode "+m"
+      else
+        mode "-m"
+      end
+    end
+
+    attr_accessor :invite_only
+    # @return [Boolean] true if the channel is invite only (+i)
+    def invite_only
+      @modes["i"]
+    end
+    alias_method :invite_only?, :invite_only
+
+    def invite_only=(bool)
+      if bool
+        mode "+i"
+      else
+        mode "-i"
+      end
+    end
+
+    attr_accessor :key
+    # @return [String, nil]
+    def key
+      @modes["k"]
+    end
+
+    def key=(new_key)
+      if new_key.nil?
+        mode "-k #{key}"
+      else
+        mode "+k #{new_key}"
+      end
+    end
+
+    # Sets or unsets modes. Most of the time you won't need this but
+    # use setter methods like {Channel#invite_only=}.
+    # @param [String] s a mode string
+    # @return [void]
+    # @example
+    #   channel.mode "+n"
+    def mode(s)
+      @bot.raw "MODE #@name #{s}"
+    end
+
+    # @api private
+    # @return [void]
+    def sync_modes(all = true)
+      unsync :users
+      unsync :bans
+      unsync :modes
+      @bot.raw "NAMES #@name" if all
+      @bot.raw "MODE #@name +b" # bans
+      @bot.raw "MODE #@name"
+    end
+
+    # @return [Boolean] true if `user` is opped in the channel
+    def opped?(user)
+      user = User.find_ensured(user, @bot) unless user.is_a?(User)
+      @users[user] == "@"
+    end
+
+    # @return [Boolean] true if `user` is voiced in the channel
+    def voiced?(user)
+      user = User.find_ensured(user, @bot) unless user.is_a?(User)
+      @users[user] == "+"
+    end
+
+    # Bans someone from the channel.
+    #
+    # @param [Ban, Mask, User, String] target the mask to ban
+    # @return [Mask] the mask used for banning
+    def ban(target)
+      mask = Mask.from(target)
+
+      @bot.raw "MODE #@name +b #{mask}"
+      mask
+    end
+
+    # Unbans someone from the channel.
+    #
+    # @param [Ban, Mask, User, String] target the mask to unban
+    # @return [Mask] the mask used for unbanning
+    def unban(target)
+      mask = Mask.from(target)
+
+      @bot.raw "MODE #@name -b #{mask}"
+      mask
+    end
+
+    # @param [String, User] user the user to op
+    # @return [void]
+    def op(user)
+      @bot.raw "MODE #@name +o #{user}"
+    end
+
+    # @param [String, User] user the user to deop
+    # @return [void]
+    def deop(user)
+      @bot.raw "MODE #@name -o #{user}"
+    end
+
+    # @param [String, User] user the user to voice
+    # @return [void]
+    def voice(user)
+      @bot.raw "MODE #@name +v #{user}"
+    end
+
+    # @param [String, User] user the user to devoice
+    # @return [void]
+    def devoice(user)
+      @bot.raw "MODE #@name -v #{user}"
+    end
+
+    # @api private
+    # @return [void]
+    def add_user(user, mode = nil)
+      @in_channel = true if user == @bot
+      @users[user] = mode # TODO can a user have more than one mode?
+    end
+
+    # @api private
+    # @return [void]
+    def remove_user(user)
+      @in_channel = false if user == @bot
+      @users.delete(user)
+    end
+
+    # Removes all users
+    #
+    # @api private
+    # @return [void]
+    def clear_users
+      @users.clear
+    end
+
+    # Send a message to the channel.
+    #
+    # @param [String] message the message
+    # @return [void]
+    def send(message)
+      @bot.msg(@name, message)
+    end
+    alias_method :privmsg, :send
+
+
+    # Send a CTCP to the channel.
+    #
+    # @param [String] message the ctcp message
+    # @return [void]
+    def ctcp(message)
+      send "\001#{message}\001"
+    end
+
+    # Invoke an action (/me) in the channel.
+    #
+    # @param [String] message the message
+    # @return [void]
+    def action(message)
+      @bot.action(@name, message)
+    end
+
+    # Invites a user to the channel.
+    #
+    # @param [String, User] user the user to invite
+    # @return [void]
+    def invite(user)
+      @bot.raw("INVITE #{user} #@name")
+    end
+
+    # Sets the topic.
+    #
+    # @param [String] new_topic the new topic
+    # @raise [Exceptions::TopicTooLong]
+    def topic=(new_topic)
+      if new_topic.size > @bot.irc.isupport["TOPICLEN"] && @bot.strict?
+        raise Exceptions::TopicTooLong, new_topic
+      end
+
+      @bot.raw "TOPIC #@name :#{new_topic}"
+    end
+
+    # Kicks a user from the channel.
+    #
+    # @param [String, User] user the user to kick
+    # @param [String] a reason for the kick
+    # @raise [Exceptions::KickReasonTooLong]
+    # @return [void]
+    def kick(user, reason = nil)
+      if reason.to_s.size > @bot.irc.isupport["KICKLEN"] && @bot.strict?
+        raise Exceptions::KickReasonTooLong, reason
+      end
+
+      @bot.raw("KICK #@name #{user} :#{reason}")
+    end
+
+    # Invites a user to the channel.
+    #
+    # @param [String, User] user the user to invite
+    # @return [void]
+    def invite(user)
+      @bot.raw "INVITE #{user} #@name"
+    end
+
+    # Causes the bot to part from the channel.
+    #
+    # @param [String] message the part message.
+    # @return [void]
+    def part(message = nil)
+      @bot.raw "PART #@name :#{message}"
+    end
+
+    # Joins the channel
+    #
+    # @param [String] key the channel key, if any. If none is
+    #                 specified but @key is set, @key will be used
+    # @return [void]
+    def join(key = nil)
+      if key.nil? and modes["k"] != true
+        key = modes["k"]
+      end
+      @bot.raw "JOIN #{[@name, key].compact.join(" ")}"
+    end
+
+    # @return [String]
+    def to_s
+      @name
+    end
+    alias_method :to_str, :to_s
+
+    # @return [String]
+    def inspect
+      "#<Channel name=#{@name.inspect}>"
+    end
+  end
+end

data/lib/newton/constants.rb

@@ -0,0 +1,123 @@
+module Newton
+  ERR_NOSUCHNICK       = 401
+  ERR_NOSUCHSERVER     = 402
+  ERR_NOSUCHCHANNEL    = 403
+  ERR_CANNOTSENDTOCHAN = 404
+  ERR_TOOMANYCHANNELS  = 405
+  ERR_WASNOSUCHNICK    = 406
+  ERR_TOOMANYTARGETS   = 407
+  ERR_NOORIGIN         = 409
+  ERR_NORECIPIENT      = 411
+  ERR_NOTEXTTOSEND     = 412
+  ERR_NOTOPLEVEL       = 413
+  ERR_WILDTOPLEVEL     = 414
+  ERR_UNKNOWNCOMMAND   = 421
+  ERR_NOMOTD           = 422
+  ERR_NOADMININFO      = 423
+  ERR_FILEERROR        = 424
+  ERR_NONICKNAMEGIVEN  = 431
+  ERR_ERRONEUSNICKNAME = 432
+  ERR_NICKNAMEINUSE    = 433
+  ERR_NICKCOLLISION    = 436
+  ERR_USERNOTINCHANNEL = 441
+  ERR_NOTONCHANNEL     = 442
+  ERR_USERONCHANNEL    = 443
+  ERR_NOLOGIN          = 444
+  ERR_SUMMONDISABLED   = 445
+  ERR_USERSDISABLED    = 446
+  ERR_NOTREGISTERED    = 451
+  ERR_NEEDMOREPARAMS   = 461
+  ERR_ALREADYREGISTRED = 462
+  ERR_NOPERMFORHOST    = 463
+  ERR_PASSWDMISMATCH   = 464
+  ERR_YOUREBANNEDCREEP = 465
+  ERR_KEYSET           = 467
+  ERR_CHANNELISFULL    = 471
+  ERR_UNKNOWNMODE      = 472
+  ERR_INVITEONLYCHAN   = 473
+  ERR_BANNEDFROMCHAN   = 474
+  ERR_BADCHANNELKEY    = 475
+  ERR_NOPRIVILEGES     = 481
+  ERR_CHANOPRIVSNEEDED = 482
+  ERR_CANTKILLSERVER   = 483
+  ERR_NOOPERHOST       = 491
+  ERR_UMODEUNKNOWNFLAG = 501
+  ERR_USERSDONTMATCH   = 502
+
+  RPL_NONE = 300
+  RPL_USERHOST        = 302
+  RPL_ISON            = 303
+  RPL_AWAY            = 301
+  RPL_UNAWAY          = 305
+  RPL_NOWAWAY         = 306
+  RPL_WHOISUSER       = 311
+  RPL_WHOISSERVER     = 312
+  RPL_WHOISOPERATOR   = 313
+  RPL_WHOISIDLE       = 317
+  RPL_ENDOFWHOIS      = 318
+  RPL_WHOISCHANNELS   = 319
+  RPL_WHOWASUSER      = 314
+  RPL_ENDOFWHOWAS     = 369
+  RPL_LISTSTART       = 321
+  RPL_LIST            = 322
+  RPL_LISTEND         = 323
+  RPL_CHANNELMODEIS   = 324
+  RPL_WHOISACCOUNT    = 330
+  RPL_NOTOPIC         = 331
+  RPL_TOPIC           = 332
+  RPL_INVITING        = 341
+  RPL_SUMMONING       = 342
+  RPL_VERSION         = 351
+  RPL_WHOREPLY        = 352
+  RPL_ENDOFWHO        = 315
+  RPL_NAMEREPLY       = 353
+  RPL_NAMREPLY        = 353
+  RPL_ENDOFNAMES      = 366
+  RPL_LINKS           = 364
+  RPL_ENDOFLINKS      = 365
+  RPL_BANLIST         = 367
+  RPL_ENDOFBANLIST    = 368
+  RPL_INFO            = 371
+  RPL_ENDOFINFO       = 374
+  RPL_MOTDSTART       = 375
+  RPL_MOTD            = 372
+  RPL_ENDOFMOTD       = 376
+  RPL_YOUREOPER       = 381
+  RPL_REHASHING       = 382
+  RPL_TIME            = 391
+  RPL_USERSSTART      = 392
+  RPL_USERS           = 393
+  RPL_ENDOFUSERS      = 394
+  RPL_NOUSERS         = 395
+  RPL_TRACELINK       = 200
+  RPL_TRACECONNECTING = 201
+  RPL_TRACEHANDSHAKE  = 202
+  RPL_TRACEUNKNOWN    = 203
+  RPL_TRACEOPERATOR   = 204
+  RPL_TRACEUSER       = 205
+  RPL_TRACESERVER     = 206
+  RPL_TRACENEWTYPE    = 208
+  RPL_TRACELOG        = 261
+  RPL_STATSLINKINFO   = 211
+  RPL_STATSCOMMANDS   = 212
+  RPL_STATSCLINE      = 213
+  RPL_STATSNLINE      = 214
+  RPL_STATSILINE      = 215
+  RPL_STATSKLINE      = 216
+  RPL_STATSYLINE      = 218
+  RPL_ENDOFSTATS      = 219
+  RPL_STATSLLINE      = 241
+  RPL_STATSUPTIME     = 242
+  RPL_STATSOLINE      = 243
+  RPL_STATSHLINE      = 244
+  RPL_UMODEIS         = 221
+  RPL_LUSERCLIENT     = 251
+  RPL_LUSEROP         = 252
+  RPL_LUSERUNKNOWN    = 253
+  RPL_LUSERCHANNELS   = 254
+  RPL_LUSERME         = 255
+  RPL_ADMINME         = 256
+  RPL_ADMINLOC1       = 257
+  RPL_ADMINLOC2       = 258
+  RPL_ADMINEMAIL      = 259
+end

data/lib/newton/exceptions.rb

@@ -0,0 +1,25 @@
+module Newton
+  module Exceptions
+    # Generic error. Superclass for all Newton-specific errors.
+    class Generic < ::StandardError
+    end
+
+    class ArgumentTooLong < Generic
+    end
+
+    # Error that is raised when a topic is too long to be set.
+    class TopicTooLong < ArgumentTooLong
+    end
+
+    # Error that is raised when a nick is too long to be used.
+    class NickTooLong < ArgumentTooLong
+    end
+
+    # Error that is raised when a kick reason is too long.
+    class KickReasonTooLong < ArgumentTooLong
+    end
+
+    class UnsupportedFeature < Generic
+    end
+  end
+end

data/lib/newton/formatted_logger.rb

@@ -0,0 +1,64 @@
+module Newton
+  class FormattedLogger
+    COLORS = {
+      :reset => "\e[0m",
+      :bold => "\e[1m",
+      :red => "\e[31m",
+      :green => "\e[32m",
+      :yellow => "\e[33m",
+      :blue => "\e[34m",
+    }
+
+    class << self
+      # @return [void]
+      def debug(message)
+        log(message, :debug)
+      end
+
+      # @api private
+      # @return [void]
+      def log(message, kind = :generic)
+        message = message.to_s.chomp # don't want to tinker with the original string
+        unless $stdout.tty?
+          $stderr.puts message
+          return
+        end
+
+        if kind == :debug
+          prefix = colorize("!! ", :yellow)
+          message = prefix + message
+        else
+          pre, msg = message.split(" :", 2)
+          pre_parts = pre.split(" ")
+
+          if kind == :incoming
+            prefix = colorize(">> ", :green)
+
+            if pre_parts.size == 1
+              pre_parts[0] = colorize(pre_parts[0], :bold)
+            else
+              pre_parts[0] = colorize(pre_parts[0], :blue)
+              pre_parts[1] = colorize(pre_parts[1], :bold)
+            end
+
+          elsif kind == :outgoing
+            prefix = colorize("<< ", :red)
+            pre_parts[0] = colorize(pre_parts[0], :bold)
+          end
+
+          message = prefix + pre_parts.join(" ")
+          message << colorize(" :#{msg}", :yellow) if msg
+        end
+        $stderr.puts message
+      end
+
+      # @api private
+      # @param [String] text text to colorize
+      # @param [Array<Symbol>] codes array of colors to apply
+      # @return [String] colorized string
+      def colorize(text, *codes)
+        COLORS.values_at(*codes).join + text + COLORS[:reset]
+      end
+    end
+  end
+end