blur 1.8.6 → 2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37ce3e4e8a98062906f53c98b5baa1b798fe089b
-  data.tar.gz: 4406a27f69812c4b181949a2f2106f55e663c0a9
+  metadata.gz: 976b042f31815f52310f120ccc9c2a3082fb0a93
+  data.tar.gz: 5b9a9266a92d19dd4b90494abe093dd26548b308
 SHA512:
-  metadata.gz: f3f6a46334910c4be692cfa1c56587613bc981dcaeb8be10b5a931951a10e8a1e20607a66c8afea0837f066648591d3b1e64675388633352f5834e11d7f292ec
-  data.tar.gz: 1aac96349671e30b299bc4fdb92b8a6df71d57e93b36361ee036780ca37b713a41d6ecdf0b831cad43dbb9ee92128d6c9bf3e14aa8bad3aaa7b1a3bacf6e966e
+  metadata.gz: 6630820a3dba98df19c1995971b0fab17187226356306f1354c19ea71819748bf6cb85299efddf556ffe101aec19d2a073ea8564e06655f774bc5e53d5a3e340
+  data.tar.gz: 7d7b87e2dc3952bcd6ce7b1360dc2f7e7cb88e795f61fcba3898d5713f42ebc144bc437dcf66daa4f1dedb93e87f0de01f409fadc26e54577a500f9e90105f8b

data/README.md

@@ -6,15 +6,6 @@ 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.
-
-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.
-
-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)
 
@@ -22,7 +13,6 @@ 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
@@ -31,5 +21,4 @@ Future Plans
 ------------
   * DCC File-transfers
   * DH1080 Key-Exchange
-  * ISupport implementation
   * Better event-handling in scripts

data/executables/blur

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$:.unshift File.join __dir__, '../library'
+
+require 'optparse'
+
+options = {
+  verbose: false,
+  environment: 'development',
+  config_path: 'config.yml'
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #$0 [-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 => exception
+  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 exception
+  exit 1
+end
+
+config_path = File.expand_path options[:config_path]
+unless File.readable? config_path
+  fail "Configuration file `#{config_path}' is not readable"
+  exit 1
+end
+
+@client = Blur::Client.new options
+@client.connect
+
+# vim: syntax=ruby

data/library/blur.rb

@@ -1,36 +1,61 @@
 # encoding: utf-8
 
-require 'pp'
 require 'yaml'
-require 'majic'
 require 'socket'
 require 'ostruct'
 require 'openssl'
+
+require 'deep_merge/rails_compat'
 require 'eventmachine'
+require 'ircparser'
 
 # Require all library files.
+require 'blur/logging'
 require 'blur/version'
-require 'blur/client'
-require 'blur/evaluable'
-require 'blur/script/dsl'
-require 'blur/extension'
+require 'blur/callbacks'
 require 'blur/script'
+require 'blur/script_cache'
 require 'blur/network'
-require 'blur/encryption'
+require 'blur/client'
+require 'blur/user'
+require 'blur/channel'
 require 'blur/enhancements'
-require 'blur/script/cache'
-require 'blur/network/user'
-require 'blur/network/channel'
-require 'blur/network/command'
 require 'blur/network/isupport'
 require 'blur/network/connection'
-require 'blur/script/commands'
 
 # Blur is a very modular IRC-framework for ruby.
 #
 # It allows the developer to extend it in multiple ways.
 # It can be by handlers, scripts, communications, and what have you.
 module Blur
+  # Contains all superscript classes for scripts that may be used.
+  @@scripts = {}
+
+  # Creates a new superscript class and inserts it into the list of scripts.
+  def self.Script name, *args, &block
+    klass = Class.new SuperScript
+    klass.name = name
+    klass.events = {}
+    klass.class_exec &block
+    klass.init
+
+    @@scripts[name] = klass
+  end
+
+  # Gets all superscript classes.
+  def self.scripts
+    @@scripts
+  end
+
+  # Resets all scripts.
+  #
+  # This method will call `deinit` on each script class before removing them to
+  # give them a chance to clean up.
+  def self.reset_scripts!
+    @@scripts.each_value &:deinit
+    @@scripts.clear
+  end
+
   # Instantiates a client with given options and then makes the client instance
   # evaluate the given block to form a DSL.
   #

data/library/blur/callbacks.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Blur
+  module Callbacks
+    # Our list of callbacks.
+    @@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.
+    def emit name, *args
+      EM.defer do
+        notify_scripts name, *args
+      end
+
+      if (callbacks = @@callbacks[name]) and callbacks.any?
+        EM.defer do
+          callbacks.each{|callback| callback.call *args }
+        end
+      end
+    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|
+        begin
+          script.class.events[name].each do |method|
+            if method.is_a? Proc
+              method.call script, *args
+            else
+              script.__send__ method, *args
+            end
+          end
+        rescue => exception
+          STDERR.puts "#{exception.class}: #{exception.message}"
+          STDERR.puts nil, 'Backtrace:', '---', exception.backtrace
+        end
+      end
+    end
+  end
+end

data/library/blur/channel.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+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   = String.new
+      @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#{self.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

@@ -8,44 +8,72 @@ 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 Callbacks
     include Handling, Logging
+
+    # Client error.
+    Error = Class.new StandardError
+
+    # 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] the options that is passed upon initialization.
-    attr_accessor :options
-    # @return [Array] a list of scripts that is loaded during runtime.
-    attr_accessor :scripts
     # @return [Array] a list of instantiated networks.
     attr_accessor :networks
-    
+    # @return [Hash] client configuration.
+    attr_accessor :config
+    # @return [Hash] initialized scripts.
+    attr_accessor :scripts
+
+    attr_accessor :verbose
+
     # 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]
+      @verbose = options[:verbose] == true
+
+      load_config!
+
+      networks = @config['blur']['networks']
+
+      if networks and 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? }
+      networks = @networks.reject &:connected?
       
       EventMachine.run do
