weechat 0.0.1

data/lib/weechat/modifier.rb

@@ -0,0 +1,24 @@
+module Weechat
+  # Note: As opposed to plain WeeChat, we properly parse arguments
+  # given to a command, like a shell would.
+  class Modifier < Hook
+    attr_reader :modifier
+    def initialize(modifier, &callback)
+      super
+      @modifier = modifier.to_s
+      @callback         = callback # we do not use the Callback class
+                                   # here because we need the return
+                                   # value of the callback
+      @ptr              = Weechat.hook_modifier(modifier, "modifier_callback", id.to_s)
+    end
+
+    alias_method :exec, :call
+
+    class << self
+      def call(modifier, data, string)
+        Weechat.hook_modifier_exec(modifier.to_s, data.to_s, string.to_s)
+      end
+      alias_method :exec, :call
+    end
+  end
+end

data/lib/weechat/option.rb

@@ -0,0 +1,46 @@
+module Weechat
+  class Option < Blankslate
+    @options = [] # we can't use a Hash because hashing
+    # blankslate... breaks things
+
+
+    def self.options
+      @options
+    end
+
+    def initialize(config, option)
+      self.__class__.options << [config, option, self]
+      @old_obj     = config.__get(option)
+      @config = config
+      @option = option
+      @frozen      = false
+    end
+
+    def __freeze__
+      @frozen = true
+    end
+
+    def method_missing(m, *args, &block)
+      if @frozen
+        obj = @old_obj
+      else
+        obj = @config.__get(@option)
+      end
+      ret = obj.__send__(m, *args, &block)
+
+      if (@old_obj != obj) && !@frozen
+        @config.set!(@option, obj)
+      end
+
+      unless @frozen
+        begin
+          @old_obj = obj.dup
+        rescue TypeError
+          @old_obj = obj
+        end
+      end
+
+      ret
+    end
+  end
+end

data/lib/weechat/plugin.rb

@@ -0,0 +1,106 @@
+module Weechat
+  # == Gettable properties
+  #
+  # [filename]    Filename of the plugin
+  # [handle]      ?
+  # [name]        Name of the plugin
+  # [description] Description of the plugin
+  # [author]      Author of the plugin
+  # [version]     Version of the plugin
+  # [license]     Licence of the plugin
+  # [charset]     ?
+  # [debug?]      ?
+  class Plugin
+    include Weechat::Pointer
+    extend Weechat::Properties
+
+    @mappings = {
+      :licence => :license,
+      :debug?  => :debug,
+    }
+
+    @transformations = {
+      [:debug] => lambda {|v| Weechat.integer_to_bool(v) },
+    }
+
+    init_properties
+
+    class << self
+      def find_by_name(name)
+        if name.nil? or name.empty? or name == "core"
+          return Plugin.new("")
+        end
+        plugins.find {|plugin| plugin.name == name}
+      end
+      alias_method :find, :find_by_name
+
+      def plugins
+        plugins = [Plugin.new("")]
+        Weechat::Infolist.parse("plugin").each do |plugin|
+          plugins << Plugin.new(plugin[:pointer])
+        end
+        plugins
+      end
+      alias_method :all, :plugins
+
+      # Loads a plugin.
+      #
+      # @return [void]
+      def load(name)
+        Weechat.exec("/plugin load #{name}")
+      end
+
+      # Reloads all plugins.
+      #
+      # Note: This will not reload the ruby plugin.
+      #
+      # @return [Array<Plugin>] All plugins that have been reloaded.
+      def reload_all
+        plugins = all.select{|plugin| plugin.name != "ruby"}
+        plugins.each {|plugin| plugin.reload}
+      end
+    end
+
+    def name
+      Weechat.plugin_get_name(@ptr)
+    end
+
+    # Unloads the plugin.
+    #
+    # @param [Boolean] force If the plugin to be unloaded is "ruby",
+    #   +force+ has to be true.
+    # @return [Boolean] true if we attempted to unload the plugin
+    def unload(force = false)
+      if name == "ruby" and !force
+        Weechat.puts "Won't unload the ruby plugin unless you force it."
+        false
+      else
+        Weechat.exec("/plugin unload #{name}")
+        true
+      end
+    end
+
+    # Reload the plugin.
+    #
+    # @param [Boolean] force If the plugin to be reloaded is "ruby", +force+ has to be true.
+    # @return [Boolean] true if we attempted to reload the plugin
+    def reload(force = false)
+      if name == "ruby" and !force
+        Weechat.puts "Won't reload the ruby plugin unless you force it."
+      else
+        Weechat.exec("/plugin reload #{name}")
+      end
+    end
+
+    # Returns an array of all scripts loaded by this plugin.
+    #
+    # @return [Array<Script>]
+    def scripts
+      scripts = []
+      Infolist.parse("#{name}_script").each do |script|
+        scripts << Script.new(script[:pointer], self)
+      end
+      scripts
+    end
+  end
+end

data/lib/weechat/pointer.rb

