weechat 0.0.4 → 0.0.5

data/ChangeLog

@@ -1,5 +1,63 @@
+2010-01-03  Dominik Honnef  <dominikho@gmx.net>
+
+	* lib/weechat/bar.rb: added support for bars and bar items
+	* lib/weechat.rb: added support for bars and bar items
+
+	* lib/weechat.rb: bumped version to 0.0.5
+
+2010-01-02  Dominik Honnef  <dominikho@gmx.net>
+
+	* lib/weechat/server.rb (Weechat::IRC::Server.find): unitized find/from_name
+	(Weechat::IRC::Server#get_infolist): removed
+
+	* lib/weechat/plugin.rb (Weechat::Plugin.find): unitized find/from_name
+
+	* lib/weechat/properties.rb (Weechat::Properties::ClassMethods#all):
+	centralised the procedure of getting all instances of a buffer/plugin/etc
+
+2009-12-31  Dominik Honnef  <dominikho@gmx.net>
+
+	* lib/weechat/properties.rb (Weechat::Properties::ClassMethods#apply_rtransformation):
+	added method for applying reverse transformations
+
+	* lib/weechat/input.rb (Weechat::Input#length): added alias #length to #size
+
+	* Rakefile: added missing gem dependency on json
+
+	* lib/weechat/command.rb (Weechat::Command#initialize): dup
+	arguments passed to Command.new
+
+	* lib/weechat/callbacks.rb (Weechat::Callbacks): made callback
+	handling more centralized; changed all uses
+
+	* lib/weechat.rb: do not serialize arbitrary objects anymore
+	* lib/weechat/rubyext/object.rb: deleted file
+
+	* lib/weechat/rubyext/hash.rb (Hash#to_weechat_config)
+	(Hash::from_weechat_config.): use JSON for storing hashes
+	* lib/weechat.rb: use JSON for storing hashes
+
+	* lib/weechat/color.rb (Weechat::Color#color): made name to color
+	lookup dynamic
+
+	* lib/weechat/rubyext/string.rb (String#irc_downcase)
+	(String#irc_downcase): added RFC 1459 up/downcasing to strings
+
+	* lib/weechat/color.rb (Weechat::Color.const_missing): added
+	dynamic color lookup
+
 2009-12-24  Dominik Honnef  <dominikho@gmx.net>
 
+	* *: substituted #initialize with #from_ptr and #from_name where
+	appropriate
+
+	* lib/weechat.rb (Weechat::Helper#process_callback): small performance tweak
+
+	* lib/weechat.rb (Weechat::Helper#process_callback): added alias collect? for collect
+	* lib/weechat/process.rb (Weechat::Process): added alias collect? for collect
+
+	* lib/weechat/hooks/signal.rb (Weechat::Hooks::Signal.send): implemented weechat_hook_signal_send
+
 	* lib/weechat.rb (Weechat): bumped version to 0.0.4
 
 	* lib/weechat/properties.rb (Weechat::Properties::InstanceMethods#get_infolist)

data/Rakefile

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'rake/gempackagetask'
 
-VERSION = "0.0.4"
+VERSION = "0.0.5"
 
 spec = Gem::Specification.new do |s|
   s.name              = "weechat"
@@ -20,7 +20,7 @@ spec = Gem::Specification.new do |s|
   # s.required_ruby_version = '>= 1.9.1'
 
   # s.add_dependency "keyword_arguments"
-
+  s.add_dependency "json"
   # s.add_development_dependency "baretest"
   # s.add_development_dependency "mocha"
 

data/TODO

@@ -91,7 +91,7 @@ hooks:
 [ ] hook_connect
 [x] hook_print
 [x] hook_signal
-[ ] hook_signal_send
+[x] hook_signal_send
 [x] hook_config
 [ ] hook_completion
 [ ] hook_completion_list_add
@@ -130,15 +130,15 @@ nicklist:
 [ ] nicklist_remove_all
 
 bars:
-[ ] bar_item_search
-[ ] bar_item_new
-[ ] bar_item_update
-[ ] bar_item_remove
-[ ] bar_search
-[ ] bar_new
-[ ] bar_set
-[ ] bar_update
-[ ] bar_remove
+[x] bar_item_search
+[x] bar_item_new
+[x] bar_item_update
+[x] bar_item_remove
+[x] bar_search
+[x] bar_new
+[x] bar_set
+[x] bar_update
+[x] bar_remove
 
 commands:
 [x] command
@@ -186,3 +186,6 @@ upgrade:
 
 Functionality:
 [x] if a buffer is a channel, get nicks, usercount, topic, etc
+
+Known limitations:
+- on /upgrade, the library forgets all callbacks

data/lib/weechat.rb

@@ -6,14 +6,14 @@ end
 require 'pp'
 
 module Weechat
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
   module Helper
     def command_callback(id, buffer, args)
-      Weechat::Command.find_by_id(id).call(Weechat::Buffer.new(buffer), args)
+      Weechat::Command.find_by_id(id).call(Weechat::Buffer.from_ptr(buffer), args)
     end
 
     def command_run_callback(id, buffer, command)
-      Weechat::Hooks::CommandRunHook.find_by_id(id).call(Weechat::Buffer.new(buffer), command)
+      Weechat::Hooks::CommandRunHook.find_by_id(id).call(Weechat::Buffer.from_ptr(buffer), command)
     end
 
     def timer_callback(id, remaining)
@@ -28,12 +28,16 @@ module Weechat
       Weechat::Buffer.call_close_callback(method, buffer)
     end
 
+    def bar_build_callback(id, item, window)
+      Weechat::Bar::Item.call_build_callback(id, window)
+    end
+
     def info_callback(id, info, arguments)
       Weechat::Info.find_by_id(id).call(arguments).to_s
     end
 
     def print_callback(id, buffer, date, tags, displayed, highlight, prefix, message)
-      buffer    = Weechat::Buffer.new(buffer)
+      buffer    = Weechat::Buffer.from_ptr(buffer)
       date      = Time.at(date.to_i)
       tags      = tags.split(",")
       displayed = Weechat.integer_to_bool(displayed)
@@ -50,10 +54,10 @@ module Weechat
       [/irc_(channel|pv)_opened/, /^logger_(start|stop|backlog)$/,
        /^buffer_(closing|closed|lines_hidden|moved|opened|renamed|switch)$/,
        /^buffer_(title|type)_changed$/,
-       /^buffer_localvar_(added|changed|removed)$/] => lambda { |v| Weechat::Buffer.new(v) },
-      [/irc_server_(connecting|connected|disconnected)/] => lambda { |v| Weechat::Server.new(v) },
+       /^buffer_localvar_(added|changed|removed)$/] => lambda { |v| Weechat::Buffer.from_ptr(v) },
+      [/irc_server_(connecting|connected|disconnected)/] => lambda { |v| Weechat::Server.from_name(v) },
       [/weechat_(highlight|pv)/] => lambda { |v| Weechat::Line.parse(v) },
-      [/window_(scrolled|unzooming|unzoomed|zooming|zoomed)/] => lambda { |v| Weechat::Window.new(v) },
+      [/window_(scrolled|unzooming|unzoomed|zooming|zoomed)/] => lambda { |v| Weechat::Window.from_ptr(v) },
     }
 
     def signal_callback(id, signal, data)
@@ -76,21 +80,22 @@ module Weechat
              end
 
       process = Weechat::Process.find_by_id(id)
-      if process.collect
+      if process.collect?
         process.buffer(stdout, stderr)
         if code == :error || code != :running
           process.call(code, process.stdout, process.stderr)
         end
       else
-        Weechat::Process.find_by_id(id).call(code, stdout, stderr)
+        process.call(code, stdout, stderr)
       end
     end
 
     ModifierCallbackTransformations = {
+      [/^irc_(in|out)_.+$/] => lambda { |v| Weechat::IRC::Server.from_name(v) },
       ['irc_color_decode', 'irc_color_encode'] => lambda { |v| Weechat.integer_to_bool(v) },
-      [/^bar_condition_.+$/]                   => lambda { |v| Weechat::Window.new(v) },
+      [/^bar_condition_.+$/]                   => lambda { |v| Weechat::Window.from_ptr(v) },
       ["input_text_content", "input_text_display",
-       "input_text_display_with_cursor"]       => lambda { |v| Weechat::Buffer.new(v) },
+       "input_text_display_with_cursor"]       => lambda { |v| Weechat::Buffer.from_ptr(v) },
       ["weechat_print"]                        => lambda { |v|
         parts = v.split(";")
         parts[0] = Weechat::Plugin.find(parts[0])
@@ -111,6 +116,7 @@ module Weechat
     def modifier_callback(id, modifier, modifier_data, s)
       klass = Weechat::Modifiers::Mappings[modifier] || Weechat::Modifier
       modifier_data = Weechat::Utilities.apply_transformation(modifier, modifier_data, ModifierCallbackTransformations)
+      modifier_data = [modifier_data] unless modifier_data.is_a?(Array)
       args = modifier_data + [Weechat::Line.parse(s)]
       callback = klass.find_by_id(id)
       callback ||= Weechat::Modifier.find_by_id(id)
@@ -172,6 +178,11 @@ module Weechat
       bool ? 1 : 0
     end
 
+    alias_method :old_bar_update, :bar_update
+    def bar_update(name)
+      old_bar_update(name.to_s)
+    end
+
     alias_method :old_mkdir_home, :mkdir_home
     alias_method :old_mkdir, :mkdir
     alias_method :old_mkdir_parents, :mkdir_parents
@@ -232,6 +243,7 @@ require 'weechat/blankslate.rb'
 require 'weechat/line.rb'
 require 'weechat/terminal.rb'
 require 'weechat/callback.rb'
+require 'weechat/callbacks.rb'
 require 'weechat/property.rb'
 require 'weechat/properties.rb'
 require 'weechat/exceptions.rb'
@@ -244,6 +256,7 @@ require 'weechat/modifier.rb'
 require 'weechat/input.rb'
 require 'weechat/buffer.rb'
 require 'weechat/window.rb'
+require 'weechat/bar.rb'
 require 'weechat/server.rb'
 require 'weechat/channel.rb'
 require 'weechat/user.rb'
@@ -253,8 +266,8 @@ require 'weechat/color.rb'
 require 'weechat/plugin.rb'
 require 'weechat/rubyext/string.rb'
 require 'weechat/rubyext/boolean.rb'
-require 'weechat/rubyext/object.rb'
 require 'weechat/rubyext/array.rb'
+require 'weechat/rubyext/hash.rb'
 require 'weechat/rubyext/integer.rb'
 require 'weechat/rubyext/float.rb'
 require 'weechat/hooks.rb'

data/lib/weechat/bar.rb

@@ -0,0 +1,167 @@
+module Weechat
+  class Bar
+    class Item
+      include Weechat::Pointer
+      extend Weechat::Properties
+      extend Weechat::Callbacks
+
+      @transformations = {
+        [:plugin] => lambda { |v| Weechat::Plugin.from_ptr(v) },
+      }
+
+      @mappings = {}
+      @rtransformations = {}
+      @settable_properties = %w()
+
+      init_properties
+      @type = "bar_item"
+
+      class << self
+        def items
+          items = []
+          Weechat::Infolist.parse("bar_item").each do |item|
+            items << Item.find(item[:name])
+          end
+          items
+        end
+        alias_method :all, :items
+
+        def find(name)
+          ptr = Weechat.bar_item_search(name)
+          if !ptr.empty?
+            from_ptr(ptr)
+          else
+            nil
+          end
+        end
+        alias_method :from_name, :find
+      end # eigenclass
+
+      def initialize(name, &build_callback)
+        id = self.class.compute_free_id
+        @ptr = Weechat.bar_item_new(name, "bar_build_callback", id.to_s)
+        if @ptr.empty?
+          raise "Could not create bar item"
+        end
+
+        self.class.register_callback(
+                                     :build_callback => Callback.new(build_callback),
+                                     :ptr            => @ptr
+                                     )
+      end
+
+      def update
+        Weechat.bar_item_update(@name)
+      end
+
+      def delete
+        # TODO mark deletion status
+        Weechat.bar_item_remove(@ptr)
+      end
+      alias_method :remove, :delete
+
+      class << self
+        def call_build_callback(id, window)
+          window = Window.from_ptr(window)
+          call_callback(id, :build_callback, window).to_s
+        end
+      end # eigenclass
+    end # Item
+
+    include Weechat::Pointer
+    extend Weechat::Properties
+
+    @transformations = {
+      [:hidden, :separator] => lambda { |v| Weechat.integer_to_bool(v) },
+      [:type] => lambda { |v| [:root, :window][v] },
+      [:position] => lambda { |v| [:top, :bottom, :left, :right][v] },
+      [:filling_top_bottom, :filling_left_right] => lambda { |v|
+        [:horizontal, :vertical, :columns_horizontal, :columns_vertical][v]
+      },
+      [:color_fg, :color_delim, :color_bg] => lambda { |v| Weechat::Color.new(v) },
+      [:bar_window] => lambda { |v| Weechat::Window.from_ptr(v) },
+      [:items] => lambda { |v|
+        items = v.split(",")
+        items.map { |item|
+          item = item.split("+")
+          item.size == 1 ? item.first : item
+        }
+      },
+    }
+
+    @mappings = {
+      :hidden? => :hidden,
+      :separator? => :separator,
+      :has_separator? => :separator,
+    }
+
+    @rtransformations = {
+      [:hidden, :separator] => lambda { |v|
+        v.to_weechat_config
+      },
+      [:color_fg, :color_delim, :color_bg] => lambda { |v|
+        if v.respond_to?(:name)
+          v.name
+        else
+          v
+        end
+      },
+      [:name, :type, :condition, :position, :filling_top_bottom,
+       :filling_left_right, :size, :size_max, :priority] => lambda  { |v| v.to_s},
+      [:items] => lambda { |v|
+        v.map {|item|
+          if item.is_a?(Array)
+            item.join("+")
+          else
+            item.to_s
+          end
+        }.join(",")
+      },
+    }
+
+    @settable_properties = %w(name hidden priority conditions position filling_top_bottom
+    filling_left_right size size_max color_fg color_delim color_bg separator items)
+
+    init_properties
+
+    class << self
+      def find(name)
+        ptr = Weechat.bar_search(name)
+        if !ptr.empty?
+          from_ptr(ptr)
+        else
+          nil
+        end
+      end
+      alias_method :from_name, :find
+    end # eigenclass
+
+    def initialize(args = {})
+      mapped_args = {}
+      args.each do |key, value|
+        mapped_args[key] = self.class.apply_rtransformation(key, value)
+      end
+
+      @ptr = Weechat.bar_new(*mapped_args.values_at(:name, :hidden, :priority, :type,
+                                                    :condition, :position, :filling_top_bottom,
+                                                    :filling_left_right, :size, :size_max,
+                                                    :color_fg, :color_delim, :color_bg, :separator,
+                                                    :items))
+      if @ptr.empty?
+        raise "Could not create bar"
+      end
+
+      @name = args[:name]
+    end
+
+    def update
+      Weechat.bar_update(self.name)
+    end
+
+    def delete
+      # TODO mark deletion state
+      Weechat.bar_remove(@ptr)
+    end
+    alias_method :remove, :delete
+  end # Bar
+end # Weechat

data/lib/weechat/buffer.rb

@@ -3,10 +3,10 @@ module Weechat
   #
   # == Creating new buffers
   #
-  # Using {Buffer.create}, one can create new buffers which even
+  # Using {Buffer.new}, one can create new buffers which even
   # respond to input and closing using hooks (procs or methods or
   # anything that responds to #call).
-  #   Buffer.create("my buffer",
+  #   Buffer.new("my buffer",
   #     lambda {|b, i|
   #       # work with input
   #     },
@@ -97,17 +97,7 @@ module Weechat
   class Buffer
     include Weechat::Pointer
     extend Weechat::Properties
-
-    # @overload input
-    #   @return [Weechat::Input]
-    # @overload input=(val)
-    #   Sets the content of the input line.
-    #
-    #   @return [void]
-    #   @see Input#text=
-    attr_accessor :input
-
-    @callbacks = []
+    extend Weechat::Callbacks
 
     # A list of all properties that can be retrieved using {#get_string_property}.
     #
@@ -143,7 +133,7 @@ module Weechat
       [:notify] => lambda {|v| NOTIFY_LEVELS[v] },
       [:text_search] => lambda {|v| [:none, :backward, :foward][v] },
       [:type] => lambda {|v| [:formatted, :free][v]},
-      [:plugin] => lambda {|v| Weechat::Plugin.new(v)},
+      [:plugin] => lambda {|v| Weechat::Plugin.from_ptr(v)},
     }.freeze
 
     # The transformation procedures that get applied to values before they
@@ -180,37 +170,19 @@ module Weechat
       :position            => :number,
       :position=           => :number=,
       :active?             => :current_buffer,
+      :current?            => :current_buffer,
     }.freeze
 
     init_properties
 
     class << self
-      # @return [Buffer]
-      # @see #initialize
-      def from_ptr(ptr)
-        self.new(ptr)
-      end
-
       def find(plugin, name)
         plugin = Weechat::Plugin.from_name(plugin) if plugin.is_a?(String)
-        buffers.find {|buffer|
+        all.find {|buffer|
           buffer.name == name && buffer.plugin == plugin
         }
       end
 
-      # Returns a list of all buffers
-      #
-      # @return [Array<Buffer>]
-      # @todo move into own module
-      def buffers
-        buffers = []
-        Weechat::Infolist.parse("buffer").each do |buffer|
-          buffers << Buffer.new(buffer[:pointer])
-        end
-        buffers
-      end
-      alias_method :all, :buffers
-
       # Finds a buffer by its name and its plugin.
       #
       # @param [String] name The name of the buffer to find
@@ -227,7 +199,7 @@ module Weechat
         if ptr == ""
           nil
         else
-          Buffer.new(ptr)
+          Buffer.from_ptr(ptr)
         end
       end
       alias_method :find, :find_by_name
@@ -244,14 +216,10 @@ module Weechat
           pattern = Regexp.new("^#{pattern}$")
         end
 
-        Weechat::Infolist.parse("buffer").select {|h|
+        Weechat::Infolist.parse("buffer", "", "", properties, :name, :pointer).select {|h|
           h[:name] =~ pattern
         }.map {|h|
-          Buffer.new(h[:pointer])
-        }.select {|b|
-          properties.all? {|key, value|
-            b.__send__(key) == value
-          }
+          Buffer.from_ptr(h[:pointer])
         }
       end
 
@@ -264,8 +232,8 @@ module Weechat
       # @see .call_close_callback
       # @private
       def call_input_callback(id, buffer, input)
-        buffer = Buffer.new(buffer)
-        return @callbacks[id.to_i][:input_callback].call(buffer, input)
+        buffer = Buffer.from_ptr(buffer)
+        call_callback(id, :input_callback, buffer, input)
       end
 
       # This method manages all close callbacks, resolving the
@@ -277,63 +245,67 @@ module Weechat
       # @see .call_input_callback
       # @private
       def call_close_callback(id, buffer)
-        buffer = Buffer.new(buffer)
-        return @callbacks[id.to_i][:close_callback].call(buffer)
-      end
-
-      # Returns all callbacks
-      #
-      # @return [Array<Hash{Symbol => String, #call}>] An array of hashes containing
-      #   the callbacks and pointers of the buffers to which the callbacks are assigned to
-      # @see #input_callback
-      # @see #close_callback
-      def callbacks
-        @callbacks
+        buffer = Buffer.from_ptr(buffer)
+        call_callback(id, :close_callback, buffer)
       end
 
       # Returns the current buffer.
       #
       # @return [Buffer] The current buffer
       def current
-        Buffer.new(Weechat.current_buffer)
+        Buffer.from_ptr(Weechat.current_buffer)
       end
 
-      # Creates a new buffer.
-      #
-      # @param [#to_s] name The name of the new buffer
-      # @param [#call] input_callback The callback to be called when something
-      #   is entered in the new buffer's input line
-      # @param [#call] close_callback The callback to be called when the new buffer
-      #   is being closed
-      # @example
-      #   Buffer.create("my buffer",
-      #     lambda {|b, i|
-      #       # work with input
-      #     },
-      #     lambda {|b|
-      #       # respond to the closing of a buffer
-      #     }
-      #   )
-      # @return [Buffer] The new buffer
-      # @raise [Exception::DuplicateBufferName] In case a buffer with that name already exists
-      def create(name, input_callback, close_callback)
-        @callbacks << {
-          :input_callback => EvaluatedCallback.new(input_callback),
-          :close_callback => EvaluatedCallback.new(close_callback),
-        }
-        id = @callbacks.size - 1
-        ptr = Weechat.buffer_new(name.to_s, "input_callback", id.to_s, "close_callback", id.to_s)
-        if ptr.empty?
-          raise Exception::DuplicateBufferName, name.to_s
-        else
-          @callbacks[-1][:ptr] = ptr
-          Buffer.new(ptr)
-        end
+      def from_ptr(ptr)
+        o = super
+        o.instance_variable_set(:@input, Weechat::Input.new(o))
+        o.instance_variable_set(:@keybinds, {})
+        o
       end
     end
 
-    def initialize(ptr)
-      super
+
+    # @overload input
+    #   @return [Weechat::Input]
+    # @overload input=(val)
+    #   Sets the content of the input line.
+    #
+    #   @return [void]
+    #   @see Input#text=
+    attr_accessor :input
+
+    # Creates a new buffer.
+    #
+    # @param [#to_s] name The name of the new buffer
+    # @param [#call] input_callback The callback to be called when something
+    #   is entered in the new buffer's input line
+    # @param [#call] close_callback The callback to be called when the new buffer
+    #   is being closed
+    # @example
+    #   Buffer.create("my buffer",
+    #     lambda {|b, i|
+    #       # work with input
+    #     },
+    #     lambda {|b|
+    #       # respond to the closing of a buffer
+    #     }
+    #   )
+    # @return [Buffer] The new buffer
+    # @raise [Exception::DuplicateBufferName] In case a buffer with that name already exists
+    def initialize(name, input_callback, close_callback)
+      id = self.class.compute_free_id
+
+      @ptr = Weechat.buffer_new(name.to_s, "input_callback", id.to_s, "close_callback", id.to_s)
+      if @ptr.empty?
+        raise Exception::DuplicateBufferName, name.to_s
+      end
+
+      self.class.register_callback(
+                        :input_callback => EvaluatedCallback.new(input_callback),
+                        :close_callback => EvaluatedCallback.new(close_callback),
+                        :ptr            => @ptr
+                                   )
+
       @input = Weechat::Input.new(self)
       @keybinds = {}
     end
@@ -357,7 +329,7 @@ module Weechat
     #
     # @return [Boolean]
     def valid?
-      Buffer.buffers.map{|b|b.pointer}.include?(@ptr)
+      Buffer.all.map{|b|b.pointer}.include?(@ptr)
     end
     alias_method :exist?, :valid?
 
@@ -376,6 +348,23 @@ module Weechat
       IRC::Channel.new(self)
     end
 
+    def server
+      return nil unless ["core", "irc"].include? self.plugin.name
+      parts = self.name.split(".")
+      name1, name2 = parts[0], parts[1..-1].join(",")
+
+      server = begin
+                 IRC::Server.from_name(name1)
+               rescue Exception::UnknownServer
+                 begin
+                   raise Exception::UnknownServer if name2.empty?
+                   IRC::Server.from_name(name2)
+                 rescue Exception::UnknownServer
+                   nil
+                 end
+               end
+    end
+
     # Send a command to the current buffer.
     #
     # Note: If the given command does not start with a slash, one will be added.
@@ -446,14 +435,6 @@ module Weechat
       Weechat.buffer_clear(@ptr)
     end
 
-    # Returns the callbacks assigned to the buffer.
-    #
-    # @return (see Weechat::Buffer.callbacks)
-    # @private
-    def callbacks
-      self.class.callbacks.find {|c| c.ptr == @ptr}
-    end
-
     # The input callback assigned to the buffer.
     #
     # @return [#call]
@@ -562,12 +543,8 @@ module Weechat
     def windows
       Window.all.select {|window| window.buffer == self }
     end
-
-    def plugin
-      Plugin.new(Weechat.buffer_get_pointer(@ptr, "plugin"))
-    end
   end
 
   # The core buffer
-  Core = Buffer.new("")
+  Core = Buffer.from_ptr("")
 end

data/lib/weechat/callbacks.rb

@@ -0,0 +1,35 @@
+module Weechat
+  module Callbacks
+    @unique_id = 0
+    @callbacks = {}
+
+    class << self
+      attr_reader :callbacks
+      attr_reader :unique_id
+
+      def compute_free_id
+        @unique_id += 1
+      end
+    end
+
+    def call_callback(id, type, *args)
+      return callbacks[id.to_i][type].call(*args)
+    end
+
+    def register_callback(args = {})
+      callbacks[unique_id] = args
+    end
+
+    def compute_free_id
+      Callbacks.compute_free_id
+    end
+
+    def callbacks
+      Callbacks.callbacks
+    end
+
+    def unique_id
+      Callbacks.unique_id
+    end
+  end
+end

data/lib/weechat/channel.rb

@@ -13,10 +13,9 @@ module Weechat
       init_properties
 
       class << self
-        def channels
+        def all
           Weechat::Buffer.all.select {|b| b.channel?}.map{|b| b.channel}
         end
-        alias_method :all, :channels
 
         def find(server, channel)
           server  = server.name if server.respond_to?(:name)
@@ -27,7 +26,7 @@ module Weechat
 
       attr_reader :buffer
       def initialize(buffer)
-        @buffer = Buffer.new(buffer.to_s)
+        @buffer = Buffer.from_ptr(buffer.to_s)
         @ptr    = @buffer.ptr
         if not ["channel"].include?(@buffer.localvar_type)
           raise Exception::NotAChannel, buffer.ptr
@@ -40,7 +39,7 @@ module Weechat
       end
 
       def server
-        IRC::Server.new(@buffer.localvar_server)
+        IRC::Server.from_name(@buffer.localvar_server)
       end
 
       def part(reason="")

data/lib/weechat/color.rb

@@ -8,18 +8,22 @@ module Weechat
       new(v)
     end
 
+    def self.const_missing(c)
+      self.new(c.to_s.downcase)
+    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
+    def color
+      Weechat.color(name)
     end
-    alias_method :to_str, :to_s
+    alias_method :to_s, :color
+    alias_method :to_str, :color
 
     def to_weechat_config
       @name

data/lib/weechat/command.rb

@@ -6,6 +6,7 @@ module Weechat
     attr_reader :args_description
     attr_reader :completion
     def initialize(*args, &callback)
+      args = args.map{|e| e.dup}
       raise "No callback specified" if callback.nil?
       super
 
@@ -56,6 +57,7 @@ module Weechat
 
     class << self
       def find_by_command(name)
+        name[0..0] = '' if name[0..0] == '/'
         @hooks.values.find {|h| h.command == name}
       end
       alias_method :find_by_name, :find_by_command

data/lib/weechat/hook.rb

@@ -12,8 +12,7 @@ module Weechat
         @hook_classes << by
       end
 
-      def hooks; @hooks; end
-      alias_method :all, :hooks
+      def all; @hooks; end
 
       def init
         @hooks = {}

data/lib/weechat/hooks/signal.rb

@@ -6,6 +6,13 @@ module Weechat
         @callback = EvaluatedCallback.new(callback)
         @ptr      = Weechat.hook_signal(signal, "signal_callback", id.to_s)
       end
+
+      class << self
+        def send(signal, type, data)
+          Weechat.hook_signal_send(signal.to_s, type.to_s, data.to_s)
+        end
+        alias_method :exec, :send
+      end
     end
   end
 end

data/lib/weechat/input.rb

@@ -25,6 +25,7 @@ module Weechat
     def size
       @buffer.input_buffer_size
     end
+    alias_method :length, :size
 
     def pos
       @buffer.input_buffer_pos

data/lib/weechat/plugin.rb

@@ -26,22 +26,19 @@ module Weechat
     init_properties
 
     class << self
-      def find_by_name(name)
+      def find(name)
         if name.nil? or name.empty? or name == "core"
-          return Plugin.new("")
+          return Plugin.from_ptr("")
         end
-        plugins.find {|plugin| plugin.name == name}
+        all.find {|plugin| plugin.name == name}
       end
-      alias_method :find, :find_by_name
+      alias_method :from_name, :find
 
-      def plugins
-        plugins = [Plugin.new("")]
-        Weechat::Infolist.parse("plugin").each do |plugin|
-          plugins << Plugin.new(plugin[:pointer])
-        end
-        plugins
+      def all
+        items = super
+        items[0,0] = Plugin.find("")
+        items
       end
-      alias_method :all, :plugins
 
       # Loads a plugin.
       #

data/lib/weechat/pointer.rb

@@ -1,5 +1,17 @@
 module Weechat
   module Pointer
+    module ClassMethods
+      def from_ptr(ptr)
+        o = allocate
+        o.instance_variable_set(:@ptr, ptr)
+        o
+      end
+    end
+
+    def self.included(by)
+      by.extend Weechat::Pointer::ClassMethods
+    end
+
     attr_reader :ptr
     alias_method :pointer, :ptr
 
@@ -7,10 +19,6 @@ module Weechat
       @ptr
     end
 
-    def initialize(ptr)
-      @ptr = ptr
-    end
-
     def ==(other)
       other.respond_to?(:ptr) and @ptr == other.ptr
     end

data/lib/weechat/process.rb

@@ -15,6 +15,7 @@ module Weechat
       @callback = EvaluatedCallback.new(callback)
       @ptr      = Weechat.hook_process(command, timeout, "process_callback", id.to_s)
     end
+    alias_method :collect?, :collect
 
     def stdout
       @stdout.join("")

data/lib/weechat/properties.rb

@@ -36,6 +36,14 @@ module Weechat
         @type
       end
 
+      def all
+        items = []
+        Weechat::Infolist.parse(@type).each do |item|
+          items << from_ptr(item[:pointer])
+        end
+        items
+      end
+
       def init_properties
         @known_string_properties  ||= [].freeze
         @known_integer_properties ||= [].freeze
@@ -77,6 +85,10 @@ module Weechat
       def apply_transformation(property, value)
         Utilities.apply_transformation(property, value, @transformations)
       end
+
+      def apply_rtransformation(property, value)
+        Utilities.apply_transformation(property, value, @rtransformations)
+      end
     end
 
     module InstanceMethods
@@ -168,7 +180,7 @@ module Weechat
       #
       # @return [Hash{Symbol => Object}] All properties in the infolist
       def get_infolist(*fields)
-        Weechat::Infolist.parse(self.class.type, @ptr, {}, fields)
+        Weechat::Infolist.parse(self.class.type, @ptr, "", {}, *fields)
       end
 
       # Returns a property obtained by an infolist.

data/lib/weechat/rubyext/hash.rb

@@ -0,0 +1,10 @@
+require 'json'
+class Hash
+  def to_weechat_config
+    to_json
+  end
+
+  def self.from_weechat_config(v)
+    JSON.load(v)
+  end
+end

data/lib/weechat/rubyext/string.rb

@@ -139,4 +139,32 @@ class String
     end
     out
   end
+
+  # Downcase a string (nickname) according to RFC 1459.
+  #
+  # @return [String]
+  def irc_downcase
+    downcase.tr("[]\\~", "{}|^")
+  end
+
+  # Same as #irc_downcase, but modifying the string in place.
+  #
+  # @return [String] self
+  def irc_downcase!
+    replace(irc_downcase)
+  end
+
+  # Upcases a string (nickname) according to RFC 1459.
+  #
+  # @return [String]
+  def irc_upcase
+    upcase.tr("{}|^", "[]\\~")
+  end
+
+  # Same as #irc_upcase, but modifying the string in place.
+  #
+  # @return [String] self
+  def irc_upcase!
+    replace(irc_upcase)
+  end
 end

data/lib/weechat/script.rb

@@ -67,10 +67,9 @@ module Weechat
     init_properties
 
     class << self
-      def scripts(plugin = nil)
+      def all(plugin = nil)
         Plugin.all.map {|plugin| plugin.scripts}.flatten
       end
-      alias_method :all, :scripts
     end
 
     def initialize(ptr, plugin)

data/lib/weechat/server.rb

@@ -12,7 +12,7 @@ module Weechat
           if b.empty?
             nil
           else
-            Weechat::Buffer.new(b)
+            Weechat::Buffer.from_ptr(b)
           end
         },
         [:ipv6, :ssl, :ssl_verify, :autoconnect, :autoreconnect,
@@ -39,28 +39,44 @@ module Weechat
       }.freeze
 
       init_properties
+      @type = "irc_server"
 
       def autojoin?
         !disable_autojoin
       end
 
       attr_reader :ptr
-      def initialize(name)
-        @ptr = @name = name.to_s
-        raise Exception::UnknownServer, name if get_infolist.empty?
+      def initialize(*args)
+        # TODO allow the creation of new channels using commands
       end
 
-      class << self
-        alias_method :from_name, :new
+      def ==(other)
+        @ptr == other.ptr
+      end
+      alias_method :eql?, "=="
+      alias_method :equal?, "=="
 
-        def servers
+      def hash
+        @ptr.hash
+      end
+
+      class << self
+        def all
           servers = []
           Weechat::Infolist.parse("irc_server").each do |server|
-            servers << Server.new(server[:name])
+            servers << Server.from_name(server[:name])
           end
           servers
         end
-        alias_method :all, :servers
+
+        def find(name)
+          o = allocate
+          o.instance_variable_set(:@ptr, name)
+          o.instance_variable_set(:@name, name.to_s)
+          raise Exception::UnknownServer, name if o.get_infolist.empty?
+          o
+        end
+        alias_method :from_name, :find
       end
 
       def channels
@@ -82,10 +98,6 @@ module Weechat
       end
 
       # TODO method for creating a new server
-
-      def get_infolist
-        Weechat::Infolist.parse("irc_server", "", @name)
-      end
     end
   end
 end

data/lib/weechat/window.rb

@@ -58,7 +58,7 @@ module Weechat
     # @private
     @transformations = {
       [:first_line_displayed, :scroll] => lambda {|v| Weechat.integer_to_bool(v) },
-      [:buffer] => lambda {|v| Buffer.new(v) },
+      [:buffer] => lambda {|v| Buffer.from_ptr(v) },
     }.freeze
 
     # @private
@@ -78,26 +78,18 @@ module Weechat
 
     class << self
       def current
-        Window.new(Weechat.current_window)
+        Window.from_ptr(Weechat.current_window)
       end
 
-      # @todo TODO move into own module
-      def windows
-        windows = []
-        Weechat::Infolist.parse("window").each do |window|
-          windows << Window.new(window[:pointer])
-        end
-        windows
+      def from_ptr(*args)
+        o = super
+        o.instance_variable_set(:@chat, Chat.new(o))
+        o
       end
-      alias_method :all, :windows
     end
 
     init_properties
 
     attr_reader :chat
-    def initialize(*args)
-      super
-      @chat = Chat.new(self)
-    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: weechat
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Dominik Honnef
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-24 00:00:00 +01:00
+date: 2010-01-03 00:00:00 +01:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: An abstraction layer on top of the WeeChat API, allowing a cleaner and more intuitive way of writing Ruby scripts for WeeChat.
 email: dominikho@gmx.net
 executables: []
@@ -23,6 +32,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/weechat/terminal.rb
+- lib/weechat/bar.rb
 - lib/weechat/option.rb
 - lib/weechat/infolist.rb
 - lib/weechat/script.rb
@@ -36,10 +46,10 @@ files:
 - lib/weechat/pointer.rb
 - lib/weechat/buffer.rb
 - lib/weechat/color.rb
-- lib/weechat/rubyext/object.rb
 - lib/weechat/rubyext/float.rb
 - lib/weechat/rubyext/array.rb
 - lib/weechat/rubyext/integer.rb
+- lib/weechat/rubyext/hash.rb
 - lib/weechat/rubyext/string.rb
 - lib/weechat/rubyext/boolean.rb
 - lib/weechat/hook.rb
@@ -51,6 +61,7 @@ files:
 - lib/weechat/line.rb
 - lib/weechat/exceptions.rb
 - lib/weechat/command.rb
+- lib/weechat/callbacks.rb
 - lib/weechat/channel.rb
 - lib/weechat/info.rb
 - lib/weechat/process.rb

data/lib/weechat/rubyext/object.rb

@@ -1,12 +0,0 @@
-require 'yaml'
-class Object
-  def to_weechat_config
-    to_yaml
-  end
-
-  def self.from_weechat_config(v)
-    YAML.load(v)
-  end
-
-  alias_method :__class__, :class
-end