-        EventMachine.error_handler{|e| p e }
+        load_scripts!
+        networks.each &:connect
 
-        networks.each do |network|
-          network.delegate = self
-          network.connect
+        EventMachine.error_handler do |exception|
+          log.error "#{exception.message ^ :bold} on line #{exception.line.to_s ^ :bold}"
+          puts exception.backtrace.join "\n"
         end
       end
     end
@@ -56,43 +84,17 @@ module Blur
     #
     # @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
+    def got_message network, message
+      if @verbose
+        log "#{'←' ^ :green} #{message.command.to_s.ljust(8, ' ') ^ :light_gray} #{message.parameters.map(&:inspect).join ' '}"
       end
-    end
-    
-    # Searches for scripts in working_directory/scripts and then loads them.
-    def load_scripts
-      # Load script extensions.
-      Script.load_extensions!
+      name = :"got_#{message.command.downcase}"
 
-      # 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
+      if respond_to? name
+        __send__ name, network, message
       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!
-
-      @scripts.each do |script|
-        script.unload!
-      end.clear
-    end
-
     # Called when a network connection is either closed, or terminated.
     def network_connection_closed network
       emit :connection_close, network
@@ -103,8 +105,6 @@ module Blur
     #
     # @param [optional, Symbol] signal The signal received by the system, if any.
     def quit signal = :SIGINT
-      unload_scripts
-      
       @networks.each do |network|
         network.transmit :QUIT, "Got SIGINT?"
         network.disconnect
@@ -112,46 +112,77 @@ module Blur
       
       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.
-    #
-    # @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
+
+    # 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']
+      scripts_cache_dir = File.expand_path @config['blur']['cache_dir']
+
+      Dir.glob File.join(scripts_dir, '*.rb') do |file|
+        begin
+          load file, true
+        rescue Exception => e
+          STDERR.puts "The script `#{file}' failed to load"
+          STDERR.puts "#{e.class}: #{e.message}"
+          STDERR.puts
+          STDERR.puts 'Backtrace:', '---', e.backtrace
         end
       end
+
+      scripts_config = @config['scripts']
+
+      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
+
+      emit :scripts_loaded
     end
-    
-    # Stores the block as an event-handler with name `name`.
+
+    # Unloads initialized scripts and superscripts.
     #
-    # @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
+    # 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.
+    #
+    # @returns true on success, false otherwise.
+    def load_config!
+      config = YAML.load_file @config_path
+
+      if config.key? @environment
+        @config = config[@environment]
+        @config.deeper_merge! DEFAULT_CONFIG
+
+        emit :config_load
+      else
+        raise Error, "No configuration found for specified environment `#{@environment}'"
+      end
     end
-    
   end
 end