@@ -0,0 +1,28 @@
+module Weechat
+  module Pointer
+    attr_reader :ptr
+    alias_method :pointer, :ptr
+
+    def to_s
+      @ptr
+    end
+
+    def initialize(ptr)
+      @ptr = ptr
+    end
+
+    def ==(other)
+      @ptr == other.ptr
+    end
+    alias_method :eql?, "=="
+    alias_method :equal?, "=="
+
+    def hash
+      @ptr.hash
+    end
+
+    def inspect
+      sprintf "#<%s:0x%x @ptr=%p>", self.class, object_id << 1, @ptr
+    end
+  end
+end

data/lib/weechat/process.rb

@@ -0,0 +1,32 @@
+module Weechat
+  class Process < Hook
+    # Returns a new instance of Process
+    #
+    # @param [String] command Command to execute
+    # @param [Integer] timeout Timeout after which to terminate the process
+    # @param [Boolean] collect If true, buffer output until process ends
+
+    attr_reader :collect
+    def initialize(command, timeout = 0, collect = false, &callback)
+      super
+      @command  = command
+      @collect  = collect
+      @stdout, @stderr = [], []
+      @callback = Callback.new(callback)
+      @ptr      = Weechat.hook_process(command, timeout, "process_callback", id.to_s)
+    end
+
+    def stdout
+      @stdout.join("")
+    end
+
+    def stderr
+      @stderr.join("")
+    end
+
+    def buffer(stdout, stderr)
+      @stdout << stdout
+      @stderr << stderr
+    end
+  end
+end

data/lib/weechat/properties.rb

