irc_parser 0.1.0

data/lib/irc_parser/factory.erb

@@ -0,0 +1,53 @@
+#class Struct::<%= name %>
+
+  def initialize(prefix = nil, arguments = nil)
+    arguments ? super(prefix, *arguments) : super(prefix)
+
+  <% if @postfix_format %>
+    self.postfix ||= <%= @postfix_format.inspect %>
+  <% end %>
+
+  <% csv_arguments.each do |argument| %>
+    self[<%=argument[:name].inspect%>] = Array(self[<%=argument[:name].inspect%>]).join(<%=argument[:csv].inspect%>)
+  <% end %>
+
+    yield self if block_given?
+  end
+
+  def format_postfix(hash)
+    self.postfix = <%= @postfix_format.inspect %> % hash
+  end
+
+  EMPTY_STRING = "".freeze
+
+  # Generates the IRC message. It will have the form:
+  # ':prefix IDENTIFIER param1 param2 :postfix thay may have spaces\r\n'
+  def to_s
+    result = "#{prefix && prefix != EMPTY_STRING ? ":#{prefix} " : nil}<%= @identifier %>"
+
+  <% arguments.each_with_index do |argument, index| %>
+    part = self[<%= argument[:name].inspect %>]
+    <% if argument.member?(:default) %>
+    result << " " << ((part && part != EMPTY_STRING) ? part.to_s : <%= argument[:default].inspect %>)
+    <% else %>
+    result << " " << part.to_s if (part && part != EMPTY_STRING)
+    <% end %>
+  <% end %>
+
+    result << " :#{postfix}" if postfix && postfix != EMPTY_STRING
+    result << "\r\n"
+  end
+  alias_method :to_str, :to_s
+
+<% csv_arguments.each do |argument| %>
+  def <%=argument[:name]%>
+    self[<%=argument[:name].inspect%>].split(<%=argument[:csv].inspect%>)
+  end
+
+  def <%=argument[:name]%>=(val)
+    self[<%=argument[:name].inspect%>] = Array(val).join(<%=argument[:csv].inspect%>)
+  end
+<% end %>
+
+#end
+# vim: set ft=ruby ts=8 sw=2 tw=0 :

data/lib/irc_parser/helper.rb

