weechat 0.0.1

data/lib/weechat/callback.rb

@@ -0,0 +1,11 @@
+module Weechat
+  class Callback
+    def initialize(callback)
+      @callback = callback
+    end
+
+    def call(*args)
+      return Weechat::Utilities.evaluate_call {@callback.call(*args)}
+    end
+  end
+end

data/lib/weechat/color.rb

@@ -0,0 +1,41 @@
+module Weechat
+  # This class represents a Weechat color.
+  #
+  # It is created from a color name and saves that name and the color
+  # representation.
+  class Color
+    def self.from_weechat_config(v)
+      new(v)
+    end
+
+    # @param [String] name Name of the color
+    attr_reader :name
+    attr_reader :color
+    def initialize(name)
+      @name = name
+      @color = Weechat.color(name)
+    end
+
+    def to_s
+      @color
+    end
+    alias_method :to_str, :to_s
+
+    def to_weechat_config
+      @name
+    end
+
+    def ==(other)
+      @name == other.name
+    end
+  end
+
+  class << self
+    alias_method :old_color, :color
+    def color(name)
+      color = Weechat.old_color(name)
+      color.empty? ? nil : color
+    end
+    alias_method :get_color, :color
+  end
+end

data/lib/weechat/command.rb

@@ -0,0 +1,66 @@
+module Weechat
+  # Note: As opposed to plain WeeChat, we properly parse arguments
+  # given to a command, like a shell would.
+  class Command < Hook
+    attr_reader :command
+    attr_reader :description
+    attr_reader :args
+    attr_reader :args_description
+    attr_reader :completion
+    def initialize(*args, &callback)
+      raise "No callback specified" if callback.nil?
+      super
+
+      if args.size == 2
+        @command, @description = args
+      elsif args.size == 1 && args[0].is_a?(Hash)
+        @command, @description, @args, =
+        args[0].values_at(:command, :description, :args)
+
+        @completion = case args[0][:completion]
+                      when Array
+                        args[0][:completion].join(" || ")
+                      else
+                        args[0][:completion].to_s
+                      end
+
+        case args[0][:args_description]
+        when Hash
+          lines = []
+          color = Weechat.color("white")
+          reset = Weechat.color("reset")
+          max_length = args[0][:args_description].keys.map {|k| k.size}.max
+          args[0][:args_description].each do |key, value|
+            key = (" " * (max_length - key.size)) + key
+            lines << "#{color}#{key}: #{reset}#{value}"
+          end
+          @args_description = lines.join("\n")
+        when Array
+          @args_description = args[0][:args_description].join("\n")
+        else
+          @args_description = args[0][:args_description].to_s
+        end
+
+      else
+        raise "Please supply two arguments or a hash"
+      end
+
+      @command[0..0] = '' if @command[0..0] == '/'
+      @callback         = Callback.new(callback)
+      @ptr              = Weechat.hook_command(@command,
+                                       @description.to_s,
+                                       @args.to_s,
+                                       @args_description.to_s,
+                                       @completion.to_s,
+                                       "command_callback",
+                                       id.to_s)
+    end
+
+    class << self
+      def find_by_command(name)
+        @hooks.values.find {|h| h.command == name}
+      end
+      alias_method :find_by_name, :find_by_command
+    end
+  end
+end

data/lib/weechat/exceptions.rb

@@ -0,0 +1,31 @@
+module Weechat
+  module Exception
+    # This exception gets raised whenever one tries to read a property
+    # that doesn't exist.
+    #
+    # @see Buffer#get_property
+    # @see Window#get_property
+    class UnknownProperty < RuntimeError; end
+
+    # This exception gets raised whenever one tries to set a property
+    # that cannot be set.
+    #
+    # @see Buffer#set_property
+    # @see Window#set_property
+    class UnsettableProperty < RuntimeError; end
+
+    # This exception gets raised whenever one tries to set a property,
+    # supplying a value not suiting it.
+    class InvalidPropertyValue < RuntimeError; end
+
+    # This exception gets raised when one tries to create a buffer
+    # with the name of an already existing one.
+    #
+    # @see Buffer.create
+    class DuplicateBufferName < RuntimeError; end
+
+    class WEECHAT_RC_OK < ::Exception; end
+    class WEECHAT_RC_ERROR < ::Exception; end
+    class WEECHAT_RC_OK_EAT < ::Exception; end
+  end
+end

data/lib/weechat/hook.rb

