From c5fab448d4260594a876a2d29339156e45bfd379 Mon Sep 17 00:00:00 2001 From: Eric Wong Date: Fri, 5 Apr 2013 22:08:41 +0000 Subject: tree reorganization + various maint fixes Using an ext/ directory is easier to grok for RubyGems --- .gitignore | 2 +- GNUmakefile | 63 ++ README | 16 + doc.mk | 27 - ext/mahoro/extconf.rb | 9 + ext/mahoro/mahoro.c | 565 ++++++++++++++++ ext/mahoro/nogvl_compat.h | 54 ++ extconf.rb | 9 - mahoro.c | 565 ---------------- mahoro.gemspec | 8 +- nogvl_compat.h | 54 -- setup.rb | 1586 +++++++++++++++++++++++++++++++++++++++++++++ test.rb | 104 --- test/test_mahoro.rb | 105 +++ www/.gitignore | 1 + 15 files changed, 2404 insertions(+), 764 deletions(-) create mode 100644 GNUmakefile create mode 100644 README delete mode 100644 doc.mk create mode 100644 ext/mahoro/extconf.rb create mode 100644 ext/mahoro/mahoro.c create mode 100644 ext/mahoro/nogvl_compat.h delete mode 100644 extconf.rb delete mode 100644 mahoro.c delete mode 100644 nogvl_compat.h create mode 100644 setup.rb delete mode 100755 test.rb create mode 100755 test/test_mahoro.rb create mode 100644 www/.gitignore diff --git a/.gitignore b/.gitignore index 63dfd4f..eb14a42 100644 --- a/.gitignore +++ b/.gitignore @@ -5,4 +5,4 @@ Makefile /doc /.ri -mahoro.txt +*.tar.gz diff --git a/GNUmakefile b/GNUmakefile new file mode 100644 index 0000000..9fb82f5 --- /dev/null +++ b/GNUmakefile @@ -0,0 +1,63 @@ +# maintainer jobs here, not needed for normal users +all:: + +.ri/created.rid: ext/mahoro/mahoro.c lib/mahoro/thread_safe.rb + rdoc --ri -o $(@D) $^ + +order = +order += Mahoro +order += Mahoro.new +order += Mahoro\#file +order += Mahoro\#buffer +order += Mahoro\#flags= +order += Mahoro\#valid? +order += Mahoro\#compile +order += Mahoro.compile +order += Mahoro::ThreadSafe + +www/API: .ri/created.rid + ( \ + for i in $(order); \ + do \ + ri --no-standard-docs -T -d .ri -w 80 "$$i" \ + | col -b \ + | grep -vF $(CURDIR)/.ri; \ + done \ + ) > $@ + +www/API.gz: www/API + gzip < $< > $@ + touch -r $< $@ + +www/README.gz: README + install -p -m 644 README www/ + gzip < $< > $@ + touch -r $< $@ + +all:: www/API.gz www/README.gz +clean: + $(RM) www/* + +ifneq ($(VERSION),) +gem := mahoro-$(VERSION).gem +$(gem): $(shell git ls-files) + VERSION=$(VERSION) gem build mahoro.gemspec + +tgz := mahoro-$(VERSION).tar.gz +$(tgz): $(shell git ls-files) + git archive --format=tar --prefix=mahoro-$(VERSION)/ HEAD | \ + gzip -9 > $@ +else +gem tgz: + @echo >&2 error VERSION not defined + @false +endif + +package: $(gem) $(tgz) + +RSYNC = rsync +publish_doc: all + $(RSYNC) --delete --exclude .gitignore -av \ + www/ dcvr:/srv/bogomips/mahoro/ + +.PHONY: publish_doc package diff --git a/README b/README new file mode 100644 index 0000000..6f8abc3 --- /dev/null +++ b/README @@ -0,0 +1,16 @@ +Mahoro - a Ruby interface to libmagic + +An interface to libmagic to determine file types using "magic" numbers. +This can be used in place of calling the file(1) command in Ruby scripts. +Shu-yu Guo is the original author but all maintenance is handled by +Eric Wong nowadays. + +documentation: http://bogomips.org/mahoro/API +source: git clone git://bogomips.org/mahoro.git +cgit web viewer: http://bogomips.org/mahoro.git/ +mailing list: mahoro@librelist.org (plain-text only, please) +maintainer: Eric Wong +libmagic: https://en.wikipedia.org/wiki/Libmagic + +Feel free to contact Eric Wong privately via plain-text email if you're not +comfortable with the public mailing list. diff --git a/doc.mk b/doc.mk deleted file mode 100644 index 2480585..0000000 --- a/doc.mk +++ /dev/null @@ -1,27 +0,0 @@ -all:: - -.ri/created.rid: mahoro.c lib/mahoro/thread_safe.rb - rdoc --ri -o $(@D) $^ - -order = -order += Mahoro -order += Mahoro.new -order += Mahoro\#file -order += Mahoro\#buffer -order += Mahoro\#flags= -order += Mahoro\#valid? -order += Mahoro\#compile -order += Mahoro.compile -order += Mahoro::ThreadSafe - -mahoro.txt: .ri/created.rid - ( \ - for i in $(order); \ - do \ - ri --no-standard-docs -T -d .ri -w 80 "$$i" \ - | col -b \ - | grep -vF $(CURDIR)/.ri; \ - done \ - ) > $@ - -all:: mahoro.txt diff --git a/ext/mahoro/extconf.rb b/ext/mahoro/extconf.rb new file mode 100644 index 0000000..0709016 --- /dev/null +++ b/ext/mahoro/extconf.rb @@ -0,0 +1,9 @@ +require 'mkmf' + +dir_config('magic') +have_library('magic', 'magic_open') +have_func('rb_thread_call_without_gvl') +have_func('rb_thread_blocking_region') +create_makefile('mahoro') + +# arch-tag: extconf diff --git a/ext/mahoro/mahoro.c b/ext/mahoro/mahoro.c new file mode 100644 index 0000000..01d1cf8 --- /dev/null +++ b/ext/mahoro/mahoro.c @@ -0,0 +1,565 @@ +/* + * This file is Public Domain. + * + * Note: The current maintainer (Eric Wong) respects and preserves the + * original coding style of the original author (Shu-yu Guo) in case + * he ever chooses to return to this project. + */ + +#include +#include +#include "nogvl_compat.h" + +#ifndef RSTRING_LEN +# define RSTRING_LEN(s)->len +#endif +#ifndef RSTRING_PTR +# define RSTRING_PTR(s)->ptr +#endif + +static VALUE eMahoroError; +static ID id_to_path; + +struct nogvl_args { + magic_t cookie; + union { + const char *path; + int fd; + } as; +}; + +/* :nodoc: called automatically by GC */ +static void +mahoro_free(ptr) + void *ptr; +{ + if (ptr) + magic_close((magic_t)ptr); +} + +/* :nodoc: called automatically on Mahoro#initialize */ +static VALUE +mahoro_allocate(klass) + VALUE klass; +{ + return Data_Wrap_Struct(klass, 0, mahoro_free, 0); +} + +static void * +nogvl_load(ptr) + void *ptr; +{ + struct nogvl_args *args = ptr; + + return magic_load(args->cookie, args->as.path) ? ptr : NULL; +} + +/* + * call-seq: + * Mahoro.new(flags = Mahoro::NONE, path = nil) -> mahoro_obj + * + * Create and initialize a new Mahoro object. + * +flags+ may be one or more of any combination of the Mahoro:: constants + * supported by Mahoro#flags=. + * +path+ (if not nil) is a colon-separated list of database files, see + * Mahoro#load. + * + * If +path+ is not given (or nil), the default database is used. + * Consult your libmagic(3) documentation for the location of that file + * as it varies by installation. + */ +static VALUE +mahoro_initialize(argc, argv, self) + int argc; + VALUE *argv, self; +{ + int flags = MAGIC_NONE; + struct nogvl_args args; + VALUE vpath, vflags; + + args.as.path = NULL; + + switch(rb_scan_args(argc, argv, "02", &vflags, &vpath)) { + case 2: + if(!NIL_P(vpath)) { + args.as.path = StringValueCStr(vpath); + } + /* fallthrough */ + case 1: + flags = FIX2INT(vflags); + break; + } + + if(!(args.cookie = magic_open(flags))) { + rb_raise(eMahoroError, "failed to initialize magic cookie"); + } + + if(NOGVL(nogvl_load, &args, RUBY_UBF_IO, NULL)) { + rb_raise(eMahoroError, "failed to load database: %s", + magic_error(args.cookie)); + } + + DATA_PTR(self) = args.cookie; + + return self; +} + +static void * +nogvl_file(ptr) + void *ptr; +{ + struct nogvl_args *args = ptr; + + return (void *)magic_file(args->cookie, args->as.path); +} + +/* + * call-seq: + * mahoro_obj.file(filename) -> String + * + * Returns a textual description of the contents of the +filename+ given. + * Use Mahoro#buffer instead of this method if the contents of your + * file is already in memory. + * Raises Mahoro::Error on failed lookups. + */ +static VALUE +mahoro_file(self, path) + VALUE self, path; +{ + const char *msg; + struct nogvl_args args; + + args.cookie = (magic_t)DATA_PTR(self); + + /* Pathname objects may be transformed via #to_path */ + if (rb_respond_to(path, id_to_path)) + path = rb_funcall(path, id_to_path, 0); + + args.as.path = StringValueCStr(path); + + if(!(msg = NOGVL(nogvl_file, &args, RUBY_UBF_IO, NULL))) { + rb_raise(eMahoroError, "failed lookup: %s", + magic_error(args.cookie)); + } + + return rb_str_new2(msg); +} + +/* + * call-seq: + * mahoro_obj.buffer(buffer) -> String + * + * Returns a textual description of the contents of the +buffer+ given. + * +buffer+ should be a String object. + * Use Mahoro#file instead of this method if the contents is not already + * in memory (and possibly too large to fit into memory). + * Raises Mahoro::Error on failed lookups. + */ +static VALUE +mahoro_buffer(self, input) + VALUE self, input; +{ + const char *msg; + magic_t cookie = (magic_t)DATA_PTR(self); + + StringValue(input); + + if(!(msg = magic_buffer(cookie, RSTRING_PTR(input), + RSTRING_LEN(input)))) { + rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie)); + } + + return rb_str_new2(msg); +} + +/* + * call-seq: + * mahoro_obj.flags = flags + * + * Change the behavior of an already-initialized Mahoro object. The + * behavior of a Mahoro object is specified at load time, but may be + * changed after-the-fact. + * +flags+ is a bitwise (OR) mask of one or more of the following constants + * in the Mahoro namespace: + * + * - APPLE + * - CHECK + * - COMPRESS + * - CONTINUE + * - DEBUG + * - DEVICES + * - ERROR + * - MIME + * - MIME_ENCODING + * - MIME_TYPE + * - NONE + * - NO_CHECK_APPTYPE + * - NO_CHECK_COMPRESS + * - NO_CHECK_ELF + * - NO_CHECK_ENCODING + * - NO_CHECK_SOFT + * - NO_CHECK_TAR + * - NO_CHECK_TEXT + * - NO_CHECK_TOKENS + * - PRESERVE_ATIME + * - RAW + * - SYMLINK + */ +static VALUE +mahoro_set_flags(self, flags) + VALUE self, flags; +{ + magic_t cookie = (magic_t)DATA_PTR(self); + + return INT2FIX(magic_setflags(cookie, FIX2INT(flags))); +} + +static void * +nogvl_check(ptr) + void *ptr; +{ + struct nogvl_args *args = ptr; + + return magic_check(args->cookie, args->as.path) ? ptr : NULL; +} + +/* + * call-seq: + * mahoro_obj.check(path = nil) -> true or false + * + * This is used to check the validity of entries in the colon separated + * database files passed in as +path+. If +path+ is not passed (or nil), + * this will check the default database. + */ +static VALUE +mahoro_check(argc, argv, self) + int argc; + VALUE *argv, self; +{ + struct nogvl_args args; + VALUE vpath; + + args.cookie = (magic_t)DATA_PTR(self); + args.as.path = NULL; + + switch(rb_scan_args(argc, argv, "01", &vpath)) { + case 1: + if(!NIL_P(vpath)) { + args.as.path = StringValueCStr(vpath); + } + break; + } + + if(!NOGVL(nogvl_check, &args, RUBY_UBF_IO, 0)) { + return Qtrue; + } else { + return Qfalse; + } +} + +static void * +nogvl_compile(ptr) + void *ptr; +{ + struct nogvl_args *args = ptr; + + return magic_compile(args->cookie, args->as.path) ? ptr : NULL; +} + +/* + * call-seq: + * mahoro_obj.compile(path) -> true + * + * Compile the the colon separated list of database files passed in as +path+. + * It returns true on success and raises Mahoro::Error on failure. + * Compiled files created are named from the +File.basename+ of each file + * argument with ".mgc" appended to it. + * + * There is no need to use this function if you are using the default magic(5) + * database on your operating system. This is only needed if you require + * additional magic not in the default magic database. + * + * Users of this method are likely to need Mahoro#load (and vice-versa). + */ +static VALUE +mahoro_compile(self, path) + VALUE self, path; +{ + struct nogvl_args args; + + args.cookie = (magic_t)DATA_PTR(self); + args.as.path = StringValueCStr(path); + + if(NOGVL(nogvl_compile, &args, RUBY_UBF_IO, NULL)) { + rb_raise(eMahoroError, "failed compile: %s", + magic_error(args.cookie)); + } + + return Qtrue; +} + +/* + * call-seq: + * Mahoro.compile(path) -> true + * + * This is a wrapper around the Mahoro#compile instance method, but does not + * require an existing Mahoro object. Use the instance method unless you only + * need to test the validity of a magic(5) database. + */ +static VALUE +mahoro_s_compile(klass, path) + VALUE klass, path; +{ + VALUE m = rb_funcall(klass, rb_intern("new"), 0, 0); + + return mahoro_compile(m, path); +} + +/* + * call-seq: + * mahoro_obj.load(path) -> mahoro_obj + * + * Used to load the the colon-separated list of database files (+path+). + * The ".mgc" suffix will be added to each filename where appropriate. + * This will raise Mahoro::Error on failure. + * + * There is no need to use this function if you are using the default magic(5) + * database on your operating system. This is only needed if you require + * additional magic not in the default magic database. + * + * The default database file is named by the MAGIC environment variable. + * Consult your libmagic installation documentation for the location of + * your default database file name. + * + * Users of this method are likely to need Mahoro#compile (and vice-versa). + */ +static VALUE +mahoro_load(self, path) + VALUE self, path; +{ + struct nogvl_args args; + + args.cookie = (magic_t)DATA_PTR(self); + args.as.path = StringValueCStr(path); + + if(NOGVL(nogvl_load, &args, RUBY_UBF_IO, NULL)) { + rb_raise(eMahoroError, "failed load: %s", + magic_error(args.cookie)); + } + + return self; +} + +void Init_mahoro(void) +{ + VALUE cMahoro; + /* + * Mahoro is a simple interface to libmagic. + * + * Common use cases: + * + * # initialize a Mahoro object for reading MIME types + * mahoro_obj = Mahoro.new(Mahoro::MIME) + * + * # get the MIME type of a file on disk + * # This is ideal for large files which you do not need to + * # read in their entirety. + * mahoro_obj.file('/path/to/file.c') -> 'text/x-c' + * + * # get the MIME type of a string buffer + * # This is only ideal if you already have the buffer in + * # memory or intend to process it soon + * str = File.read('/path/to/file.c') + * mahoro_obj.buffer(str) -> 'text/x-c' + * + * # switch the Mahoro object to return an ASCII description + * mahoro_obj.flags = Mahoro::NONE + * + * # Similar to the above example, but the Mahoro object + * # now returns a textual description + * mahoro_obj.file('/path/to/file.c') -> 'ASCII C program text' + * + * # Similar to the above example, but the Mahoro object + * # now returns a textual description + * str = File.read('/path/to/file.c') + * mahoro_obj.buffer(str) -> 'ASCII C program text' + * + * Mahoro is not thread-safe by default, see Mahoro::ThreadSafe for + * making this module thread-safe. + * + * More information about libmagic: + * https://en.wikipedia.org/wiki/Libmagic + * + * Source code is available via git: + * git clone git://bogomips.org/mahoro.git + * + * And viewable with a web browser via cgit: + * http://bogomips.org/mahoro.git + * + * Eric Wong is the current maintainer of Mahoro. + * Plain-text comments, questions, bug reports, patches and + * pull requests are all highly welcome on the public mailing list: + * mahoro@librelist.org + * + * You may contact Eric privately at normalperson@yhbt.net + * + * Please generate patches using the "git format-patch" command. + * Use of "git send-email" to send a patch is recommended. + * For reviewed patches, you may also send a pull request formatted + * using the "git request-pull" command. + * + * Do not expect Eric to read HTML email under any circumstances. + */ + cMahoro = rb_define_class("Mahoro", rb_cObject); + eMahoroError = rb_define_class_under(cMahoro, "Error", rb_eStandardError); + + /* No special handling, the default */ + rb_define_const(cMahoro, "NONE", INT2FIX(MAGIC_NONE)); + + /* print debugging messages to stderr */ + rb_define_const(cMahoro, "DEBUG", INT2FIX(MAGIC_DEBUG)); + + /* Follow symlinks */ + rb_define_const(cMahoro, "SYMLINK", INT2FIX(MAGIC_SYMLINK)); + + /* Check inside compressed files */ + rb_define_const(cMahoro, "COMPRESS", INT2FIX(MAGIC_COMPRESS)); + + /* Look at the contents of devices */ + rb_define_const(cMahoro, "DEVICES", INT2FIX(MAGIC_DEVICES)); + +#ifdef MAGIC_MIME_TYPE + /* + * Return only the MIME type + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE)); +#endif + + /* Return all matches */ + rb_define_const(cMahoro, "CONTINUE", INT2FIX(MAGIC_CONTINUE)); + + /* + * Check the magic database for consistency and + * print warnings to stderr + */ + rb_define_const(cMahoro, "CHECK", INT2FIX(MAGIC_CHECK)); + + /* preserve access time of files analyzed */ + rb_define_const(cMahoro, "PRESERVE_ATIME", + INT2FIX(MAGIC_PRESERVE_ATIME)); + + /* + * Don't translate unprintable characters to a \\ooo octal + * representation + */ + rb_define_const(cMahoro, "RAW", INT2FIX(MAGIC_RAW)); + + /* + * Treat operating system errors while trying to open files + * and follow symlinks as real errors, instead of printing + * them in the magic buffer. + */ + rb_define_const(cMahoro, "ERROR", INT2FIX(MAGIC_ERROR)); + +#ifdef MAGIC_MIME_ENCODING + /* + * Return a MIME encoding, instead of a textual description. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING)); +#endif + + /* return both MIME type and encoding */ + rb_define_const(cMahoro, "MIME", INT2FIX(MAGIC_MIME)); + +#ifdef MAGIC_APPLE + /* + * Return both Apple creator and type. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "APPLE", INT2FIX(MAGIC_APPLE)); +#endif + +#ifdef MAGIC_NO_CHECK_COMPRESS + /* + * Don't check for or inside compressed files. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_COMPRESS", + INT2FIX(MAGIC_NO_CHECK_COMPRESS)); +#endif + +#ifdef MAGIC_NO_CHECK_TAR + /* + * Don't examine tar files. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR)); +#endif + +#ifdef MAGIC_NO_CHECK_SOFT + /* + * Don't consult magic files. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT)); +#endif + +#ifdef MAGIC_NO_CHECK_APPTYPE + /* + * Don't check application type (EMX only). + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_APPTYPE", + INT2FIX(MAGIC_NO_CHECK_APPTYPE)); +#endif + +#ifdef MAGIC_NO_CHECK_ELF + /* + * Don't check for ELF details. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF)); +#endif + +#ifdef MAGIC_NO_CHECK_ASCII + /* + * Don't check for various types of ASCII text files. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_TEXT", + INT2FIX(MAGIC_NO_CHECK_ASCII)); +#endif + +#ifdef MAGIC_NO_CHECK_TOKENS + /* + * Don't check for known tokens inside ASCII files. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_TOKENS", + INT2FIX(MAGIC_NO_CHECK_TOKENS)); +#endif + +#ifdef MAGIC_NO_CHECK_ENCODING + /* + * Don't check for text encodings. + * This constant may not be defined on older systems. + */ + rb_define_const(cMahoro, "NO_CHECK_ENCODING", + INT2FIX(MAGIC_NO_CHECK_ENCODING)); +#endif + + rb_define_alloc_func(cMahoro, mahoro_allocate); + rb_define_method(cMahoro, "initialize", mahoro_initialize, -1); + rb_define_method(cMahoro, "file", mahoro_file, 1); + rb_define_method(cMahoro, "buffer", mahoro_buffer, 1); + rb_define_method(cMahoro, "flags=", mahoro_set_flags, 1); + rb_define_method(cMahoro, "valid?", mahoro_check, -1); + rb_define_singleton_method(cMahoro, "compile", mahoro_s_compile, 1); + rb_define_method(cMahoro, "compile", mahoro_compile, 1); + rb_define_method(cMahoro, "load", mahoro_load, 1); + id_to_path = rb_intern("to_path"); +} + +/* arch-tag: mahoro */ diff --git a/ext/mahoro/nogvl_compat.h b/ext/mahoro/nogvl_compat.h new file mode 100644 index 0000000..c5b6778 --- /dev/null +++ b/ext/mahoro/nogvl_compat.h @@ -0,0 +1,54 @@ +#ifndef NOGVL_COMPAT_H +#define NOGVL_COMPAT_H +/* + * Compatibility layer for various GVL-releasing wrappers. + * + * This layer will be updated to favor compatibility with the latest + * Matz Ruby C API, currently Ruby 2.0.0 (as of 2013-04-05). + * + * rb_thread_call_without_gvl was detectable via have_func in 1.9.3, + * but not usable. So we must check for ruby/thread.h and use + * rb_thread_blocking_region if ruby/thread.h is not available + * + * HAVE_RUBY_THREAD_H is defined by ruby.h in 2.0.0, NOT using + * extconf.rb since that may find ruby/thread.h in a different + * installation + */ +#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \ + defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H /* Ruby 2.0.0 */ +# include +# define NOGVL(fn,data1,ubf,data2) \ + rb_thread_call_without_gvl((fn),(data1),(ubf),(data2)) +#elif defined(HAVE_RB_THREAD_BLOCKING_REGION) /* Ruby 1.9.x */ +# define COMPAT_FN (VALUE (*)(void *)) +# define NOGVL(fn,data1,ubf,data2) \ + (void *)rb_thread_blocking_region(COMPAT_FN(fn),(data1),(ubf),(data2)) +#else /* Ruby 1.8 */ +/* + * Ruby 1.8 does not have a GVL, we'll just enable signal interrupts + * here in case we make interruptible syscalls + */ +# define RUBY_UBF_IO ((rb_unblock_function_t *)-1) +# include "rubysig.h" +typedef void rb_unblock_function_t(void *); +typedef void *rb_blocking_function_t(void *); + +static void * +fake_nogvl(fn, data1, ubf, data2) + rb_blocking_function_t fn; + void *data1; + rb_unblock_function_t ubf; + void *data2; +{ + void *rv; + + TRAP_BEG; + rv = fn(data1); + TRAP_END; + + return rv; +} +# define NOGVL(fn,data1,ubf,data2) fake_nogvl((fn),(data1),(ubf),(data2)) +#endif + +#endif /* NOGVL_COMPAT_H */ diff --git a/extconf.rb b/extconf.rb deleted file mode 100644 index 0709016..0000000 --- a/extconf.rb +++ /dev/null @@ -1,9 +0,0 @@ -require 'mkmf' - -dir_config('magic') -have_library('magic', 'magic_open') -have_func('rb_thread_call_without_gvl') -have_func('rb_thread_blocking_region') -create_makefile('mahoro') - -# arch-tag: extconf diff --git a/mahoro.c b/mahoro.c deleted file mode 100644 index 01d1cf8..0000000 --- a/mahoro.c +++ /dev/null @@ -1,565 +0,0 @@ -/* - * This file is Public Domain. - * - * Note: The current maintainer (Eric Wong) respects and preserves the - * original coding style of the original author (Shu-yu Guo) in case - * he ever chooses to return to this project. - */ - -#include -#include -#include "nogvl_compat.h" - -#ifndef RSTRING_LEN -# define RSTRING_LEN(s)->len -#endif -#ifndef RSTRING_PTR -# define RSTRING_PTR(s)->ptr -#endif - -static VALUE eMahoroError; -static ID id_to_path; - -struct nogvl_args { - magic_t cookie; - union { - const char *path; - int fd; - } as; -}; - -/* :nodoc: called automatically by GC */ -static void -mahoro_free(ptr) - void *ptr; -{ - if (ptr) - magic_close((magic_t)ptr); -} - -/* :nodoc: called automatically on Mahoro#initialize */ -static VALUE -mahoro_allocate(klass) - VALUE klass; -{ - return Data_Wrap_Struct(klass, 0, mahoro_free, 0); -} - -static void * -nogvl_load(ptr) - void *ptr; -{ - struct nogvl_args *args = ptr; - - return magic_load(args->cookie, args->as.path) ? ptr : NULL; -} - -/* - * call-seq: - * Mahoro.new(flags = Mahoro::NONE, path = nil) -> mahoro_obj - * - * Create and initialize a new Mahoro object. - * +flags+ may be one or more of any combination of the Mahoro:: constants - * supported by Mahoro#flags=. - * +path+ (if not nil) is a colon-separated list of database files, see - * Mahoro#load. - * - * If +path+ is not given (or nil), the default database is used. - * Consult your libmagic(3) documentation for the location of that file - * as it varies by installation. - */ -static VALUE -mahoro_initialize(argc, argv, self) - int argc; - VALUE *argv, self; -{ - int flags = MAGIC_NONE; - struct nogvl_args args; - VALUE vpath, vflags; - - args.as.path = NULL; - - switch(rb_scan_args(argc, argv, "02", &vflags, &vpath)) { - case 2: - if(!NIL_P(vpath)) { - args.as.path = StringValueCStr(vpath); - } - /* fallthrough */ - case 1: - flags = FIX2INT(vflags); - break; - } - - if(!(args.cookie = magic_open(flags))) { - rb_raise(eMahoroError, "failed to initialize magic cookie"); - } - - if(NOGVL(nogvl_load, &args, RUBY_UBF_IO, NULL)) { - rb_raise(eMahoroError, "failed to load database: %s", - magic_error(args.cookie)); - } - - DATA_PTR(self) = args.cookie; - - return self; -} - -static void * -nogvl_file(ptr) - void *ptr; -{ - struct nogvl_args *args = ptr; - - return (void *)magic_file(args->cookie, args->as.path); -} - -/* - * call-seq: - * mahoro_obj.file(filename) -> String - * - * Returns a textual description of the contents of the +filename+ given. - * Use Mahoro#buffer instead of this method if the contents of your - * file is already in memory. - * Raises Mahoro::Error on failed lookups. - */ -static VALUE -mahoro_file(self, path) - VALUE self, path; -{ - const char *msg; - struct nogvl_args args; - - args.cookie = (magic_t)DATA_PTR(self); - - /* Pathname objects may be transformed via #to_path */ - if (rb_respond_to(path, id_to_path)) - path = rb_funcall(path, id_to_path, 0); - - args.as.path = StringValueCStr(path); - - if(!(msg = NOGVL(nogvl_file, &args, RUBY_UBF_IO, NULL))) { - rb_raise(eMahoroError, "failed lookup: %s", - magic_error(args.cookie)); - } - - return rb_str_new2(msg); -} - -/* - * call-seq: - * mahoro_obj.buffer(buffer) -> String - * - * Returns a textual description of the contents of the +buffer+ given. - * +buffer+ should be a String object. - * Use Mahoro#file instead of this method if the contents is not already - * in memory (and possibly too large to fit into memory). - * Raises Mahoro::Error on failed lookups. - */ -static VALUE -mahoro_buffer(self, input) - VALUE self, input; -{ - const char *msg; - magic_t cookie = (magic_t)DATA_PTR(self); - - StringValue(input); - - if(!(msg = magic_buffer(cookie, RSTRING_PTR(input), - RSTRING_LEN(input)))) { - rb_raise(eMahoroError, "failed lookup: %s", magic_error(cookie)); - } - - return rb_str_new2(msg); -} - -/* - * call-seq: - * mahoro_obj.flags = flags - * - * Change the behavior of an already-initialized Mahoro object. The - * behavior of a Mahoro object is specified at load time, but may be - * changed after-the-fact. - * +flags+ is a bitwise (OR) mask of one or more of the following constants - * in the Mahoro namespace: - * - * - APPLE - * - CHECK - * - COMPRESS - * - CONTINUE - * - DEBUG - * - DEVICES - * - ERROR - * - MIME - * - MIME_ENCODING - * - MIME_TYPE - * - NONE - * - NO_CHECK_APPTYPE - * - NO_CHECK_COMPRESS - * - NO_CHECK_ELF - * - NO_CHECK_ENCODING - * - NO_CHECK_SOFT - * - NO_CHECK_TAR - * - NO_CHECK_TEXT - * - NO_CHECK_TOKENS - * - PRESERVE_ATIME - * - RAW - * - SYMLINK - */ -static VALUE -mahoro_set_flags(self, flags) - VALUE self, flags; -{ - magic_t cookie = (magic_t)DATA_PTR(self); - - return INT2FIX(magic_setflags(cookie, FIX2INT(flags))); -} - -static void * -nogvl_check(ptr) - void *ptr; -{ - struct nogvl_args *args = ptr; - - return magic_check(args->cookie, args->as.path) ? ptr : NULL; -} - -/* - * call-seq: - * mahoro_obj.check(path = nil) -> true or false - * - * This is used to check the validity of entries in the colon separated - * database files passed in as +path+. If +path+ is not passed (or nil), - * this will check the default database. - */ -static VALUE -mahoro_check(argc, argv, self) - int argc; - VALUE *argv, self; -{ - struct nogvl_args args; - VALUE vpath; - - args.cookie = (magic_t)DATA_PTR(self); - args.as.path = NULL; - - switch(rb_scan_args(argc, argv, "01", &vpath)) { - case 1: - if(!NIL_P(vpath)) { - args.as.path = StringValueCStr(vpath); - } - break; - } - - if(!NOGVL(nogvl_check, &args, RUBY_UBF_IO, 0)) { - return Qtrue; - } else { - return Qfalse; - } -} - -static void * -nogvl_compile(ptr) - void *ptr; -{ - struct nogvl_args *args = ptr; - - return magic_compile(args->cookie, args->as.path) ? ptr : NULL; -} - -/* - * call-seq: - * mahoro_obj.compile(path) -> true - * - * Compile the the colon separated list of database files passed in as +path+. - * It returns true on success and raises Mahoro::Error on failure. - * Compiled files created are named from the +File.basename+ of each file - * argument with ".mgc" appended to it. - * - * There is no need to use this function if you are using the default magic(5) - * database on your operating system. This is only needed if you require - * additional magic not in the default magic database. - * - * Users of this method are likely to need Mahoro#load (and vice-versa). - */ -static VALUE -mahoro_compile(self, path) - VALUE self, path; -{ - struct nogvl_args args; - - args.cookie = (magic_t)DATA_PTR(self); - args.as.path = StringValueCStr(path); - - if(NOGVL(nogvl_compile, &args, RUBY_UBF_IO, NULL)) { - rb_raise(eMahoroError, "failed compile: %s", - magic_error(args.cookie)); - } - - return Qtrue; -} - -/* - * call-seq: - * Mahoro.compile(path) -> true - * - * This is a wrapper around the Mahoro#compile instance method, but does not - * require an existing Mahoro object. Use the instance method unless you only - * need to test the validity of a magic(5) database. - */ -static VALUE -mahoro_s_compile(klass, path) - VALUE klass, path; -{ - VALUE m = rb_funcall(klass, rb_intern("new"), 0, 0); - - return mahoro_compile(m, path); -} - -/* - * call-seq: - * mahoro_obj.load(path) -> mahoro_obj - * - * Used to load the the colon-separated list of database files (+path+). - * The ".mgc" suffix will be added to each filename where appropriate. - * This will raise Mahoro::Error on failure. - * - * There is no need to use this function if you are using the default magic(5) - * database on your operating system. This is only needed if you require - * additional magic not in the default magic database. - * - * The default database file is named by the MAGIC environment variable. - * Consult your libmagic installation documentation for the location of - * your default database file name. - * - * Users of this method are likely to need Mahoro#compile (and vice-versa). - */ -static VALUE -mahoro_load(self, path) - VALUE self, path; -{ - struct nogvl_args args; - - args.cookie = (magic_t)DATA_PTR(self); - args.as.path = StringValueCStr(path); - - if(NOGVL(nogvl_load, &args, RUBY_UBF_IO, NULL)) { - rb_raise(eMahoroError, "failed load: %s", - magic_error(args.cookie)); - } - - return self; -} - -void Init_mahoro(void) -{ - VALUE cMahoro; - /* - * Mahoro is a simple interface to libmagic. - * - * Common use cases: - * - * # initialize a Mahoro object for reading MIME types - * mahoro_obj = Mahoro.new(Mahoro::MIME) - * - * # get the MIME type of a file on disk - * # This is ideal for large files which you do not need to - * # read in their entirety. - * mahoro_obj.file('/path/to/file.c') -> 'text/x-c' - * - * # get the MIME type of a string buffer - * # This is only ideal if you already have the buffer in - * # memory or intend to process it soon - * str = File.read('/path/to/file.c') - * mahoro_obj.buffer(str) -> 'text/x-c' - * - * # switch the Mahoro object to return an ASCII description - * mahoro_obj.flags = Mahoro::NONE - * - * # Similar to the above example, but the Mahoro object - * # now returns a textual description - * mahoro_obj.file('/path/to/file.c') -> 'ASCII C program text' - * - * # Similar to the above example, but the Mahoro object - * # now returns a textual description - * str = File.read('/path/to/file.c') - * mahoro_obj.buffer(str) -> 'ASCII C program text' - * - * Mahoro is not thread-safe by default, see Mahoro::ThreadSafe for - * making this module thread-safe. - * - * More information about libmagic: - * https://en.wikipedia.org/wiki/Libmagic - * - * Source code is available via git: - * git clone git://bogomips.org/mahoro.git - * - * And viewable with a web browser via cgit: - * http://bogomips.org/mahoro.git - * - * Eric Wong is the current maintainer of Mahoro. - * Plain-text comments, questions, bug reports, patches and - * pull requests are all highly welcome on the public mailing list: - * mahoro@librelist.org - * - * You may contact Eric privately at normalperson@yhbt.net - * - * Please generate patches using the "git format-patch" command. - * Use of "git send-email" to send a patch is recommended. - * For reviewed patches, you may also send a pull request formatted - * using the "git request-pull" command. - * - * Do not expect Eric to read HTML email under any circumstances. - */ - cMahoro = rb_define_class("Mahoro", rb_cObject); - eMahoroError = rb_define_class_under(cMahoro, "Error", rb_eStandardError); - - /* No special handling, the default */ - rb_define_const(cMahoro, "NONE", INT2FIX(MAGIC_NONE)); - - /* print debugging messages to stderr */ - rb_define_const(cMahoro, "DEBUG", INT2FIX(MAGIC_DEBUG)); - - /* Follow symlinks */ - rb_define_const(cMahoro, "SYMLINK", INT2FIX(MAGIC_SYMLINK)); - - /* Check inside compressed files */ - rb_define_const(cMahoro, "COMPRESS", INT2FIX(MAGIC_COMPRESS)); - - /* Look at the contents of devices */ - rb_define_const(cMahoro, "DEVICES", INT2FIX(MAGIC_DEVICES)); - -#ifdef MAGIC_MIME_TYPE - /* - * Return only the MIME type - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "MIME_TYPE", INT2FIX(MAGIC_MIME_TYPE)); -#endif - - /* Return all matches */ - rb_define_const(cMahoro, "CONTINUE", INT2FIX(MAGIC_CONTINUE)); - - /* - * Check the magic database for consistency and - * print warnings to stderr - */ - rb_define_const(cMahoro, "CHECK", INT2FIX(MAGIC_CHECK)); - - /* preserve access time of files analyzed */ - rb_define_const(cMahoro, "PRESERVE_ATIME", - INT2FIX(MAGIC_PRESERVE_ATIME)); - - /* - * Don't translate unprintable characters to a \\ooo octal - * representation - */ - rb_define_const(cMahoro, "RAW", INT2FIX(MAGIC_RAW)); - - /* - * Treat operating system errors while trying to open files - * and follow symlinks as real errors, instead of printing - * them in the magic buffer. - */ - rb_define_const(cMahoro, "ERROR", INT2FIX(MAGIC_ERROR)); - -#ifdef MAGIC_MIME_ENCODING - /* - * Return a MIME encoding, instead of a textual description. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "MIME_ENCODING", INT2FIX(MAGIC_MIME_ENCODING)); -#endif - - /* return both MIME type and encoding */ - rb_define_const(cMahoro, "MIME", INT2FIX(MAGIC_MIME)); - -#ifdef MAGIC_APPLE - /* - * Return both Apple creator and type. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "APPLE", INT2FIX(MAGIC_APPLE)); -#endif - -#ifdef MAGIC_NO_CHECK_COMPRESS - /* - * Don't check for or inside compressed files. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_COMPRESS", - INT2FIX(MAGIC_NO_CHECK_COMPRESS)); -#endif - -#ifdef MAGIC_NO_CHECK_TAR - /* - * Don't examine tar files. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_TAR", INT2FIX(MAGIC_NO_CHECK_TAR)); -#endif - -#ifdef MAGIC_NO_CHECK_SOFT - /* - * Don't consult magic files. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_SOFT", INT2FIX(MAGIC_NO_CHECK_SOFT)); -#endif - -#ifdef MAGIC_NO_CHECK_APPTYPE - /* - * Don't check application type (EMX only). - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_APPTYPE", - INT2FIX(MAGIC_NO_CHECK_APPTYPE)); -#endif - -#ifdef MAGIC_NO_CHECK_ELF - /* - * Don't check for ELF details. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_ELF", INT2FIX(MAGIC_NO_CHECK_ELF)); -#endif - -#ifdef MAGIC_NO_CHECK_ASCII - /* - * Don't check for various types of ASCII text files. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_TEXT", - INT2FIX(MAGIC_NO_CHECK_ASCII)); -#endif - -#ifdef MAGIC_NO_CHECK_TOKENS - /* - * Don't check for known tokens inside ASCII files. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_TOKENS", - INT2FIX(MAGIC_NO_CHECK_TOKENS)); -#endif - -#ifdef MAGIC_NO_CHECK_ENCODING - /* - * Don't check for text encodings. - * This constant may not be defined on older systems. - */ - rb_define_const(cMahoro, "NO_CHECK_ENCODING", - INT2FIX(MAGIC_NO_CHECK_ENCODING)); -#endif - - rb_define_alloc_func(cMahoro, mahoro_allocate); - rb_define_method(cMahoro, "initialize", mahoro_initialize, -1); - rb_define_method(cMahoro, "file", mahoro_file, 1); - rb_define_method(cMahoro, "buffer", mahoro_buffer, 1); - rb_define_method(cMahoro, "flags=", mahoro_set_flags, 1); - rb_define_method(cMahoro, "valid?", mahoro_check, -1); - rb_define_singleton_method(cMahoro, "compile", mahoro_s_compile, 1); - rb_define_method(cMahoro, "compile", mahoro_compile, 1); - rb_define_method(cMahoro, "load", mahoro_load, 1); - id_to_path = rb_intern("to_path"); -} - -/* arch-tag: mahoro */ diff --git a/mahoro.gemspec b/mahoro.gemspec index f33b488..67335c6 100644 --- a/mahoro.gemspec +++ b/mahoro.gemspec @@ -3,7 +3,7 @@ ENV["VERSION"] or abort "VERSION= must be specified" Gem::Specification.new do |s| s.name = %q{mahoro} s.version = ENV["VERSION"].dup - s.homepage = "http://mahoro.rubyforge.org/" + s.homepage = "http://bogomips.org/mahoro/README" s.authors = [ "Shu-yu Guo", "Eric Wong" ] s.description = %{ An interface to libmagic to determine file types using "magic" numbers. @@ -12,14 +12,14 @@ Shu-yu Guo is the original author but all maintenance is handled by Eric Wong nowadays. source: http://bogomips.org/mahoro.git/ +documentation: http://bogomips.org/mahoro/ }.strip s.email = %q{normalperson@yhbt.net} s.files = `git ls-files`.split(/\n/) s.rubyforge_project = %q{mahoro} s.summary = 'An interface to libmagic' - s.test_files = %w(test.rb) - s.extensions = %w(extconf.rb) - s.extra_rdoc_files = %w(mahoro.c) + s.extensions = %w(ext/mahoro/extconf.rb) + s.extra_rdoc_files = %w(ext/mahoro/mahoro.c) s.rdoc_options = %w(--exclude \.o --exclude \.so) s.license = "Public Domain" diff --git a/nogvl_compat.h b/nogvl_compat.h deleted file mode 100644 index c5b6778..0000000 --- a/nogvl_compat.h +++ /dev/null @@ -1,54 +0,0 @@ -#ifndef NOGVL_COMPAT_H -#define NOGVL_COMPAT_H -/* - * Compatibility layer for various GVL-releasing wrappers. - * - * This layer will be updated to favor compatibility with the latest - * Matz Ruby C API, currently Ruby 2.0.0 (as of 2013-04-05). - * - * rb_thread_call_without_gvl was detectable via have_func in 1.9.3, - * but not usable. So we must check for ruby/thread.h and use - * rb_thread_blocking_region if ruby/thread.h is not available - * - * HAVE_RUBY_THREAD_H is defined by ruby.h in 2.0.0, NOT using - * extconf.rb since that may find ruby/thread.h in a different - * installation - */ -#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \ - defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H /* Ruby 2.0.0 */ -# include -# define NOGVL(fn,data1,ubf,data2) \ - rb_thread_call_without_gvl((fn),(data1),(ubf),(data2)) -#elif defined(HAVE_RB_THREAD_BLOCKING_REGION) /* Ruby 1.9.x */ -# define COMPAT_FN (VALUE (*)(void *)) -# define NOGVL(fn,data1,ubf,data2) \ - (void *)rb_thread_blocking_region(COMPAT_FN(fn),(data1),(ubf),(data2)) -#else /* Ruby 1.8 */ -/* - * Ruby 1.8 does not have a GVL, we'll just enable signal interrupts - * here in case we make interruptible syscalls - */ -# define RUBY_UBF_IO ((rb_unblock_function_t *)-1) -# include "rubysig.h" -typedef void rb_unblock_function_t(void *); -typedef void *rb_blocking_function_t(void *); - -static void * -fake_nogvl(fn, data1, ubf, data2) - rb_blocking_function_t fn; - void *data1; - rb_unblock_function_t ubf; - void *data2; -{ - void *rv; - - TRAP_BEG; - rv = fn(data1); - TRAP_END; - - return rv; -} -# define NOGVL(fn,data1,ubf,data2) fake_nogvl((fn),(data1),(ubf),(data2)) -#endif - -#endif /* NOGVL_COMPAT_H */ diff --git a/setup.rb b/setup.rb new file mode 100644 index 0000000..5eb5006 --- /dev/null +++ b/setup.rb @@ -0,0 +1,1586 @@ +# -*- encoding: binary -*- +# +# setup.rb +# +# Copyright (c) 2000-2005 Minero Aoki +# +# This program is free software. +# You can distribute/modify this program under the terms of +# the GNU LGPL, Lesser General Public License version 2.1. +# + +unless Enumerable.method_defined?(:map) # Ruby 1.4.6 + module Enumerable + alias map collect + end +end + +unless File.respond_to?(:read) # Ruby 1.6 + def File.read(fname) + open(fname) {|f| + return f.read + } + end +end + +unless Errno.const_defined?(:ENOTEMPTY) # Windows? + module Errno + class ENOTEMPTY + # We do not raise this exception, implementation is not needed. + end + end +end + +def File.binread(fname) + open(fname, 'rb') {|f| + return f.read + } +end + +# for corrupted Windows' stat(2) +def File.dir?(path) + File.directory?((path[-1,1] == '/') ? path : path + '/') +end + + +class ConfigTable + + include Enumerable + + def initialize(rbconfig) + @rbconfig = rbconfig + @items = [] + @table = {} + # options + @install_prefix = nil + @config_opt = nil + @verbose = true + @no_harm = false + end + + attr_accessor :install_prefix + attr_accessor :config_opt + + attr_writer :verbose + + def verbose? + @verbose + end + + attr_writer :no_harm + + def no_harm? + @no_harm + end + + def [](key) + lookup(key).resolve(self) + end + + def []=(key, val) + lookup(key).set val + end + + def names + @items.map {|i| i.name } + end + + def each(&block) + @items.each(&block) + end + + def key?(name) + @table.key?(name) + end + + def lookup(name) + @table[name] or setup_rb_error "no such config item: #{name}" + end + + def add(item) + @items.push item + @table[item.name] = item + end + + def remove(name) + item = lookup(name) + @items.delete_if {|i| i.name == name } + @table.delete_if {|name, i| i.name == name } + item + end + + def load_script(path, inst = nil) + if File.file?(path) + MetaConfigEnvironment.new(self, inst).instance_eval File.read(path), path + end + end + + def savefile + '.config' + end + + def load_savefile + begin + File.foreach(savefile()) do |line| + k, v = *line.split(/=/, 2) + self[k] = v.strip + end + rescue Errno::ENOENT + setup_rb_error $!.message + "\n#{File.basename($0)} config first" + end + end + + def save + @items.each {|i| i.value } + File.open(savefile(), 'w') {|f| + @items.each do |i| + f.printf "%s=%s\n", i.name, i.value if i.value? and i.value + end + } + end + + def load_standard_entries + standard_entries(@rbconfig).each do |ent| + add ent + end + end + + def standard_entries(rbconfig) + c = rbconfig + + rubypath = File.join(c['bindir'], c['ruby_install_name'] + c['EXEEXT']) + + major = c['MAJOR'].to_i + minor = c['MINOR'].to_i + teeny = c['TEENY'].to_i + version = "#{major}.#{minor}" + + # ruby ver. >= 1.4.4? + newpath_p = ((major >= 2) or + ((major == 1) and + ((minor >= 5) or + ((minor == 4) and (teeny >= 4))))) + + if c['rubylibdir'] + # V > 1.6.3 + libruby = "#{c['prefix']}/lib/ruby" + librubyver = c['rubylibdir'] + librubyverarch = c['archdir'] + siteruby = c['sitedir'] + siterubyver = c['sitelibdir'] + siterubyverarch = c['sitearchdir'] + elsif newpath_p + # 1.4.4 <= V <= 1.6.3 + libruby = "#{c['prefix']}/lib/ruby" + librubyver = "#{c['prefix']}/lib/ruby/#{version}" + librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" + siteruby = c['sitedir'] + siterubyver = "$siteruby/#{version}" + siterubyverarch = "$siterubyver/#{c['arch']}" + else + # V < 1.4.4 + libruby = "#{c['prefix']}/lib/ruby" + librubyver = "#{c['prefix']}/lib/ruby/#{version}" + librubyverarch = "#{c['prefix']}/lib/ruby/#{version}/#{c['arch']}" + siteruby = "#{c['prefix']}/lib/ruby/#{version}/site_ruby" + siterubyver = siteruby + siterubyverarch = "$siterubyver/#{c['arch']}" + end + parameterize = lambda {|path| + path.sub(/\A#{Regexp.quote(c['prefix'])}/, '$prefix') + } + + if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg } + makeprog = arg.sub(/'/, '').split(/=/, 2)[1] + else + makeprog = 'make' + end + + [ + ExecItem.new('installdirs', 'std/site/home', + 'std: install under libruby; site: install under site_ruby; home: install under $HOME')\ + {|val, table| + case val + when 'std' + table['rbdir'] = '$librubyver' + table['sodir'] = '$librubyverarch' + when 'site' + table['rbdir'] = '$siterubyver' + table['sodir'] = '$siterubyverarch' + when 'home' + setup_rb_error '$HOME was not set' unless ENV['HOME'] + table['prefix'] = ENV['HOME'] + table['rbdir'] = '$libdir/ruby' + table['sodir'] = '$libdir/ruby' + end + }, + PathItem.new('prefix', 'path', c['prefix'], + 'path prefix of target environment'), + PathItem.new('bindir', 'path', parameterize.call(c['bindir']), + 'the directory for commands'), + PathItem.new('libdir', 'path', parameterize.call(c['libdir']), + 'the directory for libraries'), + PathItem.new('datadir', 'path', parameterize.call(c['datadir']), + 'the directory for shared data'), + PathItem.new('mandir', 'path', parameterize.call(c['mandir']), + 'the directory for man pages'), + PathItem.new('sysconfdir', 'path', parameterize.call(c['sysconfdir']), + 'the directory for system configuration files'), + PathItem.new('localstatedir', 'path', parameterize.call(c['localstatedir']), + 'the directory for local state data'), + PathItem.new('libruby', 'path', libruby, + 'the directory for ruby libraries'), + PathItem.new('librubyver', 'path', librubyver, + 'the directory for standard ruby libraries'), + PathItem.new('librubyverarch', 'path', librubyverarch, + 'the directory for standard ruby extensions'), + PathItem.new('siteruby', 'path', siteruby, + 'the directory for version-independent aux ruby libraries'), + PathItem.new('siterubyver', 'path', siterubyver, + 'the directory for aux ruby libraries'), + PathItem.new('siterubyverarch', 'path', siterubyverarch, + 'the directory for aux ruby binaries'), + PathItem.new('rbdir', 'path', '$siterubyver', + 'the directory for ruby scripts'), + PathItem.new('sodir', 'path', '$siterubyverarch', + 'the directory for ruby extentions'), + PathItem.new('rubypath', 'path', rubypath, + 'the path to set to #! line'), + ProgramItem.new('rubyprog', 'name', rubypath, + 'the ruby program using for installation'), + ProgramItem.new('makeprog', 'name', makeprog, + 'the make program to compile ruby extentions'), + SelectItem.new('shebang', 'all/ruby/never', 'ruby', + 'shebang line (#!) editing mode'), + BoolItem.new('without-ext', 'yes/no', 'no', + 'does not compile/install ruby extentions') + ] + end + private :standard_entries + + def load_multipackage_entries + multipackage_entries().each do |ent| + add ent + end + end + + def multipackage_entries + [ + PackageSelectionItem.new('with', 'name,name...', '', 'ALL', + 'package names that you want to install'), + PackageSelectionItem.new('without', 'name,name...', '', 'NONE', + 'package names that you do not want to install') + ] + end + private :multipackage_entries + + ALIASES = { + 'std-ruby' => 'librubyver', + 'stdruby' => 'librubyver', + 'rubylibdir' => 'librubyver', + 'archdir' => 'librubyverarch', + 'site-ruby-common' => 'siteruby', # For backward compatibility + 'site-ruby' => 'siterubyver', # For backward compatibility + 'bin-dir' => 'bindir', + 'bin-dir' => 'bindir', + 'rb-dir' => 'rbdir', + 'so-dir' => 'sodir', + 'data-dir' => 'datadir', + 'ruby-path' => 'rubypath', + 'ruby-prog' => 'rubyprog', + 'ruby' => 'rubyprog', + 'make-prog' => 'makeprog', + 'make' => 'makeprog' + } + + def fixup + ALIASES.each do |ali, name| + @table[ali] = @table[name] + end + @items.freeze + @table.freeze + @options_re = /\A--(#{@table.keys.join('|')})(?:=(.*))?\z/ + end + + def parse_opt(opt) + m = @options_re.match(opt) or setup_rb_error "config: unknown option #{opt}" + m.to_a[1,2] + end + + def dllext + @rbconfig['DLEXT'] + end + + def value_config?(name) + lookup(name).value? + end + + class Item + def initialize(name, template, default, desc) + @name = name.freeze + @template = template + @value = default + @default = default + @description = desc + end + + attr_reader :name + attr_reader :description + + attr_accessor :default + alias help_default default + + def help_opt + "--#{@name}=#{@template}" + end + + def value? + true + end + + def value + @value + end + + def resolve(table) + @value.gsub(%r<\$([^/]+)>) { table[$1] } + end + + def set(val) + @value = check(val) + end + + private + + def check(val) + setup_rb_error "config: --#{name} requires argument" unless val + val + end + end + + class BoolItem < Item + def config_type + 'bool' + end + + def help_opt + "--#{@name}" + end + + private + + def check(val) + return 'yes' unless val + case val + when /\Ay(es)?\z/i, /\At(rue)?\z/i then 'yes' + when /\An(o)?\z/i, /\Af(alse)\z/i then 'no' + else + setup_rb_error "config: --#{@name} accepts only yes/no for argument" + end + end + end + + class PathItem < Item + def config_type + 'path' + end + + private + + def check(path) + setup_rb_error "config: --#{@name} requires argument" unless path + path[0,1] == '$' ? path : File.expand_path(path) + end + end + + class ProgramItem < Item + def config_type + 'program' + end + end + + class SelectItem < Item + def initialize(name, selection, default, desc) + super + @ok = selection.split('/') + end + + def config_type + 'select' + end + + private + + def check(val) + unless @ok.include?(val.strip) + setup_rb_error "config: use --#{@name}=#{@template} (#{val})" + end + val.strip + end + end + + class ExecItem < Item + def initialize(name, selection, desc, &block) + super name, selection, nil, desc + @ok = selection.split('/') + @action = block + end + + def config_type + 'exec' + end + + def value? + false + end + + def resolve(table) + setup_rb_error "$#{name()} wrongly used as option value" + end + + undef set + + def evaluate(val, table) + v = val.strip.downcase + unless @ok.include?(v) + setup_rb_error "invalid option --#{@name}=#{val} (use #{@template})" + end + @action.call v, table + end + end + + class PackageSelectionItem < Item + def initialize(name, template, default, help_default, desc) + super name, template, default, desc + @help_default = help_default + end + + attr_reader :help_default + + def config_type + 'package' + end + + private + + def check(val) + unless File.dir?("packages/#{val}") + setup_rb_error "config: no such package: #{val}" + end + val + end + end + + class MetaConfigEnvironment + def initialize(config, installer) + @config = config + @installer = installer + end + + def config_names + @config.names + end + + def config?(name) + @config.key?(name) + end + + def bool_config?(name) + @config.lookup(name).config_type == 'bool' + end + + def path_config?(name) + @config.lookup(name).config_type == 'path' + end + + def value_config?(name) + @config.lookup(name).config_type != 'exec' + end + + def add_config(item) + @config.add item + end + + def add_bool_config(name, default, desc) + @config.add BoolItem.new(name, 'yes/no', default ? 'yes' : 'no', desc) + end + + def add_path_config(name, default, desc) + @config.add PathItem.new(name, 'path', default, desc) + end + + def set_config_default(name, default) + @config.lookup(name).default = default + end + + def remove_config(name) + @config.remove(name) + end + + # For only multipackage + def packages + raise '[setup.rb fatal] multi-package metaconfig API packages() called for single-package; contact application package vendor' unless @installer + @installer.packages + end + + # For only multipackage + def declare_packages(list) + raise '[setup.rb fatal] multi-package metaconfig API declare_packages() called for single-package; contact application package vendor' unless @installer + @installer.packages = list + end + end + +end # class ConfigTable + + +# This module requires: #verbose?, #no_harm? +module FileOperations + + def mkdir_p(dirname, prefix = nil) + dirname = prefix + File.expand_path(dirname) if prefix + $stderr.puts "mkdir -p #{dirname}" if verbose? + return if no_harm? + + # Does not check '/', it's too abnormal. + dirs = File.expand_path(dirname).split(%r<(?=/)>) + if /\A[a-z]:\z/i =~ dirs[0] + disk = dirs.shift + dirs[0] = disk + dirs[0] + end + dirs.each_index do |idx| + path = dirs[0..idx].join('') + Dir.mkdir path unless File.dir?(path) + end + end + + def rm_f(path) + $stderr.puts "rm -f #{path}" if verbose? + return if no_harm? + force_remove_file path + end + + def rm_rf(path) + $stderr.puts "rm -rf #{path}" if verbose? + return if no_harm? + remove_tree path + end + + def remove_tree(path) + if File.symlink?(path) + remove_file path + elsif File.dir?(path) + remove_tree0 path + else + force_remove_file path + end + end + + def remove_tree0(path) + Dir.foreach(path) do |ent| + next if ent == '.' + next if ent == '..' + entpath = "#{path}/#{ent}" + if File.symlink?(entpath) + remove_file entpath + elsif File.dir?(entpath) + remove_tree0 entpath + else + force_remove_file entpath + end + end + begin + Dir.rmdir path + rescue Errno::ENOTEMPTY + # directory may not be empty + end + end + + def move_file(src, dest) + force_remove_file dest + begin + File.rename src, dest + rescue + File.open(dest, 'wb') {|f| + f.write File.binread(src) + } + File.chmod File.stat(src).mode, dest + File.unlink src + end + end + + def force_remove_file(path) + begin + remove_file path + rescue + end + end + + def remove_file(path) + File.chmod 0777, path + File.unlink path + end + + def install(from, dest, mode, prefix = nil) + $stderr.puts "install #{from} #{dest}" if verbose? + return if no_harm? + + realdest = prefix ? prefix + File.expand_path(dest) : dest + realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest) + str = File.binread(from) + if diff?(str, realdest) + verbose_off { + rm_f realdest if File.exist?(realdest) + } + File.open(realdest, 'wb') {|f| + f.write str + } + File.chmod mode, realdest + + File.open("#{objdir_root()}/InstalledFiles", 'a') {|f| + if prefix + f.puts realdest.sub(prefix, '') + else + f.puts realdest + end + } + end + end + + def diff?(new_content, path) + return true unless File.exist?(path) + new_content != File.binread(path) + end + + def command(*args) + $stderr.puts args.join(' ') if verbose? + system(*args) or raise RuntimeError, + "system(#{args.map{|a| a.inspect }.join(' ')}) failed" + end + + def ruby(*args) + command config('rubyprog'), *args + end + + def make(task = nil) + command(*[config('makeprog'), task].compact) + end + + def extdir?(dir) + File.exist?("#{dir}/MANIFEST") or File.exist?("#{dir}/extconf.rb") + end + + def files_of(dir) + Dir.open(dir) {|d| + return d.select {|ent| File.file?("#{dir}/#{ent}") } + } + end + + DIR_REJECT = %w( . .. CVS SCCS RCS CVS.adm .svn ) + + def directories_of(dir) + Dir.open(dir) {|d| + return d.select {|ent| File.dir?("#{dir}/#{ent}") } - DIR_REJECT + } + end + +end + + +# This module requires: #srcdir_root, #objdir_root, #relpath +module HookScriptAPI + + def get_config(key) + @config[key] + end + + alias config get_config + + # obsolete: use metaconfig to change configuration + def set_config(key, val) + @config[key] = val + end + + # + # srcdir/objdir (works only in the package directory) + # + + def curr_srcdir + "#{srcdir_root()}/#{relpath()}" + end + + def curr_objdir + "#{objdir_root()}/#{relpath()}" + end + + def srcfile(path) + "#{curr_srcdir()}/#{path}" + end + + def srcexist?(path) + File.exist?(srcfile(path)) + end + + def srcdirectory?(path) + File.dir?(srcfile(path)) + end + + def srcfile?(path) + File.file?(srcfile(path)) + end + + def srcentries(path = '.') + Dir.open("#{curr_srcdir()}/#{path}") {|d| + return d.to_a - %w(. ..) + } + end + + def srcfiles(path = '.') + srcentries(path).select {|fname| + File.file?(File.join(curr_srcdir(), path, fname)) + } + end + + def srcdirectories(path = '.') + srcentries(path).select {|fname| + File.dir?(File.join(curr_srcdir(), path, fname)) + } + end + +end + + +class ToplevelInstaller + + Version = '3.4.1' + Copyright = 'Copyright (c) 2000-2005 Minero Aoki' + + TASKS = [ + [ 'all', 'do config, setup, then install' ], + [ 'config', 'saves your configurations' ], + [ 'show', 'shows current configuration' ], + [ 'setup', 'compiles ruby extentions and others' ], + [ 'install', 'installs files' ], + [ 'test', 'run all tests in test/' ], + [ 'clean', "does `make clean' for each extention" ], + [ 'distclean',"does `make distclean' for each extention" ] + ] + + def ToplevelInstaller.invoke + config = ConfigTable.new(load_rbconfig()) + config.load_standard_entries + config.load_multipackage_entries if multipackage? + config.fixup + klass = (multipackage?() ? ToplevelInstallerMulti : ToplevelInstaller) + klass.new(File.dirname($0), config).invoke + end + + def ToplevelInstaller.multipackage? + File.dir?(File.dirname($0) + '/packages') + end + + def ToplevelInstaller.load_rbconfig + if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg } + ARGV.delete(arg) + load File.expand_path(arg.split(/=/, 2)[1]) + $".push 'rbconfig.rb' + else + require 'rbconfig' + end + ::Config::CONFIG + end + + def initialize(ardir_root, config) + @ardir = File.expand_path(ardir_root) + @config = config + # cache + @valid_task_re = nil + end + + def config(key) + @config[key] + end + + def inspect + "#<#{self.class} #{__id__()}>" + end + + def invoke + run_metaconfigs + case task = parsearg_global() + when nil, 'all' + parsearg_config + init_installers + exec_config + exec_setup + exec_install + else + case task + when 'config', 'test' + ; + when 'clean', 'distclean' + @config.load_savefile if File.exist?(@config.savefile) + else + @config.load_savefile + end + __send__ "parsearg_#{task}" + init_installers + __send__ "exec_#{task}" + end + end + + def run_metaconfigs + @config.load_script "#{@ardir}/metaconfig" + end + + def init_installers + @installer = Installer.new(@config, @ardir, File.expand_path('.')) + end + + # + # Hook Script API bases + # + + def srcdir_root + @ardir + end + + def objdir_root + '.' + end + + def relpath + '.' + end + + # + # Option Parsing + # + + def parsearg_global + while arg = ARGV.shift + case arg + when /\A\w+\z/ + setup_rb_error "invalid task: #{arg}" unless valid_task?(arg) + return arg + when '-q', '--quiet' + @config.verbose = false + when '--verbose' + @config.verbose = true + when '--help' + print_usage $stdout + exit 0 + when '--version' + puts "#{File.basename($0)} version #{Version}" + exit 0 + when '--copyright' + puts Copyright + exit 0 + else + setup_rb_error "unknown global option '#{arg}'" + end + end + nil + end + + def valid_task?(t) + valid_task_re() =~ t + end + + def valid_task_re + @valid_task_re ||= /\A(?:#{TASKS.map {|task,desc| task }.join('|')})\z/ + end + + def parsearg_no_options + unless ARGV.empty? + task = caller(0).first.slice(%r<`parsearg_(\w+)'>, 1) + setup_rb_error "#{task}: unknown options: #{ARGV.join(' ')}" + end + end + + alias parsearg_show parsearg_no_options + alias parsearg_setup parsearg_no_options + alias parsearg_test parsearg_no_options + alias parsearg_clean parsearg_no_options + alias parsearg_distclean parsearg_no_options + + def parsearg_config + evalopt = [] + set = [] + @config.config_opt = [] + while i = ARGV.shift + if /\A--?\z/ =~ i + @config.config_opt = ARGV.dup + break + end + name, value = *@config.parse_opt(i) + if @config.value_config?(name) + @config[name] = value + else + evalopt.push [name, value] + end + set.push name + end + evalopt.each do |name, value| + @config.lookup(name).evaluate value, @config + end + # Check if configuration is valid + set.each do |n| + @config[n] if @config.value_config?(n) + end + end + + def parsearg_install + @config.no_harm = false + @config.install_prefix = '' + while a = ARGV.shift + case a + when '--no-harm' + @config.no_harm = true + when /\A--prefix=/ + path = a.split(/=/, 2)[1] + path = File.expand_path(path) unless path[0,1] == '/' + @config.install_prefix = path + else + setup_rb_error "install: unknown option #{a}" + end + end + end + + def print_usage(out) + out.puts 'Typical Installation Procedure:' + out.puts " $ ruby #{File.basename $0} config" + out.puts " $ ruby #{File.basename $0} setup" + out.puts " # ruby #{File.basename $0} install (may require root privilege)" + out.puts + out.puts 'Detailed Usage:' + out.puts " ruby #{File.basename $0} " + out.puts " ruby #{File.basename $0} [] []" + + fmt = " %-24s %s\n" + out.puts + out.puts 'Global options:' + out.printf fmt, '-q,--quiet', 'suppress message outputs' + out.printf fmt, ' --verbose', 'output messages verbosely' + out.printf fmt, ' --help', 'print this message' + out.printf fmt, ' --version', 'print version and quit' + out.printf fmt, ' --copyright', 'print copyright and quit' + out.puts + out.puts 'Tasks:' + TASKS.each do |name, desc| + out.printf fmt, name, desc + end + + fmt = " %-24s %s [%s]\n" + out.puts + out.puts 'Options for CONFIG or ALL:' + @config.each do |item| + out.printf fmt, item.help_opt, item.description, item.help_default + end + out.printf fmt, '--rbconfig=path', 'rbconfig.rb to load',"running ruby's" + out.puts + out.puts 'Options for INSTALL:' + out.printf fmt, '--no-harm', 'only display what to do if given', 'off' + out.printf fmt, '--prefix=path', 'install path prefix', '' + out.puts + end + + # + # Task Handlers + # + + def exec_config + @installer.exec_config + @config.save # must be final + end + + def exec_setup + @installer.exec_setup + end + + def exec_install + @installer.exec_install + end + + def exec_test + @installer.exec_test + end + + def exec_show + @config.each do |i| + printf "%-20s %s\n", i.name, i.value if i.value? + end + end + + def exec_clean + @installer.exec_clean + end + + def exec_distclean + @installer.exec_distclean + end + +end # class ToplevelInstaller + + +class ToplevelInstallerMulti < ToplevelInstaller + + include FileOperations + + def initialize(ardir_root, config) + super + @packages = directories_of("#{@ardir}/packages") + raise 'no package exists' if @packages.empty? + @root_installer = Installer.new(@config, @ardir, File.expand_path('.')) + end + + def run_metaconfigs + @config.load_script "#{@ardir}/metaconfig", self + @packages.each do |name| + @config.load_script "#{@ardir}/packages/#{name}/metaconfig" + end + end + + attr_reader :packages + + def packages=(list) + raise 'package list is empty' if list.empty? + list.each do |name| + raise "directory packages/#{name} does not exist"\ + unless File.dir?("#{@ardir}/packages/#{name}") + end + @packages = list + end + + def init_installers + @installers = {} + @packages.each do |pack| + @installers[pack] = Installer.new(@config, + "#{@ardir}/packages/#{pack}", + "packages/#{pack}") + end + with = extract_selection(config('with')) + without = extract_selection(config('without')) + @selected = @installers.keys.select {|name| + (with.empty? or with.include?(name)) \ + and not without.include?(name) + } + end + + def extract_selection(list) + a = list.split(/,/) + a.each do |name| + setup_rb_error "no such package: #{name}" unless @installers.key?(name) + end + a + end + + def print_usage(f) + super + f.puts 'Inluded packages:' + f.puts ' ' + @packages.sort.join(' ') + f.puts + end + + # + # Task Handlers + # + + def exec_config + run_hook 'pre-config' + each_selected_installers {|inst| inst.exec_config } + run_hook 'post-config' + @config.save # must be final + end + + def exec_setup + run_hook 'pre-setup' + each_selected_installers {|inst| inst.exec_setup } + run_hook 'post-setup' + end + + def exec_install + run_hook 'pre-install' + each_selected_installers {|inst| inst.exec_install } + run_hook 'post-install' + end + + def exec_test + run_hook 'pre-test' + each_selected_installers {|inst| inst.exec_test } + run_hook 'post-test' + end + + def exec_clean + rm_f @config.savefile + run_hook 'pre-clean' + each_selected_installers {|inst| inst.exec_clean } + run_hook 'post-clean' + end + + def exec_distclean + rm_f @config.savefile + run_hook 'pre-distclean' + each_selected_installers {|inst| inst.exec_distclean } + run_hook 'post-distclean' + end + + # + # lib + # + + def each_selected_installers + Dir.mkdir 'packages' unless File.dir?('packages') + @selected.each do |pack| + $stderr.puts "Processing the package `#{pack}' ..." if verbose? + Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}") + Dir.chdir "packages/#{pack}" + yield @installers[pack] + Dir.chdir '../..' + end + end + + def run_hook(id) + @root_installer.run_hook id + end + + # module FileOperations requires this + def verbose? + @config.verbose? + end + + # module FileOperations requires this + def no_harm? + @config.no_harm? + end + +end # class ToplevelInstallerMulti + + +class Installer + + FILETYPES = %w( bin lib ext data conf man ) + + include FileOperations + include HookScriptAPI + + def initialize(config, srcroot, objroot) + @config = config + @srcdir = File.expand_path(srcroot) + @objdir = File.expand_path(objroot) + @currdir = '.' + end + + def inspect + "#<#{self.class} #{File.basename(@srcdir)}>" + end + + def noop(rel) + end + + # + # Hook Script API base methods + # + + def srcdir_root + @srcdir + end + + def objdir_root + @objdir + end + + def relpath + @currdir + end + + # + # Config Access + # + + # module FileOperations requires this + def verbose? + @config.verbose? + end + + # module FileOperations requires this + def no_harm? + @config.no_harm? + end + + def verbose_off + begin + save, @config.verbose = @config.verbose?, false + yield + ensure + @config.verbose = save + end + end + + # + # TASK config + # + + def exec_config + exec_task_traverse 'config' + end + + alias config_dir_bin noop + alias config_dir_lib noop + + def config_dir_ext(rel) + extconf if extdir?(curr_srcdir()) + end + + alias config_dir_data noop + alias config_dir_conf noop + alias config_dir_man noop + + def extconf + ruby "#{curr_srcdir()}/extconf.rb", *@config.config_opt + end + + # + # TASK setup + # + + def exec_setup + exec_task_traverse 'setup' + end + + def setup_dir_bin(rel) + files_of(curr_srcdir()).each do |fname| + update_shebang_line "#{curr_srcdir()}/#{fname}" + end + end + + alias setup_dir_lib noop + + def setup_dir_ext(rel) + make if extdir?(curr_srcdir()) + end + + alias setup_dir_data noop + alias setup_dir_conf noop + alias setup_dir_man noop + + def update_shebang_line(path) + return if no_harm? + return if config('shebang') == 'never' + old = Shebang.load(path) + if old + $stderr.puts "warning: #{path}: Shebang line includes too many args. It is not portable and your program may not work." if old.args.size > 1 + new = new_shebang(old) + return if new.to_s == old.to_s + else + return unless config('shebang') == 'all' + new = Shebang.new(config('rubypath')) + end + $stderr.puts "updating shebang: #{File.basename(path)}" if verbose? + open_atomic_writer(path) {|output| + File.open(path, 'rb') {|f| + f.gets if old # discard + output.puts new.to_s + output.print f.read + } + } + end + + def new_shebang(old) + if /\Aruby/ =~ File.basename(old.cmd) + Shebang.new(config('rubypath'), old.args) + elsif File.basename(old.cmd) == 'env' and old.args.first == 'ruby' + Shebang.new(config('rubypath'), old.args[1..-1]) + else + return old unless config('shebang') == 'all' + Shebang.new(config('rubypath')) + end + end + + def open_atomic_writer(path, &block) + tmpfile = File.basename(path) + '.tmp' + begin + File.open(tmpfile, 'wb', &block) + File.rename tmpfile, File.basename(path) + ensure + File.unlink tmpfile if File.exist?(tmpfile) + end + end + + class Shebang + def Shebang.load(path) + line = nil + File.open(path) {|f| + line = f.gets + } + return nil unless /\A#!/ =~ line + parse(line) + end + + def Shebang.parse(line) + cmd, *args = *line.strip.sub(/\A\#!/, '').split(' ') + new(cmd, args) + end + + def initialize(cmd, args = []) + @cmd = cmd + @args = args + end + + attr_reader :cmd + attr_reader :args + + def to_s + "#! #{@cmd}" + (@args.empty? ? '' : " #{@args.join(' ')}") + end + end + + # + # TASK install + # + + def exec_install + rm_f 'InstalledFiles' + exec_task_traverse 'install' + end + + def install_dir_bin(rel) + install_files targetfiles(), "#{config('bindir')}/#{rel}", 0755 + end + + def install_dir_lib(rel) + install_files libfiles(), "#{config('rbdir')}/#{rel}", 0644 + end + + def install_dir_ext(rel) + return unless extdir?(curr_srcdir()) + install_files rubyextentions('.'), + "#{config('sodir')}/#{File.dirname(rel)}", + 0555 + end + + def install_dir_data(rel) + install_files targetfiles(), "#{config('datadir')}/#{rel}", 0644 + end + + def install_dir_conf(rel) + # FIXME: should not remove current config files + # (rename previous file to .old/.org) + install_files targetfiles(), "#{config('sysconfdir')}/#{rel}", 0644 + end + + def install_dir_man(rel) + install_files targetfiles(), "#{config('mandir')}/#{rel}", 0644 + end + + def install_files(list, dest, mode) + mkdir_p dest, @config.install_prefix + list.each do |fname| + install fname, dest, mode, @config.install_prefix + end + end + + def libfiles + glob_reject(%w(*.y *.output), targetfiles()) + end + + def rubyextentions(dir) + ents = glob_select("*.#{@config.dllext}", targetfiles()) + if ents.empty? + setup_rb_error "no ruby extention exists: 'ruby #{$0} setup' first" + end + ents + end + + def targetfiles + mapdir(existfiles() - hookfiles()) + end + + def mapdir(ents) + ents.map {|ent| + if File.exist?(ent) + then ent # objdir + else "#{curr_srcdir()}/#{ent}" # srcdir + end + } + end + + # picked up many entries from cvs-1.11.1/src/ignore.c + JUNK_FILES = %w( + core RCSLOG tags TAGS .make.state + .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb + *~ *.old *.bak *.BAK *.orig *.rej _$* *$ + + *.org *.in .* + ) + + def existfiles + glob_reject(JUNK_FILES, (files_of(curr_srcdir()) | files_of('.'))) + end + + def hookfiles + %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt| + %w( config setup install clean ).map {|t| sprintf(fmt, t) } + }.flatten + end + + def glob_select(pat, ents) + re = globs2re([pat]) + ents.select {|ent| re =~ ent } + end + + def glob_reject(pats, ents) + re = globs2re(pats) + ents.reject {|ent| re =~ ent } + end + + GLOB2REGEX = { + '.' => '\.', + '$' => '\$', + '#' => '\#', + '*' => '.*' + } + + def globs2re(pats) + /\A(?:#{ + pats.map {|pat| pat.gsub(/[\.\$\#\*]/) {|ch| GLOB2REGEX[ch] } }.join('|') + })\z/ + end + + # + # TASK test + # + + TESTDIR = 'test' + + def exec_test + unless File.directory?('test') + $stderr.puts 'no test in this package' if verbose? + return + end + $stderr.puts 'Running tests...' if verbose? + begin + require 'test/unit' + rescue LoadError + setup_rb_error 'test/unit cannot loaded. You need Ruby 1.8 or later to invoke this task.' + end + runner = Test::Unit::AutoRunner.new(true) + runner.to_run << TESTDIR + runner.run + end + + # + # TASK clean + # + + def exec_clean + exec_task_traverse 'clean' + rm_f @config.savefile + rm_f 'InstalledFiles' + end + + alias clean_dir_bin noop + alias clean_dir_lib noop + alias clean_dir_data noop + alias clean_dir_conf noop + alias clean_dir_man noop + + def clean_dir_ext(rel) + return unless extdir?(curr_srcdir()) + make 'clean' if File.file?('Makefile') + end + + # + # TASK distclean + # + + def exec_distclean + exec_task_traverse 'distclean' + rm_f @config.savefile + rm_f 'InstalledFiles' + end + + alias distclean_dir_bin noop + alias distclean_dir_lib noop + + def distclean_dir_ext(rel) + return unless extdir?(curr_srcdir()) + make 'distclean' if File.file?('Makefile') + end + + alias distclean_dir_data noop + alias distclean_dir_conf noop + alias distclean_dir_man noop + + # + # Traversing + # + + def exec_task_traverse(task) + run_hook "pre-#{task}" + FILETYPES.each do |type| + if type == 'ext' and config('without-ext') == 'yes' + $stderr.puts 'skipping ext/* by user option' if verbose? + next + end + traverse task, type, "#{task}_dir_#{type}" + end + run_hook "post-#{task}" + end + + def traverse(task, rel, mid) + dive_into(rel) { + run_hook "pre-#{task}" + __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '') + directories_of(curr_srcdir()).each do |d| + traverse task, "#{rel}/#{d}", mid + end + run_hook "post-#{task}" + } + end + + def dive_into(rel) + return unless File.dir?("#{@srcdir}/#{rel}") + + dir = File.basename(rel) + Dir.mkdir dir unless File.dir?(dir) + prevdir = Dir.pwd + Dir.chdir dir + $stderr.puts '---> ' + rel if verbose? + @currdir = rel + yield + Dir.chdir prevdir + $stderr.puts '<--- ' + rel if verbose? + @currdir = File.dirname(rel) + end + + def run_hook(id) + path = [ "#{curr_srcdir()}/#{id}", + "#{curr_srcdir()}/#{id}.rb" ].detect {|cand| File.file?(cand) } + return unless path + begin + instance_eval File.read(path), path, 1 + rescue + raise if $DEBUG + setup_rb_error "hook #{path} failed:\n" + $!.message + end + end + +end # class Installer + + +class SetupError < StandardError; end + +def setup_rb_error(msg) + raise SetupError, msg +end + +if $0 == __FILE__ + begin + ToplevelInstaller.invoke + rescue SetupError + raise if $DEBUG + $stderr.puts $!.message + $stderr.puts "Try 'ruby #{$0} --help' for detailed usage." + exit 1 + end +end diff --git a/test.rb b/test.rb deleted file mode 100755 index 5c2c23d..0000000 --- a/test.rb +++ /dev/null @@ -1,104 +0,0 @@ -#!/usr/bin/env ruby - -require 'test/unit' -require 'mahoro' -require 'mahoro/thread_safe' -require 'pathname' - -class MahoroTestCase < Test::Unit::TestCase - - def setup - @m = Mahoro.new - end - - # Different versions of libmagic may generate different values. - # So far, we have seen: - # - ASCII C program text - # - C source, ASCII text - def assert_c_text(buf) - assert_match(/\bC\b/, buf, "contains the letter C") - assert_match(/\s/, buf, "contains spaces") - assert_match(/(?:source|text)/, buf, "is source or text") - end - - def test_pathname - @m.flags = Mahoro::NONE - pn = Pathname.new('mahoro.c') - assert_c_text(@m.file(pn)) - end - - def test_file - @m.flags = Mahoro::NONE - assert_c_text(@m.file('mahoro.c')) - end - - def test_mime_file - @m.flags = Mahoro::MIME - assert({ - 'text/x-c; charset=us-ascii' => true, - 'text/x-c charset=us-ascii' => true - }.include?(@m.file('mahoro.c'))) - end - - def test_null_byte_in_path - assert_raises(ArgumentError) { @m.file("mahoro.c\0foo") } - end - - def test_buffer - @m.flags = Mahoro::NONE - assert_c_text(@m.buffer(File.read('mahoro.c'))) - end - - def test_buffer_string_convert - tmp = File.read('mahoro.c') - buf = Struct.new(:to_str).new(tmp) - assert_c_text(@m.buffer(buf)) - end - - def test_buffer_invalid - @m.flags = Mahoro::NONE - assert_raises(TypeError) { @m.buffer @m } - end - - def test_mime_buffer - @m.flags = Mahoro::MIME - assert({ - 'text/x-c; charset=us-ascii' => true, - 'text/x-c charset=us-ascii' => true - }.include?(@m.buffer(File.read('mahoro.c')))) - end - - def test_valid - assert(@m.valid?, 'Default database was not valid.') - end - - def test_valid_with_null - assert_raises(ArgumentError) { @m.valid? "mahoro.c\0" } - end - - def test_compile - File.open(__FILE__) do |fp| - fp.flock File::LOCK_EX - assert Mahoro.compile("magic.sample") - assert_nothing_raised do - File.unlink("magic.sample.mgc") - end - end - end - - def test_compile_bad - assert_raises(ArgumentError) do - Mahoro.compile "magic.sample\0" - end - end - - def test_thread_safe - before = @m.method(:file) - @m.extend(Mahoro::ThreadSafe) - @m.flags = Mahoro::NONE - assert_c_text(@m.file('mahoro.c')) - assert_not_equal(before.object_id, @m.method(:file).object_id) - end -end - -# arch-tag: test diff --git a/test/test_mahoro.rb b/test/test_mahoro.rb new file mode 100755 index 0000000..54aff7b --- /dev/null +++ b/test/test_mahoro.rb @@ -0,0 +1,105 @@ +#!/usr/bin/env ruby + +require 'test/unit' +require 'mahoro' +require 'mahoro/thread_safe' +require 'pathname' + +class MahoroTestCase < Test::Unit::TestCase + C_FILE = "#{File.dirname(__FILE__)}/../ext/mahoro/mahoro.c" + + def setup + @m = Mahoro.new + end + + # Different versions of libmagic may generate different values. + # So far, we have seen: + # - ASCII C program text + # - C source, ASCII text + def assert_c_text(buf) + assert_match(/\bC\b/, buf, "contains the letter C") + assert_match(/\s/, buf, "contains spaces") + assert_match(/(?:source|text)/, buf, "is source or text") + end + + def test_pathname + @m.flags = Mahoro::NONE + pn = Pathname.new(C_FILE) + assert_c_text(@m.file(pn)) + end + + def test_file + @m.flags = Mahoro::NONE + assert_c_text(@m.file(C_FILE)) + end + + def test_mime_file + @m.flags = Mahoro::MIME + assert({ + 'text/x-c; charset=us-ascii' => true, + 'text/x-c charset=us-ascii' => true + }.include?(@m.file(C_FILE))) + end + + def test_null_byte_in_path + assert_raises(ArgumentError) { @m.file("#{C_FILE}\0foo") } + end + + def test_buffer + @m.flags = Mahoro::NONE + assert_c_text(@m.buffer(File.read(C_FILE))) + end + + def test_buffer_string_convert + tmp = File.read(C_FILE) + buf = Struct.new(:to_str).new(tmp) + assert_c_text(@m.buffer(buf)) + end + + def test_buffer_invalid + @m.flags = Mahoro::NONE + assert_raises(TypeError) { @m.buffer @m } + end + + def test_mime_buffer + @m.flags = Mahoro::MIME + assert({ + 'text/x-c; charset=us-ascii' => true, + 'text/x-c charset=us-ascii' => true + }.include?(@m.buffer(File.read(C_FILE)))) + end + + def test_valid + assert(@m.valid?, 'Default database was not valid.') + end + + def test_valid_with_null + assert_raises(ArgumentError) { @m.valid? "#{C_FILE}\0" } + end + + def test_compile + File.open(__FILE__) do |fp| + fp.flock File::LOCK_EX + assert Mahoro.compile("magic.sample") + assert_nothing_raised do + File.unlink("magic.sample.mgc") + end + end + end + + def test_compile_bad + assert_raises(ArgumentError) do + Mahoro.compile "magic.sample\0" + end + end + + def test_thread_safe + before = @m.method(:file) + @m.extend(Mahoro::ThreadSafe) + @m.flags = Mahoro::NONE + assert_c_text(@m.file(C_FILE)) + assert_not_equal(before.object_id, @m.method(:file).object_id) + end +end + +# arch-tag: test diff --git a/www/.gitignore b/www/.gitignore new file mode 100644 index 0000000..72e8ffc --- /dev/null +++ b/www/.gitignore @@ -0,0 +1 @@ +* -- cgit v1.2.3-24-ge0c7