@@ -0,0 +1,71 @@
+module IRCParser
+  module Helper
+    extend self
+
+    def underscore(string)
+      string.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+    end
+
+    def parse_regexp(text)
+      /#{ text.to_s.split(".").join("\\.").gsub(/\*|\?/, ".*") }/
+    end
+
+    # http://tools.ietf.org/html/rfc1459#section-4.3.2
+    # c - returns a list of servers which the server may connect to or allow connections from;
+    # h - returns a list of servers which are either forced to be treated as leaves or allowed to act as hubs;
+    # i - returns a list of hosts which the server allows a client to connect from;
+    # k - returns a list of banned username/hostname combinations for that server;
+    # l - returns a list of the server's connections, showing how long each connection has been established and the traffic
+    #     over that connection in bytes and messages for each direction;
+    # m - returns a list of commands supported by the server and the usage count for each if the usage count is non zero;
+    # o - returns a list of hosts from which normal clients may become operators;
+    # y - show Y (Class) lines from server's configuration file;
+    # u - returns a string showing how long the server has been up.
+    STATS_MODES = %w|c h i k l m o y u|
+
+    NICK_REGEXP = /^[a-zA-Z]+[a-zA-Z0-9]*/
+
+    def valid_nick?(nick)
+      nick =~ NICK_REGEXP
+    end
+
+    def invalid_nick?(nick)
+      not valid_nick?(nick)
+    end
+
+    module NicknameHelpers
+      %w|valid_nick? invalid_nick?|.each do |meth|
+        define_method(meth) { IRCParser::Helper.send(meth, self) }
+      end
+    end
+
+    CHANNEL_PREFIXES = {
+      :normal   => "#",
+      :local    => "&",
+      :modeless => "+",
+      :safe     => "!"
+    }
+
+    CHANNEL_REGEXP = /^[#{CHANNEL_PREFIXES.values.join("|")}][a-zA-Z0-9]+/
+
+    def valid_channel_name?(name)
+      name.to_s =~ CHANNEL_REGEXP
+    end
+
+    def invalid_channel_name?(name)
+      not valid_channel_name?(name)
+    end
+
+    CHANNEL_PREFIXES.each do |channel_mode, prefix|
+      define_method("#{channel_mode}_channel?") do |name|
+        name.to_s[0, 1] == prefix
+      end
+    end
+
+    module Channel
+      (CHANNEL_PREFIXES.keys.map {|mode| "#{mode}_channel?" } + %w|valid_channel_name? invalid_channel_name?|).each do |meth|
+        define_method(meth) { IRCParser::Helper.send(meth, self) }
+      end
+    end
+  end
+end

data/lib/irc_parser/messages.rb

@@ -0,0 +1,96 @@
+require 'erb'
+
+module IRCParser
+  module Messages
+    # Store all known message classes under convenient keys so they are easy to find.
+    ALL = Hash.new
+
+    # Create a Message class and save it on the IRCParser::Messages::ALL hash
+    # for easy retrieval with different names.
+    def self.define_message(name, *arguments, &block)
+      klass = message_class(name, *arguments, &block)
+      [klass.name.to_s, klass.name.to_s.upcase, klass.to_sym.to_s, klass.to_sym.to_s.upcase, klass.identifier.to_s].uniq.each do |key|
+        IRCParser::Messages::ALL[key] = klass
+        IRCParser::Messages::ALL[key.to_sym] = klass
+      end
+      IRCParser::Messages::ALL[klass.identifier.to_s.to_i] = klass if klass.identifier.to_s =~ /^\d+$/
+      const_set(name, klass)
+    end
+
+    IMPLEMENTATION_PATH = File.expand_path(File.join(File.dirname(__FILE__), "factory.erb"))
+    IMPLEMENTATION = File.read(IMPLEMENTATION_PATH)
+
+    # Creates a message class, which inherits from a ruby Struct to save the different message params.
+    def self.message_class(name, *arguments, &block)
+      # # #
+      # Prepare information needed to generate the classes
+      # # #
+
+      # klass.to_sym is convenient name for storing the class in the ALL hash. E.g.: AWAY -> :away
+      to_sym = IRCParser::Helper.underscore(name).to_sym
+      identifier = (arguments.first.is_a?(String) ? arguments.shift : name).to_s.upcase.to_sym
+      postfix_format = arguments.pop if arguments.last.is_a?(String)
+      postfix_alias = arguments.pop.keys.first if arguments.last.is_a?(Hash) && arguments.last.values.first == :postfix
+
+      placeholders = 0 # used to give name to placeholder arguments.
+
+      # normalize the parameter information so it is easy to work with.
+      arguments.map! do |arg|
+        if arg.is_a?(Hash)      then {:name => arg.keys.first}.merge(arg.values.first)
+        elsif arg.is_a?(String) then {:name => "placeholder_#{placeholders += 1}", :default => arg}
+        else                         {:name => arg}
+        end
+      end
+
+      # we will generate accessors to move from and to char separated values (char can be a comma, a space, etc..)
+      csv_arguments = arguments.select { |arg| arg.has_key?(:csv) }
+
+      # # #
+      # Generate the class, inhereting from Struct, and generate its methods.
+      # # #
+
+      klass = Struct.new("IRC#{name}", *([:prefix] + (arguments.map { |arg| arg[:name] } + [:postfix]))) do
+        @name, @to_sym, @identifier, @postfix_format = name, to_sym, identifier, postfix_format
+
+        extend ClassMethods
+
+        # It would be trivial to rewrite the code on factory.erb using define_methods,
+        # but the code generated using eval runs about 10% faster, with the only caveat
+        # *sometimes* is a little harder to follow backtraces when errors occur.
+        class_eval(ERB.new(IMPLEMENTATION).result(binding), IMPLEMENTATION_PATH)
+
+        [postfix_alias, :body, :message].compact.uniq.each do |attr|
+          alias_method attr, :postfix
+          alias_method "#{attr}=", :postfix=
+        end
+      end
+
+      # # #
+      # Evaluate any additional configuration block passed to this method, and return the resulting class.
+      # # #
+
+      klass.class_eval(&block) if block
+      klass
+    end
+
+    module ClassMethods
+      attr_reader :name, :to_sym, :identifier, :postfix_format
+
+      def is_error?
+        !(@name !~ /^Err[A-Z]/)
+      end
+
+      def is_reply?
+        !(@name !~ /^Rpl[A-Z]/)
+      end
+
+      def is_command?
+        !(@name =~ /^(Rpl|Err)[A-Z]/)
+      end
+    end
+
+    require 'irc_parser/messages/commands'
+    require 'irc_parser/messages/errors'
+    require 'irc_parser/messages/replies'
+  end
+end

data/lib/irc_parser/messages/commands.rb

@@ -0,0 +1,274 @@
+module IRCParser::Messages
+  define_message :Admin   , :target
+  define_message :Away    , :away_message => :postfix
+  define_message :Connect , :target_server, :port, :remote_server
+  define_message :Info    , :target
+  define_message :Invite  , :to_nick, :channel
+  define_message :Join    , {:channels => {:csv => ","}}, {:keys => {:csv => ","}}
+  define_message :Kick    , {:channels => {:csv => ","}}, {:users => {:csv => ","}}, :kick_message => :postfix
+  define_message :Kill    , :nick, :kill_message => :postfix
+  define_message :Links   , :remote_server, :server_mask
+  define_message :List    , :channels => {:csv => ","}
+  define_message :Names   , :channels => {:csv => ","}
+  define_message :Oper    , :user, :password
+  define_message :Part    , {:channels => {:csv => ","}}, :part_message
+  define_message :Pass    , :password
+  define_message :Ping    , :target, :final_target
+  define_message :Pong    , :server, :target
+  define_message :Quit    , :quit_message => :postfix
+  define_message :Rehash
+  define_message :Restart
+  define_message :SQuit   , :server, :reason => :postfix
+  define_message :Stats   , :mode, :server
+  define_message :Time    , :for_server
+  define_message :Topic   , :channel, :topic => :postfix
+  define_message :Trace   , :target
+  define_message :User    , :user, {:mode => { :default => "*" }}, {:servername => { :default => "*" }}, :realname => :postfix
+  define_message :Users   , :target
+  define_message :Version , :server
+  define_message :WallOps , :wall_message => :postfix
+
+  define_message :Mode, :target, :flags, :limit, :user, :ban_mask do
+
+    # Channel Parameters: <channel> {[+|-]|o|p|s|i|t|n|b|v} [<limit>] [<user>] [<ban mask>]
+    # User Parameters: <nickname> {[+|-]|i|w|s|o}
+    def initialize(prefix, params = [], &block)
+      super(prefix, *params)
+
+      return if params == nil || params.length <= 1
+
+      if params.length != 5 && params.length != 2
+        self.target = params[0]
+        self.flags = params[1]
+
+        if remaining = params[2..-1]
+          if remaining.first =~ /\d+/ || self.flags =~ /\+k/
+            self.limit = remaining.shift
+          elsif self.flags =~ /\+b/
+            self.ban_mask = remaining.first
+          else
+            self.user, self.ban_mask = *remaining
+          end
+        end
+      end
+
+      self.flags = self.flags.downcase if self.flags
+    end
+
+    def for_channel?
+      IRCParser::Helper.valid_channel_name?(target)
+    end
+
+    def for_user?
+      IRCParser::Helper.valid_nick?(target)
+    end
+
+    CHANNEL_MODES = {
+      :invitation          => "I", # set/remove an invitation mask to automatically override the invite-only flag;
+      :exception           => "e", # set/remove an exception mask to override a ban mask;
+      :quiet               => "q", # toggle the quiet channel flag;
+      :reop                => "r", # toggle the server reop channel flag;
+      :anonymous           => "a", # toggle the anonymous channel flag;
+      :ban_mask            => "b", # set a ban mask to keep users out;
+      :creator             => "O", # give "channel creator" status;
+      :invite_only         => "i", # invite-only channel flag;
+      :moderated           => "m", # moderated channel;
+      :no_foreign_messages => "n", # no messages to channel from clients on the outside;
+      :operator            => "o", # give/take channel operator privileges;
+      :password            => "k", # set a channel key (password).
+      :private             => "p", # private channel flag;
+      :secret              => "s", # secret channel flag;
+      :speaker             => "v", # give/take the ability to speak on a moderated channel;
+      :topic_by_op_only    => "t", # topic settable by channel operator only flag;
+      :users_limit         => "l"  # set the user limit to channel;
+    }
+
+    def negative_flags?
+      flags && ( flags[0,1] == "-" )
+    end
+
+    def positive_flags?
+      not negative_flags?
+    end
+
+    def negative_flags!
+      self.flags ||= ""
+
+      case flags[0,1]
+      when "-" then # Do nothing
+      when "+" then self.flags[0] = "-"
+      else
+        self.flags.insert(0, "-") # Should not happen. Anyway.
+      end
+    end
+
+    def positive_flags!
+      self.flags ||= ""
+
+      case flags[0,1]
+      when "+" then # Do nothing
+      when "-" then self.flags[0] = "+"
+      else
+        self.flags.insert(0, "+") # Should not happen. Anyway.
+      end
+    end
+
+    CHANNEL_MODES.each do |name, flag|
+      define_method("chan_flags_include_#{name}?") do
+        flags && for_channel? && flags.include?(flag)
+      end
+
+      define_method("chan_#{name}?") do
+        flags && for_channel? && flags.include?(flag) && positive_flags?
+      end
+
+      define_method("chan_#{name}!") do
+        self.flags ||= ""
+        self.flags = flags + flag unless flags.include?(flag)
+      end
+    end
+
+    USER_MODES = {
+      :invisible        => "i", # marks a users as invisible;
+      :server_receptor  => "s", # marks a user for receipt of server notices;
+      :wallops_receptor => "w", # user receives wallops;
+      :operator         => "o", # operator flag.
+      :away             => "a", # user is flagged as away;
+      :restricted       => "r", # restricted user connection;
+      :local_operator   => "O"  # local operator flag;
+    }
+
+    USER_MODES.each do |name, flag|
+      define_method("user_flags_include_#{name}?") do
+        flags && for_user? && flags.include?(flag)
+      end
+
+      define_method("user_#{name}?") do
+        flags && for_user? && flags.include?(flag) && positive_flags?
+      end
+
+      define_method("user_#{name}!") do
+        self.flags ||= ""
+        self.flags = flags + flag unless self.flags.include?(flag)
+      end
+    end
+  end
+
+  # hopcount: removed in RFC 2812
+  define_message :Nick, :nick, :hopcount do
+    def invalid_nick?
+      IRCParser::Helper.invalid_nick?(nick)
+    end
+
+    def changing?
+      prefix.to_s =~ /\S/
+    end
+  end
+
+  define_message :Server, :server, :hopcount, :info => :postfix do
+    def hopcount
+      self[:hopcount].to_i
+    end
+
+    # not sure about this one, from RFC 2813
+    # http://tools.ietf.org/html/rfc2813#section-4.1.2
+    def token
+      info
+    end
+  end
+
+  module MesageMan
+    def for_channel?
+      IRCParser::Helper.valid_channel_name?(target.to_s)
+    end
+
+    def for_user?
+      IRCParser::Helper.valid_nick?(target.to_s)
+    end
+
+    def for_server_pattern?
+      target.to_s =~ /^\$/
+    end
+
+    def for_host_pattern?
+      target.to_s =~ /^\#/
+    end
+
+    def server_pattern
+      for_server_pattern? && IRCParser::Helper::parse_regexp(target[1..-1])
+    end
+
+    def host_pattern
+      for_host_pattern? && IRCParser::Helper::parse_regexp(target[1..-1])
+    end
+  end
+
+  define_message :PrivMsg, :target, :body => :postfix do
+    include MesageMan
+  end
+
+  define_message :Notice, :target, :body => :postfix do
+    include MesageMan
+  end
+
+  define_message :Who, :pattern, :operator do
+    alias_method :operator?, :operator
+
+    def for_channel?
+      IRCParser::Helper.valid_channel_name?(pattern)
+    end
+
+    def operator!(true_or_false = true)
+      self.operator = true_or_false ? "o" : ""
+    end
+
+    def regexp
+      IRCParser::Helper.parse_regexp(pattern)
+    end
+  end
+
+  define_message :WhoIs, :target, :pattern do
+    def initialize(prefix, params = [], &block)
+      super(prefix, *params)
+      self.target, self.pattern = nil, self.target if params && params.length == 1
+    end
+
+    def regexp
+      IRCParser::Helper.parse_regexp(pattern)
+    end
+  end
+
+  define_message :WhoWas, :nick, :count, :server do
+    def count
+      self[:count].to_i
+    end
+  end
+
+  define_message :Error, :nick, :error_message => :postfix do
+    def initialize(prefix, params = [], &block)
+      super(prefix, *params)
+
+      if params
+        if params.length == 2
+          self.nick, self.error_message = *params
+        else
+          self.error_message = params.first
+        end
+      end
+    end
+  end
+
+  define_message :Summon, :nick, :server
+
+  define_message :UserHost, :nicks => { :csv => " " } do
+    def initialize(prefix = nil, *nicks)
+      super(prefix, nicks.join(" "))
+    end
+  end
+
+  define_message :IsOn, :nicks => { :csv => " " } do
+    def initialize(prefix = nil, *nicks)
+      super(prefix, nicks.join(" "))
+    end
+  end
+end