grinch 1.0.1 → 1.1.0

data/lib/cinch/isupport.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Cinch
   # This class exposes parsed ISUPPORT information of the IRC network.
   class ISupport < Hash
     @@mappings = {
-      %w[PREFIX] => lambda {|v|
+      %w[PREFIX] => lambda { |v|
         modes, prefixes = v.match(/^\((.+)\)(.+)$/)[1..2]
         h = {}
         modes.split("").each_with_index do |c, i|
@@ -11,18 +13,18 @@ module Cinch
         h
       },
 
-      %w[CHANTYPES] => lambda {|v| v.split("")},
-      %w[CHANMODES] => lambda {|v|
+      %w[CHANTYPES] => ->(v) { v.split("") },
+      %w[CHANMODES] => lambda { |v|
         h = {}
-        h["A"], h["B"], h["C"], h["D"] = v.split(",").map {|l| l.split("")}
+        h["A"], h["B"], h["C"], h["D"] = v.split(",").map { |l| l.split("") }
         h
       },
 
       %w[MODES MAXCHANNELS NICKLEN MAXBANS TOPICLEN
-       KICKLEN CHANNELLEN CHIDLEN SILENCE AWAYLEN
-       MAXTARGETS WATCH MONITOR] => lambda {|v| v.to_i},
+         KICKLEN CHANNELLEN CHIDLEN SILENCE AWAYLEN
+         MAXTARGETS WATCH MONITOR] => ->(v) { v.to_i },
 
-      %w[CHANLIMIT MAXLIST IDCHAN] => lambda {|v|
+      %w[CHANLIMIT MAXLIST IDCHAN] => lambda { |v|
         h = {}
         v.split(",").each do |pair|
           args, num = pair.split(":")
@@ -33,7 +35,7 @@ module Cinch
         h
       },
 
-      %w[TARGMAX] => lambda {|v|
+      %w[TARGMAX] => lambda { |v|
         h = {}
         v.split(",").each do |pair|
           name, value = pair.split(":")
@@ -42,11 +44,11 @@ module Cinch
         h
       },
 
-      %w[NETWORK] => lambda {|v| v},
-      %w[STATUSMSG] => lambda {|v| v.split("")},
-      %w[CASEMAPPING] => lambda {|v| v.to_sym},
-      %w[ELIST] => lambda {|v| v.split("")},
-      # TODO STD
+      %w[NETWORK] => ->(v) { v },
+      %w[STATUSMSG] => ->(v) { v.split("") },
+      %w[CASEMAPPING] => ->(v) { v.to_sym },
+      %w[ELIST] => ->(v) { v.split("") },
+      # TODO: STD
     }
 
     def initialize(*args)
@@ -56,13 +58,13 @@ module Cinch
       # allowing the use of strictness=:strict for servers that don't
       # support ISUPPORT (hopefully none, anyway)
 
-      self["PREFIX"]    =  {"o" => "@", "v" => "+"}
+      self["PREFIX"]    =  { "o" => "@", "v" => "+" }
       self["CHANTYPES"] =  ["#"]
       self["CHANMODES"] =  {
-        "A"             => ["b"],
-        "B"             => ["k"],
-        "C"             => ["l"],
-        "D"             => %w[i m n p s t r]
+        "A" => ["b"],
+        "B" => ["k"],
+        "C" => ["l"],
+        "D" => %w[i m n p s t r],
       }
       self["MODES"]       = 1
       self["NICKLEN"]     = Float::INFINITY
@@ -74,7 +76,7 @@ module Cinch
       self["AWAYLEN"]     = Float::INFINITY
       self["MAXTARGETS"]  = 1
       self["MAXCHANNELS"] = Float::INFINITY # deprecated
-      self["CHANLIMIT"]   = {"#" => Float::INFINITY}
+      self["CHANLIMIT"]   = { "#" => Float::INFINITY }
       self["STATUSMSG"]   = []
       self["CASEMAPPING"] = :rfc1459
       self["ELIST"]       = []
@@ -87,7 +89,7 @@ module Cinch
       options.each do |option|
         name, value = option.split("=")
         if value
-          proc = @@mappings.find {|key, _| key.include?(name)}
+          proc = @@mappings.find { |key, _| key.include?(name) }
           self[name] = (proc && proc[1].call(value)) || value
         else
           self[name] = true

data/lib/cinch/log_filter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cinch
   # LogFilter describes an interface for filtering log messages before
   # they're printed.
@@ -15,7 +17,6 @@ module Cinch
     #   :error, :fatal] event The kind of message
     # @return [String, nil] The modified message, as it should be
     #   logged, or nil if the message shouldn't be logged at all
-    def filter(message, event)
-    end
+    def filter(message, event); end
   end
 end

data/lib/cinch/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cinch
   # This is the base logger class from which all loggers have to
   # inherit.
@@ -5,7 +7,7 @@ module Cinch
   # @version 2.0.0
   class Logger
     # @private
-    LevelOrder = [:debug, :log, :info, :warn, :error, :fatal]
+    LevelOrder = %i[debug log info warn error fatal].freeze
 
     # @return [Array<:debug, :log, :info, :warn, :error, :fatal>]
     #   The minimum level of events to log
@@ -109,13 +111,15 @@ module Cinch
     # @version 2.0.0
     def log(messages, event = :debug, level = event)
       return unless will_log?(level)
+
       @mutex.synchronize do
         Array(messages).each do |message|
           message = format_general(message)
           message = format_message(message, event)
 
           next if message.nil?
-          @output.puts message.encode("locale", {:invalid => :replace, :undef => :replace})
+
+          @output.puts message.encode("locale", invalid: :replace, undef: :replace)
         end
       end
     end
@@ -129,6 +133,7 @@ module Cinch
     end
 
     private
+
     def format_message(message, level)
       __send__ "format_#{level}", message
     end

data/lib/cinch/logger/formatted_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cinch/logger"
 
 module Cinch
@@ -6,24 +8,25 @@ module Cinch
     class FormattedLogger < Logger
       # @private
       Colors = {
-        :reset => "\e[0m",
-        :bold => "\e[1m",
-        :red => "\e[31m",
-        :green => "\e[32m",
-        :yellow => "\e[33m",
-        :blue => "\e[34m",
-        :black => "\e[30m",
-        :bg_white => "\e[47m",
-      }
+        reset: "\e[0m",
+        bold: "\e[1m",
+        red: "\e[31m",
+        green: "\e[32m",
+        yellow: "\e[33m",
+        blue: "\e[34m",
+        black: "\e[30m",
+        bg_white: "\e[47m",
+      }.freeze
 
       # (see Logger#exception)
       def exception(e)
         lines = ["#{e.backtrace.first}: #{e.message} (#{e.class})"]
-        lines.concat e.backtrace[1..-1].map {|s| "\t" + s}
+        lines.concat e.backtrace[1..-1].map { |s| "\t" + s }
         log(lines, :exception, :error)
       end
 
       private
+
       def timestamp
         Time.now.strftime("[%Y/%m/%d %H:%M:%S.%L]")
       end
@@ -34,6 +37,7 @@ module Cinch
       # @return [String] colorized string
       def colorize(text, *codes)
         return text unless @output.tty?
+
         codes = Colors.values_at(*codes).join
         text = text.gsub(/#{Regexp.escape(Colors[:reset])}/, Colors[:reset] + codes)
         codes + text + Colors[:reset]
@@ -71,9 +75,9 @@ module Cinch
         end
 
         "%s %s %s %s" % [timestamp,
-                          prefix,
-                          pre_parts.join(" "),
-                          msg ? colorize(":#{msg}", :yellow) : ""]
+                         prefix,
+                         pre_parts.join(" "),
+                         msg ? colorize(":#{msg}", :yellow) : ""]
       end
 
       def format_outgoing(message)

data/lib/cinch/logger/zcbot_logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cinch/logger"
 module Cinch
   class Logger
@@ -10,10 +12,12 @@ module Cinch
       # (see Logger#log)
       def log(messages, event, level = event)
         return if event != :incoming
+
         super
       end
 
       private
+
       def format_incoming(message)
         Time.now.strftime("%m/%d/%Y %H:%M:%S ") + message
       end

data/lib/cinch/logger_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cinch
   # This class allows Cinch to use multiple loggers at once. A common
   # use-case would be to log formatted messages to STDERR and a
@@ -22,62 +24,61 @@ module Cinch
 
     # (see Logger#level=)
     def level=(level)
-      each {|l| l.level = level}
+      each { |l| l.level = level }
     end
 
     # (see Logger#log)
     def log(messages, event = :debug, level = event)
-      messages = Array(messages).map {|m| filter(m, event)}.compact
-      each {|l| l.log(messages, event, level)}
+      messages = Array(messages).map { |m| filter(m, event) }.compact
+      each { |l| l.log(messages, event, level) }
     end
 
     # (see Logger#debug)
     def debug(message)
-      (m = filter(message, :debug)) && each {|l| l.debug(m)}
+      (m = filter(message, :debug)) && each { |l| l.debug(m) }
     end
 
     # (see Logger#error)
     def error(message)
-      (m = filter(message, :error)) && each {|l| l.error(m)}
+      (m = filter(message, :error)) && each { |l| l.error(m) }
     end
 
     # (see Logger#error)
     def fatal(message)
-      (m = filter(message, :fatal)) && each {|l| l.fatal(m)}
+      (m = filter(message, :fatal)) && each { |l| l.fatal(m) }
     end
 
     # (see Logger#info)
     def info(message)
-      (m = filter(message, :info)) && each {|l| l.info(m)}
+      (m = filter(message, :info)) && each { |l| l.info(m) }
     end
 
     # (see Logger#warn)
     def warn(message)
-      (m = filter(message, :warn)) && each {|l| l.warn(m)}
+      (m = filter(message, :warn)) && each { |l| l.warn(m) }
     end
 
     # (see Logger#incoming)
     def incoming(message)
-      (m = filter(message, :incoming)) && each {|l| l.incoming(m)}
+      (m = filter(message, :incoming)) && each { |l| l.incoming(m) }
     end
 
     # (see Logger#outgoing)
     def outgoing(message)
-      (m = filter(message, :outgoing)) && each {|l| l.outgoing(m)}
+      (m = filter(message, :outgoing)) && each { |l| l.outgoing(m) }
     end
 
     # (see Logger#exception)
     def exception(e)
-      each {|l| l.exception(e)}
+      each { |l| l.exception(e) }
     end
 
     private
+
     def filter(m, ev)
       @filters.each do |f|
         m = f.filter(m, ev)
-        if m.nil?
-          break
-        end
+        break if m.nil?
       end
       m
     end

data/lib/cinch/mask.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cinch
   # This class represents masks, which are primarily used for bans.
   class Mask
@@ -39,11 +41,11 @@ module Cinch
     # @return [Boolean]
     # @version 1.1.2
     def match(target)
-      return self.class.from(target).mask =~ @regexp
+      self.class.from(target).mask =~ @regexp
 
-      # TODO support CIDR (freenode)
+      # TODO: support CIDR (freenode)
     end
-    alias_method :=~, :match
+    alias =~ match
 
     # @return [String]
     def to_s
@@ -57,13 +59,13 @@ module Cinch
     def self.from(target)
       return target if target.is_a?(self)
 
-      if target.respond_to?(:mask)
-        mask = target.mask
-      else
-        mask = Mask.new(target.to_s)
-      end
+      mask = if target.respond_to?(:mask)
+               target.mask
+             else
+               Mask.new(target.to_s)
+             end
 
-      return mask
+      mask
     end
   end
 end

data/lib/cinch/message.rb

@@ -108,11 +108,11 @@ module Cinch
       @params  = parse_params(raw_params)
       @tags    = parse_tags(tags)
 
-      @user    = parse_user
+      @user = parse_user
       @channel, @statusmsg_mode = parse_channel
-      @target  = @channel || @user
-      @server  = parse_server
-      @error   = parse_error
+      @target = @channel || @user
+      @server = parse_server
+      @error = parse_error
       @message = parse_message
 
       @ctcp_message = parse_ctcp_message
@@ -333,9 +333,9 @@ module Cinch
       statusmsg = @bot.irc.isupport["STATUSMSG"]
       if statusmsg.include?(s[0]) && chantypes.include?(s[1])
         status = @bot.irc.isupport["PREFIX"].invert[s[0]]
-        return s[1..-1], status
+        [s[1..-1], status]
       elsif chantypes.include?(s[0])
-        return s, nil
+        [s, nil]
       end
     end
 

data/lib/cinch/message_queue.rb

@@ -1,4 +1,5 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
+
 require "cinch/open_ended_queue"
 
 module Cinch
@@ -11,7 +12,7 @@ module Cinch
       @socket = socket
       @bot    = bot
 
-      @queues            = {:generic => OpenEndedQueue.new}
+      @queues            = { generic: OpenEndedQueue.new }
       @queues_to_process = Queue.new
       @queued_queues     = Set.new
 
@@ -61,6 +62,7 @@ module Cinch
     end
 
     private
+
     def wait
       if @log.size > 1
         mps            = @bot.config.messages_per_second || @bot.irc.network.default_messages_per_second
@@ -74,7 +76,7 @@ module Cinch
         if effective_size <= 0
           @log.clear
         elsif effective_size >= max_queue_size
-          sleep 1.0/mps
+          sleep 1.0 / mps
         end
       end
     end
@@ -102,6 +104,5 @@ module Cinch
         @bot.loggers.error "Could not send message (connectivity problems): #{message}"
       end
     end
-
   end # class MessageQueue
 end

data/lib/cinch/mode_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cinch/exceptions"
 
 module Cinch
@@ -16,7 +18,7 @@ module Cinch
     #   A mapping describing which modes require parameters
     # @return [(Array<(Symbol<:add, :remove>, String<char>, String<param>), foo)]
     def self.parse_modes(modes, params, param_modes = {})
-      if modes.size == 0
+      if modes.empty?
         return nil, ErrEmptyString
         # raise Exceptions::InvalidModeString, 'Empty mode string'
       end
@@ -47,8 +49,8 @@ module Cinch
           count = 0
         else
           param = nil
-          if param_modes.has_key?(direction) && param_modes[direction].include?(ch)
-            if params.size > 0
+          if param_modes.key?(direction) && param_modes[direction].include?(ch)
+            if !params.empty?
               param = params.shift
             else
               return changes, NotEnoughParametersError.new(ch)
@@ -60,7 +62,7 @@ module Cinch
         end
       end
 
-      if params.size > 0
+      unless params.empty?
         return changes, TooManyParametersError.new(modes, params)
         # raise Exceptions::InvalidModeString, 'Too many parameters: %s %s' % [modes, params]
       end
@@ -70,7 +72,7 @@ module Cinch
         # raise Exceptions::InvalidModeString, 'Empty mode sequence: %s' % modes
       end
 
-      return changes, nil
+      [changes, nil]
     end
   end
 end