balotelli 0.4.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7addde5a832912208f7790a6559c172d818a555a
-  data.tar.gz: 0a86ccc08b3e928152d024d9e8e154aa36cdbf46
+  metadata.gz: 4af3a056d835bb509c9a8eeae2591a21c9f51f4a
+  data.tar.gz: fcb7b59a3e774c88e92318b375acdffe4ae3bde5
 SHA512:
-  metadata.gz: a252b2a40886641e5912b5818416a53d014b3c2b1a026f9a688153c1a5397d162be1da2d4b755a36250ee27487cbe5526940eba3a77108c90a59b11982d18168
-  data.tar.gz: 9f37a6595af818d752e9cfcdd7814ad183ccf09364b6b36f6445ca8137e3b685bfdacd64cb9c1b809ec0307eccfc1f5910bdab42dfba919e1f59dfaa245d6450
+  metadata.gz: 1cda3aa74be90d37dac1f12f4dabd1b34c9336c4972b941d3e1b65691421e00d95d7f52e904be66f82564859a5ec616294beba6eb4d65e629597b70251924083
+  data.tar.gz: 8dfff8deb52f2b9cfcff2bce18308b28b5d14f777d2edf34b1aa7e479fbf0d03b591da357f9a35a14fa37c70747eb2dedfc89c20481d9ebaa654ffee51b3fbd2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    balotelli (0.4.2.1)
+    balotelli (0.5.0)
 
 GEM
   remote: https://rubygems.org/
@@ -10,6 +10,7 @@ GEM
     rake (10.4.2)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES

data/lib/balotelli/base.rb

@@ -1,11 +1,14 @@
 require 'balotelli/core/irc'
-require 'balotelli/core/router'
+require 'balotelli/core/router/router'
+require 'balotelli/core/router/match'
+require 'balotelli/core/router/action'
 require 'balotelli/core/priv_msg'
 require 'balotelli/core/join'
 require 'balotelli/core/kick'
 require 'balotelli/core/irc_logger'
 require 'balotelli/core/utils'
 require 'balotelli/config'
+require 'balotelli/thread/pool'
 
 module Balotelli
   class Base
@@ -66,6 +69,7 @@ module Balotelli
       def setup
         setup_router
 
+        @pool = Thread::Pool.new(Thread::Pool.cpu_count)
         @modules = {}
         @cache = Hash.new { |hash, key| hash[key] = {} }
         @cvs = {}
@@ -95,8 +99,6 @@ module Balotelli
       def mod_match(str, priv = false)
         if str =~ /\A[^a-zA-Z0-9\s]?(\S+) ?(.*)/
           if (mod = @cache[:modules][Regexp.last_match(1).downcase])
-            str.slice!(0..Regexp.last_match(1).length)
-            str.lstrip!
             mod.match(Regexp.last_match(2), priv)
           end
         elsif str == :join
@@ -126,7 +128,7 @@ module Balotelli
         elsif !(str =~ /(JOIN\s|PRIVMSG\s)/)
           process_table(str)
         else
-          Thread.new { process_message(str) }
+          @pool.process { process_message(str) }
         end
       end
 
