weechat 0.0.1

data/lib/weechat/property.rb

@@ -0,0 +1,47 @@
+module Weechat
+  class Property < Blankslate
+    @properties = [] # we can't use a Hash because hashing
+                     # blankslate... breaks things
+
+    
+    def self.properties
+      @properties
+    end
+
+    def initialize(weechat_obj, property)
+      self.__class__.properties << [weechat_obj.ptr, property, self]
+      @old_obj     = weechat_obj.__get_property(property)
+      @weechat_obj = weechat_obj
+      @property    = property
+      @settable    = weechat_obj.settable_property?(property)
+      @frozen      = false
+    end
+
+    def __freeze__
+      @frozen = true
+    end
+
+    def method_missing(m, *args, &block)
+      if @frozen
+        obj = @old_obj
+      else
+        obj = @weechat_obj.__get_property(@property)
+      end
+      ret = obj.__send__(m, *args, &block)
+
+      if (@old_obj != obj) && @settable && !@frozen
+        @weechat_obj.set_property(@property, obj)
+      end
+
+      unless @frozen
+        begin
+          @old_obj = obj.dup
+        rescue TypeError
+          @old_obj = obj
+        end
+      end
+      
+      ret
+    end
+  end
+end

data/lib/weechat/rubyext/array.rb

@@ -0,0 +1,22 @@
+class Array
+  def self.from_weechat_config(v)
+    v.escaped_split(",")
+  end
+
+  def to_weechat_config
+    map {|entry|
+      case entry
+      when String
+        entry.gsub(/(\\+)?,/) {|m|
+          if $1.nil?
+            "\\,"
+          else
+            $1 + $1 + "\\,"
+          end
+        }
+      else
+        entry.to_weechat_config
+      end
+    }.join(",")
+  end
+end

data/lib/weechat/rubyext/boolean.rb

@@ -0,0 +1,17 @@
+class Boolean
+  def self.from_weechat_config(v)
+    Weechat.integer_to_bool(Weechat.config_string_to_boolean(v))
+  end
+end
+
+class TrueClass
+  def to_weechat_config
+    "on"
+  end
+end
+
+class FalseClass
+  def to_weechat_config
+    "off"
+  end
+end

data/lib/weechat/rubyext/float.rb

@@ -0,0 +1,9 @@
+class Float
+  def self.from_weechat_config(v)
+    Float(v)
+  end
+
+  def to_weechat_config
+    to_s
+  end
+end

data/lib/weechat/rubyext/integer.rb

@@ -0,0 +1,9 @@
+class Integer
+  def self.from_weechat_config(v)
+    Integer(v)
+  end
+
+  def to_weechat_config
+    to_s
+  end
+end

data/lib/weechat/rubyext/object.rb

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

data/lib/weechat/rubyext/string.rb