@@ -0,0 +1,93 @@
+module Weechat
+  # Each hook as an unique ID, which is passed to the middle-man
+  # callback, which then calls the appropriate callback.
+  class Hook
+    include Weechat::Pointer
+
+    @hook_classes = [self]
+    def self.inherited(by)
+      by.init
+      @hook_classes << by
+    end
+
+    def self.hooks; @hooks; end
+
+    def self.init
+      @hooks = {}
+    end
+
+    init
+
+    attr_reader :id
+    attr_reader :callback
+    def initialize(*args)
+      @id       = self.class.compute_free_id
+      @ptr      = nil
+      @callback = nil
+      @hooked   = true
+      self.class.register(self)
+    end
+
+    def callback=(callback)
+      @callback = Callback.new(callback)
+    end
+
+    class << self
+      alias_method :hook, :new
+    end
+
+    # def to_s
+    #   @ptr
+    # end
+
+    def hooked?
+      @hooked
+    end
+
+    # low level unhooking, no checks whatsoever. Basically used for
+    # unhooking foreign hooks.
+    def self.unhook(ptr)
+      Weechat.unhook(ptr)
+    end
+
+    # Note: this also unhooks all hooks that were made using the API
+    def self.unhook_all
+      @hook_classes.each do |hook_class|
+        hook_class.hooks.values.each {|hook| hook.unhook}
+      end
+      Weechat.unhook_all
+    end
+
+    def unhook(_raise = true)
+      if _raise and !hooked?
+        raise "not hooked"
+      end
+
+      self.class.unhook(@ptr)
+      self.class.unregister(self)
+      @callback = nil
+      @hooked = false
+      true
+    end
+
+    def call(*args)
+      return @callback.call(*args)
+    end
+
+    def self.find_by_id(id)
+      @hooks[id.to_i]
+    end
+
+    def self.compute_free_id
+      (@hooks.keys.max || -1) + 1
+    end
+
+    def self.register(hook)
+      @hooks[hook.id] = hook
+    end
+
+    def self.unregister(hook)
+      @hooks.delete hook.id
+    end
+  end
+end

data/lib/weechat/hooks.rb

@@ -0,0 +1,8 @@
+module Weechat
+  module Hooks
+  end
+end
+
+require 'weechat/hooks/command_run.rb'
+require 'weechat/hooks/print.rb'
+require 'weechat/hooks/config.rb'

data/lib/weechat/hooks/command_run.rb

@@ -0,0 +1,30 @@
+module Weechat
+  module Hooks
+    class CommandRun < Hook
+      # Returns a new instance of CommandRunHook
+      #
+      # @param [Boolean] also_arguments If true, two hooks will be
+      #   made, one for "$command" and one for "$command *", matching
+      #   both calls with and without arguments
+      def initialize(command, also_arguments = false, &callback)
+        super
+        @command  = if command.is_a? Command
+                      command.command
+                    else
+                      command.to_s
+                    end
+
+        @callback = Callback.new(callback)
+        @ptr      = Weechat.hook_command_run(@command, "command_run_callback", id.to_s)
+        if also_arguments
+          @ptr2 = Weechat.hook_command_run("#@command *", "command_run_callback", id.to_s)
+        end
+      end
+
+      def unhook(*args)
+        super
+        self.class.unhook(@ptr2) if @ptr2
+      end
+    end
+  end
+end

data/lib/weechat/hooks/config.rb

@@ -0,0 +1,11 @@
+module Weechat
+  module Hooks
+    class Config < Hook
+      def initialize(option, &callback)
+        super
+        @callback = Callback.new(callback)
+        @ptr      = Weechat.hook_config(option, "config_callback", id.to_s)
+      end
+    end
+  end
+end

data/lib/weechat/hooks/print.rb

@@ -0,0 +1,14 @@
+module Weechat
+  module Hooks
+    class Print < Hook
+      def initialize(buffer='*', tags = [], message = '', strip_colors = false, &callback)
+        super
+        buffer = buffer.ptr if buffer.respond_to?(:ptr)
+        tags = tags.join(",")
+        strip_colors = Weechat.bool_to_integer(strip_colors)
+        @callback = Callback.new(callback)
+        @ptr      = Weechat.hook_print(buffer, tags, message, strip_colors, "print_callback", id.to_s)
+      end
+    end
+  end
+end

data/lib/weechat/info.rb