@@ -140,25 +142,23 @@ module Balotelli
 
       def process_private_message(str, user, channel, message)
         privacy = !(channel =~ /#.+/)
-        if (route = match(message, privacy)) ||
-           (route = mod_match(message, privacy))
-          new_response(user, channel, message, route, Core::PrivMsg, privacy)
+        if (matched = match(message, privacy)) ||
+           (matched = mod_match(message, privacy))
+          new_response(user, channel, message, matched, Core::PrivMsg, privacy)
         end
       end
 
       def process_join(str, user, channel)
-        if (route = match(:join)) || (route = mod_match(:join))
-          new_response(user, channel, nil, route, Core::Join)
+        if (matched = match(:join)) || (matched = mod_match(:join))
+          new_response(user, channel, nil, matched, Core::Join)
         end
       end
 
 
       def new_response(user, channel, message, route_match, klass, priv = nil)
-        route_pattern, block, module_name = route_match.flatten
         message = klass.new(*[user, channel, message, priv].compact)
-        matchdata = message.content.match(route_pattern) if route_pattern.is_a?(Regexp)
-        new(block, message, matchdata).tap do |response|
-          response.extend(module_name) if module_name.class.to_s == 'Module'
+        new(route_match.block, message, route_match.match_data).tap do |response|
+          response.extend(route_match.mod_name) if route_match.mod_name.class == ::Module
         end.execute!
       end
 

data/lib/balotelli/core/irc_logger.rb

@@ -8,6 +8,28 @@ module Balotelli
         "#{datetime.utc}: #{msg}\n"
       end
 
+      module Methods
+        def sgets
+          str = orig_sgets
+          to_log = "<<#{str.inspect}\n"
+          @log_file.info(to_log)
+          if str =~ /\A:?\S+ \S+ (#\S+) .*/
+            @logger.channel_log(Regexp.last_match(1).downcase, to_log)
+          end
+          str
+        end
+
+        def sputs(str)
+          orig_sputs(str)
+          to_log = ">>#{str.inspect}\n"
+          @log_file.info(to_log)
+          if str =~ /\A:?\S+ (#\S+) .*/
+            @logger.channel_log(Regexp.last_match(1).downcase, to_log)
+          end
+          str
+        end
+      end
+
       attr_reader :log_file, :dir, :channels, :channels_logs
 
       def initialize(dir = '', log_name = 'logs.log', channels = [])
@@ -44,28 +66,6 @@ module Balotelli
         end
       end
 
-      module Methods
-        def sgets
-          str = orig_sgets
-          to_log = "<<#{str.inspect}\n"
-          @log_file.info(to_log)
-          if str =~ /\A:?\S+ \S+ (#\S+) .*/
-            @logger.channel_log(Regexp.last_match(1).downcase, to_log)
-          end
-          str
-        end
-
-        def sputs(str)
-          orig_sputs(str)
-          to_log = ">>#{str.inspect}\n"
-          @log_file.info(to_log)
-          if str =~ /\A:?\S+ (#\S+) .*/
-            @logger.channel_log(Regexp.last_match(1).downcase, to_log)
-          end
-          str
-        end
-      end
-
       def define_log_method
         define_method :log_file do |str|
           class_variable_get(:@log_file)

data/lib/balotelli/core/router/action.rb

@@ -0,0 +1,13 @@
+module Balotelli
+  module Core
+    module Router
+      class Action
+        attr_reader :block, :mod_name
+        def initialize(block, mod_name)
+          @block = block
+          @mod_name = mod_name
+        end
+      end
+    end
+  end
+end

data/lib/balotelli/core/router/match.rb

@@ -0,0 +1,24 @@
+module Balotelli
+  module Core
+    module Router
+      class Match
+        attr_reader :data, :pattern, :block, :mod_name
+        def initialize(data, pattern, action, privacy)
+          @data = data
+          @pattern = pattern
+          @block = action.block
+          @mod_name = action.mod_name
+          @private = privacy
+        end
+
+        def is_private?
+          @private
+        end
+
+        def match_data
+          @match_data ||= data.match(pattern) if pattern.is_a?(Regexp)
+        end
+      end
+    end
+  end
+end

data/lib/balotelli/core/router/router.rb

@@ -0,0 +1,51 @@
+module Balotelli
+  module Core
+    module Router
+      RouteCollisionError = Class.new(StandardError)
+
+      def setup_router
+        @routes = {}
+      end
+
+      def on(route, options = {}, &block)
+        raise 'no block given' if block.nil?
+
+        privacy = options.fetch(:private, false)
+
+        if privacy == :both
+          on(route, options.clone.tap { |o| o[:private] = true }, &block)
+          on(route, options.clone.tap { |o| o[:private] = false }, &block)
+          return
+        end
+
+        @routes[route] ||= {}
+
+        if @routes[route][privacy] && !options[:force]
+          raise RouteCollisionError,
+            "Route #{route.inspect}, private: #{options[:private]} already exists"
+        end
+
+        @routes[route][privacy] = Action.new(block, self)
+      end
+
+      def match?(str, route)
+        case route
+        when Regexp
+          str =~ route
+        when String
+          str == route
+        when Symbol
+          str == route
+        end
+      end
+
+      def match(str, priv = false)
+        if (route = @routes.detect { |k, v| match?(str, k) && v[priv] })
+          pattern = route[0]
+          action = route[1][priv]
+          Match.new(str, pattern, action, priv)
+        end
+      end
+    end
+  end
+end

data/lib/balotelli/module/base.rb

@@ -1,4 +1,4 @@
-require 'balotelli/core/router'
+require 'balotelli/core/router/router'
 
 module Balotelli
   module Module

data/lib/balotelli/thread/pool.rb

@@ -0,0 +1,470 @@
+# https://github.com/meh/ruby-thread/blob/master/lib/thread/pool.rb
+require 'thread'
+require 'etc'
+
+# A pool is a container of a limited amount of threads to which you can add
+# tasks to run.
+#
+# This is usually more performant and less memory intensive than creating a
+# new thread for every task.
+class Thread::Pool
+  # A task incapsulates a block being ran by the pool and the arguments to pass
+  # to it.
+  class Task
+    Timeout = Class.new(Exception)
+    Asked   = Class.new(Exception)
+
+    attr_reader :pool, :timeout, :exception, :thread, :started_at, :result
+
+    # Create a task in the given pool which will pass the arguments to the
+    # block.
+    def initialize(pool, *args, &block)
+      @pool      = pool
+      @arguments = args
+      @block     = block
+
+      @running    = false
+      @finished   = false
+      @timedout   = false
+      @terminated = false
+    end
+
+    def running?
+      @running
+    end
+
+    def finished?
+      @finished
+    end
+
+    def timeout?
+      @timedout
+    end
+
+    def terminated?
+      @terminated
+    end
+
+    # Execute the task.
+    def execute
+      return if terminated? || running? || finished?
+
+      @thread     = Thread.current
+      @running    = true
+      @started_at = Time.now
+
+      pool.__send__ :wake_up_timeout
+
+      begin
+        @result = @block.call(*@arguments)
+      rescue Exception => reason
+        if reason.is_a? Timeout
+          @timedout = true
+        elsif reason.is_a? Asked
+          return
+        else
+          @exception = reason
+          raise @exception if Thread::Pool.abort_on_exception
+        end
+      end
+
+      @running  = false
+      @finished = true
+      @thread   = nil
+    end
+
+    # Raise an exception in the thread used by the task.
+    def raise(exception)
+      @thread.raise(exception) if @thread
+    end
+
+    # Terminate the exception with an optionally given exception.
+    def terminate!(exception = Asked)
+      return if terminated? || finished? || timeout?
+
+      @terminated = true
+
+      return unless running?
+
+      self.raise exception
+    end
+
+    # Force the task to timeout.
+    def timeout!
+      terminate! Timeout
+    end
+
+    # Timeout the task after the given time.
+    def timeout_after(time)
+      @timeout = time
+
+      pool.__send__ :timeout_for, self, time
+
+      self
+    end
+  end
+
+  attr_reader :min, :max, :spawned, :waiting
+
+  # Create the pool with minimum and maximum threads.
+  #
+  # The pool will start with the minimum amount of threads created and will
+  # spawn new threads until the max is reached in case of need.
+  #
+  # A default block can be passed, which will be used to {#process} the passed
+  # data.
+  def initialize(min, max = nil, &block)
+    @min   = min
+    @max   = max || min
+    @block = block
+
+    @cond  = ConditionVariable.new
+    @mutex = Mutex.new
+
+    @done       = ConditionVariable.new
+    @done_mutex = Mutex.new
+
+    @todo     = []
+    @workers  = []
+    @timeouts = {}
+
+    @spawned       = 0
+    @waiting       = 0
+    @shutdown      = false
+    @trim_requests = 0
+    @auto_trim     = false
+    @idle_trim     = nil
+    @timeout       = nil
+
+    @mutex.synchronize {
+      min.times {
+        spawn_thread
+      }
+    }
+  end
+
+  # Check if the pool has been shut down.
+  def shutdown?
+    !!@shutdown
+  end
+
+  # Check if auto trimming is enabled.
+  def auto_trim?
+    @auto_trim
+  end
+
+  # Enable auto trimming, unneeded threads will be deleted until the minimum
+  # is reached.
+  def auto_trim!
+    @auto_trim = true
+
+    self
+  end
+
+  # Disable auto trimming.
+  def no_auto_trim!
+    @auto_trim = false
+
+    self
+  end
+
+  # Check if idle trimming is enabled.
+  def idle_trim?
+    !@idle_trim.nil?
+  end
+
+  # Enable idle trimming. Unneeded threads will be deleted after the given number of seconds of inactivity.
+  # The minimum number of threads is respeced.
+  def idle_trim!(timeout)
+    @idle_trim = timeout
+
+    self
+  end
+
+  # Turn of idle trimming.
+  def no_idle_trim!
+    @idle_trim = nil
+
+    self
+  end
+
+  # Resize the pool with the passed arguments.
+  def resize(min, max = nil)
+    @min = min
+    @max = max || min
+
+    trim!
+  end
+
+  # Get the amount of tasks that still have to be run.
+  def backlog
+    @mutex.synchronize {
+      @todo.length
+    }
+  end
+
+  # Are all tasks consumed?
+  def done?
+    @mutex.synchronize {
+      _done?
+    }
+  end
+
+  # Wait until all tasks are consumed. The caller will be blocked until then.
+  def wait(what = :idle)
+    case what
+    when :done
+      until done?
+        @done_mutex.synchronize {
+          break if _done?
+
+          @done.wait @done_mutex
+        }
+      end
+
+    when :idle
+      until idle?
+        @done_mutex.synchronize {
+          break if _idle?
+
+          @done.wait @done_mutex
+        }
+      end
+    end
+
+    self
+  end
+
+  # Check if there are idle workers.
+  def idle?
+    @mutex.synchronize {
+      _idle?
+    }
+  end
+
+  # Add a task to the pool which will execute the block with the given
+  # argument.
+  #
+  # If no block is passed the default block will be used if present, an
+  # ArgumentError will be raised otherwise.
+  def process(*args, &block)
+    unless block || @block
+      raise ArgumentError, 'you must pass a block'
+    end
+
+    task = Task.new(self, *args, &(block || @block))
+
+    @mutex.synchronize {
+      raise 'unable to add work while shutting down' if shutdown?
+
+      @todo << task
+
+      if @waiting == 0 && @spawned < @max
+        spawn_thread
+      end
+
+      @cond.signal
+    }
+
+    task
+  end
+
+  alias << process
+
+  # Trim the unused threads, if forced threads will be trimmed even if there
+  # are tasks waiting.
+  def trim(force = false)
+    @mutex.synchronize {
+      if (force || @waiting > 0) && @spawned - @trim_requests > @min
+        @trim_requests += 1
+        @cond.signal
+      end
+    }
+
+    self
+  end
+
+  # Force #{trim}.
+  def trim!
+    trim true
+  end
+
+  # Shut down the pool instantly without finishing to execute tasks.
+  def shutdown!
+    @mutex.synchronize {
+      @shutdown = :now
+      @cond.broadcast
+    }
+
+    wake_up_timeout
+
+    self
+  end
+
+  # Shut down the pool, it will block until all tasks have finished running.
+  def shutdown
+    @mutex.synchronize {
+      @shutdown = :nicely
+      @cond.broadcast
+    }
+
+    until @workers.empty?
+      if worker = @workers.first
+        worker.join
+      end
+    end
+
+    if @timeout
+      @shutdown = :now
+
+      wake_up_timeout
+
+      @timeout.join
+    end
+  end
+
+  # Shutdown the pool after a given amount of time.
+  def shutdown_after(timeout)
+    Thread.new {
+      sleep timeout
+
+      shutdown
+    }
+  end
+
+  class << self
+    # If true, tasks will allow raised exceptions to pass through.
+    #
+    # Similar to Thread.abort_on_exception
+    attr_accessor :abort_on_exception
+
+    def cpu_count
+      Etc.nprocessors * 2
+    rescue
+      16
+    end
+  end
+
+  private
+  def timeout_for(task, timeout)
+    unless @timeout
+      spawn_timeout_thread
+    end
+
+    @mutex.synchronize {
+      @timeouts[task] = timeout
+
+      wake_up_timeout
+    }
+  end
+
+  def wake_up_timeout
+    if defined? @pipes
+      @pipes.last.write_nonblock 'x' rescue nil
+    end
+  end
+
+  def spawn_thread
+    @spawned += 1
+
+    thread = Thread.new {
+      loop do
+        task = @mutex.synchronize {
+          if @todo.empty?
+            while @todo.empty?
+              if @trim_requests > 0
+                @trim_requests -= 1
+
+                break
+              end
+
+              break if shutdown?
+
+              @waiting += 1
+
+              done!
+
+              if @idle_trim and @spawned > @min
+                check_time = Time.now + @idle_trim
+                @cond.wait @mutex, @idle_trim
+                @trim_requests += 1 if Time.now >= check_time && @spawned - @trim_requests > @min
+              else
+                @cond.wait @mutex
+              end
+
+              @waiting -= 1
+            end
+
+            break if @todo.empty? && shutdown?
+          end
+
+          @todo.shift
+        } or break
+
+        task.execute
+
+        break if @shutdown == :now
+
+        trim if auto_trim? && @spawned > @min
+      end
+
+      @mutex.synchronize {
+        @spawned -= 1
+        @workers.delete thread
+      }
+    }
+
+    @workers << thread
+
+    thread
+  end
+
+  def spawn_timeout_thread
+    @pipes   = IO.pipe
+    @timeout = Thread.new {
+      loop do
+        now     = Time.now
+        timeout = @timeouts.map {|task, time|
+          next unless task.started_at
+
+          now - task.started_at + task.timeout
+        }.compact.min unless @timeouts.empty?
+
+        readable, = IO.select([@pipes.first], nil, nil, timeout)
+
+        break if @shutdown == :now
+
+        if readable && !readable.empty?
+          readable.first.read_nonblock 1024
+        end
+
+        now = Time.now
+        @timeouts.each {|task, time|
+          next if !task.started_at || task.terminated? || task.finished?
+
+          if now > task.started_at + task.timeout
+            task.timeout!
+          end
+        }
+
+        @timeouts.reject! { |task, _| task.terminated? || task.finished? }
+
+        break if @shutdown == :now
+      end
+    }
+  end
+
+  def _done?
+    @todo.empty? and @waiting == @spawned
+  end
+
+  def _idle?
+    @todo.length < @waiting
+  end
+
+  def done!
+    @done_mutex.synchronize {
+      @done.broadcast if _done? or _idle?
+    }
+  end
+end

data/lib/balotelli/version.rb

@@ -1,3 +1,3 @@
 module Balotelli
-  VERSION = '0.4.2.1'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/test/lib/balotelli/base_test.rb

@@ -37,8 +37,8 @@ class BaseTest < Minitest::Test
 
   def test_it_matches_module_routes
     TestBot.register(Balotelli::Module::Asdf)
-    assert_equal TestBot.mod_match("asdf Yes, sir")[0], /yes/i
+    assert_equal TestBot.mod_match("asdf Yes, sir").pattern, /yes/i
     TestBot.register(Balotelli::Module::Xyz, "hoh")
-    assert_equal TestBot.mod_match("!hoh Si si")[0], /si/i
+    assert_equal TestBot.mod_match("!hoh Si si").pattern, /si/i
   end
 end

data/test/lib/balotelli/core/router_test.rb

@@ -20,7 +20,9 @@ class RouterTest < Minitest::Test
   def test_it_mathes_routes
     lam = -> { puts 'kk' }
     @route.on %r{ono}i, private: true, &lam
-    assert @route.match('onOmatopeja', true) == [%r{ono}i, [lam, @route]]
+    first_match = @route.match('onOmatopeja', true)
+    assert first_match.pattern == %r{ono}i
+    assert first_match.block == lam
     refute @route.match('onOmatopeja', false)
     @route.on 'asdf', &lam
     assert @route.match('asdf')

metadata

@@ -1,52 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: balotelli
 version: !ruby/object:Gem::Version
-  version: 0.4.2.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Marcin Henryk Bartkowiak
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-10-30 00:00:00.000000000 Z
+date: 2016-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  name: bundler
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 10.4.2
-  type: :development
+  name: rake
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 10.4.2
 - !ruby/object:Gem::Dependency
-  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.8.0
-  type: :development
+  name: minitest
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -76,9 +76,12 @@ files:
 - lib/balotelli/core/join.rb
 - lib/balotelli/core/kick.rb
 - lib/balotelli/core/priv_msg.rb
-- lib/balotelli/core/router.rb
+- lib/balotelli/core/router/action.rb
+- lib/balotelli/core/router/match.rb
+- lib/balotelli/core/router/router.rb
 - lib/balotelli/core/utils.rb
 - lib/balotelli/module/base.rb
+- lib/balotelli/thread/pool.rb
 - lib/balotelli/version.rb
 - test/lib/balotelli/asdf.rb
 - test/lib/balotelli/balotelli_helper_test.rb
@@ -94,7 +97,7 @@ homepage: https://github.com/mhib/balotelli
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -109,9 +112,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.4
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.6.6
+signing_key:
 specification_version: 4
 summary: Simple IRC bot framework
 test_files:
@@ -125,4 +128,3 @@ test_files:
 - test/lib/balotelli/special_one.rb
 - test/lib/balotelli/xyz.rb
 - test/test_helper.rb
-has_rdoc: 

data/lib/balotelli/core/router.rb

@@ -1,46 +0,0 @@
-module Balotelli
-  module Core
-    module Router
-      def setup_router
-        @routes = {}
-      end
-
-      def on(route, option = {}, &block)
-        raise 'no block given' if block.nil?
-
-        option[:private] = false if !option.key?(:private) || route == :join
-
-        if option[:private] == :both
-          on(route, option.clone.tap { |o| o[:private] = true }, &block)
-          on(route, option.clone.tap { |o| o[:private] = false }, &block)
-          return
-        end
-
-        @routes[route] ||= {}
-
-        if @routes[route][option[:private]] && !option[:force]
-          raise "Route #{route.inspect}, private: #{option[:private]} already exists"
-        end
-
-        @routes[route][option[:private]] = [block, self]
-      end
-
-      def match?(str, route)
-        case route
-        when Regexp
-          str =~ route
-        when String
-          str == route
-        when Symbol
-          str == route
-        end
-      end
-
-      def match(str, priv = false)
-        if (m = @routes.detect { |k, v| match?(str, k) && v[priv] })
-          [m[0], m[1][priv]]
-        end
-      end
-    end
-  end
-end