rroonga 0.9.2-mswin32

data/license/RUBY

@@ -0,0 +1,59 @@
+Rcairo is copyrighted free software by the persons listed in AUTHORS 
+distributed under the same conditions as ruby; which follow:
+
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the GPL
+(see the file GPL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/misc/grnop2ruby.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009  Yuto Hayamizu <y.hayamizu@gmail.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+#
+# This script expects "groonga.h" as a first argument, extracts the
+# 'grn_operator', and write 'rb_define_const's of 'grn_operator' to
+# standard outout.
+#
+# Usage:
+#   ruby grnop2ruby.rb /path/to/groonga.h
+#
+
+replace_dictionary = {
+  "VAR" => "VARIABLE",
+  "EXPR" => "EXPRESSION",
+  "NOP" => "NO_OPERATION",
+  "REF" => "REFERENCE",
+  "OBJ" => "OBJECT",
+  "INCR" => "INCREMENT",
+  "DECR" => "DECREMENT",
+  "MOD" => "MODULO",
+  "LCP" => "LONGEST_COMMON_PREFIX",
+}
+
+ARGF.each_line do |line|
+  case line
+  when /\A\s+(GRN_OP_\w+)/
+    operator = $1
+    rb_operator = operator.gsub(/\AGRN_OP_/, "").split("_").map{ |word|
+      replace_dictionary[word] || word
+    }.join("_")
+    puts "    rb_define_const(rb_mGrnOperation, \"%s\",
+                    UINT2NUM(%s));" % [rb_operator, operator]
+  end
+end

data/pkg-config.rb