@@ -0,0 +1,312 @@
+module Weechat
+  module Properties
+    module ClassMethods
+      # Returns all known properties.
+      #
+      # @return [Array<Symbol>] The properties
+      def known_properties
+        @known_integer_properties + @known_string_properties
+      end
+
+      def known_integer_properties
+        @known_integer_properties
+      end
+
+      def known_string_properties
+        @known_string_properties
+      end
+
+      def settable_properties
+        @settable_properties
+      end
+
+      def transformations
+        @transformations
+      end
+
+      def rtransformations
+        @rtransformations
+      end
+
+      def mappings
+        @mappings
+      end
+
+      def type
+        @type
+      end
+
+      def init_properties
+        @known_string_properties  ||= [].freeze
+        @known_integer_properties ||= [].freeze
+        @settable_properties      ||= [].freeze
+        @transformations          ||= {}.freeze
+        @rtransformations         ||= {}.freeze
+        @mappings                 ||= {}.freeze
+
+        @type = self.name.downcase.split("::").last
+
+        # this defines all the getter methods
+        known_properties.each do |property|
+          define_method(property) { get_property(property) }
+        end
+
+        # this defined all the setter methods
+        @settable_properties.each do |property|
+          define_method(property + '=') {|v| set_property(property, v, true) }
+        end
+
+        # this adds a few aliases to make interfaces more rubyish
+        @mappings.each do |key, value|
+          if respond_to?(value)
+            # it is a string/integer property
+            alias_method key, value
+          else
+            # it is an infolist property
+            define_method(key) do |*args|
+              __send__(value, *args)
+            end
+          end
+
+        end
+
+        InstanceMethods.alias_methods(@type)
+        include InstanceMethods
+      end
+
+      def apply_transformation(property, value)
+        Utilities.apply_transformation(property, value, @transformations)
+      end
+    end
+
+    module InstanceMethods
+      # Get a property. Transformations, if appropriate, will be applied to the value
+      # before returning it. This means that e.g. 0 and 1 might be turned into false and true.
+      #
+      # @raise [Exception::UnknownProperty]
+      # @return [String, Number, Boolean]
+      # @see #get_integer_property
+      # @see #get_string_property
+      # @see #get_infolist_property
+      # @see #set_property
+      def get_property(property)
+        raise Exception::UnknownProperty.new(property) unless valid_property?(property)
+        case ret = __get_property(property)
+        when true, false, nil
+          ret
+        else
+          Property.new(self, property)
+        end
+      end
+
+      # @private
+      def __get_property(property)
+        property = property.to_s
+        if valid_property?(property, :integer)
+          v = get_integer_property(property)
+        elsif valid_property?(property, :string)
+          v = get_string_property(property)
+        elsif valid_property?(property, :infolist)
+          v = get_infolist_property(property)
+        else
+          raise Exception::UnknownProperty.new(property)
+        end
+
+        return self.class.apply_transformation(property, v)
+      end
+
+      # Returns an integer property.
+      #
+      # @raise [Exception::UnknownProperty]
+      # @return [Number]
+      # @see #get_integer
+      # @see #get_property
+      # @see #get_string_property
+      # @see #get_infolist_property
+      def get_integer_property(property)
+        property = property.to_s
+        raise Exception::UnknownProperty.new(property) unless valid_property?(property, :integer)
+        get_integer(property)
+      end
+
+      # Returns an integer property, not doing any checks.
+      #
+      # @return [Number]
+      # @see #get_integer_property
+      # @see #get_string
+      # @see #get_property
+      def get_integer(property)
+        Weechat.__send__("#{self.class.type}_get_integer", @ptr, property.to_s).to_i
+      end
+
+      # Returns a string property.
+      #
+      # @raise [Exception::UnknownProperty]
+      # @return [String]
+      # @see #get_string
+      # @see #get_property
+      # @see #get_integer_property
+      # @see #set_string_property
+      def get_string_property(property)
+        property = property.to_s
+        raise Exception::UnknownProperty.new(property) unless valid_property?(property, :string)
+        get_string(property)
+      end
+
+      # Returns a string property, not doing any checks.
+      #
+      # @return [String]
+      # @see #get_string_property
+      # @see #get_property
+      # @see #get_integer
+      # @see #set_string_property
+      def get_string(property)
+        Weechat.__send__("#{self.class.type}_get_string", @ptr, property.to_s)
+      end
+
+      # Returns a hash representation of the associated infolist.
+      #
+      # @return [Hash{Symbol => Object}] All properties in the infolist
+      def get_infolist
+        Weechat::Infolist.parse(self.class.type, @ptr)
+      end
+
+      # Returns a property obtained by an infolist.
+      #
+      # @raise [Exception::UnknownProperty]
+      # @return [String]
+      # @see #get_property
+      # @see #get_string_property
+      # @see #get_integer_property
+      def get_infolist_property(property)
+        property = property.to_sym
+        values = get_infolist.first
+        raise Exception::UnknownProperty.new(property.to_s) unless values[property]
+        values[property]
+      end
+
+      # Checks if a property can be set.
+      #
+      # @return [Boolean]
+      # @see #valid_property?
+      # @see #set_property
+      def settable_property?(property)
+        set_method = "#{self.class.type}_set"
+        return false unless Weechat.respond_to?(set_method)
+
+        property = property.to_s
+        self.class.settable_properties.include?(property)
+      end
+
+      # Sets a property. Transformations, if appropriate, will be applied to the value
+      # before setting it. This means that e.g. true and false will be turned into 1 and 0.
+      #
+      # @raise [Exception::UnsettableProperty]
+      # @return [String, Integer] The value after if has been transformed
+      # @see #set_string_property
+      # @see #set
+      def set_property(property, v, freeze = false)
+        property = property.to_s
+        raise Exception::UnsettableProperty.new(property) unless settable_property?(property)
+        v = Utilities.apply_transformation(property, v, self.class.rtransformations)
+
+        set(property, v)
+        if freeze
+          Property.properties.each do |prop|
+            if prop[0..1] == [@ptr, property]
+              prop[2].__freeze__
+            end
+          end
+        end
+      end
+
+      # Sets a string property, not applying any transformations.
+      #
+      # @raise [Exception::UnsettableProperty]
+      # @return [String] The value
+      # @see #set_property
+      # @see #set
+      def set_string_property(property, v)
+        property = property.to_s
+        raise Exception::UnsettableProperty.new(property) unless settable_property?(property)
+        set(property, v)
+      end
+
+      # Sets a property, not doing any checks or conversions whatsoever.
+      #
+      # @return [Object] The value
+      # @see #set_property
+      # @see #set_string_property
+      def set(property, value)
+        set_method = "#{self.class.type}_set"
+        raise CannotSetProperties unless Weechat.respond_to?(set_method)
+        Weechat.__send__(set_method, @ptr, property.to_s, value.to_s)
+        value
+      end
+
+      # Checks if a property is valid. That is, if get_(integer|string|infolist)_property are
+      # able to return a value.
+      #
+      # @param [#to_s] property The name of the property
+      # @param [Symbol] type The type of properties to check for.
+      #   Can be one of :all, :string, :integer, :localvar or :infolist
+      # @return [Boolean]
+      # @see #settable_property?
+      # @see #get_property
+      def valid_property?(property, type = :all)
+        property = property.to_s
+        case type
+        when :all
+          valid_property?(property, :string) or
+            valid_property?(property, :integer) or
+            valid_property?(property, :localvar) or
+            valid_property?(property, :infolist)
+        when :string
+          self.class.known_string_properties.include?(property) or valid_property?(property, :localvar)
+        when :integer
+          self.class.known_integer_properties.include?(property)
+        when :localvar
+          property =~ /^localvar_.+$/
+        when :infolist
+          get_infolist.first[property.to_sym]
+        end
+      end
+
+      # method_missing returns buffer local variables.
+      #
+      # @return [String]
+      def method_missing(m, *args)
+        if args.empty? && valid_property?(m.to_s)
+          get_property(m.to_s)
+        else
+          super
+        end
+      end
+
+      # Returns a Hash representation of the object.
+      #
+      # @return [Hash{Symbol => Object}]
+      def to_h
+        h = {}
+        self.class.known_properties.each do |property|
+          val = __get_property(property)
+          h[property.to_sym] = val
+        end
+
+        get_infolist.first.each do |property, value|
+          prop = __get_property(property)
+          h[property] = prop
+        end
+
+        h
+      end
+
+      def self.alias_methods(type)
+        alias_method "#{type}_get_integer", :get_integer
+        alias_method "#{type}_get_string", :get_string
+      end
+    end
+
+    include ClassMethods
+  end
+end