@@ -0,0 +1,14 @@
+module Weechat
+  # Note: As opposed to plain WeeChat, we properly parse arguments
+  # given to a command, like a shell would.
+  class Info < Hook
+    attr_reader :name
+    attr_reader :description
+    def initialize(name, description, &callback)
+      super
+      @name, @description = name, description
+      @callback         = callback
+      @ptr              = Weechat.hook_info(name, description, "info_callback", id.to_s)
+    end
+  end
+end

data/lib/weechat/infolist.rb

@@ -0,0 +1,32 @@
+module Weechat
+  class Infolist
+    def self.parse(type, ptr="", arguments="")
+      infolist_ptr = Weechat.infolist_get(type, ptr, arguments)
+      ret = []
+      while Weechat.infolist_next(infolist_ptr) > 0
+        h = { }
+        str = Weechat.infolist_fields(infolist_ptr)
+        str.split(/,/).each do |item|
+          type, name = item.split(/:/)
+          h[name.to_sym] = case type
+                           when 'p'
+                             Weechat.infolist_pointer(infolist_ptr, name)
+                           when 'i'
+                             Weechat.infolist_integer(infolist_ptr, name)
+                           when 's'
+                             Weechat.infolist_string(infolist_ptr, name)
+                           when 'b'
+                             # FIXME: not exposed to script API yet.
+                             # Weechat.infolist_buffer(infolist_ptr, name)
+                           when 't'
+                             Weechat.infolist_time(infolist_ptr, name)
+                           end
+        end
+
+        ret.push h
+      end
+      Weechat.infolist_free(infolist_ptr)
+      return ret
+    end
+  end
+end

data/lib/weechat/input.rb

@@ -0,0 +1,45 @@
+  # :input=>1,
+  # :input_buffer_alloc=>256,
+  # :input_buffer_length=>0,
+  # :input_buffer_1st_display=>0,
+
+module Weechat
+  class Input
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    # Returns the current content of the input line.
+    def to_s
+      @buffer.get_property("input")
+    end
+    alias_method :text, :to_s
+    alias_method :content, :to_s
+
+    # Sets the content of the input line.
+    def text=(val)
+      @buffer.set_property("input", val)
+    end
+    alias_method :content=, "text="
+
+    def size
+      @buffer.input_buffer_size
+    end
+
+    def pos
+      @buffer.input_buffer_pos
+    end
+
+    def get_unknown_commands=(val)
+      @buffer.set_property("input_get_unknown_commands", val)
+    end
+
+    # Returns true if unknown commands are being sent as plain text to the buffer.
+    #
+    # @return [Boolean]
+    def get_unknown_commands?
+      @buffer.get_property("input_get_unknown_commands")
+    end
+    alias_method :get_unknown_commands, :get_unknown_commands?
+  end
+end

data/lib/weechat/line.rb

@@ -0,0 +1,60 @@
+module Weechat
+  # This class encapsulates lines like they're printed in WeeChat.
+  #
+  # A line usually consists of a prefix (doesn't have to) and a text.
+  # One can access both parts individually, or call methods on both
+  # combined, which means that the method will be first called on the
+  # prefix and then on the text part.
+  class Line
+    class << self
+      def parse(line)
+        parts = line.split("\t")
+        case parts.size
+        when 0
+          parts = ["", ""]
+        when 1
+          parts.unshift ""
+        when 2
+        else
+          parts = [parts[0], parts[1..-1].join("\t")]
+        end
+
+        new(*parts)
+      end
+
+      def from_hash(h)
+        prefix  = h.delete(:prefix)
+        message = h.delete(:message)
+        new(prefix, message, h)
+      end
+    end
+
+    %w(y date date_printed str_time tags_count tags displayed highlight last_read_line).each do |prop|
+      define_method(prop) { details[prop] }
+      define_method("#{prop}=") {|v| details[prop] = v }
+    end
+
+    attr_accessor :prefix
+    attr_accessor :message
+    attr_reader   :details
+    def initialize(prefix, message, details = {})
+      @prefix, @message, @details = prefix, message, details
+    end
+
+    def to_s
+      join("\t")
+    end
+
+    def join(delimiter)
+      [prefix.empty? ? nil : prefix, message].compact.join(delimiter)
+    end
+
+    def method_missing(m, *args)
+      rets = []
+      [prefix, message].each do |var|
+        rets << var.__send__(m, *args) rescue var
+      end
+      [rets[0].empty? ? nil : rets[0], rets[1]].compact.join("\t")
+    end
+  end
+end