@@ -0,0 +1,333 @@
+# Copyright 2008-2009 Kouhei Sutou <kou@cozmixng.org>
+# This file is made available under the same terms as Ruby.
+
+require "rbconfig"
+
+require 'mkmf'
+require 'shellwords'
+require 'English'
+require 'pathname'
+
+class PackageConfig
+  @@default_prepend_paths = []
+  @@default_append_paths = []
+
+  class << self
+    def prepend_default_path(path)
+      @@default_prepend_paths.unshift(path)
+    end
+
+    def append_default_path(path)
+      @@default_append_paths << path
+    end
+  end
+
+  attr_accessor :msvc_syntax
+  def initialize(name, path=nil, msvc_syntax=false)
+    @name = name
+    @path = path || ENV["PKG_CONFIG_PATH"]
+    @path = [@path, guess_default_path].compact.join(separator)
+    @msvc_syntax = msvc_syntax
+    @variables = @declarations = nil
+    override_variables = with_config("override-variables", "")
+    @override_variables = parse_override_variables(override_variables)
+  end
+
+  def exist?
+    not pc.nil?
+  end
+
+  def requires
+    parse_requires(declaration("Requires"))
+  end
+
+  def requires_private
+    parse_requires(declaration("Requires.private"))
+  end
+
+  def cflags
+    path_flags, other_flags = collect_cflags
+    (other_flags + path_flags).join(" ")
+  end
+
+  def cflags_only_I
+    collect_cflags[0].join(" ")
+  end
+
+  def libs
+    path_flags, other_flags = collect_libs
+    (other_flags + path_flags).join(" ")
+  end
+
+  def libs_only_l
+    collect_libs[1].find_all do |arg|
+      if @msvc_syntax
+        /\.lib\z/ =~ arg
+      else
+        /\A-l/ =~ arg
+      end
+    end.join(" ")
+  end
+
+  def version
+    declaration("Version")
+  end
+
+  def variable(name)
+    parse_pc if @variables.nil?
+    expand_value(@override_variables[name] || @variables[name])
+  end
+
+  def declaration(name)
+    parse_pc if @declarations.nil?
+    expand_value(@declarations[name])
+  end
+
+  private
+  def paths
+    paths = @@default_prepend_paths
+    paths += @path.split(separator)
+    paths += @@default_append_paths
+    paths
+  end
+
+  def pc
+    paths.each do |path|
+      pc_name = File.join(path, "#{@name}.pc")
+      return pc_name if File.exist?(pc_name)
+    end
+    return nil
+  end
+
+  def separator
+    File.expand_path(".").index(":") ? ";" : ":"
+  end
+
+  def collect_cflags
+    all_cflags = (requires_private + requires.reverse).collect do |package|
+      self.class.new(package, @path, @msvc_syntax).cflags
+    end
+    all_cflags = [declaration("Cflags")] + all_cflags
+    all_cflags = all_cflags.join(" ").gsub(/-I /, '-I').split.uniq
+    path_flags, other_flags = all_cflags.partition {|flag| /\A-I/ =~ flag}
+    path_flags = path_flags.reject do |flag|
+      flag == "-I/usr/include"
+    end
+    if @msvc_syntax
+      path_flags = path_flags.collect do |flag|
+        flag.gsub(/\A-I/, "/I")
+      end
+    end
+    [path_flags, other_flags]
+  end
+
+  def collect_libs
+    all_libs = requires.collect do |package|
+      self.class.new(package, @path, @msvc_syntax).libs
+    end
+    all_libs = [declaration("Libs")] + all_libs
+    all_libs = all_libs.join(" ").gsub(/-([Ll]) /, '\1').split.uniq
+    path_flags, other_flags = all_libs.partition {|flag| /\A-L/ =~ flag}
+    path_flags = path_flags.reject do |flag|
+      /\A-L\/usr\/lib(?:64)?\z/ =~ flag
+    end
+    if @msvc_syntax
+      path_flags = path_flags.collect do |flag|
+        flag.gsub(/\A-L/, "/libpath:")
+      end
+      other_flags = other_flags.collect do |flag|
+        if /\A-l/ =~ flag
+          "#{$POSTMATCH}.lib"
+        else
+          flag
+        end
+      end
+    end
+    [path_flags, other_flags]
+  end
+
+  IDENTIFIER_RE = /[\w.]+/
+  def parse_pc
+    raise ".pc for #{@name} doesn't exist." unless exist?
+    @variables = {}
+    @declarations = {}
+    File.open(pc) do |input|
+      input.each_line do |line|
+        line = line.gsub(/#.*/, '').strip
+        next if line.empty?
+        case line
+        when /^(#{IDENTIFIER_RE})=/
+          @variables[$1] = $POSTMATCH.strip
+        when /^(#{IDENTIFIER_RE}):/
+          @declarations[$1] = $POSTMATCH.strip
+        end
+      end
+    end
+  end
+
+  def parse_requires(requires)
+    return [] if requires.nil?
+    requires_without_version = requires.gsub(/[<>]?=\s*[\d.]+\s*/, '')
+    requires_without_version.split(/[,\s]+/)
+  end
+
+  def parse_override_variables(override_variables)
+    variables = {}
+    override_variables.split(",").each do |variable|
+      name, value = variable.split("=", 2)
+      variables[name] = value
+    end
+    variables
+  end
+
+  def expand_value(value)
+    return nil if value.nil?
+    value.gsub(/\$\{(#{IDENTIFIER_RE})\}/) do
+      variable($1)
+    end
+  end
+
+  def search_pkg_config_from_path(pkg_config)
+    (ENV["PATH"] || "").split(separator).each do |path|
+      try_pkg_config = Pathname(path) + pkg_config
+      return try_pkg_config if try_pkg_config.exist?
+    end
+    nil
+  end
+
+  def search_pkg_config_by_dln_find_exe(pkg_config)
+    begin
+      require "dl/import"
+    rescue LoadError
+      return nil
+    end
+    dln = Module.new
+    dln.module_eval do
+      if DL.const_defined?(:Importer)
+        extend DL::Importer
+      else
+        extend DL::Importable
+      end
+      begin
+        dlload RbConfig::CONFIG["LIBRUBY"]
+      rescue RuntimeError
+        return nil if $!.message == "unknown error"
+        return nil if /: image not found\z/ =~ $!.message
+        raise
+      rescue DL::DLError
+        return nil
+      end
+      extern "const char *dln_find_exe(const char *, const char *)"
+    end
+    path = dln.dln_find_exe(pkg_config.to_s, nil)
+    if path.size.zero?
+      nil
+    else
+      Pathname(path.to_s)
+    end
+  end
+
+  def guess_default_path
+    default_path = ["/usr/local/lib64/pkgconfig",
+                    "/usr/local/lib/pkgconfig",
+                    "/usr/local/libdata/pkgconfig",
+                    "/opt/local/lib/pkgconfig",
+                    "/usr/lib64/pkgconfig",
+                    "/usr/lib/pkgconfig",
+                    "/usr/X11/lib/pkgconfig/",
+                    "/usr/share/pkgconfig"].join(separator)
+    libdir = ENV["PKG_CONFIG_LIBDIR"]
+    default_path = [libdir, default_path].join(separator) if libdir
+
+    pkg_config = with_config("pkg-config", ENV["PKG_CONFIG"] || "pkg-config")
+    pkg_config = Pathname.new(pkg_config)
+    unless pkg_config.absolute?
+      found_pkg_config = search_pkg_config_from_path(pkg_config)
+      pkg_config = found_pkg_config if found_pkg_config
+    end
+    unless pkg_config.absolute?
+      found_pkg_config = search_pkg_config_by_dln_find_exe(pkg_config)
+      pkg_config = found_pkg_config if found_pkg_config
+    end
+
+    return default_path unless pkg_config.absolute?
+    [(pkg_config.parent.parent + "lib" + "pkgconfig").to_s,
+     (pkg_config.parent.parent + "libdata" + "pkgconfig").to_s,
+     default_path].join(separator)
+  end
+end
+
+module PKGConfig
+  module_function
+  def msvc?
+    /mswin32/.match(RUBY_PLATFORM) and /^cl\b/.match(Config::CONFIG['CC'])
+  end
+
+  def package_config(package)
+    PackageConfig.new(package, nil, msvc?)
+  end
+
+  def exist?(pkg)
+    package_config(pkg).exist?
+  end
+
+  def libs(pkg)
+    package_config(pkg).libs
+  end
+
+  def libs_only_l(pkg)
+    package_config(pkg).libs_only_l
+  end
+
+  def cflags(pkg)
+    package_config(pkg).cflags
+  end
+
+  def cflags_only_I(pkg)
+    package_config(pkg).cflags_only_I
+  end
+
+  def modversion(pkg)
+    package_config(pkg).version
+  end
+
+  def check_version?(pkg, major = 0, minor = 0, micro = 0)
+    return false unless exist?(pkg)
+    ver = modversion(pkg).split(".").collect{|item| item.to_i}
+    (0..2).each {|i| ver[i] = 0 unless ver[i]}
+
+    (ver[0] > major ||
+     (ver[0] == major && ver[1] > minor) ||
+     (ver[0] == major && ver[1] == minor &&
+      ver[2] >= micro))
+  end
+
+  def have_package(pkg, major = nil, minor = 0, micro = 0)
+    if major.nil?
+      STDOUT.print("checking for #{pkg}... ")
+    else
+      STDOUT.print("checking for #{pkg} version (>= #{major}.#{minor}.#{micro})... ")
+    end
+    major ||= 0
+    STDOUT.flush
+    if check_version?(pkg, major, minor, micro)
+      STDOUT.print "yes\n"
+      libraries = libs_only_l(pkg)
+      dldflags = libs(pkg)
+      dldflags = (Shellwords.shellwords(dldflags) -
+                  Shellwords.shellwords(libraries))
+      dldflags = dldflags.map {|s| /\s/ =~ s ? "\"#{s}\"" : s }.join(' ')
+      $libs   += ' ' + libraries
+      if /mswin32/ =~ RUBY_PLATFORM
+	$DLDFLAGS += ' ' + dldflags
+      else
+	$LDFLAGS += ' ' + dldflags
+      end
+      $CFLAGS += ' ' + cflags(pkg)
+      true
+    else
+      STDOUT.print "no\n"
+      false
+    end
+  end
+end

data/test-unit/Rakefile

@@ -0,0 +1,40 @@
+# -*- ruby -*-
+
+require 'rubygems'
+gem 'rdoc'
+require 'hoe'
+require './lib/test/unit/version.rb'
+
+ENV["NODOT"] = "yes"
+
+version = Test::Unit::VERSION
+ENV["VERSION"] = version
+Hoe.spec('test-unit') do |p|
+  Hoe::Test::SUPPORTED_TEST_FRAMEWORKS[:testunit2] = "test/run-test.rb"
+  p.version = version
+  p.developer('Kouhei Sutou', 'kou@cozmixng.org')
+  p.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+
+  # Ex-Parrot:
+  # p.developer('Nathaniel Talbott', 'nathaniel@talbott.ws')
+end
+
+task :check_manifest => :clean_test_result
+task :check_manifest => :clean_coverage
+
+task :clean_test_result do
+  test_results = Dir.glob("**/.test-result")
+  sh("rm", "-rf", *test_results) unless test_results.empty?
+end
+
+task :clean_coverage do
+  sh("rm", "-rf", "coverage")
+end
+
+task :tag do
+  message = "Released Test::Unit #{version}!"
+  base = "svn+ssh://#{ENV['USER']}@rubyforge.org/var/svn/test-unit/"
+  sh 'svn', 'copy', '-m', message, "#{base}trunk", "#{base}tags/#{version}"
+end
+
+# vim: syntax=Ruby