@@ -0,0 +1,142 @@
+class String
+  def self.from_weechat_config(v)
+    v
+  end
+
+  def to_weechat_config
+    self
+  end
+
+  # Checks if the string represents a valid channel name
+  #
+  # @return [Boolean]
+  def channel?
+    Weechat.info_get("irc_is_channel", self) == '1' ? true : false
+  end
+
+  # Returns the nick part of a banmask
+  #
+  # @return [String] The nick
+  def nick
+    Weechat.info_get("irc_nick_from_host", self)
+  end
+
+  # Removes or replaces all color codes
+  #
+  # @param [String] replacement The replacement string for color codes
+  # @return [String] A new string without color codes
+  def remove_color(replacement='')
+    Weechat.string_remove_color(self, replacement)
+  end
+  alias_method :remove_colors, :remove_color
+  alias_method :strip_colors, :remove_color
+
+  # Same as {#remove_color} but changing the string in place.
+  #
+  # @param (see String#remove_color)
+  # @return [String] self
+  def remove_color!(replacement='')
+    self.replace(remove_color(replacement))
+  end
+  alias_method :remove_colors!, :remove_color!
+  alias_method :strip_colors!, :remove_color!
+
+  def escaped_split(split_char, escape_char = "\\")
+    parts = []
+    escaping = false
+    cur = ""
+
+    self.split('').each do |char|
+      if char == escape_char
+        if escaping
+          cur << char
+          escaping = false
+        else
+          escaping = true
+        end
+      elsif char == split_char
+        if !escaping
+          parts << cur
+          cur = ""
+        else
+          cur << char
+          escaping = false
+        end
+      else
+        if escaping
+          cur << escape_char
+          escaping = false
+        end
+        cur << char
+      end
+    end
+    parts << cur
+    if parts.size == 1 && parts[0].empty?
+      []
+    else
+      parts
+    end
+  end
+
+  # @author Loren Segal
+  def shell_split
+    out = [""]
+    state = :none
+    escape_next = false
+    quote = ""
+    strip.split(//).each do |char|
+      case state
+      when :none, :space
+        case char
+        when /\s/
+          out << "" unless state == :space
+          state = :space
+          escape_next = false
+        when "\\"
+          if escape_next
+            out.last << char
+            escape_next = false
+          else
+            escape_next = true
+          end
+        when '"', "'"
+          if escape_next
+            out.last << char
+            escape_next = false
+          else
+            state = char
+            quote = ""
+          end
+        else
+          state = :none
+          out.last << char
+          escape_next = false
+        end
+      when '"', "'"
+        case char
+        when '"', "'"
+          if escape_next
+            quote << char
+            escape_next = false
+          elsif char == state
+            out.last << quote
+            state = :none
+          else
+            quote << char
+          end
+        when '\\'
+          if escape_next
+            quote << char
+            escape_next = false
+          else
+            escape_next = true
+          end
+        else
+          quote << char
+          escape_next = false
+        end
+      end
+    end
+    out
+  end
+end

data/lib/weechat/script.rb

@@ -0,0 +1,85 @@
+module Weechat
+  class Script
+    module Skeleton
+      def self.included(other)
+        other.__send__ :include, InstanceMethods
+        other.__send__ :extend, InstanceMethods
+        other.__send__ :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def script
+          {
+            :license     => 'unlicensed',
+            :version     => '0.0.1',
+            :author      => 'Anonymous',
+            :description => 'Empty script description',
+            :charset     => '',
+            :gem_version => '0.0.1',
+          }.merge(@script)
+        end
+
+        def config
+          @config || Weechat::Script::Config.new({})
+        end
+      end
+
+      module InstanceMethods
+        def weechat_init
+          if (self.script[:gem_version].split('.') <=> Weechat::VERSION.split('.')) > 0
+            Weechat.puts "This script ('#{self.script[:name]}') "\
+            "requires a version of the weechat ruby gem of at least #{self.script[:gem_version]}. "\
+            "You are currently using the version #{Weechat::VERSION}"
+            return Weechat::WEECHAT_RC_ERROR
+          end
+
+          ret = Weechat.register(self.script[:name],
+                                 self.script[:author],
+                                 self.script[:version],
+                                 self.script[:license],
+                                 self.script[:description],
+                                 'weechat_script_unload',
+                                 self.script[:charset])
+          if Weechat.integer_to_bool(ret)
+            self.config.set_script_name!(self.script[:name])
+            self.config.init!
+            if respond_to?(:setup)
+              return Weechat::Utilities.evaluate_call { setup }
+            end
+
+            return Weechat::WEECHAT_RC_OK
+          end
+        end
+
+        def weechat_script_unload
+          if respond_to?(:teardown)
+            return Weechat::Utilities.evaluate_call { teardown }
+          end
+
+          return Weechat::WEECHAT_RC_OK
+        end
+      end
+    end
+
+    include Weechat::Pointer
+    extend Weechat::Properties
+
+    init_properties
+
+    class << self
+      def scripts(plugin = nil)
+        Plugin.all.map {|plugin| plugin.scripts}.flatten
+      end
+      alias_method :all, :scripts
+    end
+
+    def initialize(ptr, plugin)
+      super(ptr)
+      @plugin = plugin
+    end
+
+    def get_infolist
+      Weechat::Infolist.parse("#{@plugin.name}_script", @ptr)
+    end
+  end
+end

data/lib/weechat/script/config.rb

@@ -0,0 +1,146 @@
+module Weechat
+  class Script
+    class Config
+      def initialize(specification)
+        @specification = specification
+        @script        = nil
+      end
+
+      def init!
+        populate!
+        hook!(false) {|config, value|
+          config.gsub!(/^plugins\.var\.ruby\.#{@script}\./, '')
+          spec = @specification[config]
+          begin
+            spec[0].from_weechat_config(value)
+          rescue
+            set!(config, spec[1])
+          end
+        }
+      end
+
+      # Hook for config changes
+      def hook!(evaluate = true, &callback)
+        @specification.each do |config, spec|
+          type    = spec[0]
+          default = spec[1]
+          Weechat::Hooks::Config.new("plugins.var.ruby.#{@script}.#{config}") {|config, value|
+            if evaluate
+              value = type.from_weechat_config(value) rescue default
+            end
+            callback.call(config, value)
+          }
+        end
+      end
+
+      def set_script_name!(name)
+        @script = name
+      end
+
+      # Resets all options to their default.
+      #
+      # @return [void]
+      def reset!
+        clear!
+        populate!
+      end
+
+      # Unsets all options.
+      #
+      # @return [void]
+      def clear!
+        @specification.keys.each {|key| unset!(key)}
+      end
+
+      # This will set the default values for all unset options.
+      #
+      # @return [void]
+      def populate!
+        @specification.each do |key, value|
+          if not set?(key)
+            set!(key, value[1])
+          end
+        end
+      end
+
+      # Checks if an option is set.
+      #
+      # @param [#to_s] option
+      # @return [Boolean]
+      def set?(option)
+        Weechat.integer_to_bool(Weechat.config_is_set_plugin(option.to_s))
+      end
+
+      # Unsets an option.
+      #
+      # @param [#to_s] The option to unset
+      # @return [Weechat::CONFIG_OPTION_UNSET_OK_NO_RESET,
+      #   Weechat::CONFIG_OPTION_UNSET_RESET,
+      #   Weechat::CONFIG_OPTION_UNSET_REMOVED,
+      #   Weechat::CONFIG_OPTION_UNSET_ERROR] Integer denoting in how
+      #   far unsetting the option worked.
+      # @see http://www.weechat.org/files/doc/stable/weechat_plugin_api.en.html#_weechat_config_unset_plugin
+      def unset!(option)
+        Weechat.config_unset_plugin(option.to_s)
+      end
+
+      # Returns an option. If it isn't set, return the default value.
+      #
+      # @param [#to_s] option
+      # @return [Object]
+      def get!(option)
+        case ret = __get(option)
+        when true, false, nil
+          ret
+        else
+          Option.new(self, option)
+        end
+      end
+
+      def __get(option)
+        if set?(option)
+          return @specification[option][0].from_weechat_config(Weechat.config_get_plugin(option))
+        else
+          return @specification[option][1]
+        end
+      end
+
+      # Sets the value of an option.
+      #
+      # @param [#to_s] option
+      # @param [#to_weechat_config, #to_s] value
+      # @return [Weechat::CONFIG_OPTION_SET_OK_CHANGED,
+      #   Weechat::CONFIG_OPTION_SET_OK_SAME_VALUE,
+      #   Weechat::CONFIG_OPTION_SET_OPTION_NOT_FOUND,
+      #   Weechat::CONFIG_OPTION_SET_ERROR] Integer denoting in how
+      #   far setting the option worked.
+      # @see http://www.weechat.org/files/doc/stable/weechat_plugin_api.en.html#_weechat_config_set_plugin
+      def set!(option, value, freeze = false)
+        value = value.to_weechat_config
+        Weechat.config_set_plugin(option.to_s, value)
+        if freeze
+          Option.options.each do |opt|
+            if opt[0..1] == [self, option]
+              opt[2].__freeze__
+            end
+          end
+        end
+      end
+
+      def method_missing(m, *args)
+        ms = m.to_s
+        if ms[-1..-1] != '='
+          if @specification.has_key?(ms)
+            return get!(ms)
+          end
+        else
+          if @specification.has_key?(ms[0..-2])
+            return set!(ms[0..-2], args[0], true)
+          end
+        end
+
+        super
+      end
+    end
+  end
+end