blur 1.8.6 → 2.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 37ce3e4e8a98062906f53c98b5baa1b798fe089b
-  data.tar.gz: 4406a27f69812c4b181949a2f2106f55e663c0a9
+SHA256:
+  metadata.gz: 6c4add65cc3b256a41629f69bb62065d523f60a5cd934d8b4c1045b326113ce6
+  data.tar.gz: f55fbec4a5863465d61f110ceeb1fe3b7f89d6a6d9fc659ac30907ef7921e510
 SHA512:
-  metadata.gz: f3f6a46334910c4be692cfa1c56587613bc981dcaeb8be10b5a931951a10e8a1e20607a66c8afea0837f066648591d3b1e64675388633352f5834e11d7f292ec
-  data.tar.gz: 1aac96349671e30b299bc4fdb92b8a6df71d57e93b36361ee036780ca37b713a41d6ecdf0b831cad43dbb9ee92128d6c9bf3e14aa8bad3aaa7b1a3bacf6e966e
+  metadata.gz: 05bc91b4a941bfe212e42d9a0c56d6e7969aa01e9cde2fa86946dc0f24244b462de299683d06875e2ea3bdad7e32280afd869cac6874d0fd7ef1f3d9bfa10d63
+  data.tar.gz: 9ca64c3952d10ccb6c9dce8a51723da4b81643b46d2090aa72b72886965d8973da540a6b9da477254493baf99d1ad2174b7c5129557f963fb08db892ce42a632

data/README.md

@@ -1,35 +1,21 @@
-Blur
-====
+# Blur
 Blur is an event-driven IRC-framework written in and for Ruby.
 
 There are a bunch of other well-written, well-running IRC libraries made for
 Ruby, but for me, they don't quite cut it as **the** library I wanted to use for
 my IRC services. That's how Blur came to be.
 
