glib2 0.90.2-x86-mingw32

data/extconf.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+require 'mkmf'
+require 'rbconfig'
+require 'fileutils'
+
+package = "glib2"
+
+base_dir = Pathname(__FILE__).dirname.expand_path
+ext_dir = base_dir + "ext" + package
+mkmf_gnome2_dir = base_dir + 'lib'
+
+ruby = File.join(RbConfig::CONFIG['bindir'],
+                 RbConfig::CONFIG['ruby_install_name'] +
+                 RbConfig::CONFIG["EXEEXT"])
+
+build_dir = Pathname("ext") + package
+FileUtils.mkdir_p(build_dir.to_s) unless build_dir.exist?
+extconf_rb_path = ext_dir + "extconf.rb"
+system(ruby, "-C", build_dir.to_s, extconf_rb_path.to_s, *ARGV) || exit(false)
+
+create_makefile(package)
+FileUtils.mv("Makefile", "Makefile.lib")
+
+File.open("Makefile", "w") do |makefile|
+  makefile.puts(<<-EOM)
+all:
+	(cd ext/#{package} && $(MAKE))
+	$(MAKE) -f Makefile.lib
+
+install:
+	(cd ext/#{package} && $(MAKE) install)
+	$(MAKE) -f Makefile.lib install
+
+site-install:
+	(cd ext/#{package} && $(MAKE) site-install)
+	$(MAKE) -f Makefile.lib site-install
+
+clean:
+	(cd ext/#{package} && $(MAKE) clean)
+	$(MAKE) -f Makefile.lib clean
+
+distclean:
+	(cd ext/#{package} && $(MAKE) distclean)
+	$(MAKE) -f Makefile.lib distclean
+	@rm -f Makefile.lib
+EOM
+end

data/lib/glib-mkenums.rb

@@ -0,0 +1,199 @@
+#
+# glib-mkenums.rb
+#
+# C language enum description generation library like as glib-mkenums tool.
+#
+# Copyright(C) 2006-2008 Ruby-GNOME2 Project.
+#
+# This program is licenced under the same license of Ruby-GNOME2.
+#
+
+module GLib
+  class EnumDefinition
+    attr_accessor :EnumName, :enum_name, :ENUM_NAME, :ENUM_SHORT
+    attr_accessor :type, :Type
+    attr_accessor :g_type_prefix, :prefix
+
+    attr_reader :constants
+
+    def initialize(name, const_lines, g_type_prefix, options={})
+      @options = options || {}
+      @EnumName = name
+      @g_type_prefix = g_type_prefix
+      @constants = []
+      @enum_name = @EnumName.sub(/^[A-Z]/){|v| v.downcase}.gsub(/[A-Z]+/){|v| "_" + v.downcase}.sub(/(^_|_$)/, "")
+      @ENUM_NAME = @enum_name.upcase
+      @ENUM_SHORT = @ENUM_NAME.sub(/^#{@g_type_prefix.sub(/_TYPE.*$/, "")}/, "").sub(/^_/, "")
+
+      parse_const_lines(const_lines)
+    end
+
+    def parse_const_lines(const_lines)
+      ret = ""
+
+      if @options[:force_flags] or /<</ =~ const_lines
+        @type = "flags"
+        @Type = "Flags"
+      else
+        @type = "enum"
+        @Type = "Enum"
+      end
+      constants = []
+      const_lines.scan(/^\s*([^\s,]*).*\n/) do |name|
+        constants << name[0] unless name[0] =~ /(^[\/\*]|^$)/
+      end
+      @prefix = extract_prefix(constants)
+      constants.each do |name|
+        @constants << [name, name.sub(/#{@prefix}/, "").gsub(/_/, "-").downcase]
+      end
+    end
+
+    def extract_prefix(ary)
+      return [] if ary == nil
+      a = ary[0].split(//)
+      if ary.size == 1
+        @ENUM_NAME + "_"
+      else
+        ary[1..-1].each do |b|
+          b = b.split(//)
+          l = [a.length, b.length].min
+          a = a[0, (0...l).find{|i| a[i] != b[i] } || l]
+        end 
+        a.join('')
+      end
+    end
+
+    def create_c
+      constants = "\n" + @constants.collect{|name, nick|
+        %Q[      { #{name}, "#{name}", "#{nick}" },\n] 
+      }.join +
+        %Q[      { 0, NULL, NULL }]
+
+      ret = <<-CREATE_C
+
+GType
+#{@enum_name}_get_type (void)
+{
+  static GType etype = 0;
+  if (etype == 0) {
+    static const G#{@Type}Value values[] = {#{constants}
+    };
+    etype = g_#{@type}_register_static ("#{@EnumName}", values);
+  }
+  return etype;
+}
+      CREATE_C
+      ret
+    end
+
+    def create_h
+      %Q[
+GType #{@enum_name}_get_type (void);
+#define #{@g_type_prefix}#{@ENUM_SHORT} (#{@enum_name}_get_type())]
+    end
+
+
+    def self.parse(data, g_type_prefix, options={})
+      options ||= {}
+      enums = []
+      data.scan(/^\s*typedef\s+enum\s*
+                \{?\s*(.*?)
+                \}\s*(\w+);/mx){|constants, name|
+        enum_options = {}
+        force_flags_patterns = [(options[:force_flags] || [])].flatten
+        if force_flags_patterns.any? {|pattern| pattern === name}
+          enum_options[:force_flags] = true
+        end
+        enum = new(name, constants, g_type_prefix, enum_options)
+        enums << enum
+      }
+      enums
+    end
+  end
+
+  class MkEnums
+    # Create target_filename.c and target_filename.h from files
+    # with g_type_prefix and include_files.
+    # * target_filename: the target file name. This creates #{target_filename.c} and #{target_filename.h}.
+    # * files: header files to parse
+    # * g_type_prefix: the gtype prefix such as GTK_TYPE_
+    # * include_files: define #include <file> lines into target_filename.c
+    def self.create(target_filename, files, g_type_prefix, include_files,
+                    options)
+      puts "creating #{target_filename}.c"
+      mkenums = MkEnums.new(target_filename, files, g_type_prefix, include_files,
+                            options)
+
+      open("#{target_filename}.c", "w") do |out|
+        out.write(mkenums.create_c)
+      end
+      puts "creating #{target_filename}.h"
+      open("#{target_filename}.h", "w") do |out|
+        out.write(mkenums.create_h)
+      end
+    end
+
+    # Initialize GLib::MkEnums
+    #
+    # * target_filename: the target file name. This creates #{target_filename.c} and #{target_filename.h}.
+    # * files: header files to parse
+    # * g_type_prefix: the gtype prefix such as GTK_TYPE_
+    # * include_files: define #include <file> lines into target_filename.c
+    def initialize(target_filename, files, g_type_prefix, include_files, options)
+      @target_filename = target_filename
+      @include_files = include_files
+      @targets = []
+      files.each do |path|
+        data = ""
+        File.open(path) do |i|
+          data = i.read
+        end
+        @targets << [path, EnumDefinition.parse(data, g_type_prefix, options)]
+      end
+    end
+
+    def create_enums(meth)  # :nodoc:
+      ret = ""
+      @targets.each do |target|
+        if target[1].size > 0
+          ret << %Q[\n\n/* enumerations from "#{target[0]}" */]
+          target[1].each{|enum|
+            ret << enum.__send__(meth)
+          }
+        end
+      end
+      ret
+    end
+
+    # Create a C source as a String.
+    def create_c
+      ret = "\n/* Generated by glib-mkenums.rb ($Id: glib-mkenums.rb 3896 2010-09-25 07:49:34Z ktou $) */ \n\n"
+      ret << %Q[#include "#{@target_filename}.h"\n]
+      @include_files.each do |file|
+        ret << "#include <#{file}>\n"
+      end
+      ret << "\n"
+      ret << create_enums(:create_c)
+      ret << "\n\n/* Generated data ends here */\n\n"
+      ret
+    end
+
+    # Create a C header as a String.
+    def create_h
+      header = "#{@target_filename}.h"
+      const = "__#{File.basename(header).upcase.gsub(/-|\./, '_')}__"
+
+      ret = "\n/* Generated by glib-mkenums.rb ($Id: glib-mkenums.rb 3896 2010-09-25 07:49:34Z ktou $) */ \n\n"
+      ret << "#ifndef #{const}\n"
+      ret << "#define #{const}\n\n"
+      ret << "#include <glib-object.h>\n\n"
+      ret << "G_BEGIN_DECLS"
+      ret << create_enums(:create_h)
+      ret << "\n\nG_END_DECLS\n\n"
+      ret << "#endif /* #{const} */\n"
+      ret << "\n/* Generated data ends here */\n\n"
+      ret
+    end
+  end
+end
+

data/lib/glib2.rb

@@ -0,0 +1,239 @@
+#
+# glib2.rb
+# Copyright(C) 2005-2010 Ruby-GNOME2 Project.
+#
+# This program is licenced under the same 
+# license of Ruby-GNOME2.
+#
+
+require 'pathname'
+require 'English'
+require 'thread'
+
+module GLib
+  module_function
+  def check_binding_version?(major, minor, micro)
+    BINDING_VERSION[0] > major ||
+      (BINDING_VERSION[0] == major && 
+       BINDING_VERSION[1] > minor) ||
+      (BINDING_VERSION[0] == major && 
+       BINDING_VERSION[1] == minor &&
+       BINDING_VERSION[2] >= micro)  
+  end
+
+  def exit_application(exception, status)
+    msg = exception.message || exception.to_s
+    msg = exception.class.to_s if msg == ""
+    backtrace = exception.backtrace
+    $stderr.puts backtrace.shift + ": #{msg}"
+    backtrace.each do |v|
+      $stderr.puts "\t from #{v}"
+    end
+    exit(status)
+  end
+
+  def __add_one_arg_setter(klass)
+    #for Instance methods.
+    ary = klass.instance_methods(false)
+    ary.each do |m|
+      if /^set_(.*)/ =~ m and not ary.include? "#{$1}=" and klass.instance_method(m).arity == 1
+	begin
+          klass.module_eval("def #{$1}=(val); set_#{$1}(val); val; end\n")
+        rescue SyntaxError
+          $stderr.print "Couldn't create #{klass}\##{$1}=(v).\n" if $DEBUG
+        end
+      end
+    end
+    #for Class methods/Module functions.
+    if Object.method(:methods).arity == -1
+      ary = klass.methods(false)
+    else
+      ary = klass.methods
+    end
+    ary.each do |m|
+      if /^set_(.*)/ =~ m and not ary.include? "#{$1}=" and klass.method(m).arity == 1
+	begin
+          klass.module_eval("def self.#{$1}=(val); set_#{$1}(val); val; end\n")
+        rescue SyntaxError
+          $stderr.print "Couldn't create #{klass}\##{$1}=(v).\n" if $DEBUG
+        end
+      end
+    end
+  end
+
+  def prepend_environment_path(path)
+    path = Pathname(path) unless path.is_a?(Pathname)
+    if path.exist?
+      environment_name = "PATH"
+      separator = File::PATH_SEPARATOR
+
+      paths = (ENV[environment_name] || '').split(/#{separator}/)
+      dir = path.to_s
+      dir = dir.gsub(/\//, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+      unless paths.include?(dir)
+        paths = [dir] + paths
+        ENV[environment_name] = paths.join(separator)
+      end
+    end
+  end
+end
+
+
+base_dir = Pathname.new(__FILE__).dirname.dirname.expand_path
+vendor_dir = base_dir + "vendor" + "local"
+GLib.prepend_environment_path(vendor_dir + "bin")
+begin
+  major, minor, micro, = RUBY_VERSION.split(/\./)
+  require "#{major}.#{minor}/glib2.so"
+rescue LoadError
+  require 'glib2.so'
+end
+
+module GLib
+  
+  class Type
+
+    def decendants
+      [self] + children.map{|t| t.decendants }.flatten
+    end
+
+    def ancestors
+      #  ([self] + interfaces + (parent ? parent.ancestors : [])).reverse.uniq.reverse
+      [self] + (parent ? parent.ancestors : [])
+    end
+  end
+
+
+  class Enum
+    def _dump(limit)
+      Marshal.dump(to_i, limit)
+    end
+
+    def self._load(obj)
+      new(Marshal.load(obj))
+    end
+  end
+
+
+  class Flags
+    def _dump(limit)
+      Marshal.dump(to_i, limit)
+    end
+
+    def self._load(obj)
+      new(Marshal.load(obj))
+    end
+
+    # FIXME
+    def inspect
+      values = self.class.values
+      if values.find{|x| x == self }
+        body = nick
+      else
+        a = values.select{|x| self >= x }
+        a = a.reject{|x| a.find{|y| y > x } }
+        body = a.empty? ? '{}' : a.map{|x| x.nick }.join('|')
+      end
+      format('#<%s %s>', self.class.inspect, body)
+    end
+  end
+
+  module Log
+    DOMAIN = "Ruby/GLib"
+    LEVELS = { 
+      LEVEL_ERROR => "ERROR",
+      LEVEL_CRITICAL => "CRITICAL",
+      LEVEL_WARNING => "WARNING",
+      LEVEL_MESSAGE => "MESSAGE",
+      LEVEL_INFO => "INFO",
+      LEVEL_DEBUG => "DEBUG"
+    }
+
+    module_function
+    def error(str)
+      log(DOMAIN, LEVEL_ERROR, caller(1)[0] << ": " << str)
+    end
+    def message(str)
+      log(DOMAIN, LEVEL_MESSAGE, caller(1)[0] << ": " << str)
+    end
+    def critical(str)
+      log(DOMAIN, LEVEL_CRITICAL, caller(1)[0] << ": " << str)
+    end
+    def warning(str)
+      log(DOMAIN,  LEVEL_WARNING, caller(1)[0] << ": " << str)
+    end
+    
+    def set_log_domain(domain)
+      level = GLib::Log::LEVEL_MASK
+      if $DEBUG
+        level = 255
+      elsif $VERBOSE
+        level = 127
+      end
+      GLib::Log.set_handler(domain, level)
+    end
+  end
+
+  if const_defined?(:UserDirectory)
+    class UserDirectory
+      constants.each do |name|
+        if /\ADIRECTORY_/ =~ name
+          const_set($POSTMATCH, const_get(name))
+        end
+      end
+    end
+  end
+
+  LOG_DOMAIN = "GLib"
+
+  class Object
+    LOG_DOMAIN = "GLib-GObject"
+  end
+
+  class Thread
+    LOG_DOMAIN = "GThread"
+  end
+
+  module Module
+    LOG_DOMAIN = "GModule"
+  end
+end
+
+GLib::Log.set_log_domain(nil)
+GLib::Log.set_log_domain(GLib::LOG_DOMAIN)
+GLib::Log.set_log_domain(GLib::Object::LOG_DOMAIN)
+GLib::Log.set_log_domain(GLib::Thread::LOG_DOMAIN)
+GLib::Log.set_log_domain(GLib::Module::LOG_DOMAIN)
+
+# Ruby-GetText-Package support
+begin
+  require 'gettext'
+rescue LoadError
+  unless defined? GetText
+    module GetText
+      module_function
+      def _(msgid); msgid; end
+      def N_(msgid); msgid; end
+      def n_(msgid, msgid_plural, n)
+	n == 1 ? msgid : msgid_plural
+      end
+      def s_(msgid, div = '|')
+	if index = msgid.rindex(div)
+	  msgid = msgid[(index + 1)..-1]
+	else
+	  msgid
+	end
+      end
+      def bindtextdomain(domainname, path = nil, locale = nil, charset = nil)
+      end
+    end
+  end
+end
+
+=begin
+Don't we need this?
+ObjectSpace.define_finalizer(GLib) {
+  GLib::Log.cancel_handler
+  puts "GLib::Log.cancel_handler was called." if $DEBUG
+}
+=end

data/lib/gnome2-win32-binary-downloader.rb

@@ -0,0 +1,92 @@
+# Copyright(C) 2010 Ruby-GNOME2 Project.
+#
+# This program is licenced under the same license of Ruby-GNOME2.
+
+require 'open-uri'
+require 'rubygems'
+require 'mechanize'
+
+class GNOME2Win32BinaryDownloader
+  class << self
+    def download(options)
+      downloader = new(options)
+      packages = options[:packages] || [options[:package]]
+      packages.compact.each do |package|
+        downloader.download_package(package)
+      end
+      dependencies = options[:dependencies] || [options[:dependency]]
+      dependencies.compact.each do |dependency|
+        downloader.download_dependency(dependency)
+      end
+    end
+  end
+
+  URL_BASE = "http://ftp.gnome.org/pub/gnome/binaries/win32"
+  def initialize(options={})
+    @output_dir = options[:output_dir] || File.join("vendor", "local")
+  end
+
+  def download_package(package)
+    version_page = agent.get("#{URL_BASE}/#{package}")
+    latest_version_link = version_page.links.sort_by do |link|
+      if /\A(\d+\.\d+)\/\z/ =~ link.href
+        $1.split(/\./).collect {|component| component.to_i}
+      else
+        [-1]
+      end
+    end.last
+
+    latest_version_page = latest_version_link.click
+    latest_version = latest_version_page.links.collect do |link|
+      if /_([\d\.\-]+)_win32\.zip\z/ =~ link.href
+        version = $1
+        [version.split(/[\.\-]/).collect {|component| component.to_i}, version]
+      else
+        [[-1], nil]
+      end
+    end.sort_by do |normalized_version, version|
+      normalized_version
+    end.last[1]
+
+    latest_version_page.links.each do |link|
+      if /_#{Regexp.escape(latest_version)}_win32\.zip\z/ =~ link.href
+        click_zip_link(link)
+      end
+    end
+  end
+
+  def download_dependency(dependency)
+    dependencies_page = agent.get("#{URL_BASE}/dependencies")
+    latest_version = dependencies_page.links.collect do |link|
+      if /\A#{Regexp.escape(dependency)}_([\d\.\-]+)_win32\.zip\z/ =~ link.href
+        version = $1
+        [version.split(/[\.\-]/).collect {|component| component.to_i}, version]
+      else
+        [[-1], nil]
+      end
+    end.sort_by do |normalized_version, version|
+      normalized_version
+    end.last[1]
+    dependencies_page.links.each do |link|
+      if /\A#{Regexp.escape(dependency)}(?:-dev)?_#{Regexp.escape(latest_version)}_win32.zip/ =~ link.href
+        click_zip_link(link)
+      end
+    end
+  end
+
+  private
+  def agent
+    @agent ||= Mechanize.new
+  end
+
+  def click_zip_link(link)
+    zip = link.click
+    FileUtils.mkdir_p(@output_dir)
+    Dir.chdir(@output_dir) do
+      open(zip.filename, "wb") do |file|
+        file.print(zip.body)
+      end
+      system("unzip '#{zip.filename}'")
+    end
+  end
+end