fast-xs-0.8.0/0000755000175000017500000000000011770425650012417 5ustar tfheentfheenfast-xs-0.8.0/README.rdoc0000644000175000017500000000535511770425650014235 0ustar tfheentfheen= fast_xs, excessively fast escaping * http://rubyforge.org/projects/fast-xs * http://fast-xs.rubyforge.org/ * mailto:fast-xs-general@rubyforge.org * git://rubyforge.org/fast-xs.git * http://fast-xs.rubyforge.org/git?p=fast-xs.git == DESCRIPTION: fast_xs provides C extensions for escaping text. The original String#fast_xs method is based on the xchar code by Sam Ruby: * http://intertwingly.net/stories/2005/09/28/xchar.rb * http://intertwingly.net/blog/2005/09/28/XML-Cleansing _why also packages an older version with Hpricot (patches submitted). The version here should be compatible with the latest version of Hpricot code. Ruby on Rails will automatically use String#fast_xs from either Hpricot or this gem version with the bundled Builder package. String#fast_xs is an almost exact translation of Sam Ruby's original implementation (String#to_xs), but it does escape """ (which is an optional, but all parsers are able ot handle it. XML::Builder as packaged in Rails 2.0 will be automatically use String#fast_xs instead of String#to_xs available. === EXTRA: 'fast_xs_extra' is an experimental extension that can be used with 'fast_xs_monkey_patcher' to monkey patch methods in common libraries: CGI, ERB::Util, Rack::Utils, Mongrel However, 'fast_xs_extra' does not provide a significant performance boost like 'fast_xs' does under Ruby 1.8. == COMPATIBILITY: This package aims to be compatible with Ruby 1.8 and 1.9. It is however not as helpful in Ruby 1.9 which already provides encoding-aware string functions. Rubinius compatibility may happen in the future if deemed necessary, but this extension seems to be against the spirit of the Rubinius project. == LICENSE: (The MIT License) Copyright (c) all contributors (see logs in git) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. fast-xs-0.8.0/metadata.yml0000644000175000017500000000601311770425650014722 0ustar tfheentfheen--- !ruby/object:Gem::Specification name: fast_xs version: !ruby/object:Gem::Version hash: 63 prerelease: false segments: - 0 - 8 - 0 version: 0.8.0 platform: ruby authors: - fast_xs hackers autorequire: bindir: bin cert_chain: [] date: 2011-01-26 00:00:00 +00:00 default_executable: dependencies: - !ruby/object:Gem::Dependency name: hoe prerelease: false requirement: &id001 !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 47 segments: - 2 - 8 - 0 version: 2.8.0 type: :development version_requirements: *id001 description: |- fast_xs provides C extensions for escaping text. The original String#fast_xs method is based on the xchar code by Sam Ruby: * http://intertwingly.net/stories/2005/09/28/xchar.rb * http://intertwingly.net/blog/2005/09/28/XML-Cleansing _why also packages an older version with Hpricot (patches submitted). The version here should be compatible with the latest version of Hpricot code. Ruby on Rails will automatically use String#fast_xs from either Hpricot or this gem version with the bundled Builder package. String#fast_xs is an almost exact translation of Sam Ruby's original implementation (String#to_xs), but it does escape """ (which is an optional, but all parsers are able ot handle it. XML::Builder as packaged in Rails 2.0 will be automatically use String#fast_xs instead of String#to_xs available. email: fast-xs-general@rubyforge.org executables: [] extensions: - ext/fast_xs/extconf.rb - ext/fast_xs_extra/extconf.rb extra_rdoc_files: - Manifest.txt files: - .gitignore - GNUmakefile - History.rdoc - Manifest.txt - README.rdoc - Rakefile - ext/fast_xs/extconf.rb - ext/fast_xs/fast_xs.c - ext/fast_xs/fast_xs_type.h - ext/fast_xs/gcc.h - ext/fast_xs/ruby_1_9_compat.h - ext/fast_xs_extra/extconf.rb - ext/fast_xs_extra/fast_xs_extra.c - lib/fast_xs_monkey_patcher.rb - setup.rb - test/test_cgi_class_overrides.rb - test/test_erb_util_module_overrides.rb - test/test_mongrel_overrides.rb - test/test_rack_util_overrides.rb - test/test_xml_escaping.rb has_rdoc: true homepage: http://fast-xs.rubyforge.org/ licenses: [] post_install_message: rdoc_options: - --main - README.rdoc require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 3 segments: - 0 version: "0" required_rubygems_version: !ruby/object:Gem::Requirement none: false requirements: - - ">=" - !ruby/object:Gem::Version hash: 3 segments: - 0 version: "0" requirements: [] rubyforge_project: fast-xs rubygems_version: 1.3.7 signing_key: specification_version: 3 summary: fast_xs provides C extensions for escaping text test_files: - test/test_xml_escaping.rb - test/test_mongrel_overrides.rb - test/test_rack_util_overrides.rb - test/test_cgi_class_overrides.rb - test/test_erb_util_module_overrides.rb fast-xs-0.8.0/History.rdoc0000644000175000017500000000070611770425650014734 0ustar tfheentfheen=== 0.8.0 / 2011-01-26 * preserve encoding of original string under Ruby 1.9 * avoid warnings when monkey patching * internal cleanups Browse gitweb for full history: http://fast-xs.rubyforge.org/git?p=fast-xs.git === 0.7.3 / 2009-07-31 * 1 bug fix: * extra: fix Mongrel::HttpRequest monkey patch - thanks (again) to Jesse Storimer for noticing and reporting Browse gitweb for full history: http://fast-xs.rubyforge.org/git?p=fast-xs.git fast-xs-0.8.0/Rakefile0000644000175000017500000000127011770425650014064 0ustar tfheentfheenrequire 'hoe' hoe = Hoe.spec('fast_xs') do self.version = '0.8.0' self.author = 'fast_xs hackers' self.email = 'fast-xs-general@rubyforge.org' self.url = 'http://fast-xs.rubyforge.org/' self.history_file = 'History.rdoc' self.readme_file = 'README.rdoc' self.remote_rdoc_dir = '' self.rubyforge_name = 'fast-xs' self.spec_extras = { :extensions => Dir.glob('ext/*/extconf.rb') } end # optional rake-compiler support in case somebody needs to cross compile begin require 'rake/extensiontask' Rake::ExtensionTask.new('fast_xs', hoe.spec) Rake::ExtensionTask.new('fast_xs_extra', hoe.spec) rescue LoadError warn "rake-compiler not available, cross compiling disabled" end fast-xs-0.8.0/Manifest.txt0000644000175000017500000000070611770425650014731 0ustar tfheentfheen.gitignore GNUmakefile History.rdoc Manifest.txt README.rdoc Rakefile ext/fast_xs/extconf.rb ext/fast_xs/fast_xs.c ext/fast_xs/fast_xs_type.h ext/fast_xs/gcc.h ext/fast_xs/ruby_1_9_compat.h ext/fast_xs_extra/extconf.rb ext/fast_xs_extra/fast_xs_extra.c lib/fast_xs_monkey_patcher.rb setup.rb test/test_cgi_class_overrides.rb test/test_erb_util_module_overrides.rb test/test_mongrel_overrides.rb test/test_rack_util_overrides.rb test/test_xml_escaping.rb fast-xs-0.8.0/setup.rb0000644000175000017500000010647311770425650014117 0ustar tfheentfheen# # 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 fast-xs-0.8.0/test/0000755000175000017500000000000011770425650013376 5ustar tfheentfheenfast-xs-0.8.0/test/test_xml_escaping.rb0000644000175000017500000000416411770425650017440 0ustar tfheentfheenrequire 'fast_xs' require 'test/unit' # Based on Sam's original xchar.rb tests: class TestXmlEscaping < Test::Unit::TestCase def test_ascii assert_equal 'abc', 'abc'.fast_xs end def test_predefined assert_equal '&', '&'.fast_xs # ampersand assert_equal '<', '<'.fast_xs # left angle bracket assert_equal '>', '>'.fast_xs # right angle bracket assert_equal '"', '"'.fast_xs # double quote end def test_invalid assert_equal '*', "\x00".fast_xs # null assert_equal '*', "\x0C".fast_xs # form feed assert_equal '*', "\xEF\xBF\xBF".fast_xs # U+FFFF end def test_iso_8859_1 assert_equal 'ç', "\xE7".fast_xs # small c cedilla assert_equal '©', "\xA9".fast_xs # copyright symbol end def test_win_1252 assert_equal '’', "\x92".fast_xs # smart quote assert_equal '€', "\x80".fast_xs # euro end def test_utf8 assert_equal '’', "\xE2\x80\x99".fast_xs # right single quote assert_equal '©', "\xC2\xA9".fast_xs # copy end def test_iso_8859_1_encoding_preserved copyright = "\xA9" copyright.force_encoding Encoding::ISO_8859_1 assert_equal '©', copyright.fast_xs assert copyright.fast_xs.valid_encoding? assert_equal Encoding::ISO_8859_1, copyright.fast_xs.encoding end if defined?(Encoding) def test_win_1252_encoding_preserved euro = "\x80" euro.force_encoding Encoding::CP1252 assert_equal '€', euro.fast_xs assert euro.fast_xs.valid_encoding? assert_equal Encoding::CP1252, euro.fast_xs.encoding end if defined?(Encoding) def test_utf8_encoding_preserved copy = "\xC2\xA9" copy.force_encoding Encoding::UTF_8 assert_equal '©', copy.fast_xs assert_equal Encoding::UTF_8, copy.fast_xs.encoding assert copy.fast_xs.valid_encoding? end if defined?(Encoding) def test_large_document if ENV['LARGE_STRING_TEST'] assert(('&' * (8192 * 1024)).fast_xs) assert(('a' * (8192 * 1024)).fast_xs) end end end fast-xs-0.8.0/test/test_mongrel_overrides.rb0000644000175000017500000000106611770425650020512 0ustar tfheentfheenbegin require 'mongrel' $orig_escape = Mongrel::HttpRequest.method(:escape) $orig_unescape = Mongrel::HttpRequest.method(:unescape) rescue SyntaxError,LoadError => e warn "skipping Mongrel test, Mongrel not available or broken under 1.9.2" end require 'test/unit' require 'fast_xs_monkey_patcher' class TestMongrelHttpOverrides < Test::Unit::TestCase def test_escape assert_equal "%2B", Mongrel::HttpRequest.escape("+") end def test_unescape assert_equal "+", Mongrel::HttpRequest.unescape("%2B") end end if defined?(Mongrel::HttpRequest) fast-xs-0.8.0/test/test_rack_util_overrides.rb0000644000175000017500000000315311770425650021023 0ustar tfheentfheenrequire 'rack' $orig_escape = Rack::Utils.method(:escape) $orig_unescape = Rack::Utils.method(:unescape) require 'test/unit' require 'fast_xs_monkey_patcher' # copied and translated to Test::Unit from test/spec_utils.rb in rack class TestRackUtilModuleOverrides < Test::Unit::TestCase def test_overidden assert $orig_escape != Rack::Utils.method(:escape) assert $orig_unescape != Rack::Utils.method(:unescape) end def test_escape_html_predefined assert_equal "fo%3Co%3Ebar", Rack::Utils.escape("fobar") assert_equal "a+space", Rack::Utils.escape("a space") assert_equal "q1%212%22%27w%245%267%2Fz8%29%3F%5C", Rack::Utils.escape("q1!2\"'w$5&7/z8)?\\") matz_name = # Matsumoto "\xE3\x81\xBE\xE3\x81\xA4\xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] matz_name.force_encoding("UTF-8") if matz_name.respond_to? :force_encoding assert_equal '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8', Rack::Utils.escape(matz_name) matz_name_sep = # Matsu moto "\xE3\x81\xBE\xE3\x81\xA4 \xE3\x82\x82\xE3\x81\xA8".unpack("a*")[0] matz_name_sep.respond_to?(:force_encoding) and matz_name_sep.force_encoding("UTF-8") assert_equal '%E3%81%BE%E3%81%A4+%E3%82%82%E3%81%A8', Rack::Utils.escape(matz_name_sep) end def test_unescape assert_equal "fobar", Rack::Utils.unescape("fo%3Co%3Ebar") assert_equal "a space", Rack::Utils.unescape("a+space") assert_equal "a space", Rack::Utils.unescape("a%20space") assert_equal "q1!2\"'w$5&7/z8)?\\", Rack::Utils.unescape("q1%212%22%27w%245%267%2Fz8%29%3F%5C") end end fast-xs-0.8.0/test/test_cgi_class_overrides.rb0000644000175000017500000000433011770425650020773 0ustar tfheentfheen# -*- encoding: utf-8 -*- require 'test/unit' require 'cgi' require 'fast_xs_monkey_patcher' class TestCgiClassOverrides < Test::Unit::TestCase def test_escape_html_predefined assert_equal '&', CGI::escapeHTML('&') assert_equal '"', CGI::escapeHTML('"') assert_equal '<', CGI::escapeHTML('<') assert_equal '>', CGI::escapeHTML('>') end def test_escape_html_normal assert_equal 'hello world', CGI::escapeHTML('hello world') assert_equal '', CGI::escapeHTML('') end def test_escape_html_ignore assert_equal "\x00", CGI::escapeHTML("\x00") assert_equal "\x0C", CGI::escapeHTML("\x0C") assert_equal "\xEF\xBF\xBF", CGI::escapeHTML("\xEF\xBF\xBF") end def test_escape_cgi assert_equal 'hello%3Dworld', CGI::escape('hello=world') assert_equal '+', CGI::escape(' ') assert_equal '%2B', CGI::escape('+') assert_equal '%2C', CGI::escape(',') assert_equal 'hello-world', CGI::escape('hello-world') assert_equal 'H3LL0+W0RLD', CGI::escape('H3LL0 W0RLD') end def test_escape_cgi_high assert_equal '%C3%A8', CGI::escape('è') end def test_unescape_cgi_high assert_equal 'è', CGI::unescape('%C3%A8') end def test_unescape_cgi assert_equal 'hello=world', CGI::unescape('hello%3Dworld') assert_equal ' ', CGI::unescape('+') assert_equal '+', CGI::unescape('%2B') assert_equal ',', CGI::unescape('%2C') assert_equal '%', CGI::unescape('%') assert_equal 'hello-world', CGI::unescape('hello-world') assert_equal 'H3LL0 W0RLD', CGI::unescape('H3LL0+W0RLD') end def test_large_strings if ENV['LARGE_STRING_TEST'] assert CGI::escape('&' * (8192 * 1024)) assert CGI::escapeHTML('&' * (8192 * 1024)) end end def test_default_encoding_preserved amp = "&" assert_equal Encoding::UTF_8, amp.encoding res = CGI.escapeHTML(amp) assert_equal "&", res assert_equal Encoding::UTF_8, res.encoding end if defined?(Encoding) def test_forced_encoding_preserved amp = "&" assert_nothing_raised { amp.force_encoding Encoding::US_ASCII } res = CGI.escapeHTML(amp) assert_equal "&", res assert_equal Encoding::US_ASCII, res.encoding end if defined?(Encoding) end fast-xs-0.8.0/test/test_erb_util_module_overrides.rb0000644000175000017500000000334711770425650022225 0ustar tfheentfheenrequire 'erb' require 'test/unit' require 'fast_xs_monkey_patcher' class TestErbUtilModuleOverrides < Test::Unit::TestCase include ERB::Util def test_escape_html_predefined assert_equal '&', html_escape('&') assert_equal '"', html_escape('"') assert_equal '<', html_escape('<') assert_equal '>', html_escape('>') end def test_escape_html_normal assert_equal 'hello world', html_escape('hello world') assert_equal '', html_escape('') end def test_escape_html_ignore assert_equal "\x00", html_escape("\x00") assert_equal "\x0C", html_escape("\x0C") assert_equal "\xEF\xBF\xBF", html_escape("\xEF\xBF\xBF") end def test_escape_url assert_equal 'hello%3Dworld', url_encode('hello=world') assert_equal '%20', url_encode(' ') assert_equal '%2B', url_encode('+') assert_equal '%2C', url_encode(',') assert_equal 'hello-world', url_encode('hello-world') assert_equal 'H3LL0%20W0RLD', url_encode('H3LL0 W0RLD') end def test_preserve_encoding foo = "foo" foo.force_encoding Encoding::US_ASCII assert_equal Encoding::US_ASCII, url_encode(foo).encoding assert_equal Encoding::US_ASCII, html_escape(foo).encoding assert_equal Encoding::US_ASCII, u(foo).encoding assert_equal Encoding::US_ASCII, h(foo).encoding foo.force_encoding Encoding::BINARY assert_equal Encoding::BINARY, url_encode(foo).encoding assert_equal Encoding::BINARY, html_escape(foo).encoding assert_equal Encoding::BINARY, u(foo).encoding assert_equal Encoding::BINARY, h(foo).encoding end if defined?(Encoding) def test_large_strings if ENV['LARGE_STRING_TEST'] assert u('&' * (8192 * 1024)) assert h('&' * (8192 * 1024)) end end end fast-xs-0.8.0/.gitignore0000644000175000017500000000011111770425650014400 0ustar tfheentfheen*.so pkg tags TAGS Makefile *.so *.o *.log /doc /.config /InstalledFiles fast-xs-0.8.0/ext/0000755000175000017500000000000011770425650013217 5ustar tfheentfheenfast-xs-0.8.0/ext/fast_xs/0000755000175000017500000000000011770425650014666 5ustar tfheentfheenfast-xs-0.8.0/ext/fast_xs/gcc.h0000644000175000017500000000056511770425650015601 0ustar tfheentfheen#ifndef GCC_H #define GCC_H /* give GCC hints for better branch prediction * (we layout branches so that ASCII characters are handled faster) */ #if defined(__GNUC__) && (__GNUC__ >= 3) # define likely(x) __builtin_expect (!!(x), 1) # define unlikely(x) __builtin_expect (!!(x), 0) #else # define unlikely(x) (x) # define likely(x) (x) #endif #endif /* GCC_H */ fast-xs-0.8.0/ext/fast_xs/extconf.rb0000644000175000017500000000014011770425650016654 0ustar tfheentfheenrequire 'mkmf' have_header('assert.h') or exit dir_config('fast_xs') create_makefile('fast_xs') fast-xs-0.8.0/ext/fast_xs/fast_xs_type.h0000644000175000017500000000120411770425650017544 0ustar tfheentfheen#ifndef FAST_XS_TYPE_H #define FAST_XS_TYPE_H /* I don't trust ctype.h when it comes to locale-independence: */ static __inline__ int is_hex(const int x) { return (((x) >= '0' && (x) <= '9') || ((x) >= 'a' && (x) <= 'f') || ((x) >= 'A' && (x) <= 'F')); } static __inline__ int xtoupper(const int x) { return (x >= 'a' && x <= 'f') ? (x & ~0x20) : x; } static __inline__ int hexchar_to_int(const int x) { return (x < 'A') ? (x - '0') : (xtoupper(x) - 'A' + 10); } static __inline__ int hexpair_to_int(const int x1, const int x2) { return ((hexchar_to_int(x1) << 4) | hexchar_to_int(x2)); } #endif /* FAST_XS_TYPE_H */ fast-xs-0.8.0/ext/fast_xs/ruby_1_9_compat.h0000644000175000017500000000131011770425650020026 0ustar tfheentfheen/* Ruby 1.8.6+ macros (for compatibility with Ruby 1.9) */ #ifndef RSTRING_PTR # define RSTRING_PTR(s) (RSTRING(s)->ptr) #endif #ifndef RSTRING_LEN # define RSTRING_LEN(s) (RSTRING(s)->len) #endif #ifndef RARRAY_PTR # define RARRAY_PTR(s) (RARRAY(s)->ptr) #endif #ifndef RARRAY_LEN # define RARRAY_LEN(s) (RARRAY(s)->len) #endif #ifdef HAVE_RUBY_ENCODING_H #include static VALUE fast_xs_buf_new(VALUE orig, long len) { rb_encoding *enc = rb_enc_get(orig); VALUE str = rb_str_new(NULL, len); return rb_enc_associate(str, enc); } #else /* ! HAVE_RUBY_ENCODING_H */ static VALUE fast_xs_buf_new(VALUE orig, long len) { return rb_str_new(NULL, len); } #endif /* ! HAVE_RUBY_ENCODING_H */ fast-xs-0.8.0/ext/fast_xs/fast_xs.c0000644000175000017500000001122611770425650016503 0ustar tfheentfheen#include #include #include "ruby_1_9_compat.h" #include "fast_xs_type.h" #include "gcc.h" static ID unpack_id; static VALUE U_fmt, C_fmt; /* pass-through certain characters for CP-1252 */ #define p(x) (x-128) static const int cp_1252[] = { 8364, /* 128 => 8364, euro sign */ p(129), /* 129 => 129, pass-through */ 8218, /* 130 => 8218, single low-9 quotation mark */ 402, /* 131 => 402, latin small letter f with hook */ 8222, /* 132 => 8222, double low-9 quotation mark */ 8230, /* 133 => 8230, horizontal ellipsis */ 8224, /* 134 => 8224, dagger */ 8225, /* 135 => 8225, double dagger */ 710, /* 136 => 710, modifier letter circumflex accent */ 8240, /* 137 => 8240, per mille sign */ 352, /* 138 => 352, latin capital letter s with caron */ 8249, /* 139 => 8249, single left-pointing angle quotation mark */ 338, /* 140 => 338, latin capital ligature oe */ p(141), /* 141 => 141, pass-through */ 381, /* 142 => 381, latin capital letter z with caron */ p(143), /* 143 => 143, pass-through */ p(144), /* 144 => 144, pass-through */ 8216, /* 145 => 8216, left single quotation mark */ 8217, /* 146 => 8217, right single quotation mark */ 8220, /* 147 => 8220, left double quotation mark */ 8221, /* 148 => 8221, right double quotation mark */ 8226, /* 149 => 8226, bullet */ 8211, /* 150 => 8211, en dash */ 8212, /* 151 => 8212, em dash */ 732, /* 152 => 732, small tilde */ 8482, /* 153 => 8482, trade mark sign */ 353, /* 154 => 353, latin small letter s with caron */ 8250, /* 155 => 8250, single right-pointing angle quotation mark */ 339, /* 156 => 339, latin small ligature oe */ p(157), /* 157 => 157, pass-through */ 382, /* 158 => 382, latin small letter z with caron */ 376 /* 159 => 376} latin capital letter y with diaeresis */ }; #define VALID_VALUE(n) \ (n >= 0x20 && n <= 0xD7FF) || \ (n >= 0xE000 && n <= 0xFFFD) || \ (n >= 0x10000 && n <= 0x10FFFF) #define CP_1252_ESCAPE(n) do { \ if (n >= 128 && n <= 159) \ n = cp_1252[n - 128]; \ } while(0) static inline size_t bytes_for(int n) { if (n < 1000) return sizeof("ϧ") - 1; if (n < 10000) return sizeof("✏") - 1; if (n < 100000) return sizeof("𘚟") - 1; if (n < 1000000) return sizeof("󴈿") - 1; /* if (n < 10000000), we won't have cases above 0x10FFFF */ return sizeof("�") - 1; } static size_t escape(char *buf, int n) { #define return_const_len(x) do { \ memcpy(buf, x, sizeof(x) - 1); \ return (sizeof(x) - 1); \ } while (0) /* handle ASCII first */ if (likely(n < 128)) { if (likely(n >= 0x20 || n == '\t' || n == '\n' || n == '\r')) { if (unlikely(n == '"')) return_const_len("""); if (unlikely(n == '&')) return_const_len("&"); if (unlikely(n == '<')) return_const_len("<"); if (unlikely(n == '>')) return_const_len(">"); buf[0] = (char)n; return 1; } buf[0] = '*'; return 1; } #undef return_const_len CP_1252_ESCAPE(n); if (VALID_VALUE(n)) { /* return snprintf(buf, sizeof("􏿿"), "&#%i;", n); */ static const char digitmap[] = "0123456789"; size_t rv = sizeof("&#;") - 1; buf += bytes_for(n); *--buf = ';'; do { *--buf = digitmap[(int)(n % 10)]; ++rv; } while (n /= 10); *--buf = '#'; *--buf = '&'; return rv; } buf[0] = '*'; return 1; } static VALUE unpack_utf8(VALUE self) { return rb_funcall(self, unpack_id, 1, U_fmt); } static VALUE unpack_uchar(VALUE self) { return rb_funcall(self, unpack_id, 1, C_fmt); } /* * escapes strings for XML * The double-quote (") character is translated to """ */ static VALUE fast_xs(VALUE self) { long i; VALUE array; char *c; size_t s_len; VALUE *tmp; VALUE rv; array = rb_rescue(unpack_utf8, self, unpack_uchar, self); for (tmp = RARRAY_PTR(array), s_len = i = RARRAY_LEN(array); --i >= 0; tmp++) { int n = NUM2INT(*tmp); if (likely(n < 128)) { if (unlikely(n == '"')) s_len += (sizeof(""") - 2); if (unlikely(n == '&')) s_len += (sizeof("&") - 2); if (unlikely(n == '>' || n == '<')) s_len += (sizeof(">") - 2); continue; } CP_1252_ESCAPE(n); if (VALID_VALUE(n)) s_len += bytes_for(n) - 1; } rv = fast_xs_buf_new(self, s_len); c = RSTRING_PTR(rv); for (tmp = RARRAY_PTR(array), i = RARRAY_LEN(array); --i >= 0; tmp++) c += escape(c, NUM2INT(*tmp)); return rv; } void Init_fast_xs(void) { assert(cp_1252[159 - 128] == 376); /* just in case I skipped a line */ unpack_id = rb_intern("unpack"); U_fmt = rb_str_new("U*", 2); C_fmt = rb_str_new("C*", 2); rb_global_variable(&U_fmt); rb_global_variable(&C_fmt); rb_define_method(rb_cString, "fast_xs", fast_xs, 0); } fast-xs-0.8.0/ext/fast_xs_extra/0000755000175000017500000000000011770425650016071 5ustar tfheentfheenfast-xs-0.8.0/ext/fast_xs_extra/fast_xs_extra.c0000644000175000017500000000760611770425650021120 0ustar tfheentfheen#include #include #include "ruby_1_9_compat.h" #include "fast_xs_type.h" #include "gcc.h" #define APPEND_CONST(buf, x) do { \ buf = (char *)memcpy(buf, x, sizeof(x) - 1) + sizeof(x) - 1; \ } while (0) /* * This is coding agnostic, and works on each byte, so some multibyte * character sets may not be fully supported (but UTF-8 should be). * This is meant to be 100% compatible with the * ERB::Util::escape_html and CGI::escapeHTML methods */ static VALUE fast_xs_html(VALUE self) { long i; char *s; size_t new_len = RSTRING_LEN(self); char *new_str; VALUE rv; for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) { if (unlikely(*s == '&')) new_len += (sizeof("&") - 2); else if (unlikely(*s == '<' || *s == '>')) new_len += (sizeof(">") - 2); else if (unlikely(*s == '"')) new_len += (sizeof(""") - 2); } rv = fast_xs_buf_new(self, new_len); new_str = RSTRING_PTR(rv); for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) { if (unlikely(*s == '&')) APPEND_CONST(new_str, "&"); else if (unlikely(*s == '<')) APPEND_CONST(new_str, "<"); else if (unlikely(*s == '>')) APPEND_CONST(new_str, ">"); else if (unlikely(*s == '"')) APPEND_CONST(new_str, """); else *new_str++ = *s; } return rv; } #define CGI_URI_OK(x) \ ((x >= 'a' && x <= 'z') || \ (x >= 'A' && x <= 'Z') || \ (x >= '0' && x <= '9') || \ (x == '.' || x == '-' || x == '_')) static inline VALUE _xs_uri_encode(VALUE self, const unsigned int space_to_plus) { long i; char *s; size_t new_len = RSTRING_LEN(self); char *new_str; VALUE rv; for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) { if (likely(CGI_URI_OK(*s)) || (space_to_plus && *s == ' ')) continue; new_len += 2; } rv = fast_xs_buf_new(self, new_len); new_str = RSTRING_PTR(rv); for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) { if (likely(CGI_URI_OK(*s))) *new_str++ = *s; else if (space_to_plus && *s == ' ') *new_str++ = '+'; else { static const char cgi_digitmap[] = "0123456789ABCDEF"; unsigned char c = *s; new_str[2] = cgi_digitmap[(c % 16)]; new_str[1] = cgi_digitmap[((c/16) % 16)]; new_str[0] = '%'; new_str += 3; } } return rv; } /* * Compatible with ERB::Util::url_encode / ERB::Util::u, this iterates * through each byte, so multibyte character sets may not supported (but * UTF-8 should be). */ static VALUE fast_xs_url(VALUE self) { return _xs_uri_encode(self, 0); } /* * Compatible with CGI::escape(), this iterates through each byte, so * multibyte character sets may not supported (but UTF-8 should be). */ static VALUE fast_xs_cgi(VALUE self) { return _xs_uri_encode(self, 1); } static VALUE _uxs_uri(VALUE self, const unsigned int plus_to_space) { char *s, *new_str; long i; size_t new_len = RSTRING_LEN(self); VALUE rv; for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s) { if (unlikely(*s == '%') && likely(is_hex(s[1])) && likely(is_hex(s[2]))) { new_len -= 2; s += 2; i -= 2; } } rv = fast_xs_buf_new(self, new_len); new_str = RSTRING_PTR(rv); for (s = RSTRING_PTR(self), i = RSTRING_LEN(self); --i >= 0; ++s, ++new_str) { if (plus_to_space && unlikely(*s == '+')) *new_str = ' '; else if (unlikely(*s == '%') && likely(is_hex(s[1])) && likely(is_hex(s[2]))) { *new_str = hexpair_to_int(s[1], s[2]); s += 2; i -= 2; } else *new_str = *s; } return rv; } /* Unescapes CGI, converting plus bytes '+' to space ' ' */ static VALUE fast_uxs_cgi(VALUE self) { return _uxs_uri(self, 1); } void Init_fast_xs_extra(void) { rb_define_method(rb_cString, "fast_xs_html", fast_xs_html, 0); rb_define_method(rb_cString, "fast_xs_cgi", fast_xs_cgi, 0); rb_define_method(rb_cString, "fast_uxs_cgi", fast_uxs_cgi, 0); rb_define_method(rb_cString, "fast_xs_url", fast_xs_url, 0); } fast-xs-0.8.0/ext/fast_xs_extra/extconf.rb0000644000175000017500000000025111770425650020062 0ustar tfheentfheenrequire 'mkmf' have_header('assert.h') or exit find_header('gcc.h', File.dirname(__FILE__) + '/../fast_xs') dir_config('fast_xs_extra') create_makefile('fast_xs_extra') fast-xs-0.8.0/GNUmakefile0000644000175000017500000000201211770425650014464 0ustar tfheentfheenall: test ext := fast_xs fast_xs_extra RUBY = ruby DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts Config::CONFIG["DLEXT"]') libs := $(addsuffix .$(DLEXT),$(addprefix lib/,$(ext))) build: $(libs) makefiles = $(addsuffix /Makefile,$(addprefix ext/,$(ext))) %/Makefile: %/extconf.rb cd $(@D) && $(RUBY) extconf.rb deps := ext/fast_xs/Makefile $(wildcard ext/fast_xs/*.[ch]) extra_deps := ext/fast_xs_extra/Makefile $(wildcard ext/fast_xs_extra/*.[ch]) ext/fast_xs/fast_xs.$(DLEXT): $(deps) $(MAKE) -C $(@D) ext/fast_xs_extra/fast_xs_extra.$(DLEXT): $(extra_deps) $(MAKE) -C $(@D) lib/fast_xs.$(DLEXT): ext/fast_xs/fast_xs.$(DLEXT) lib/fast_xs_extra.$(DLEXT): ext/fast_xs_extra/fast_xs_extra.$(DLEXT) lib/%.$(DLEXT): $(MAKE) -C $(