-Blur scales. A lot.
+[![Build Status](https://travis-ci.org/mkroman/blur.svg?branch=isupport)](https://travis-ci.org/mkroman/blur)
 
-When I stresstested the library on my network, I ended up throttling my VDSL
-connection before Blur even broke a sweat - albeit I only have 20/2.
+## Getting started
 
-I managed to connect with 5000 clones before it couldn't resolve the hostname
-anymore, while this is an excellent feature, I would not suggest doing it.
 
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/mkroman/blur/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
-[![Build Status](https://travis-ci.org/mkroman/blur.svg?branch=isupport)](https://travis-ci.org/mkroman/blur)
-[![Dependency Status](https://gemnasium.com/mkroman/blur.svg)](https://gemnasium.com/mkroman/blur)
+## Documentation
 
-Features
---------
-  * SSL/TLS encryption
-  * Connect to multiple networks
-  * FiSH (channel-wide) encryptions
-  * Non-blocking connections (no threading)
-  * Extensible with scripts, (re)loadable during runtime
-  * Modular, makes it a piece of cake to extend its IRC-capability
+Documentation is available [here](https://www.rubydoc.info/github/mkroman/blur)
 
-Future Plans
-------------
-  * DCC File-transfers
-  * DH1080 Key-Exchange
-  * ISupport implementation
-  * Better event-handling in scripts
+## Features
+  * SSL/TLS connections
+  * Connect to multiple networks in a single process
+  * Non-blocking connections (no threading just for networking)
+  * Extensible with scripts that are (re)loadable during runtime

data/executables/blur

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../library/blur'
+
+require 'optparse'
+
+options = {
+  verbose: false,
+  config_path: 'config.yml'
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [-c <config>] [-e <env>]"
+
+  opts.separator ''
+  opts.separator 'Specific options:'
+
+  opts.on '-v', '--[no-]verbose', 'Enable verbose logging' do |verbose|
+    options[:verbose] = verbose
+  end
+
+  opts.on '-c', '--config=PATH', 'Set the configuration file' do |config_path|
+    options[:config_path] = config_path
+  end
+
+  opts.on '-eENV', '--environment=ENV', 'Environment to run in' do |environment|
+    options[:environment] = environment
+  end
+
+  opts.on '-r', '--require LIBRARY', 'Require the LIBRARY before running' do |lib|
+    require lib
+  end
+
+  opts.on_tail '-h', '--help', 'Show this message' do
+    puts opts
+    exit
+  end
+end.parse!
+
+begin
+  require 'blur'
+rescue LoadError => e
+  puts 'Ruby was unable to load the blur library!'
+  puts
+  puts "Please ensure that you've installed it using the following command:"
+  puts 'gem install blur'
+  raise e
+end
+
+puts "Blur #{Blur.version}"
+
+config_path = File.expand_path options[:config_path]
+puts "Loading configuration file `#{config_path}' .."
+
+raise "Configuration file `#{config_path}' is not readable" unless File.readable? config_path
+
+EM.run do
+  @client = Blur::Client.new options
+  @client.connect
+end
+
+# vim: syntax=ruby

data/library/blur/callbacks.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Blur
+  module Callbacks
+    # Get a list of callbacks registered.
+    #
+    # @returns [Array] the list of callbacks
+    def callbacks
+      @callbacks ||= {}
+    end
+
+    # Emit a new event with given arguments.
+    #
+    # @param name [Symbol] The event name.
+    # @param args [optional, Array] The list of arguments to pass.
+    # @return [true, false] True if any callbacks were invoked, nil otherwise
+    def emit name, *args
+      # Trigger callbacks in scripts before triggering events in the client.
+      notify_scripts name, *args
+
+      matching_callbacks = callbacks[name]
+      return false unless matching_callbacks&.any?
+
+      matching_callbacks.each { |callback| callback.call *args }
+    end
+
+    # Add a new event callback.
+    #
+    # @param name [Symbol] The event name.
+    # @yield [args, ...] The arguments passed from #emit.
+    def on name, &block
+      (callbacks[name] ||= []) << block
+    end
+
+    protected
+
+    def notify_scripts name, *args
+      scripts = @scripts.values.select { |script| script.class.events.key? name }
+      scripts.each do |script|
+        script.class.events[name].each do |method|
+          if method.is_a? Proc
+            method.call script, *args
+          else
+            script.__send__ method, *args
+          end
+        end
+      rescue StandardError => e
+        warn "#{e.class}: #{e.message}"
+        warn nil, 'Backtrace:', '---', e.backtrace
+      end
+    end
+  end
+end

data/library/blur/channel.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Blur
+  # The +Channel+ class is used for encapsulating a channel and its properties.
+  #
+  # Users inside the channel is stored in the {#channels} attribute.
+  #
+  # Modes can be set for a channel, but Blur is not
+  # {http://www.irc.org/tech_docs/005.html ISupport}-compliant yet.
+  #
+  # @todo make so that channels *and* users belongs to the network, and not
+  #   like now where the user belongs to the channel, resulting in multiple
+  #   user instances.
+  class Channel
+    # @return [String] the channels name.
+    attr_accessor :name
+    # @return [String] the channels topic.
+    attr_accessor :topic
+    # @return [Array] list of references to users in the channel.
+    attr_accessor :users
+    # @return [String] all the modes set on the channel.
+    attr_accessor :modes
+    # @return [Network] a reference to the network.
+    attr_accessor :network
+
+    # Instantiate a user with a nickname, a network and a user list.
+    def initialize name, network = nil
+      @name    = name
+      @users   = []
+      @modes   = ''
+      @network = network
+    end
+
+    # Merge the channels mode corresponding to the leading character (+ or -).
+    #
+    # @param [String] modes the modes to merge with.
+    def merge_modes modes
+      addition = true
+
+      modes.each_char do |char|
+        case char
+        when '+'
+          addition = true
+        when '-'
+          addition = false
+        else
+          addition ? @modes.concat(char) : @modes.delete!(char)
+        end
+      end
+    end
+
+    # Send a message to the channel.
+    #
+    # @param [String] message the message to send.
+    def say message
+      @network.say self, message
+    end
+
+    # Convert it to a debug-friendly format.
+    def inspect
+      "#<#{self.class.name}:0x#{object_id.to_s 16} " \
+        "@name=#{@name.inspect} " \
+        "@topic=#{@topic.inspect} " \
+        "@users=#{@users.inspect}>"
+    end
+
+    # Called when YAML attempts to save the object, which happens when a
+    # scripts cache contains this user and the script is unloaded.
+    def to_yaml options = {}
+      @name.to_yaml options
+    end
+
+    # Get the channels name.
+    def to_s
+      @name
+    end
+  end
+end

data/library/blur/client.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'blur/handling'
+require_relative './handling'
 
 module Blur
   # The +Client+ class is the controller of the low-level access.
@@ -8,150 +8,208 @@ module Blur
   # It stores networks, scripts and callbacks, and is also encharge of
   # distributing the incoming commands to the right networks and scripts.
   class Client
-    include Handling, Logging
-    
-    # @return [Array] the options that is passed upon initialization.
-    attr_accessor :options
-    # @return [Array] a list of scripts that is loaded during runtime.
-    attr_accessor :scripts
+    include Callbacks
+    include Handling
+
+    # The default environment.
+    ENVIRONMENT = ENV['BLUR_ENV'] || 'development'
+
+    # The default configuration.
+    DEFAULT_CONFIG = {
+      'blur' => {
+        'cache_dir' => 'cache/',
+        'scripts_dir' => 'scripts/',
+        'networks' => []
+      },
+      'scripts' => {}
+    }.freeze
+
     # @return [Array] a list of instantiated networks.
     attr_accessor :networks
-    
+    # @return [Hash] client configuration.
+    attr_accessor :config
+    # @return [Hash] initialized scripts.
+    attr_accessor :scripts
+    # @return [Boolean] whether verbose logging is enabled.
+    attr_accessor :verbose
+    # @return [String] the path to the currently used config file.
+    attr_accessor :config_path
+
     # Instantiates the client, stores the options, instantiates the networks
     # and then loads available scripts.
     #
     # @param [Hash] options the options for the client.
-    # @option options [Array] networks list of hashes that contain network
-    #   options.
-    def initialize options
-      @options   = options
-      @scripts   = []
-      @networks  = []
-      @callbacks = {}
-      
-      @networks = @options[:networks].map {|options| Network.new options }
-      
-      load_scripts
+    # @option options [String] :config_path path to a configuration file.
+    # @option options [String] :environment the client environment.
+    def initialize options = {}
+      @scripts = {}
+      @networks = []
+      @config_path = options[:config_path]
+      @environment = options[:environment] || ENVIRONMENT
+      @verbose = options[:verbose] == true
+
+      raise ConfigError, 'missing config file path in :config_path option' unless @config_path
+
+      load_config!
+
+      networks = @config['blur']['networks']
+
+      if networks&.any?
+        networks.each do |network_options|
+          @networks.<< Network.new network_options, self
+        end
+      end
+
       trap 2, &method(:quit)
     end
-    
+
     # Connect to each network available that is not already connected, then
     # proceed to start the run-loop.
     def connect
-      networks = @networks.select {|network| not network.connected? }
-      
-      EventMachine.run do
-        EventMachine.error_handler{|e| p e }
-
-        networks.each do |network|
-          network.delegate = self
-          network.connect
-        end
+      networks = @networks.reject &:connected?
+
+      load_scripts!
+      networks.each &:connect
+
+      EventMachine.error_handler do |exception|
+        message_pattern = /^.*?:(\d+):/
+        backtrace = exception.backtrace.first
+        error_line = backtrace.match(message_pattern)[1].to_i + 1
+
+        puts "#{exception.message} on line #{error_line.to_s}"
+        puts exception.backtrace.join "\n"
       end
     end
-    
+
     # Is called when a command have been received and parsed, this distributes
     # the command to the loader, which then further distributes it to events
     # and scripts.
     #
     # @param [Network] network the network that received the command.
     # @param [Network::Command] command the received command.
-    def got_command network, command
-      log "#{'←' ^ :green} #{command.name.to_s.ljust(8, ' ') ^ :light_gray} #{command.params.map(&:inspect).join ' '}"
-      name = :"got_#{command.name.downcase}"
-      
-      if respond_to? name
-        __send__ name, network, command
-      end
-    end
-    
-    # Searches for scripts in working_directory/scripts and then loads them.
-    def load_scripts
-      # Load script extensions.
-      Script.load_extensions!
-
-      # Load the scripts.
-      script_path = File.dirname $0
-      
-      Dir.glob("#{script_path}/scripts/*.rb").each do |path|
-        script = Script.new path
-        script.__client = self
-        
-        @scripts << script
-      end
-    end
-    
-    # Unload all scripts gracefully that have been loaded into the client.
-    #
-    # @see Script#unload!
-    def unload_scripts
-      # Unload script extensions.
-      Script.unload_extensions!
+    def got_message network, message
+      puts "← #{message.command.to_s.ljust(8, ' ')} #{message.parameters.map(&:inspect).join ' '}" if @verbose
 
-      @scripts.each do |script|
-        script.unload!
-      end.clear
+      name = :"got_#{message.command.downcase}"
+
+      __send__ name, network, message if respond_to? name
     end
 
     # Called when a network connection is either closed, or terminated.
     def network_connection_closed network
       emit :connection_close, network
     end
-    
+
     # Try to gracefully disconnect from each network, unload all scripts and
     # exit properly.
     #
     # @param [optional, Symbol] signal The signal received by the system, if any.
-    def quit signal = :SIGINT
-      unload_scripts
-      
+    def quit _signal = :SIGINT
       @networks.each do |network|
-        network.transmit :QUIT, "Got SIGINT?"
+        network.transmit :QUIT, 'Got SIGINT?'
         network.disconnect
       end
-      
+
       EventMachine.stop
     end
-    
-  private    
-    # Finds all callbacks with name `name` and then calls them.
-    # It also sends `name` to {Script} if the script responds to `name`, to all
-    #   available scripts.
+
+    # Reloads configuration file and scripts.
+    def reload!
+      EM.schedule do
+        unload_scripts!
+        load_config!
+        load_scripts!
+
+        yield if block_given?
+      end
+    end
+
+    # Loads all scripts in the script directory.
+    def load_scripts!
+      scripts_dir = File.expand_path @config['blur']['scripts_dir']
+      script_file_paths = Dir.glob File.join scripts_dir, '*.rb'
+
+      # Sort the script file paths by file name so they load by alphabetical
+      # order.
+      #
+      # This will make it possible to create a script called '10_database.rb'
+      # which will be loaded before '20_settings.rb' and non-numeric prefixes
+      # will be loaded after that.
+      script_file_paths = script_file_paths.sort do |a, b|
+        File.basename(a) <=> File.basename(b)
+      end
+
+      script_file_paths.each { |script_path| load_script_file script_path }
+
+      initialize_superscripts
+
+      emit :scripts_loaded
+    end
+
+    # Loads the given +file_path+ as a Ruby script, wrapping it in an anonymous
+    # module to protect our global namespace.
     #
-    # @param [Symbol] name the corresponding event-handlers name.
-    # @param [...] args Arguments that is passed to the event-handler.
-    # @private
-    def emit name, *args
-      EM.defer do
-        @callbacks[name].each do |callback|
-          begin
-            callback.call *args
-          rescue Exception => e
-            log.error "Callback `#{name}' threw an exception - #{exception.message ^ :bold} on line #{exception.line.to_s ^ :bold}"
-            puts exception.backtrace.join "\n"
-          end
-        end if @callbacks[name]
-
-        scripts = @scripts.select{|script| script.__emissions.include? name }
-        scripts.each do |script|
-          begin
-            script.__send__ name, *args
-          rescue Exception => exception
-            log.error "#{File.basename(script.__path) << " - " << exception.message ^ :bold} on line #{exception.line.to_s ^ :bold}"
-            puts exception.backtrace.join "\n"
-          end
-        end
+    # @param [String] file_path the path to the ruby script.
+    #
+    # @raise [Exception] if there was any problems loading the file
+    def load_script_file file_path
+      load file_path, true
+    rescue Exception => e
+      warn "The script `#{file_path}' failed to load"
+      warn "#{e.class}: #{e.message}"
+      warn ''
+      warn 'Backtrace:', '---', e.backtrace
+    end
+
+    # Instantiates each +SuperScript+ in the +Blur.scripts+ list by manually
+    # allocating an instance and calling #initialize on it, then the instance is
+    # stored in +Client#scripts+.
+    #
+    # @raise [Exception] any exception that might occur in any scripts'
+    #   #initialize method.
+    def initialize_superscripts
+      scripts_config = @config['scripts']
+      scripts_cache_dir = File.expand_path @config['blur']['cache_dir']
+
+      Blur.scripts.each do |name, superscript|
+        script = superscript.allocate
+        script.cache = ScriptCache.load name, scripts_cache_dir
+        script.config = scripts_config.fetch name, {}
+        script._client_ref = self
+        script.send :initialize
+
+        @scripts[name] = script
       end
     end
-    
-    # Stores the block as an event-handler with name `name`.
+
+    # Unloads initialized scripts and superscripts.
+    #
+    # This method will call #unloaded on the instance of each loaded script to
+    # give it a chance to clean up any resources.
+    def unload_scripts!
+      @scripts.each do |_name, script|
+        script.__send__ :unloaded if script.respond_to? :unloaded
+      end.clear
+
+      Blur.reset_scripts!
+    end
+
+    private
+
+    # Load the user-specified configuration file.
     #
-    # @param [Symbol] name the corresponding event-handlers name.
-    # @param [Block] block the event-handlers block that serves as a trigger.
-    # @private
-    def catch name, &block
-      (@callbacks[name] ||= []) << block
+    # @returns true on success, false otherwise.
+    def load_config!
+      config = YAML.load_file @config_path
+
+      unless config.key? @environment
+        raise ClientError, "No configuration found for specified environment `#{@environment}'"
+      end
+
+      @config = config[@environment]
+      @config.deeper_merge! DEFAULT_CONFIG
+
+      emit :config_load
     end
-    
   end
 end