pax_global_header00006660000000000000000000000064122255702450014516gustar00rootroot0000000000000052 comment=dd6d462557c0dcba3dbd9ea4e8d75496e6a753a0 backports-3.3.5/000077500000000000000000000000001222557024500135165ustar00rootroot00000000000000backports-3.3.5/.document000066400000000000000000000001021222557024500153260ustar00rootroot00000000000000lib/**/*.rb bin/* features/**/*.feature - README.rdoc LICENSE.txt backports-3.3.5/.gitignore000066400000000000000000000000621222557024500155040ustar00rootroot00000000000000*.sw? *.rbc .DS_Store coverage rdoc pkg assets rs backports-3.3.5/.gitmodules000066400000000000000000000001401222557024500156660ustar00rootroot00000000000000[submodule "spec/rubyspec"] path = spec/rubyspec url = git://github.com/rubyspec/rubyspec.git backports-3.3.5/.irbrc000066400000000000000000000000231222557024500146130ustar00rootroot00000000000000$:.unshift "./lib" backports-3.3.5/.travis.yml000066400000000000000000000004741222557024500156340ustar00rootroot00000000000000--- language: ruby rvm: - "1.8.7" - "1.9.2" - "1.9.3" - "2.0.0" - jruby-18mode - jruby-19mode - rbx-18mode - rbx-19mode matrix: allow_failures: - rvm: jruby-18mode - rvm: jruby-19mode - rvm: rbx-18mode - rvm: rbx-19mode before_install: - git submodule update --init --recursive backports-3.3.5/CHANGELOG.rdoc000066400000000000000000000176311222557024500156660ustar00rootroot00000000000000= Backports --- History == Version 3.3.0 - April 3rd, 2013 * Moved `Proc#yield` & `Hash#key` from 1.8.7 to 1.9.1 == Version 3.2.0 - April 2nd, 2013 * Moved `Dir.mktmpdir` to the stdlib 'tmpdir' for Ruby 1.8.7 * Removed `returning` as it is no longer part of Rails. == Version 3.1.0 - March 5th, 2013 * Backports can now be loaded separately! * Small tweaks and fixes for many methods to pass more RubySpecs == Version 3.0.0 - February 24th, 2013 * Features of 2.0.0 are now required when requiring 'backports'. * Additional features of 2.0.0 * Struct#to_h, NilClass#to_h, Hash#to_h * Hash#default_proc = nil * OpenStruct lib * 1.8.7's Enumerator#with_index (it wasn't in the 1.8.7 NEWS file...) == Version 2.8.0 - February 3rd, 2013 * Added some features of 2.0.0 (must be required explicitly until official release): * Array#bsearch * Range#bsearch == Version 2.7.0 - January 14th, 2013 * Added some features of 2.0.0 (must be required explicitly until official release): * Enumerable#lazy * Enumerator::Lazy == Version 2.6.0 - May 29th, 2012 * Removed Enumerable#join == Version 2.5.0 - March 25th, 2012 * Added some features of 1.9.3: * IO::NULL * IO#advise * String#byteslice * String#prepend == Version 2.4.0 - March 24th, 2012 * Add backporting for libraries * Bring libraries up to date: * Matrix * Prime * Set * Added some features of 1.9.3: * IO.write, IO.binwrite * Add forcing backports (must be required explicitly): * Hash#select (returns a Hash instead of an Array) * Enumerable / Array#map (returns an enumerator when called without a block) * String#length, size (for UTF-8 support) == Version 2.3.0 - May 13th, 2011 * Added Enumerator::Yielder#<< == Version 2.2.0 - May 13th, 2011 * Ruby 1.8.8 was officially cancelled; code was moved to Ruby 1.9.1 and README updated. * "".ord now raises an error. == Version 2.1.0 - April 16th, 2011 * Proc#curry, #lambda (thanks Konstantine Haase) == Version 2.0.0 - December 5th, 2010 Change of major version because of two small changes that are not quite compatible and because the minor version was getting quite high! * Remove attempt at faking the new method missing. Unless you used `respond_to_missing` *and* `method(:some_method_handled_with_method_missing)`, you won't see a difference, except better performance (see issue #32) and this fixes some errors (see issue #34) * Change behavior of array.flatten(0) to match Ruby 1.9 (i.e. return a dup of array, instead of array itself) == Version 1.18.0 - June 19th, 2010 * Added some features of 1.9.1: * Math#log2, Math#log with base * Also fixed Enumerator#each in 1.8.6. == Version 1.17.0 - May 17th, 2010 * Added some features of 1.9.2: * Array#repeated_combination, #repeated_permutation == Version 1.16.2 - April 11th, 2010 * Added some features of 1.9.2: * Array#uniq, #uniq! (with block) * Array#product (with block) * Dir.home * Hash#keep_if, select! * Random (new class) == Version 1.15.0 - March 23rd, 2010 * Added a features of 1.9.2: * Object#singleton_class == Version 1.14.0 - March 3rd, 2010 * Added some features of 1.9.2: * Array#rotate, rotate! * Array#keep_if, select! * Array#sort_by! * Enumerable#join * Enumerable#slice_before * Float::INFINITY, NAN * MatchData#== == Version 1.13.0 - January 20th, 2010 * Missing for 1.8.7 were * Array#permutation * Hash#hash (was only inherited) * Hash#eql? (was only inherited) == Version 1.12.0 - December 4th, 2009 * Finer grain includes (see README) require "backports/1.9" # requires all ruby backports require "backports/1.9.1" # requires all ruby backports up to 1.9.1 (but not 1.9.2) * Backported all builtin methods of 1.8.8 (most of which where moved from the 1.9 backports) * Refreshed README == Version 1.11.0 - November 4th, 2009 * Added Enumerable#flat_map / collect_concat (Ruby 1.9) * Added Object#public_send (Ruby 1.9) * Added Object#public_method (Ruby 1.9) * bug fixes == Version 1.10.0 - September 29th, 2009 * Added Enumerable#chunk (Ruby 1.9) * Added Kernel#respond_to_missing? (Ruby 1.9) * Completed Process.exec (Ruby 1.8.7) == Version 1.9.0 - September 4th, 2009 * In Ruby 1.9, most class methods of File accept filenames as String, or convertible via #to_str or #to_path. File#to_path is also an alias to File#path. These have been backported. * File.binread (actually IO.binread) * BasicObject available via "require 'backports/basic_object" == Version 1.8.4 - September 3rd, 2009 Added Dir.mktmpdir for older version of 1.8.6 == Version 1.8.1 - September 1st, 2009 Added the alias String#lines (Ruby 1.8.7) == Version 1.8 - August 30, 2009 Backports can be required selectively: * backports/1.8.7 * backports/1.9 (which include 1.8.7) * rails == Version 1.8 - August 30, 2009 Backports can be required selectively: * backports/1.8.7 * backports/1.9 (which include 1.8.7) * rails == Version 1.7.1 - August 20, 2009 Enumerable#take and Enumerable#first(n) are now returning as soon as possible. Previously, #each was yielding one element too many. See redmine issue #1554. == Version 1.7 - May 27, 2009 Porting all 1.8.7 features to rubinius was quite enlightening (http://blog.marc-andre.ca/2009/05/schizo-ruby-puzzle.html ). Many improvements were made to be consistent with MRI, e.g. converting arguments using to_int if needed, etc... The changes are now reflected in 'backports'. Some IO and ARGF methods were missing and are now complete. == Version 1.6.6 - April 30, 2009 Important bug fix. String#gsub is left alone until I find a good way to modify it. == Version 1.6 - April 29, 2009 Completed backport to 1.8.7. * Array * extract_options! * Binding * +eval+ * Dir * +each+, +foreach+ * Enumerator * +new+ * +with_object+ * +next+, +rewind+ * Hash * Optional block for delete_if, each, each_key, each_pair, each_value, reject!, select (and ENV) * Integer * moved stuff out of Fixnum * Optional block for +downto+, +times+, +upto+ * IO * Optional block for +each+, +each_line+, +each_byte+, +foreach+ (and ARGF) * Kernel * +loop+, +StopIteration+ * +__method__+, +__callee__+ * Method * +name+, +owner+, +receiver+ * Module * +class_exec+, +module_exec+ * Numeric * +step+ * Object * +define_singleton_method+ * +instance_exec+ * ObjectSpace * +each_object+ * Range * Optional block for +each+, +step+ * Regexp * +union+ * String * +try_convert+ * ascii_only? * +bytesize+ * +chr+ * +clear+ * +codepoints+, +each_codepoint+ * +stringify_keys+, +stringify_keys!+ * +each+, +each_line+, +each_byte+ * +gsub+ * +upto+ * Struct * +each+, +each_pair+ * Symbol * <=>, +casecmp+ * +capitalize+, +downcase+, +next+, +succ+, +swapcase+, +upcase+ * =~, [], empty?, length, match, size * UnboundMethod * +name+, +owner+ == Version 1.5 - April 24, 2009 * Array (completed) * +combination+ * +try_convert+ * Optional block for collect!, :map!, :each, :each_index, :reject, :reject!, :delete_if * +pop+, +shift+ * +product+ * Fixnum (completed) * +div+, +fdiv+ * +succ+ * +magnitude+ * Enumerable (completed) * +each_with_object+ * +inject+ * +max_by+, +min_by+, +minmax+, +minmax_by+ * +reduce+ * +to_a+ == Version 1.4 - April 21, 2009 * String * +rpartition+ * Proc * +yield+ == Version 1.3 - April 17, 2009 * Enumerable * none? * Array * +sample+, +shuffle+, +shuffle!+ * String * +each_char+, +chars+ * +partition+ Tests and fixes for String#start_with? and String#end_with? == Version 1.2 - April 12, 2009 * Array * +reverse_each+ * +cycle+ * Enumerable * +reverse_each+ * +each_slice+, +each_cons+ * +count+ * +cycle+ * +group_by+ * Hash * default_proc= == Version 1.1 - April 11, 2009 * Array * +flatten+, flatten! * +find_index+, +index+ * Hash * +reverse_merge+, reverse_merge! == Version 1.0 - April 2nd, 2009 === Initial release. backports-3.3.5/Gemfile000066400000000000000000000013271222557024500150140ustar00rootroot00000000000000source "http://rubygems.org" # Declare your gem's dependencies in backports.gemspec. # Bundler will treat runtime dependencies like base dependencies, and # development dependencies will be added by default to the :development group. gemspec # jquery-rails is used by the dummy application group :test do gem "rake" gem 'mspec', :git => 'git://github.com/rubyspec/mspec.git' gem 'activesupport' end # Declare any dependencies that are still in development here instead of in # your gemspec. These might include edge Rails or gems from your path or # Git. Remember to move these dependencies to your gemspec before releasing # your gem to rubygems.org. # To use debugger # gem 'ruby-debug19', :require => 'ruby-debug' backports-3.3.5/Gemfile.lock000066400000000000000000000006711222557024500157440ustar00rootroot00000000000000GIT remote: git://github.com/rubyspec/mspec.git revision: 69c388b1187789f4996eda7dec4c1404fcd6b742 specs: mspec (1.5.18) PATH remote: . specs: backports (3.3.4) GEM remote: http://rubygems.org/ specs: activesupport (3.2.13) i18n (= 0.6.1) multi_json (~> 1.0) i18n (0.6.1) multi_json (1.7.2) rake (10.1.0) PLATFORMS java ruby DEPENDENCIES activesupport backports! mspec! rake backports-3.3.5/LICENSE.txt000066400000000000000000000020501222557024500153360ustar00rootroot00000000000000Copyright (c) 2009 Marc-Andre Lafortune 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. backports-3.3.5/README.rdoc000066400000000000000000000224121222557024500153250ustar00rootroot00000000000000= Backports Library {}[https://travis-ci.org/marcandre/backports] {Gem Version}[http://badge.fury.io/rb/backports] {Click here to lend your support to: Ruby Backports and make a donation at www.pledgie.com ![42].sample rescue "dum example" will return "dum example" without this gem and 42 with it. A real incompatibility is, for example, Module::instance_methods which returns strings in 1.8 and symbols in 1.9. No change can be made without the risk of breaking existing code. Such incompatibilities are left unchanged, although you can require some of these changes in addition (see below) All features of 1.8.7 are backported (well, almost all, see the exception list bellow), and many of 1.9 are also. Some features of 2.0.0 are backported too. Some generic and self-contained features of active-support are also included. By simple I mean that String#camelcase is there, but #pluralize isn't. == Installation & compatibility +backports+ is can be installed with: (sudo) gem install backports To use: require 'rubygems' # For only specific backports: require 'backports/1.9.1/kernel/require_relative' require 'backports/2.0.0/enumerable/lazy' # For all backports up to a given version require 'backports/1.9.2' # All backports for Ruby 1.9.2 and below # Or for all backports require 'backports' Note: about a dozen of backports have a dependency that will be also loaded. For example, the backport of Enumerable#flat_map uses flatten(1), so if required from Ruby 1.8.6 (where Array#flatten does not accept an argument), the backport for Ruby's 1.8.7 flatten with an argument will also be loaded. With bundler, add to your Gemfile: gem 'backports', :require => false Run bundle install and require the desired backports. Compatible with Ruby 1.8.6, 1.8.7, 1.9.1, 1.9.2, 1.9.3, JRuby and Rubinius. = Complete List of backports == Ruby 1.8.7 Complete Ruby 1.8.7 backporting (core language). Refer to the official list of changes[https://github.com/ruby/ruby/blob/ruby_1_8_7/NEWS]. That's about 130 backports! Only exceptions: * String#gsub (the form returning an enumerator) * GC.stress= (not implemented) * Array#choice (removed in 1.9, use 1.9.1's Array#sample instead) To include _only_ these backports, require "backports/1.8.7" == Ruby 1.8.8 Ruby 1.8.8 has been officially cancelled. As of version 2.2, require "backports/1.8.8" does nothing. == Ruby 1.9.1 Additionally, the following Ruby 1.9 features have been backported: * Array * +try_convert+ * +sample+ * Enumerable * +each_with_object+ * +each_with_index+ (with arguments) * Enumerator * +new+ (with block) * File * +binread+ * +to_path+ * All class methods accepting filenames will accept files or anything with a #to_path method. * File.open accepts an options hash. * Float * +round+ * Hash * +assoc+, +rassoc+ * +key+ * +try_convert+ * default_proc= * Integer * +magnitude+ * +round+ * IO * +bin_read+ * +try_convert+ * +ungetbyte+ * IO.open accepts an options hash. * Kernel * +require_relative+ * Math * +log+ (with base) * +log2+ * Numeric * +round+ * Object * +define_singleton_method+ * +public_method+ * +public_send+ * Proc * +yield+ * +lambda?+ * +curry+ * === * Range * cover? * Regexp * +try_convert+ * String * ascii_only? * +chr+ * +clear+ * +codepoints+, +each_codepoint+ * +get_byte+, +set_byte+ * +ord+ * +try_convert+ +Enumerator+ can be accessed directly (instead of Enumerable::Enumerator) To include _only_ these backports and those of the 1.8 line, require "backports/1.9.1". Moreover, a pretty good imitation of +BasicObject+ is available, but since it is only an imitation, it must be required explicitly: require 'backports/basic_object' == Ruby 1.9.2 Finally, most of Ruby 1.9.2 features have been backported: * Array * rotate, rotate! * keep_if, select! * +product+ (with block) * +repeated_combination+, +repeated_permutation+ * sort_by! * uniq, uniq! (with block) * Complex * +to_r+ * Dir * +home+ * Enumerable * +chunk+ * +flat_map+, +collect_concat+ * +join+ * +slice_before+ * Float::INFINITY, NAN * Hash * +keep_if+, select! * Object * singleton_class * Random (new class) To include _only_ these backports and earlier, require "backports/1.9.2" == Ruby 1.9.3 Some features of Ruby 1.9.3 have been backported: * File * +NULL+ * IO * +advise+ (acts as a noop) * +write+, +binwrite+ * String * +byteslice+ * +prepend+ To include all Ruby backports but not those of Ruby 2.0 or Rails, require "backports/1.9.3" (or "backports/1.9") == Ruby 2.0.0 Some features of Ruby 2.0.0 have been backported: * Array * +bsearch+ * Enumerable * +lazy+ * Enumerator::Lazy * all methods * Hash * default_proc= (with nil argument) * +to_h+ * nil.to_h * Range * +bsearch+ * Struct * +to_h+ To include all Ruby backports but not those of Rails, require "backports/2.0" (or "backports/2.0.0") == Rails Some generic methods from Rails methods have been copied: * Enumerable * +sum+ * Hash * +symbolize_keys+, symbolize_keys! * +reverse_merge+, reverse_merge! * Module * +alias_method_chain+ * Object * +try+ * String * +camelize+, +underscore+ * +dasherize+, +demodulize+ * +constantize+ To include _only_ these Rails backports but not those of Ruby, require "backports/rails". == Libraries Libraries are slowly being backported. You simply require them as usual, ideally (but not necessarily) after requiring backports. require "backports" require "prime" 42.prime? # => false, even in Ruby 1.8.x The following libraries are up to date with Ruby 1.9.3: * Matrix * Prime * Set The following library is to date with Ruby 2.0.0: * OpenStruct (ostruct) I am aware of the following backport gem, which probably won't make it into this gem: * Net::SMTP for Ruby 1.8.6: smtp_tls[http://seattlerb.rubyforge.org/smtp_tls/] == Forcing incompatibilities Some backports would create incompatibilities in their current Ruby version but could be useful in some projects. It is possible to request such incompatible changes. Backports currently supports the following: * Hash * +select+ (returns a Hash instead of an Array) * Enumerable / Array * +map+ (returns an enumerator when called without a block) * String * +length+, +size+ (for UTF-8 support) These must be imported in addition to the backports gem, for example: require "backports/force/hash_select" {}.select{} # => {}, even in Ruby 1.8 == Thanks Thanks for the bug reports and patches, in particular the repeat offenders: * Arto Bendiken ( bendiken[http://github.com/bendiken] ) * Konstantin Haase ( rkh[https://github.com/rkh]) * Roger Pack ( rdp[http://github.com/rdp] ) The best way to submit a patch is to also submit a patch to RubySpec[https://github.com/rubyspec/rubyspec] and then a patch to backports that make it pass the spec. To test rubyspec: git submodule init && git submodule update # => pulls rubyspecs rake spec[array/bsearch] # => tests Array#bsearch rake spec[array/*] # => tests all backported Array methods rake spec (or rake spec[*/*]) # => all rubyspecs for backported methods Failures that are acceptable are added the to `tags` file. = License +backports+ is released under the terms of the MIT License, see the included LICENSE file. Author:: Marc-André Lafortune backports-3.3.5/Rakefile000066400000000000000000000074141222557024500151710ustar00rootroot00000000000000begin require "bundler/gem_tasks" rescue LoadError # bundler not installed end require 'rake/testtask' Rake::TestTask.new(:test) do |test| test.libs << 'lib' << 'test' test.pattern = 'test/**/*_test.rb' test.verbose = false end desc "Run specs, where path can be '*/*' (default), 'class/*' or 'class/method'." task :spec, :path, :action do |t, args| args.with_defaults(:path => '*/*', :action => 'ci') stats = [[0] * 5] not_found = [] mspec_cmds(args[:path], args[:action]) do |cmd, path| result = `#{cmd}` match = result.match(/(\d+) files?, (\d+) examples?, (\d+) expectations?, (\d+) failures?, (\d+) errors?/) if match.nil? puts "*** mspec returned with unexpected results:" puts result puts "Command was:", cmd fail "Unexpected output from mspec" end _, ex, p, f, e = data = match.captures.map{|x| x.to_i} not_found << path if ex == 0 stats << data if f + e > 0 puts cmd puts result else print "." STDOUT.flush end end $:.unshift 'lib' require 'backports/rails' _, ex, p, f, e = stats = stats.transpose.map{|x| x.sum} puts "*** Overall:", stats.zip(%w[files examples expectations failures errors]).map{|a| a.join(' ')}.join(', ') puts "No spec found for #{not_found.join(', ')}" unless not_found.empty? fail unless f + e == 0 end task :all_spec do # Necessary because of argument passing bug in 1.8.7 Rake::Task[:spec].invoke end task :spec_tag, :path do |t, args| Rake::Task[:spec].invoke(args[:path], 'tag -G fails') end task :default => [:test, :all_spec] DEPENDENCIES = Hash.new([]).merge!( '1.8.7/argf/chars' => 'backports/1.8.7/string/each_char', '1.8.7/argf/each_char' => 'backports/1.8.7/string/each_char', '1.8.7/array/cycle' => 'backports/1.8.7/stop_iteration', '1.8.7/enumerable/entries' => ['backports/1.8.7/enumerable/each_with_index', 'backports/1.8.7/enumerable/to_a'], '1.8.7/enumerator/rewind' => 'backports/1.8.7/enumerator/next', '1.8.7/hash/reject' => 'backports/1.8.7/integer/even', '1.9.1/hash/rassoc' => 'backports/1.9.1/hash/key', '1.9.1/proc/lambda' => 'backports/1.9.1/proc/curry', '1.9.2/complex/to_r' => 'complex', '1.9.2/array/select' => 'backports/1.8.7/array/select', '1.9.2/hash/select' => 'backports/1.8.7/hash/select', '1.9.2/enumerable/each_entry' => 'backports/1.8.7/enumerable/each_with_index', '2.0.0/hash/to_h' => 'backports/1.9.1/hash/default_proc' ) { :each_with_index => %w[enumerable/detect enumerable/find enumerable/find_all enumerable/select enumerable/to_a], :first => %w[enumerable/cycle io/bytes io/chars io/each_byte io/each_char io/lines io/each_line] }.each do |req, libs| libs.each{|l| DEPENDENCIES["1.8.7/#{l}"] = "backports/1.8.7/enumerable/#{req}" } end # These cause actual errors while loading in 1.8: IGNORE_IN_18 = %w[ 1.9.1/symbol/length 1.9.1/symbol/size 1.9.3/string/byteslice 1.8.7/proc/yield 1.9.1/proc/case_compare ] def mspec_cmds(pattern, action='ci') pattern = "lib/backports/*.*.*/#{pattern}.rb" Dir.glob(pattern) do |lib_path| _match, version, path = lib_path.match(/backports\/(\d\.\d\.\d)\/(.*)\.rb/).to_a next if path =~ /stdlib/ next if version <= RUBY_VERSION version_path = "#{version}/#{path}" next if IGNORE_IN_18.include? version_path if RUBY_VERSION < '1.9' deps = [*DEPENDENCIES[version_path]].map{|p| "-r #{p}"}.join(' ') klass, method = path.split('/') path = [klass.gsub('_', ''), method].join('/') # don't ask me why RubySpec uses matchdata instead of match_data yield %W[mspec #{action} -I lib -r ./set_version/#{version} #{deps} -r backports/#{version_path} -C spec rubyspec/core/#{path}_spec.rb ].join(' '), path end end backports-3.3.5/backports.gemspec000066400000000000000000000015121222557024500170520ustar00rootroot00000000000000# -*- encoding: utf-8 -*- lib = File.expand_path('../lib', __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'backports/version' Gem::Specification.new do |gem| gem.name = "backports" gem.version = Backports::VERSION gem.authors = ["Marc-André Lafortune"] gem.email = ["github@marc-andre.ca"] gem.description = %q{Essential backports that enable many of the nice features of Ruby 1.8.7 up to 2.0.0 for earlier versions.} gem.summary = %q{Backports of Ruby features for older Ruby.} gem.homepage = "http://github.com/marcandre/backports" gem.files = `git ls-files`.split($/) gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) } gem.test_files = gem.files.grep(%r{^(test|spec|features)/}) gem.require_paths = ["lib"] end backports-3.3.5/default.mspec000066400000000000000000000006001222557024500161670ustar00rootroot00000000000000if (Backports::TARGET_VERSION rescue false) # Conf loaded at different times, not sure why class MSpecScript # The set of substitutions to transform a spec filename # into a tag filename. set :tags_patterns, [ [%r(rubyspec/), "tags/#{RUBY_VERSION}/"] ] end SpecGuard.ruby_version_override = Backports::TARGET_VERSION if Backports::TARGET_VERSION > RUBY_VERSION end backports-3.3.5/lib/000077500000000000000000000000001222557024500142645ustar00rootroot00000000000000backports-3.3.5/lib/backports.rb000066400000000000000000000001501222557024500165750ustar00rootroot00000000000000require "backports/tools" require "backports/version" require "backports/2.0" require "backports/rails" backports-3.3.5/lib/backports/000077500000000000000000000000001222557024500162545ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7.rb000066400000000000000000000001651222557024500172560ustar00rootroot00000000000000# require this file to load all the backports of Ruby 1.8.7 require "backports/tools" Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/000077500000000000000000000000001222557024500167275ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/argf.rb000066400000000000000000000000721222557024500201720ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/argf/000077500000000000000000000000001222557024500176465ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/argf/bytes.rb000066400000000000000000000000511222557024500213150ustar00rootroot00000000000000require 'backports/1.8.7/argf/each_byte' backports-3.3.5/lib/backports/1.8.7/argf/chars.rb000066400000000000000000000000511222557024500212670ustar00rootroot00000000000000require 'backports/1.8.7/argf/each_char' backports-3.3.5/lib/backports/1.8.7/argf/each.rb000066400000000000000000000001571222557024500210760ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ARGF, :each, :force => true if RUBY_VERSION < '1.8.7' backports-3.3.5/lib/backports/1.8.7/argf/each_byte.rb000066400000000000000000000002711222557024500221160ustar00rootroot00000000000000if RUBY_VERSION < '1.8.7' require 'backports/tools' class << ARGF Backports.make_block_optional ARGF, :each_byte, :force => true alias_method :bytes, :each_byte end end backports-3.3.5/lib/backports/1.8.7/argf/each_char.rb000066400000000000000000000014501222557024500220700ustar00rootroot00000000000000unless ARGF.respond_to? :each_char require 'backports/tools' require 'enumerator' class << ARGF def each_char return to_enum(:each_char) unless block_given? if $KCODE == "UTF-8" lookup = 7.downto(4) while c = read(1) do n = c[0] leftmost_zero_bit = lookup.find{|i| n[i].zero? } case leftmost_zero_bit when 7 # ASCII yield c when 6 # UTF 8 complementary characters next # Encoding error, ignore else more = read(6-leftmost_zero_bit) break unless more yield c+more end end else while s = read(1) yield s end end self end Backports.alias_method self, :chars, :each_char end end backports-3.3.5/lib/backports/1.8.7/argf/each_line.rb000066400000000000000000000001641222557024500221030ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ARGF, :each_line, :force => true if RUBY_VERSION < '1.8.7' backports-3.3.5/lib/backports/1.8.7/argf/getbyte.rb000066400000000000000000000001341222557024500216340ustar00rootroot00000000000000require 'backports/tools' class << ARGF Backports.alias_method self, :getbyte, :getc end backports-3.3.5/lib/backports/1.8.7/argf/lines.rb000066400000000000000000000001371222557024500213060ustar00rootroot00000000000000require 'backports/tools' class << ARGF Backports.alias_method self, :lines, :each_line end backports-3.3.5/lib/backports/1.8.7/argf/readbyte.rb000066400000000000000000000001411222557024500217660ustar00rootroot00000000000000require 'backports/tools' class << ARGF Backports.alias_method self, :readbyte, :readchar end backports-3.3.5/lib/backports/1.8.7/array.rb000066400000000000000000000000721222557024500203710ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/array/000077500000000000000000000000001222557024500200455ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/array/collect.rb000066400000000000000000000001341222557024500220150ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :collect!, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/combination.rb000066400000000000000000000017061222557024500227000ustar00rootroot00000000000000unless Array.method_defined? :combination require 'backports/tools' require 'enumerator' class Array def combination(num) num = Backports.coerce_to_int(num) return to_enum(:combination, num) unless block_given? return self unless (0..size).include? num # Implementation note: slightly tricky. # Example: self = 1..7, num = 3 picks = (0...num).to_a # picks start at 0, 1, 2 max_index = ((size-num)...size).to_a # max (index for a given pick) is [4, 5, 6] pick_max_pairs = picks.zip(max_index).reverse # pick_max_pairs = [[2, 6], [1, 5], [0, 4]] leave = Proc.new{return self} loop do yield values_at(*picks) move = pick_max_pairs.find(leave){|pick, max| picks[pick] < max}.first new_index = picks[move] + 1 picks[move...num] = (new_index...(new_index+num-move)).to_a end end end end backports-3.3.5/lib/backports/1.8.7/array/cycle.rb000066400000000000000000000005151222557024500214720ustar00rootroot00000000000000unless Array.method_defined? :cycle require 'backports/tools' class Array def cycle(n = nil) return to_enum(:cycle, n) unless block_given? if n.nil? each{|e| yield e } until false else n = Backports.coerce_to_int(n) n.times{each{|e| yield e }} end nil end end end backports-3.3.5/lib/backports/1.8.7/array/delete_if.rb000066400000000000000000000001351222557024500223110ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :delete_if, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/each.rb000066400000000000000000000001301222557024500212640ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :each, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/each_index.rb000066400000000000000000000001361222557024500224610ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :each_index, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/find_index.rb000066400000000000000000000000461222557024500225010ustar00rootroot00000000000000require 'backports/1.8.7/array/index' backports-3.3.5/lib/backports/1.8.7/array/flatten.rb000066400000000000000000000025321222557024500220310ustar00rootroot00000000000000unless ([[]].flatten(1) rescue false) require 'backports/tools' class Array # Recursively flatten any contained Arrays into an one-dimensional result. # Adapted from rubinius' def flatten_with_optional_argument(level=-1) dup.flatten!(level) || self end # Flattens self in place as #flatten. If no changes are # made, returns nil, otherwise self. # Adapted from rubinius' def flatten_with_optional_argument!(level=-1) level = Backports.coerce_to_int(level) return flatten_without_optional_argument! if level < 0 out = [] ret = recursively_flatten_finite(self, out, level) replace(out) if ret ret end Backports.alias_method_chain self, :flatten, :optional_argument Backports.alias_method_chain self, :flatten!, :optional_argument # Helper to recurse through flattening # Adapted from rubinius'; recursion guards are not needed because level is finite def recursively_flatten_finite(array, out, level) ret = nil if level <= 0 out.concat(array) else array.each do |o| if ary = Backports.is_array?(o) recursively_flatten_finite(ary, out, level - 1) ret = self else out << o end end end ret end private :recursively_flatten_finite end end backports-3.3.5/lib/backports/1.8.7/array/index.rb000066400000000000000000000007061222557024500215040ustar00rootroot00000000000000unless ([1].index{true} rescue false) require 'backports/tools' require 'enumerator' class Array def index_with_block(*arg) return to_enum(:index_with_block) if arg.empty? && !block_given? return index_without_block(*arg) unless block_given? && arg.empty? each_with_index{|o,i| return i if yield o} return nil end Backports.alias_method_chain self, :index, :block alias_method :find_index, :index end end backports-3.3.5/lib/backports/1.8.7/array/map.rb000066400000000000000000000001301222557024500211410ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :map!, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/permutation.rb000066400000000000000000000014551222557024500227460ustar00rootroot00000000000000unless Array.method_defined? :permutation require 'backports/tools' require 'enumerator' class Array def permutation(num = Backports::Undefined) return to_enum(:permutation, num) unless block_given? num = num.equal?(Backports::Undefined) ? size : Backports.coerce_to_int(num) return self unless (0..size).include? num final_lambda = lambda do |partial, remain| yield partial end outer_lambda = (1..num).inject(final_lambda) do |proc, _| lambda do |partial, remain| remain.each_with_index do |val, i| new_remain = remain.dup new_remain.delete_at(i) proc.call(partial.dup << val, new_remain) end end end outer_lambda.call([], dup) end end end backports-3.3.5/lib/backports/1.8.7/array/pop.rb000066400000000000000000000007251222557024500211740ustar00rootroot00000000000000unless ([1].pop(1) rescue false) require 'backports/tools' class Array def pop_with_optional_argument(n = Backports::Undefined) return pop_without_optional_argument if n == Backports::Undefined n = Backports.coerce_to_int(n) raise ArgumentError, "negative array size" if n < 0 first = size - n first = 0 if first < 0 slice!(first..size).to_a end Backports.alias_method_chain self, :pop, :optional_argument end end backports-3.3.5/lib/backports/1.8.7/array/product.rb000066400000000000000000000016131222557024500220530ustar00rootroot00000000000000unless Array.method_defined? :product require 'backports/tools' class Array def product(*arg) # Implementation notes: We build a block that will generate all the combinations # by building it up successively using "inject" and starting with one # responsible to append the values. # result = [] arg.map!{|ary| Backports.coerce_to_ary(ary)} n = arg.inject(size) { |p, a| p * a.size } return [] if n == 0 raise RangeError, "too big a product" if n > 1<<31 arg.reverse! # to get the results in the same order as in MRI, vary the last argument first arg.push self outer_lambda = arg.inject(result.method(:push)) do |proc, values| lambda do |partial| values.each do |val| proc.call(partial.dup << val) end end end outer_lambda.call([]) result end end end backports-3.3.5/lib/backports/1.8.7/array/reject.rb000066400000000000000000000001441222557024500216450ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :reject, :reject!, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/reverse_each.rb000066400000000000000000000001401222557024500230200ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :reverse_each, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/rindex.rb000066400000000000000000000006651222557024500216720ustar00rootroot00000000000000unless ([1].rindex{true} rescue false) class Array require 'backports/tools' require 'enumerator' def rindex_with_block(*arg) return to_enum(:rindex) if !block_given? && arg.empty? return rindex_without_block(*arg) unless block_given? && arg.empty? i = 0 reverse_each{|o| i += 1; return size - i if yield o} return nil end Backports.alias_method_chain self, :rindex, :block end end backports-3.3.5/lib/backports/1.8.7/array/select.rb000066400000000000000000000001321222557024500216450ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Array, :select, :test_on => [42] backports-3.3.5/lib/backports/1.8.7/array/shift.rb000066400000000000000000000006371222557024500215150ustar00rootroot00000000000000unless ([1].shift(1) rescue false) class Array require 'backports/tools' def shift_with_optional_argument(n = Backports::Undefined) return shift_without_optional_argument if n == Backports::Undefined n = Backports.coerce_to_int(n) raise ArgumentError, "negative array size" if n < 0 slice!(0, n) end Backports.alias_method_chain self, :shift, :optional_argument end end backports-3.3.5/lib/backports/1.8.7/array/shuffle.rb000066400000000000000000000006531222557024500220320ustar00rootroot00000000000000unless Array.method_defined? :shuffle class Array def shuffle dup.shuffle! end # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Array.html] def shuffle! raise TypeError, "can't modify frozen array" if frozen? size.times do |i| r = i + Kernel.rand(size - i) self[i], self[r] = self[r], self[i] end self end end end backports-3.3.5/lib/backports/1.8.7/binding.rb000066400000000000000000000000721222557024500206650ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/binding/000077500000000000000000000000001222557024500203415ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/binding/eval.rb000066400000000000000000000002041222557024500216110ustar00rootroot00000000000000unless Binding.method_defined? :eval class Binding def eval(expr, *arg) Kernel.eval(expr, self, *arg) end end end backports-3.3.5/lib/backports/1.8.7/dir.rb000066400000000000000000000000721222557024500200310ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/dir/000077500000000000000000000000001222557024500175055ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/dir/each.rb000066400000000000000000000004041222557024500207300ustar00rootroot00000000000000require 'backports/tools' begin Backports.make_block_optional Dir, :each, :test_on => Dir.new('.') rescue # We may not be able to read the current directory, issue #58 Backports.make_block_optional Dir, :each, :force => true if RUBY_VERSION < '1.8.7' end backports-3.3.5/lib/backports/1.8.7/dir/foreach.rb000066400000000000000000000004531222557024500214430ustar00rootroot00000000000000require 'backports/tools' class << Dir begin Backports.make_block_optional self, :foreach, :test_on => Dir, :arg => '.' rescue # We may not be able to read the current directory, issue #58 Backports.make_block_optional self, :foreach, :force => true if RUBY_VERSION < '1.8.7' end end backports-3.3.5/lib/backports/1.8.7/enumerable.rb000066400000000000000000000000721222557024500213720ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/enumerable/000077500000000000000000000000001222557024500210465ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/enumerable/count.rb000066400000000000000000000005621222557024500225260ustar00rootroot00000000000000unless Enumerable.method_defined? :count require 'backports/tools' module Enumerable def count(item = Backports::Undefined) seq = 0 if item != Backports::Undefined each { |o| seq += 1 if item == o } elsif block_given? each { |o| seq += 1 if yield(o) } else each { seq += 1 } end seq end end end backports-3.3.5/lib/backports/1.8.7/enumerable/cycle.rb000066400000000000000000000010531222557024500224710ustar00rootroot00000000000000unless Enumerable.method_defined? :cycle require 'backports/tools' require 'enumerator' module Enumerable def cycle(n = nil) return to_enum(:cycle, n) unless block_given? n = n && Backports.coerce_to_int(n) if n == nil || n >= 1 cache = [] each do |elem| cache << elem yield elem end if n (n-1).times { cache.each{|e| yield e } } else loop { cache.each{|e| yield e } } end unless cache.empty? end nil end end end backports-3.3.5/lib/backports/1.8.7/enumerable/detect.rb000066400000000000000000000001371222557024500226440ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :detect, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/drop.rb000066400000000000000000000004551222557024500223430ustar00rootroot00000000000000unless Enumerable.method_defined? :drop require 'backports/tools' module Enumerable def drop(n) n = Backports.coerce_to_int(n) raise ArgumentError, "attempt to drop negative size" if n < 0 ary = to_a return [] if n > ary.size ary[n...ary.size] end end end backports-3.3.5/lib/backports/1.8.7/enumerable/drop_while.rb000066400000000000000000000006441222557024500235330ustar00rootroot00000000000000unless Enumerable.method_defined? :drop_while require 'enumerator' module Enumerable # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html] def drop_while return to_enum(:drop_while) unless block_given? ary = [] dropping = true each do |obj| ary << obj unless dropping &&= yield(obj) end ary end end end backports-3.3.5/lib/backports/1.8.7/enumerable/each_cons.rb000066400000000000000000000002571222557024500233210ustar00rootroot00000000000000require 'backports/tools' require 'enumerator' unless Enumerable.method_defined? :each_cons Backports.make_block_optional Enumerable, :each_cons, :test_on => 1..2, :arg => 1 backports-3.3.5/lib/backports/1.8.7/enumerable/each_slice.rb000066400000000000000000000002611222557024500234510ustar00rootroot00000000000000require 'backports/tools' require 'enumerator' unless Enumerable.method_defined? :each_slice Backports.make_block_optional Enumerable, :each_slice, :test_on => 1..2, :arg => 1 backports-3.3.5/lib/backports/1.8.7/enumerable/each_with_index.rb000066400000000000000000000001501222557024500245110ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :each_with_index, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/entries.rb000066400000000000000000000005161222557024500230460ustar00rootroot00000000000000if Enumerable.instance_method(:entries).arity.zero? require 'backports/tools' module Enumerable def entries_with_optional_arguments(*args) return entries_without_optional_arguments if args.empty? to_enum(:each, *args).entries end Backports.alias_method_chain self, :entries, :optional_arguments end end backports-3.3.5/lib/backports/1.8.7/enumerable/find.rb000066400000000000000000000001351222557024500223120ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :find, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/find_all.rb000066400000000000000000000001411222557024500231370ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :find_all, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/find_index.rb000066400000000000000000000007511222557024500235050ustar00rootroot00000000000000unless Enumerable.method_defined? :find_index require 'backports/tools' require 'enumerator' module Enumerable def find_index(obj = Backports::Undefined) if obj != Backports::Undefined each_with_index do |element, i| return i if element == obj end elsif block_given? each_with_index do |element, i| return i if yield element end else return to_enum(:find_index) end nil end end end backports-3.3.5/lib/backports/1.8.7/enumerable/first.rb000066400000000000000000000007671222557024500225340ustar00rootroot00000000000000unless Enumerable.method_defined? :first require 'backports/tools' module Enumerable def first(n = Backports::Undefined) if n == Backports::Undefined each{|obj| return obj} nil else n = Backports.coerce_to_int(n) raise ArgumentError, "attempt to take negative size: #{n}" if n < 0 array = [] each do |elem| array << elem break if array.size >= n end unless n == 0 array end end end end backports-3.3.5/lib/backports/1.8.7/enumerable/group_by.rb000066400000000000000000000004461222557024500232250ustar00rootroot00000000000000unless Enumerable.method_defined? :group_by require 'enumerator' module Enumerable def group_by return to_enum(:group_by) unless block_given? result = {} each do |o| result.fetch(yield(o)){|key| result[key] = []} << o end result end end end backports-3.3.5/lib/backports/1.8.7/enumerable/inject.rb000066400000000000000000000006701222557024500226520ustar00rootroot00000000000000unless ((1..2).inject(:+) rescue false) require 'backports/tools' module Enumerable def inject_with_symbol(*args, &block) return inject_without_symbol(*args, &block) if block_given? && args.size <= 1 method = args.pop inject_without_symbol(*args) {|memo, obj| memo.send(method, obj)} end Backports.alias_method_chain self, :inject, :symbol end Backports.alias_method Enumerable, :reduce, :inject end backports-3.3.5/lib/backports/1.8.7/enumerable/max_by.rb000066400000000000000000000006441222557024500226560ustar00rootroot00000000000000unless Enumerable.method_defined? :max_by require 'backports/tools' require 'enumerator' module Enumerable def max_by return to_enum(:max_by) unless block_given? max_object, max_result = nil, Backports::MOST_EXTREME_OBJECT_EVER each do |object| result = yield object max_object, max_result = object, result if max_result < result end max_object end end end backports-3.3.5/lib/backports/1.8.7/enumerable/min_by.rb000066400000000000000000000006441222557024500226540ustar00rootroot00000000000000unless Enumerable.method_defined? :min_by require 'backports/tools' require 'enumerator' module Enumerable def min_by return to_enum(:min_by) unless block_given? min_object, min_result = nil, Backports::MOST_EXTREME_OBJECT_EVER each do |object| result = yield object min_object, min_result = object, result if min_result > result end min_object end end end backports-3.3.5/lib/backports/1.8.7/enumerable/minmax.rb000066400000000000000000000010671222557024500226700ustar00rootroot00000000000000unless Enumerable.method_defined? :minmax require 'backports/tools' module Enumerable def minmax return minmax{|a,b| a <=> b} unless block_given? first_time = true min, max = nil each do |object| if first_time min = max = object first_time = false else min = object if Backports.coerce_to_comparison(min, object, yield(min, object)) > 0 max = object if Backports.coerce_to_comparison(max, object, yield(max, object)) < 0 end end [min, max] end end end backports-3.3.5/lib/backports/1.8.7/enumerable/minmax_by.rb000066400000000000000000000012721222557024500233600ustar00rootroot00000000000000unless Enumerable.method_defined? :minmax_by require 'backports/tools' require 'enumerator' module Enumerable # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html] def minmax_by return to_enum(:minmax_by) unless block_given? min_object, min_result = nil, Backports::MOST_EXTREME_OBJECT_EVER max_object, max_result = nil, Backports::MOST_EXTREME_OBJECT_EVER each do |object| result = yield object min_object, min_result = object, result if min_result > result max_object, max_result = object, result if max_result < result end [min_object, max_object] end end end backports-3.3.5/lib/backports/1.8.7/enumerable/none.rb000066400000000000000000000001711222557024500223310ustar00rootroot00000000000000unless Enumerable.method_defined? :none? module Enumerable def none?(&block) !any?(&block) end end end backports-3.3.5/lib/backports/1.8.7/enumerable/one.rb000066400000000000000000000006651222557024500221630ustar00rootroot00000000000000unless Enumerable.method_defined? :one? module Enumerable def one? found_one = false if block_given? each do |o| if yield(o) return false if found_one found_one = true end end else each do |o| if o return false if found_one found_one = true end end end found_one end end end backports-3.3.5/lib/backports/1.8.7/enumerable/partition.rb000066400000000000000000000001421222557024500234010ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :partition, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/reduce.rb000066400000000000000000000000541222557024500226410ustar00rootroot00000000000000require 'backports/1.8.7/enumerable/inject' backports-3.3.5/lib/backports/1.8.7/enumerable/reject.rb000066400000000000000000000001371222557024500226500ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :reject, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/reverse_each.rb000066400000000000000000000005001222557024500240210ustar00rootroot00000000000000unless Enumerable.method_defined? :reverse_each require 'enumerator' module Enumerable def reverse_each return to_enum(:reverse_each) unless block_given? # There is no other way then to convert to an array first... see 1.9's source. to_a.reverse_each{|e| yield e} self end end end backports-3.3.5/lib/backports/1.8.7/enumerable/select.rb000066400000000000000000000001371222557024500226530ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :select, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/sort_by.rb000066400000000000000000000001401222557024500230470ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Enumerable, :sort_by, :test_on => 1..2 backports-3.3.5/lib/backports/1.8.7/enumerable/take.rb000066400000000000000000000002331222557024500223150ustar00rootroot00000000000000unless Enumerable.method_defined? :take require 'backports/1.8.7/enumerable/first' module Enumerable def take(n) first(n) end end end backports-3.3.5/lib/backports/1.8.7/enumerable/take_while.rb000066400000000000000000000006161222557024500235120ustar00rootroot00000000000000unless Enumerable.method_defined? :take_while require 'enumerator' module Enumerable # Standard in Ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Enumerable.html] def take_while return to_enum(:take_while) unless block_given? inject([]) do |array, elem| return array unless yield elem array << elem end end end end backports-3.3.5/lib/backports/1.8.7/enumerable/to_a.rb000066400000000000000000000005261222557024500223200ustar00rootroot00000000000000if Enumerable.instance_method(:to_a).arity.zero? require 'backports/tools' require 'enumerator' module Enumerable def to_a_with_optional_arguments(*args) return to_a_without_optional_arguments if args.empty? to_enum(:each, *args).to_a end Backports.alias_method_chain self, :to_a, :optional_arguments end end backports-3.3.5/lib/backports/1.8.7/enumerator.rb000066400000000000000000000000721222557024500214340ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/enumerator/000077500000000000000000000000001222557024500211105ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/enumerator/each.rb000066400000000000000000000002711222557024500223350ustar00rootroot00000000000000unless Object.const_defined? :Enumerator require 'backports/tools' require 'enumerator' Backports.make_block_optional Enumerable::Enumerator, :each, :test_on => [42].to_enum end backports-3.3.5/lib/backports/1.8.7/enumerator/next.rb000066400000000000000000000006071222557024500224160ustar00rootroot00000000000000unless Object.const_defined? :Enumerator require 'enumerator' unless Enumerable::Enumerator.method_defined? :next class Enumerable::Enumerator require 'backports/1.8.7/stop_iteration' def next require 'generator' @generator ||= ::Generator.new(self) raise StopIteration unless @generator.next? @generator.next end end end end backports-3.3.5/lib/backports/1.8.7/enumerator/rewind.rb000066400000000000000000000004661222557024500227330ustar00rootroot00000000000000unless Object.const_defined? :Enumerator require 'enumerator' unless Enumerable::Enumerator.method_defined? :rewind class Enumerable::Enumerator def rewind require 'generator' @generator ||= ::Generator.new(self) @generator.rewind self end end end end backports-3.3.5/lib/backports/1.8.7/enumerator/with_index.rb000066400000000000000000000006141222557024500236000ustar00rootroot00000000000000unless Object.const_defined? :Enumerator require 'enumerator' unless Enumerable::Enumerator.method_defined? :with_index class Enumerable::Enumerator def with_index(offset = 0) return to_enum(:with_index, offset) unless block_given? each do |*args| yield args.size == 1 ? args[0] : args, offset offset += 1 end end end end end backports-3.3.5/lib/backports/1.8.7/env.rb000066400000000000000000000000721222557024500200430ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/env/000077500000000000000000000000001222557024500175175ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/env/delete_if.rb000066400000000000000000000001321222557024500217600ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :delete_if, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/env/each.rb000066400000000000000000000001251222557024500207420ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :each, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/env/each_key.rb000066400000000000000000000001311222557024500216070ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :each_key, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/env/each_pair.rb000066400000000000000000000001321222557024500217530ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :each_pair, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/env/each_value.rb000066400000000000000000000001331222557024500221350ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :each_value, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/env/reject.rb000066400000000000000000000002241222557024500213160ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :reject, :test_on => ENV Backports.make_block_optional ENV, :reject!, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/env/select.rb000066400000000000000000000001271222557024500213230ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional ENV, :select, :test_on => ENV backports-3.3.5/lib/backports/1.8.7/fixnum.rb000066400000000000000000000000721222557024500205610ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/fixnum/000077500000000000000000000000001222557024500202355ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/fixnum/div.rb000066400000000000000000000001511222557024500213410ustar00rootroot00000000000000unless Fixnum.method_defined? :div class Fixnum def div(n) (self / n).to_i end end end backports-3.3.5/lib/backports/1.8.7/fixnum/fdiv.rb000066400000000000000000000001441222557024500215110ustar00rootroot00000000000000unless Fixnum.method_defined? :fdiv class Fixnum def fdiv(n) to_f / n end end end backports-3.3.5/lib/backports/1.8.7/float.rb000066400000000000000000000000721222557024500203600ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/float/000077500000000000000000000000001222557024500200345ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/float/fdiv.rb000066400000000000000000000001151222557024500213060ustar00rootroot00000000000000unless Float.method_defined? :fdiv Float.send :alias_method, :fdiv, :/ end backports-3.3.5/lib/backports/1.8.7/gc.rb000066400000000000000000000000721222557024500176440ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/gc/000077500000000000000000000000001222557024500173205ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/gc/stress.rb000066400000000000000000000001761222557024500211740ustar00rootroot00000000000000unless GC.respond_to? :stress def GC.stress false end def GC.stress=(flag) raise NotImplementedError end end backports-3.3.5/lib/backports/1.8.7/hash.rb000066400000000000000000000000721222557024500201760ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/hash/000077500000000000000000000000001222557024500176525ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/hash/constructor.rb000066400000000000000000000012631222557024500225660ustar00rootroot00000000000000unless (Hash[[[:test, :test]]] rescue false) require 'backports/tools' class << Hash alias_method :constructor_without_key_value_pair_form, :[] def [](*args) if args.length == 1 arg = args.first if (h = Backports.try_convert(arg, Hash, :to_hash)) return allocate.replace(h) end if (kvps = Backports.is_array?(arg)) h = {} kvps.each do |elem| next unless arr = Backports.is_array?(elem) next unless (1..2).include? arr.size h[arr.at(0)] = arr.at(1) end return h end end constructor_without_key_value_pair_form(*args) end end end backports-3.3.5/lib/backports/1.8.7/hash/delete_if.rb000066400000000000000000000001541222557024500221170ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :delete_if, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/hash/each.rb000066400000000000000000000001471222557024500211010ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :each, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/hash/each_key.rb000066400000000000000000000001531222557024500217460ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :each_key, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/hash/each_pair.rb000066400000000000000000000001541222557024500221120ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :each_pair, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/hash/each_value.rb000066400000000000000000000001551222557024500222740ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :each_value, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/hash/eql.rb000066400000000000000000000000441222557024500207560ustar00rootroot00000000000000require 'backports/1.8.7/hash/hash' backports-3.3.5/lib/backports/1.8.7/hash/hash.rb000066400000000000000000000005051222557024500211220ustar00rootroot00000000000000class Hash def hash h = 0 each do |key, value| h ^= key.hash ^ value.hash end h end unless {}.hash == {}.hash def eql?(other) other.is_a?(Hash) && size == other.size && all? do |key, value| value.eql?(other.fetch(key){return false}) end end unless {}.eql?({}) end backports-3.3.5/lib/backports/1.8.7/hash/reject.rb000066400000000000000000000001631222557024500214530ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :reject, :reject!, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/hash/select.rb000066400000000000000000000001511222557024500214530ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Hash, :select, :test_on => {:hello => "world!"} backports-3.3.5/lib/backports/1.8.7/integer.rb000066400000000000000000000000721222557024500207100ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/integer/000077500000000000000000000000001222557024500203645ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/integer/downto.rb000066400000000000000000000001461222557024500222240ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Integer, :downto, :test_on => 42, :arg => 42 backports-3.3.5/lib/backports/1.8.7/integer/even.rb000066400000000000000000000001521222557024500216440ustar00rootroot00000000000000unless Integer.method_defined? :even? class Integer def even? self[0].zero? end end end backports-3.3.5/lib/backports/1.8.7/integer/odd.rb000066400000000000000000000001511222557024500214540ustar00rootroot00000000000000unless Integer.method_defined? :odd? class Integer def odd? !self[0].zero? end end end backports-3.3.5/lib/backports/1.8.7/integer/ord.rb000066400000000000000000000001351222557024500214740ustar00rootroot00000000000000unless Integer.method_defined? :ord class Integer def ord self end end end backports-3.3.5/lib/backports/1.8.7/integer/pred.rb000066400000000000000000000001431222557024500216410ustar00rootroot00000000000000unless Integer.method_defined? :pred class Integer def pred self - 1 end end end backports-3.3.5/lib/backports/1.8.7/integer/times.rb000066400000000000000000000001311222557024500220250ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Integer, :times, :test_on => 42 backports-3.3.5/lib/backports/1.8.7/integer/upto.rb000066400000000000000000000001441222557024500216770ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Integer, :upto, :test_on => 42, :arg => 42 backports-3.3.5/lib/backports/1.8.7/io.rb000066400000000000000000000000721222557024500176620ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/io/000077500000000000000000000000001222557024500173365ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/io/bytes.rb000066400000000000000000000000471222557024500210120ustar00rootroot00000000000000require 'backports/1.8.7/io/each_byte' backports-3.3.5/lib/backports/1.8.7/io/chars.rb000066400000000000000000000000471222557024500207640ustar00rootroot00000000000000require 'backports/1.8.7/io/each_char' backports-3.3.5/lib/backports/1.8.7/io/each.rb000066400000000000000000000001551222557024500205640ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional IO, :each, :force => true if RUBY_VERSION < '1.8.7' backports-3.3.5/lib/backports/1.8.7/io/each_byte.rb000066400000000000000000000002441222557024500216060ustar00rootroot00000000000000require 'backports/tools' if RUBY_VERSION < '1.8.7' Backports.make_block_optional IO, :each_byte, :force => true IO.send :alias_method, :bytes, :each_byte end backports-3.3.5/lib/backports/1.8.7/io/each_char.rb000066400000000000000000000013711222557024500215620ustar00rootroot00000000000000unless IO.method_defined? :each_char require 'enumerator' class IO def each_char return to_enum(:each_char) unless block_given? if $KCODE == "UTF-8" lookup = 7.downto(4) while c = read(1) do n = c[0] leftmost_zero_bit = lookup.find{|i| n[i].zero? } case leftmost_zero_bit when 7 # ASCII yield c when 6 # UTF 8 complementary characters next # Encoding error, ignore else more = read(6-leftmost_zero_bit) break unless more yield c+more end end else while s = read(1) yield s end end self end alias_method :chars, :each_char end end backports-3.3.5/lib/backports/1.8.7/io/each_line.rb000066400000000000000000000002441222557024500215720ustar00rootroot00000000000000require 'backports/tools' if RUBY_VERSION < '1.8.7' Backports.make_block_optional IO, :each_line, :force => true IO.send :alias_method, :lines, :each_line end backports-3.3.5/lib/backports/1.8.7/io/foreach.rb000066400000000000000000000002201222557024500212640ustar00rootroot00000000000000if RUBY_VERSION < '1.8.7' require 'backports/tools' class << IO Backports.make_block_optional self, :foreach, :force => true end end backports-3.3.5/lib/backports/1.8.7/io/getbyte.rb000066400000000000000000000001061222557024500213230ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method IO, :getbyte, :getc backports-3.3.5/lib/backports/1.8.7/io/lines.rb000066400000000000000000000000471222557024500207760ustar00rootroot00000000000000require 'backports/1.8.7/io/each_line' backports-3.3.5/lib/backports/1.8.7/io/readbyte.rb000066400000000000000000000001131222557024500214550ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method IO, :readbyte, :readchar backports-3.3.5/lib/backports/1.8.7/kernel.rb000066400000000000000000000000721222557024500205330ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/kernel/000077500000000000000000000000001222557024500202075ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/kernel/__method__.rb000066400000000000000000000002301222557024500226030ustar00rootroot00000000000000unless (__method__ || true rescue false) module Kernel def __method__ m = caller(1).first[/`(.*)'/,1] m.to_sym if m end end end backports-3.3.5/lib/backports/1.8.7/kernel/instance_exec.rb000066400000000000000000000004331222557024500233440ustar00rootroot00000000000000unless Object.method_defined?(:instance_exec) module Kernel def instance_exec(*arg, &block) class << self self end.send(:define_method, :"temporary method for instance_exec", &block) send(:"temporary method for instance_exec", *arg) end end end backports-3.3.5/lib/backports/1.8.7/kernel/tap.rb000066400000000000000000000001551222557024500213210ustar00rootroot00000000000000unless Kernel.method_defined? :tap module Kernel def tap yield self self end end end backports-3.3.5/lib/backports/1.8.7/method.rb000066400000000000000000000000721222557024500205330ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/method/000077500000000000000000000000001222557024500202075ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/method/name.rb000066400000000000000000000025431222557024500214600ustar00rootroot00000000000000unless Method.method_defined? :name require 'backports/tools' class Method attr_accessor :name, :receiver, :owner def unbind_with_additional_info unbound = unbind_without_additional_info unbound.name = name unbound.owner = owner unbound end Backports.alias_method_chain self, :unbind, :additional_info end class UnboundMethod attr_accessor :name, :owner def bind_with_additional_info(to) bound = bind_without_additional_info(to) bound.name = name bound.owner = owner bound.receiver = to bound end Backports.alias_method_chain self, :bind, :additional_info end module Kernel def method_with_additional_info(name) bound = method_without_additional_info(name) bound.name = name.to_s bound.receiver = self bound.owner = self.class.ancestors.find{|mod| mod.instance_methods(false).include? bound.name} bound end Backports.alias_method_chain self, :method, :additional_info end class Module def instance_method_with_additional_info(name) unbound = instance_method_without_additional_info(name) unbound.name = name.to_s unbound.owner = ancestors.find{|mod| mod.instance_methods(false).include? unbound.name} unbound end Backports.alias_method_chain self, :instance_method, :additional_info end end backports-3.3.5/lib/backports/1.8.7/module.rb000066400000000000000000000000721222557024500205400ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/module/000077500000000000000000000000001222557024500202145ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/module/class_exec.rb000066400000000000000000000000551222557024500226520ustar00rootroot00000000000000require 'backports/1.8.7/module/module_exec' backports-3.3.5/lib/backports/1.8.7/module/module_exec.rb000066400000000000000000000004311222557024500230300ustar00rootroot00000000000000unless Module.method_defined? :module_exec require 'backports/tools' require 'backports/1.8.7/kernel/instance_exec' class Module def module_exec(*arg, &block) instance_exec(*arg, &block) end end Backports.alias_method Module, :class_exec, :module_exec end backports-3.3.5/lib/backports/1.8.7/numeric.rb000066400000000000000000000000721222557024500207150ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/numeric/000077500000000000000000000000001222557024500203715ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/numeric/step.rb000066400000000000000000000001521222557024500216670ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Numeric, :step, :test_on => 42, :arg => [100, 6] backports-3.3.5/lib/backports/1.8.7/object_space.rb000066400000000000000000000000721222557024500216740ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/object_space/000077500000000000000000000000001222557024500213505ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/object_space/each_object.rb000066400000000000000000000002001222557024500241130ustar00rootroot00000000000000require 'backports/tools' class << ObjectSpace Backports.make_block_optional self, :each_object, :test_on => ObjectSpace end backports-3.3.5/lib/backports/1.8.7/process.rb000066400000000000000000000000721222557024500207310ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/process/000077500000000000000000000000001222557024500204055ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/process/exec.rb000066400000000000000000000000441222557024500216540ustar00rootroot00000000000000class << Process public :exec end backports-3.3.5/lib/backports/1.8.7/range.rb000066400000000000000000000000721222557024500203470ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/range/000077500000000000000000000000001222557024500200235ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/range/each.rb000066400000000000000000000001331222557024500212450ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Range, :each, :test_on => 69..666 backports-3.3.5/lib/backports/1.8.7/range/step.rb000066400000000000000000000001471222557024500213250ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Range, :step, :test_on => 69..666, :arg => 42 backports-3.3.5/lib/backports/1.8.7/regexp.rb000066400000000000000000000000721222557024500205450ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/regexp/000077500000000000000000000000001222557024500202215ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/regexp/union.rb000066400000000000000000000005101222557024500216720ustar00rootroot00000000000000unless (Regexp.union(%w(a b)) rescue false) require 'backports/tools' class << Regexp def union_with_array_argument(*arg) return union_without_array_argument(*arg) unless arg.size == 1 union_without_array_argument(*arg.first) end Backports.alias_method_chain self, :union, :array_argument end end backports-3.3.5/lib/backports/1.8.7/stdlib.rb000066400000000000000000000000421222557024500205310ustar00rootroot00000000000000Backports::StdLib.extend_relative backports-3.3.5/lib/backports/1.8.7/stdlib/000077500000000000000000000000001222557024500202105ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/stdlib/tmpdir.rb000066400000000000000000000020721222557024500220350ustar00rootroot00000000000000unless Dir.respond_to? :mktmpdir class << Dir def mktmpdir(prefix_suffix=nil, tmpdir=nil) raise NoMethodError, "undefined method `mktmpdir' for Dir:Class; you must require 'tmpdir'" unless respond_to? :tmpdir case prefix_suffix when nil prefix = "d" suffix = "" when String prefix = prefix_suffix suffix = "" when Array prefix = prefix_suffix[0] suffix = prefix_suffix[1] else raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}" end tmpdir ||= Dir.tmpdir t = Time.now.strftime("%Y%m%d") n = nil begin path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{Kernel.rand(0x100000000).to_s(36)}" path << "-#{n}" if n path << suffix Dir.mkdir(path, 0700) rescue Errno::EEXIST n ||= 0 n += 1 retry end if block_given? begin yield path ensure FileUtils.remove_entry_secure path end else path end end end end backports-3.3.5/lib/backports/1.8.7/stop_iteration.rb000066400000000000000000000005241222557024500223200ustar00rootroot00000000000000require 'backports/tools' unless Object.const_defined? :StopIteration class StopIteration < IndexError; end module Kernel def loop_with_stop_iteration(&block) loop_without_stop_iteration(&block) rescue StopIteration # ignore silently end Backports.alias_method_chain self, :loop, :stop_iteration end end backports-3.3.5/lib/backports/1.8.7/string.rb000066400000000000000000000000721222557024500205610ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/string/000077500000000000000000000000001222557024500202355ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/string/bytes.rb000066400000000000000000000000531222557024500217060ustar00rootroot00000000000000require 'backports/1.8.7/string/each_byte' backports-3.3.5/lib/backports/1.8.7/string/bytesize.rb000066400000000000000000000001151222557024500224150ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method String, :bytesize, :length backports-3.3.5/lib/backports/1.8.7/string/each.rb000066400000000000000000000002111222557024500214540ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional String, :each, :test_on => "abc" if "is there still an each?".respond_to? :each backports-3.3.5/lib/backports/1.8.7/string/each_byte.rb000066400000000000000000000002221222557024500225010ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional String, :each_byte, :test_on => "abc" Backports.alias_method String, :bytes, :each_byte backports-3.3.5/lib/backports/1.8.7/string/each_char.rb000066400000000000000000000004311222557024500224550ustar00rootroot00000000000000unless String.method_defined? :each_char require 'backports/tools' require 'enumerator' class String def each_char return to_enum(:each_char) unless block_given? scan(/./m) {|c| yield c} end Backports.alias_method self, :chars, :each_char end end backports-3.3.5/lib/backports/1.8.7/string/each_line.rb000066400000000000000000000002221222557024500224650ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional String, :each_line, :test_on => "abc" Backports.alias_method String, :lines, :each_line backports-3.3.5/lib/backports/1.8.7/string/end_with.rb000066400000000000000000000004341222557024500223640ustar00rootroot00000000000000unless String.method_defined? :end_with? class String def end_with?(*suffixes) suffixes.any? do |suffix| if suffix.respond_to? :to_str suffix = suffix.to_str self[-suffix.length, suffix.length] == suffix end end end end end backports-3.3.5/lib/backports/1.8.7/string/lines.rb000066400000000000000000000000531222557024500216720ustar00rootroot00000000000000require 'backports/1.8.7/string/each_line' backports-3.3.5/lib/backports/1.8.7/string/partition.rb000066400000000000000000000013211222557024500225700ustar00rootroot00000000000000unless ("check partition".partition(" ") rescue false) require 'backports/tools' class String def partition_with_new_meaning(pattern = Backports::Undefined) return partition_without_new_meaning{|c| yield c} if pattern == Backports::Undefined pattern = Backports.coerce_to(pattern, String, :to_str) unless pattern.is_a? Regexp i = index(pattern) return [self, "", ""] unless i if pattern.is_a? Regexp match = Regexp.last_match [match.pre_match, match[0], match.post_match] else last = i+pattern.length [self[0...i], self[i...last], self[last...length]] end end Backports.alias_method_chain self, :partition, :new_meaning end end backports-3.3.5/lib/backports/1.8.7/string/rpartition.rb000066400000000000000000000010041222557024500227500ustar00rootroot00000000000000unless String.method_defined? :rpartition require 'backports/tools' class String def rpartition(pattern) pattern = Backports.coerce_to(pattern, String, :to_str) unless pattern.is_a? Regexp i = rindex(pattern) return ["", "", self] unless i if pattern.is_a? Regexp match = Regexp.last_match [match.pre_match, match[0], match.post_match] else last = i+pattern.length [self[0...i], self[i...last], self[last...length]] end end end end backports-3.3.5/lib/backports/1.8.7/string/start_with.rb000066400000000000000000000004231222557024500227510ustar00rootroot00000000000000unless String.method_defined? :start_with? class String def start_with?(*prefixes) prefixes.any? do |prefix| if prefix.respond_to? :to_str prefix = prefix.to_str self[0, prefix.length] == prefix end end end end end backports-3.3.5/lib/backports/1.8.7/string/upto.rb000066400000000000000000000006541222557024500215560ustar00rootroot00000000000000unless ("abc".upto("def", true){} rescue false) require 'backports/tools' require 'enumerator' class String def upto_with_exclusive(to, excl=false) return upto_without_exclusive(to){|s| yield s} if block_given? && !excl r = Range.new(self, to, excl) return r.to_enum unless block_given? r.each{|s| yield s} self end Backports.alias_method_chain self, :upto, :exclusive end end backports-3.3.5/lib/backports/1.8.7/struct.rb000066400000000000000000000000721222557024500205770ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/struct/000077500000000000000000000000001222557024500202535ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/struct/each.rb000066400000000000000000000001571222557024500215030ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Struct, :each, :test_on => Struct.new(:foo, :bar).new backports-3.3.5/lib/backports/1.8.7/struct/each_pair.rb000066400000000000000000000001641222557024500225140ustar00rootroot00000000000000require 'backports/tools' Backports.make_block_optional Struct, :each_pair, :test_on => Struct.new(:foo, :bar).new backports-3.3.5/lib/backports/1.8.7/symbol.rb000066400000000000000000000000721222557024500205600ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.8.7/symbol/000077500000000000000000000000001222557024500202345ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.8.7/symbol/to_proc.rb000066400000000000000000000004001222557024500222200ustar00rootroot00000000000000unless Symbol.method_defined? :to_proc class Symbol # Standard in ruby 1.8.7+. See official documentation[http://ruby-doc.org/core-1.9/classes/Symbol.html] def to_proc Proc.new { |*args| args.shift.__send__(self, *args) } end end end backports-3.3.5/lib/backports/1.8.8.rb000066400000000000000000000001311222557024500172500ustar00rootroot00000000000000# require this file to load all the backports up to Ruby 1.8.8 require 'backports/1.8.7' backports-3.3.5/lib/backports/1.8.rb000066400000000000000000000001371222557024500171100ustar00rootroot00000000000000# require this file to load all the backports of the Ruby 1.8.x line require 'backports/1.8.7' backports-3.3.5/lib/backports/1.9.1.rb000066400000000000000000000002311222557024500172430ustar00rootroot00000000000000# require this file to load all the backports up to Ruby 1.9.1 (including all of 1.8.8 and below) require 'backports/1.8' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/000077500000000000000000000000001222557024500167225ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/array.rb000066400000000000000000000000721222557024500203640ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/array/000077500000000000000000000000001222557024500200405ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/array/sample.rb000066400000000000000000000010071222557024500216440ustar00rootroot00000000000000unless Array.method_defined? :sample require 'backports/tools' class Array def sample(n = Backports::Undefined) return self[Kernel.rand(size)] if n == Backports::Undefined n = Backports.coerce_to_int(n) raise ArgumentError, "negative array size" if n < 0 n = size if n > size result = Array.new(self) n.times do |i| r = i + Kernel.rand(size - i) result[i], result[r] = result[r], result[i] end result[n..size] = [] result end end end backports-3.3.5/lib/backports/1.9.1/array/try_convert.rb000066400000000000000000000002311222557024500227370ustar00rootroot00000000000000unless Array.respond_to? :try_convert require 'backports/tools' def Array.try_convert(obj) Backports.try_convert(obj, Array, :to_ary) end end backports-3.3.5/lib/backports/1.9.1/dir.rb000066400000000000000000000000721222557024500200240ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/dir/000077500000000000000000000000001222557024500175005ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/dir/to_path.rb000066400000000000000000000001071222557024500214610ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method Dir, :to_path, :path backports-3.3.5/lib/backports/1.9.1/enumerable.rb000066400000000000000000000000721222557024500213650ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/enumerable/000077500000000000000000000000001222557024500210415ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/enumerable/each_with_index.rb000066400000000000000000000006611222557024500245130ustar00rootroot00000000000000if Enumerable.instance_method(:each_with_index).arity.zero? require 'backports/tools' require 'enumerator' module Enumerable def each_with_index_with_optional_args_and_block(*args) return to_enum(:each_with_index, *args) unless block_given? idx = 0 each(*args) { |o| yield(o, idx); idx += 1 } self end Backports.alias_method_chain self, :each_with_index, :optional_args_and_block end end backports-3.3.5/lib/backports/1.9.1/enumerable/each_with_object.rb000066400000000000000000000003511222557024500246460ustar00rootroot00000000000000unless Enumerable.method_defined? :each_with_object module Enumerable def each_with_object(memo) return to_enum(:each_with_object, memo) unless block_given? each {|obj| yield obj, memo} memo end end end backports-3.3.5/lib/backports/1.9.1/enumerator.rb000066400000000000000000000000721222557024500214270ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/enumerator/000077500000000000000000000000001222557024500211035ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/enumerator/new.rb000066400000000000000000000021351222557024500222220ustar00rootroot00000000000000Enumerator = Enumerable::Enumerator unless Object.const_defined? :Enumerator # Standard in ruby 1.9 unless (Enumerator.new{} rescue false) require 'backports/tools' # new with block, standard in Ruby 1.9 class Enumerator # A simple class which allows the construction of Enumerator from a block class Yielder def initialize(&block) @final_block = block end def yield(*arg) @final_block.call(*arg) end def <<(*arg) @final_block.call(*arg) self end end class GeneratorBP # Avoid conflict with 1.8's ::Generator class def initialize(&block) @main_block = block end def each(&block) @main_block.call(Yielder.new(&block)) end end def initialize_with_optional_block(*arg, &block) return initialize_without_optional_block(*arg, &nil) unless arg.empty? # Ruby 1.9 apparently ignores the block if any argument is present initialize_without_optional_block(GeneratorBP.new(&block)) end Backports.alias_method_chain self, :initialize, :optional_block end end backports-3.3.5/lib/backports/1.9.1/enumerator/with_object.rb000066400000000000000000000003711222557024500237320ustar00rootroot00000000000000require 'backports/tools' require 'backports/1.9.1/enumerable/each_with_object' Enumerator = Enumerable::Enumerator unless Object.const_defined? :Enumerator # Standard in ruby 1.9 Backports.alias_method Enumerator, :with_object, :each_with_object backports-3.3.5/lib/backports/1.9.1/env.rb000066400000000000000000000000721222557024500200360ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/env/000077500000000000000000000000001222557024500175125ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/env/key.rb000066400000000000000000000001301222557024500206210ustar00rootroot00000000000000require 'backports/tools' class << ENV Backports.alias_method self, :key, :index end backports-3.3.5/lib/backports/1.9.1/file.rb000066400000000000000000000000721222557024500201650ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/file/000077500000000000000000000000001222557024500176415ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/file/atime.rb000066400000000000000000000001611222557024500212630ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :atime end backports-3.3.5/lib/backports/1.9.1/file/basename.rb000066400000000000000000000001641222557024500217420ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :basename end backports-3.3.5/lib/backports/1.9.1/file/binary.rb000066400000000000000000000002071222557024500214510ustar00rootroot00000000000000class File module Constants # In Ruby 1.8, it is defined only on Windows BINARY = 0 unless const_defined?(:BINARY) end end backports-3.3.5/lib/backports/1.9.1/file/blockdev.rb000066400000000000000000000001651222557024500217610ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :blockdev? end backports-3.3.5/lib/backports/1.9.1/file/chardev.rb000066400000000000000000000001641222557024500216030ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :chardev? end backports-3.3.5/lib/backports/1.9.1/file/chmod.rb000066400000000000000000000001631222557024500212600ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :chmod, 1 end backports-3.3.5/lib/backports/1.9.1/file/chown.rb000066400000000000000000000001631222557024500213040ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :chown, 2 end backports-3.3.5/lib/backports/1.9.1/file/ctime.rb000066400000000000000000000001611222557024500212650ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :ctime end backports-3.3.5/lib/backports/1.9.1/file/delete.rb000066400000000000000000000001641222557024500214310ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :delete, 0 end backports-3.3.5/lib/backports/1.9.1/file/directory.rb000066400000000000000000000001661222557024500221750ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :directory? end backports-3.3.5/lib/backports/1.9.1/file/dirname.rb000066400000000000000000000001631222557024500216050ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :dirname end backports-3.3.5/lib/backports/1.9.1/file/executable.rb000066400000000000000000000001671222557024500223130ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :executable? end backports-3.3.5/lib/backports/1.9.1/file/executable_real.rb000066400000000000000000000001741222557024500233140ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :executable_real? end backports-3.3.5/lib/backports/1.9.1/file/exist.rb000066400000000000000000000001621222557024500213210ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :exist? end backports-3.3.5/lib/backports/1.9.1/file/exists.rb000066400000000000000000000001631222557024500215050ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :exists? end backports-3.3.5/lib/backports/1.9.1/file/expand_path.rb000066400000000000000000000006731222557024500224670ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' class << File def expand_path_with_potential_to_path(file, dir = nil) raise ArgumentError, 'home not set' if file == '~' && ENV["HOME"] == '' expand_path_without_potential_to_path( Backports.convert_path(file), dir == nil ? dir : Backports.convert_path(dir) ) end Backports.alias_method_chain self, :expand_path, :potential_to_path end end backports-3.3.5/lib/backports/1.9.1/file/extname.rb000066400000000000000000000001631222557024500216270ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :extname end backports-3.3.5/lib/backports/1.9.1/file/file.rb000066400000000000000000000001611222557024500211030ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :file? end backports-3.3.5/lib/backports/1.9.1/file/ftype.rb000066400000000000000000000001611222557024500213130ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :ftype end backports-3.3.5/lib/backports/1.9.1/file/grpowned.rb000066400000000000000000000001651222557024500220150ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :grpowned? end backports-3.3.5/lib/backports/1.9.1/file/join.rb000066400000000000000000000001621222557024500211240ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :join, 0 end backports-3.3.5/lib/backports/1.9.1/file/lchmod.rb000066400000000000000000000002211222557024500214270ustar00rootroot00000000000000if RUBY_VERSION < '1.9' && File.respond_to?(:lchmod) require 'backports/tools' Backports.convert_all_arguments_to_path File, :lchmod, 1 end backports-3.3.5/lib/backports/1.9.1/file/lchown.rb000066400000000000000000000001641222557024500214610ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :lchown, 2 end backports-3.3.5/lib/backports/1.9.1/file/link.rb000066400000000000000000000001601222557024500211200ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :link end backports-3.3.5/lib/backports/1.9.1/file/lstat.rb000066400000000000000000000001611222557024500213130ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :lstat end backports-3.3.5/lib/backports/1.9.1/file/mtime.rb000066400000000000000000000001611222557024500212770ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :mtime end backports-3.3.5/lib/backports/1.9.1/file/new.rb000066400000000000000000000001571222557024500207620ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :new end backports-3.3.5/lib/backports/1.9.1/file/open.rb000066400000000000000000000012321222557024500211250ustar00rootroot00000000000000begin File.open(__FILE__, :mode => 'r'){} rescue TypeError require 'backports/tools' def open_with_options_hash(file, mode = nil, perm = Backports::Undefined, options = Backports::Undefined) mode, perm = Backports.combine_mode_perm_and_option(mode, perm, options) perm ||= 0666 # Avoid error on Rubinius, see issue #52 if block_given? open_without_options_hash(file, mode, perm){|f| yield f} else open_without_options_hash(file, mode, perm) end end Backports.alias_method_chain File, :open, :options_hash end if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :open end backports-3.3.5/lib/backports/1.9.1/file/owned.rb000066400000000000000000000001621222557024500213010ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :owned? end backports-3.3.5/lib/backports/1.9.1/file/pipe.rb000066400000000000000000000001611222557024500211210ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :pipe? end backports-3.3.5/lib/backports/1.9.1/file/readable.rb000066400000000000000000000001651222557024500217270ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :readable? end backports-3.3.5/lib/backports/1.9.1/file/readable_real.rb000066400000000000000000000001721222557024500227300ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :readable_real? end backports-3.3.5/lib/backports/1.9.1/file/readlink.rb000066400000000000000000000001641222557024500217600ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :readlink end backports-3.3.5/lib/backports/1.9.1/file/rename.rb000066400000000000000000000001621222557024500214340ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :rename end backports-3.3.5/lib/backports/1.9.1/file/setgid.rb000066400000000000000000000001631222557024500214450ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :setgid? end backports-3.3.5/lib/backports/1.9.1/file/setuid.rb000066400000000000000000000001631222557024500214630ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :setuid? end backports-3.3.5/lib/backports/1.9.1/file/size.rb000066400000000000000000000004071222557024500211410ustar00rootroot00000000000000unless File.method_defined? :size class File def size stat.size end end end if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :size? Backports.convert_first_argument_to_path File, :size end backports-3.3.5/lib/backports/1.9.1/file/socket.rb000066400000000000000000000001631222557024500214560ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :socket? end backports-3.3.5/lib/backports/1.9.1/file/split.rb000066400000000000000000000001611222557024500213170ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :split end backports-3.3.5/lib/backports/1.9.1/file/stat.rb000066400000000000000000000001601222557024500211360ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :stat end backports-3.3.5/lib/backports/1.9.1/file/sticky.rb000066400000000000000000000001631222557024500214740ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :sticky? end backports-3.3.5/lib/backports/1.9.1/file/symlink.rb000066400000000000000000000002601222557024500216520ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :symlink, 0 Backports.convert_first_argument_to_path File, :symlink? end backports-3.3.5/lib/backports/1.9.1/file/to_path.rb000066400000000000000000000001101222557024500216140ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method File, :to_path, :path backports-3.3.5/lib/backports/1.9.1/file/truncate.rb000066400000000000000000000001641222557024500220140ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :truncate end backports-3.3.5/lib/backports/1.9.1/file/unlink.rb000066400000000000000000000001641222557024500214670ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_all_arguments_to_path File, :unlink, 0 end backports-3.3.5/lib/backports/1.9.1/file/writable.rb000066400000000000000000000001651222557024500220010ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :writable? end backports-3.3.5/lib/backports/1.9.1/file/writable_real.rb000066400000000000000000000001721222557024500230020ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :writable_real? end backports-3.3.5/lib/backports/1.9.1/file/zero.rb000066400000000000000000000001611222557024500211430ustar00rootroot00000000000000if RUBY_VERSION < '1.9' require 'backports/tools' Backports.convert_first_argument_to_path File, :zero? end backports-3.3.5/lib/backports/1.9.1/float.rb000066400000000000000000000000721222557024500203530ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/float/000077500000000000000000000000001222557024500200275ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/float/round.rb000066400000000000000000000010351222557024500215020ustar00rootroot00000000000000if Float.instance_method(:round).arity.zero? require 'backports/tools' class Float def round_with_digits(ndigits=0) ndigits = Backports::coerce_to_int(ndigits) case when ndigits == 0 round_without_digits when ndigits < 0 p = 10 ** -ndigits p > abs ? 0 : (self / p).round * p else p = 10 ** ndigits prod = self * p prod.infinite? || prod.nan? ? self : prod.round.to_f / p end end Backports.alias_method_chain self, :round, :digits end end backports-3.3.5/lib/backports/1.9.1/hash.rb000066400000000000000000000000721222557024500201710ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/hash/000077500000000000000000000000001222557024500176455ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/hash/assoc.rb000066400000000000000000000003211222557024500212760ustar00rootroot00000000000000unless Hash.method_defined? :assoc class Hash def assoc(key) val = fetch(key) do return find do |k, v| [k, v] if k == key end end [key, val] end end end backports-3.3.5/lib/backports/1.9.1/hash/default_proc.rb000066400000000000000000000005031222557024500226370ustar00rootroot00000000000000unless Hash.method_defined? :default_proc= require 'backports/tools' class Hash def default_proc=(proc) if proc == nil # nil accepted in Ruby 2.0 self.default = nil self else replace(Hash.new(&Backports.coerce_to(proc, Proc, :to_proc)).merge!(self)) end end end end backports-3.3.5/lib/backports/1.9.1/hash/key.rb000066400000000000000000000001051222557024500207560ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method Hash, :key, :index backports-3.3.5/lib/backports/1.9.1/hash/rassoc.rb000066400000000000000000000002641222557024500214660ustar00rootroot00000000000000unless Hash.method_defined? :rassoc class Hash def rassoc(value) k = key(value) v = fetch(k){return nil} [k, fetch(k)] if k || v == value end end end backports-3.3.5/lib/backports/1.9.1/hash/try_convert.rb000066400000000000000000000002231222557024500225450ustar00rootroot00000000000000unless Hash.respond_to? :try_convert require 'backports/tools' def Hash.try_convert(x) Backports.try_convert(x, Hash, :to_hash) end end backports-3.3.5/lib/backports/1.9.1/integer.rb000066400000000000000000000000721222557024500207030ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/integer/000077500000000000000000000000001222557024500203575ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/integer/magnitude.rb000066400000000000000000000001141222557024500226550ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method Integer, :magnitude, :abs backports-3.3.5/lib/backports/1.9.1/integer/round.rb000066400000000000000000000012121222557024500220270ustar00rootroot00000000000000if Integer.instance_method(:round).arity.zero? require 'backports/tools' class Integer def round_with_digits(ndigits=0) ndigits = Backports::coerce_to_int(ndigits) case when ndigits.zero? self when ndigits > 0 raise RangeError if ndigits >= 1<<31 Float(self) else pow = 10 ** (-ndigits) return 0 if pow.is_a?(Float) # when ndigits hugely negative remain = self % pow comp = self < 0 ? :<= : :< remain -= pow unless remain.send(comp, pow / 2) self - remain end end Backports.alias_method_chain self, :round, :digits end end backports-3.3.5/lib/backports/1.9.1/io.rb000066400000000000000000000000721222557024500176550ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/io/000077500000000000000000000000001222557024500173315ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/io/binread.rb000066400000000000000000000003411222557024500212600ustar00rootroot00000000000000unless IO.respond_to? :binread require 'backports/tools' def IO.binread(file, length = nil, offset = 0) File.open(Backports.convert_path(file),"rb") do |f| f.seek(offset) f.read(length) end end end backports-3.3.5/lib/backports/1.9.1/io/open.rb000066400000000000000000000011101222557024500206100ustar00rootroot00000000000000begin File.open(__FILE__) { |f| IO.open(f.fileno, :mode => 'r').close } rescue TypeError require 'backports/tools' class << IO def open_with_options_hash(*args) if args.size > 2 || args[1].respond_to?(:to_hash) fd, mode, options = (args << Backports::Undefined) args = [fd, Backports.combine_mode_and_option(mode, options)] end if block_given? open_without_options_hash(*args){|f| yield f} else open_without_options_hash(*args) end end Backports.alias_method_chain self, :open, :options_hash end end backports-3.3.5/lib/backports/1.9.1/io/try_convert.rb000066400000000000000000000002171222557024500222340ustar00rootroot00000000000000unless IO.respond_to? :try_convert require 'backports/tools' def IO.try_convert(obj) Backports.try_convert(obj, IO, :to_io) end end backports-3.3.5/lib/backports/1.9.1/io/ungetbyte.rb000066400000000000000000000001121222557024500216560ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method IO, :ungetbyte, :ungetc backports-3.3.5/lib/backports/1.9.1/kernel.rb000066400000000000000000000000721222557024500205260ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/kernel/000077500000000000000000000000001222557024500202025ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/kernel/__callee__.rb000066400000000000000000000002341222557024500225470ustar00rootroot00000000000000unless (__callee__ || true rescue false) require 'backports/1.8.7/kernel/__method__' module Kernel alias_method :__callee__, :__method__ end end backports-3.3.5/lib/backports/1.9.1/kernel/define_singleton_method.rb000066400000000000000000000003271222557024500254050ustar00rootroot00000000000000unless Kernel.method_defined? :define_singleton_method module Kernel def define_singleton_method(*args, &block) class << self self end.send(:define_method, *args, &block) end end end backports-3.3.5/lib/backports/1.9.1/kernel/public_method.rb000066400000000000000000000004521222557024500233460ustar00rootroot00000000000000unless Kernel.method_defined? :public_method module Kernel def public_method(meth) if respond_to?(meth) && !protected_methods.include?(meth.to_s) method(meth) else raise NameError, "undefined method `#{meth}' for class `#{self.class}'" end end end end backports-3.3.5/lib/backports/1.9.1/kernel/public_send.rb000066400000000000000000000007321222557024500230200ustar00rootroot00000000000000unless Kernel.method_defined? :public_send module Kernel def public_send(method, *args, &block) if respond_to?(method) && !protected_methods.include?(method.to_s) send(method, *args, &block) else :foo.generate_a_no_method_error_in_preparation_for_method_missing rescue nil # otherwise a NameError might be raised when we call method_missing ourselves method_missing(method.to_sym, *args, &block) end end end end backports-3.3.5/lib/backports/1.9.1/kernel/require_relative.rb000066400000000000000000000007001222557024500240730ustar00rootroot00000000000000unless Kernel.private_method_defined? :require_relative require 'backports/tools' module Kernel def require_relative(relative_feature) file = caller.first.split(/:\d/,2).first if /\A\((.*)\)/ =~ file # eval, etc. raise LoadError, "require_relative is called in #{$1}" end require File.expand_path(Backports.convert_path(relative_feature), File.dirname(file)) end private :require_relative end end backports-3.3.5/lib/backports/1.9.1/math.rb000066400000000000000000000000721222557024500201770ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/math/000077500000000000000000000000001222557024500176535ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/math/log.rb000066400000000000000000000015571222557024500207710ustar00rootroot00000000000000unless (Math.log(2, 2) rescue false) require 'backports/tools' class << Math # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Math.html] def log_with_optional_base(numeric, base = Backports::Undefined) if base.equal?(Backports::Undefined) # Math.log(n) in 1.9.1 no longer accepts string arguments as it # did on 1.8.x, but we won't risk redefining existing behavior # when called with just one argument. log_without_optional_base(numeric) else # Math.log(n, b) in 1.9.1 does not accept string arguments: raise TypeError, "can't convert String into Float" if numeric.is_a?(String) || base.is_a?(String) log_without_optional_base(numeric) / log_without_optional_base(base) end end Backports.alias_method_chain self, :log, :optional_base end end backports-3.3.5/lib/backports/1.9.1/math/log2.rb000066400000000000000000000001331222557024500210400ustar00rootroot00000000000000unless Math.respond_to? :log2 def Math.log2(numeric) log(numeric) / log(2) end end backports-3.3.5/lib/backports/1.9.1/numeric.rb000066400000000000000000000000721222557024500207100ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/numeric/000077500000000000000000000000001222557024500203645ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/numeric/round.rb000066400000000000000000000005041222557024500220370ustar00rootroot00000000000000if Numeric.instance_method(:round).arity.zero? require 'backports/tools' class Numeric def round_with_digits(ndigits=0) ndigits = Backports::coerce_to_int(ndigits) ndigits.zero? ? round_without_digits : Float(self).round(ndigits) end Backports.alias_method_chain self, :round, :digits end end backports-3.3.5/lib/backports/1.9.1/proc.rb000066400000000000000000000000721222557024500202110ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/proc/000077500000000000000000000000001222557024500176655ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/proc/case_compare.rb000066400000000000000000000002701222557024500226320ustar00rootroot00000000000000unless Proc.new{true} === 42 class Proc # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Proc.html] alias_method :===, :call end end backports-3.3.5/lib/backports/1.9.1/proc/curry.rb000066400000000000000000000012041222557024500213530ustar00rootroot00000000000000unless Proc.method_defined? :curry require 'backports/1.9.1/proc/lambda' class Proc def curry(argc = nil) min_argc = arity < 0 ? -arity - 1 : arity argc ||= min_argc if lambda? and arity < 0 ? argc < min_argc : argc != arity raise ArgumentError, "wrong number of arguments (#{argc} for #{min_argc})" end creator = lambda? ? :lambda : :proc block = send(creator) do |*args| if args.size >= argc call(*args) else send(creator) do |*more_args| args += more_args block.call(*args) end end end end end end backports-3.3.5/lib/backports/1.9.1/proc/lambda.rb000066400000000000000000000020501222557024500214270ustar00rootroot00000000000000unless Proc.method_defined? :lambda? require 'backports/tools' class Proc # Standard in Ruby 1.9. See official documentation[http://ruby-doc.org/core-1.9/classes/Proc.html] def lambda? !!__is_lambda__ end attr_accessor :__is_lambda__ private :__is_lambda__ private :__is_lambda__= end class Method def to_proc_with_lambda_tracking proc = to_proc_without_lambda_tracking proc.send :__is_lambda__=, true proc end Backports.alias_method_chain self, :to_proc, :lambda_tracking end module Kernel def lambda_with_lambda_tracking(&block) l = lambda_without_lambda_tracking(&block) l.send :__is_lambda__=, true unless block.send(:__is_lambda__) == false l end def proc_with_lambda_tracking(&block) l = proc_without_lambda_tracking(&block) l.send :__is_lambda__=, block.send(:__is_lambda__) == true l end Backports.alias_method_chain self, :lambda, :lambda_tracking Backports.alias_method_chain self, :proc, :lambda_tracking end end backports-3.3.5/lib/backports/1.9.1/proc/yield.rb000066400000000000000000000001061222557024500213150ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method Proc, :yield, :call backports-3.3.5/lib/backports/1.9.1/range.rb000066400000000000000000000000721222557024500203420ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/range/000077500000000000000000000000001222557024500200165ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/range/cover.rb000066400000000000000000000001141222557024500214550ustar00rootroot00000000000000require 'backports/tools' Backports.alias_method Range, :cover?, :include? backports-3.3.5/lib/backports/1.9.1/regexp.rb000066400000000000000000000000721222557024500205400ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.1/regexp/000077500000000000000000000000001222557024500202145ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/regexp/try_convert.rb000066400000000000000000000002371222557024500231210ustar00rootroot00000000000000unless Regexp.respond_to? :try_convert require 'backports/tools' def Regexp.try_convert(obj) Backports.try_convert(obj, Regexp, :to_regexp) end end backports-3.3.5/lib/backports/1.9.1/stdlib.rb000066400000000000000000000000421222557024500205240ustar00rootroot00000000000000Backports::StdLib.extend_relative backports-3.3.5/lib/backports/1.9.1/stdlib/000077500000000000000000000000001222557024500202035ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.1/stdlib/prime.rb000066400000000000000000000330071222557024500216470ustar00rootroot00000000000000# # = prime.rb # # Prime numbers and factorization library. # # Copyright:: # Copyright (c) 1998-2008 Keiju ISHITSUKA(SHL Japan Inc.) # Copyright (c) 2008 Yuki Sonoda (Yugui) # # Documentation:: # Yuki Sonoda # require "singleton" require "forwardable" class Integer # Re-composes a prime factorization and returns the product. # # See Prime#int_from_prime_division for more details. def Integer.from_prime_division(pd) Prime.int_from_prime_division(pd) end # Returns the factorization of +self+. # # See Prime#prime_division for more details. def prime_division(generator = Prime::Generator23.new) Prime.prime_division(self, generator) end # Returns true if +self+ is a prime number, false for a composite. def prime? Prime.prime?(self) end # Iterates the given block over all prime numbers. # # See +Prime+#each for more details. def Integer.each_prime(ubound, &block) # :yields: prime Prime.each(ubound, &block) end end # # The set of all prime numbers. # # == Example # Prime.each(100) do |prime| # p prime #=> 2, 3, 5, 7, 11, ...., 97 # end # # == Retrieving the instance # +Prime+.new is obsolete. Now +Prime+ has the default instance and you can # access it as +Prime+.instance. # # For convenience, each instance method of +Prime+.instance can be accessed # as a class method of +Prime+. # # e.g. # Prime.instance.prime?(2) #=> true # Prime.prime?(2) #=> true # # == Generators # A "generator" provides an implementation of enumerating pseudo-prime # numbers and it remembers the position of enumeration and upper bound. # Futhermore, it is a external iterator of prime enumeration which is # compatible to an Enumerator. # # +Prime+::+PseudoPrimeGenerator+ is the base class for generators. # There are few implementations of generator. # # [+Prime+::+EratosthenesGenerator+] # Uses eratosthenes's sieve. # [+Prime+::+TrialDivisionGenerator+] # Uses the trial division method. # [+Prime+::+Generator23+] # Generates all positive integers which is not divided by 2 nor 3. # This sequence is very bad as a pseudo-prime sequence. But this # is faster and uses much less memory than other generators. So, # it is suitable for factorizing an integer which is not large but # has many prime factors. e.g. for Prime#prime? . class Prime unless Prime.const_defined? :OldCompatibility include Enumerable @the_instance = Prime.new # obsolete. Use +Prime+::+instance+ or class methods of +Prime+. def initialize @generator = EratosthenesGenerator.new extend OldCompatibility warn "Prime::new is obsolete. use Prime::instance or class methods of Prime." end class << self extend Forwardable include Enumerable # Returns the default instance of Prime. def instance; @the_instance end def method_added(method) # :nodoc: (class<< self;self;end).def_delegator :instance, method end end # Iterates the given block over all prime numbers. # # == Parameters # +ubound+:: # Optional. An arbitrary positive number. # The upper bound of enumeration. The method enumerates # prime numbers infinitely if +ubound+ is nil. # +generator+:: # Optional. An implementation of pseudo-prime generator. # # == Return value # An evaluated value of the given block at the last time. # Or an enumerator which is compatible to an +Enumerator+ # if no block given. # # == Description # Calls +block+ once for each prime number, passing the prime as # a parameter. # # +ubound+:: # Upper bound of prime numbers. The iterator stops after # yields all prime numbers p <= +ubound+. # # == Note # +Prime+.+new+ returns a object extended by +Prime+::+OldCompatibility+ # in order to compatibility to Ruby 1.8, and +Prime+#each is overwritten # by +Prime+::+OldCompatibility+#+each+. # # +Prime+.+new+ is now obsolete. Use +Prime+.+instance+.+each+ or simply # +Prime+.+each+. def each(ubound = nil, generator = EratosthenesGenerator.new, &block) generator.upper_bound = ubound generator.each(&block) end # Returns true if +value+ is prime, false for a composite. # # == Parameters # +value+:: an arbitrary integer to be checked. # +generator+:: optional. A pseudo-prime generator. def prime?(value, generator = Prime::Generator23.new) value = -value if value < 0 return false if value < 2 for num in generator q,r = value.divmod num return true if q < num return false if r == 0 end end # Re-composes a prime factorization and returns the product. # # == Parameters # +pd+:: Array of pairs of integers. The each internal # pair consists of a prime number -- a prime factor -- # and a natural number -- an exponent. # # == Example # For [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]], it returns # p_1**e_1 * p_2**e_2 * .... * p_n**e_n. # # Prime.int_from_prime_division([[2,2], [3,1]]) #=> 12 def int_from_prime_division(pd) pd.inject(1){|value, (prime, index)| value *= prime**index } end # Returns the factorization of +value+. # # == Parameters # +value+:: An arbitrary integer. # +generator+:: Optional. A pseudo-prime generator. # +generator+.succ must return the next # pseudo-prime number in the ascendent # order. It must generate all prime numbers, # but may generate non prime numbers. # # === Exceptions # +ZeroDivisionError+:: when +value+ is zero. # # == Example # For an arbitrary integer # n = p_1**e_1 * p_2**e_2 * .... * p_n**e_n, # prime_division(n) returns # [[p_1, e_1], [p_2, e_2], ...., [p_n, e_n]]. # # Prime.prime_division(12) #=> [[2,2], [3,1]] # def prime_division(value, generator= Prime::Generator23.new) raise ZeroDivisionError if value == 0 if value < 0 value = -value pv = [[-1, 1]] else pv = [] end for prime in generator count = 0 while (value1, mod = value.divmod(prime) mod) == 0 value = value1 count += 1 end if count != 0 pv.push [prime, count] end break if value1 <= prime end if value > 1 pv.push [value, 1] end return pv end # An abstract class for enumerating pseudo-prime numbers. # # Concrete subclasses should override succ, next, rewind. class PseudoPrimeGenerator include Enumerable def initialize(ubound = nil) @ubound = ubound end def upper_bound=(ubound) @ubound = ubound end def upper_bound @ubound end # returns the next pseudo-prime number, and move the internal # position forward. # # +PseudoPrimeGenerator+#succ raises +NotImplementedError+. def succ raise NotImplementedError, "need to define `succ'" end # alias of +succ+. def next raise NotImplementedError, "need to define `next'" end # Rewinds the internal position for enumeration. # # See +Enumerator+#rewind. def rewind raise NotImplementedError, "need to define `rewind'" end # Iterates the given block for each prime numbers. def each(&block) return self.dup unless block if @ubound last_value = nil loop do prime = succ break last_value if prime > @ubound last_value = block.call(prime) end else loop do block.call(succ) end end end # see +Enumerator+#with_index. alias with_index each_with_index # see +Enumerator+#with_object. def with_object(obj) return enum_for(:with_object) unless block_given? each do |prime| yield prime, obj end end end # An implementation of +PseudoPrimeGenerator+. # # Uses +EratosthenesSieve+. class EratosthenesGenerator < PseudoPrimeGenerator def initialize @last_prime = nil super end def succ @last_prime = @last_prime ? EratosthenesSieve.instance.next_to(@last_prime) : 2 end def rewind initialize end alias next succ end # An implementation of +PseudoPrimeGenerator+ which uses # a prime table generated by trial division. class TrialDivisionGenerator= @primes.length # Only check for prime factors up to the square root of the potential primes, # but without the performance hit of an actual square root calculation. if @next_to_check + 4 > @ulticheck_next_squared @ulticheck_index += 1 @ulticheck_next_squared = @primes.at(@ulticheck_index + 1) ** 2 end # Only check numbers congruent to one and five, modulo six. All others # are divisible by two or three. This also allows us to skip checking against # two and three. @primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil? @next_to_check += 4 @primes.push @next_to_check if @primes[2..@ulticheck_index].find {|prime| @next_to_check % prime == 0 }.nil? @next_to_check += 2 end return @primes[index] end end # Internal use. An implementation of eratosthenes's sieve class EratosthenesSieve include Singleton BITS_PER_ENTRY = 16 # each entry is a set of 16-bits in a Fixnum NUMS_PER_ENTRY = BITS_PER_ENTRY * 2 # twiced because even numbers are omitted ENTRIES_PER_TABLE = 8 NUMS_PER_TABLE = NUMS_PER_ENTRY * ENTRIES_PER_TABLE FILLED_ENTRY = (1 << NUMS_PER_ENTRY) - 1 def initialize # :nodoc: # bitmap for odd prime numbers less than 256. # For an arbitrary odd number n, @tables[i][j][k] is # * 1 if n is prime, # * 0 if n is composite, # where i,j,k = indices(n) @tables = [[0xcb6e, 0x64b4, 0x129a, 0x816d, 0x4c32, 0x864a, 0x820d, 0x2196].freeze] end # returns the least odd prime number which is greater than +n+. def next_to(n) n = (n-1).div(2)*2+3 # the next odd number to given n table_index, integer_index, bit_index = indices(n) loop do extend_table until @tables.length > table_index for j in integer_index...ENTRIES_PER_TABLE if !@tables[table_index][j].zero? for k in bit_index...BITS_PER_ENTRY return NUMS_PER_TABLE*table_index + NUMS_PER_ENTRY*j + 2*k+1 if !@tables[table_index][j][k].zero? end end bit_index = 0 end table_index += 1; integer_index = 0 end end private # for an odd number +n+, returns (i, j, k) such that @tables[i][j][k] represents primarity of the number def indices(n) # binary digits of n: |0|1|2|3|4|5|6|7|8|9|10|11|.... # indices: |-| k | j | i # because of NUMS_PER_ENTRY, NUMS_PER_TABLE k = (n & 0b00011111) >> 1 j = (n & 0b11100000) >> 5 i = n >> 8 return i, j, k end def extend_table lbound = NUMS_PER_TABLE * @tables.length ubound = lbound + NUMS_PER_TABLE new_table = [FILLED_ENTRY] * ENTRIES_PER_TABLE # which represents primarity in lbound...ubound (3..Integer(Math.sqrt(ubound))).step(2) do |p| i, j, k = indices(p) next if @tables[i][j][k].zero? start = (lbound.div(p)+1)*p # least multiple of p which is >= lbound start += p if start.even? (start...ubound).step(2*p) do |n| _, j, k = indices(n) new_table[j] &= FILLED_ENTRY^(1< class Symbol def <=>(with) return nil unless with.is_a? Symbol to_s <=> with.to_s end end end backports-3.3.5/lib/backports/1.9.1/symbol/downcase.rb000066400000000000000000000001651222557024500223610ustar00rootroot00000000000000unless Symbol.method_defined? :downcase class Symbol def downcase to_s.downcase.to_sym end end end backports-3.3.5/lib/backports/1.9.1/symbol/element_reference.rb000066400000000000000000000001471222557024500242250ustar00rootroot00000000000000unless Symbol.method_defined? :[] class Symbol def [](*args) to_s[*args] end end end backports-3.3.5/lib/backports/1.9.1/symbol/empty.rb000066400000000000000000000001501222557024500217060ustar00rootroot00000000000000unless Symbol.method_defined? :empty? class Symbol def empty? to_s.empty? end end end backports-3.3.5/lib/backports/1.9.1/symbol/length.rb000066400000000000000000000001501222557024500220310ustar00rootroot00000000000000unless Symbol.method_defined? :length class Symbol def length to_s.length end end end backports-3.3.5/lib/backports/1.9.1/symbol/match.rb000066400000000000000000000002131222557024500216440ustar00rootroot00000000000000unless Symbol.method_defined? :match class Symbol def match(with) to_s =~ with end alias_method :=~, :match end end backports-3.3.5/lib/backports/1.9.1/symbol/next.rb000066400000000000000000000000461222557024500215320ustar00rootroot00000000000000require 'backports/1.9.1/symbol/succ' backports-3.3.5/lib/backports/1.9.1/symbol/size.rb000066400000000000000000000001421222557024500215230ustar00rootroot00000000000000unless Symbol.method_defined? :size class Symbol def size to_s.size end end end backports-3.3.5/lib/backports/1.9.1/symbol/succ.rb000066400000000000000000000002071222557024500215100ustar00rootroot00000000000000unless Symbol.method_defined? :succ class Symbol def succ to_s.succ.to_sym end alias_method :next, :succ end end backports-3.3.5/lib/backports/1.9.1/symbol/swapcase.rb000066400000000000000000000001651222557024500223640ustar00rootroot00000000000000unless Symbol.method_defined? :swapcase class Symbol def swapcase to_s.swapcase.to_sym end end end backports-3.3.5/lib/backports/1.9.1/symbol/upcase.rb000066400000000000000000000001571222557024500220370ustar00rootroot00000000000000unless Symbol.method_defined? :upcase class Symbol def upcase to_s.upcase.to_sym end end end backports-3.3.5/lib/backports/1.9.2.rb000066400000000000000000000001701222557024500172460ustar00rootroot00000000000000# require this file to load all the backports up to Ruby 1.9.2 require 'backports/1.9.1' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/000077500000000000000000000000001222557024500167235ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/array.rb000066400000000000000000000000721222557024500203650ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/array/000077500000000000000000000000001222557024500200415ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/array/keep_if.rb000066400000000000000000000002551222557024500217720ustar00rootroot00000000000000unless Array.method_defined? :keep_if class Array def keep_if return to_enum(:keep_if) unless block_given? delete_if{|elem| !yield elem} end end end backports-3.3.5/lib/backports/1.9.2/array/product.rb000066400000000000000000000013731222557024500220520ustar00rootroot00000000000000if ([1].product([2]){break false} rescue true) require 'backports/tools' require 'backports/1.8.7/array/product' class Array def product_with_block(*arg, &block) return product_without_block(*arg) unless block_given? # Same implementation as 1.8.7, but yielding arg.map!{|ary| Backports.coerce_to_ary(ary)} arg.reverse! # to get the results in the same order as in MRI, vary the last argument first arg.push self outer_lambda = arg.inject(block) do |proc, values| lambda do |partial| values.each do |val| proc.call(partial.dup << val) end end end outer_lambda.call([]) self end Backports.alias_method_chain self, :product, :block end end backports-3.3.5/lib/backports/1.9.2/array/repeated_combination.rb000066400000000000000000000013651222557024500245460ustar00rootroot00000000000000unless Array.method_defined? :repeated_combination require 'backports/tools' require 'backports/1.8.7/array/index' class Array # Note: Combinations are not yielded in the same order as MRI. # This is not a bug; the spec states that the order is implementation dependent def repeated_combination(num) return to_enum(:repeated_combination, num) unless block_given? num = Backports.coerce_to_int(num) if num <= 0 yield [] if num == 0 else copy = dup indices = Array.new(num, 0) indices[-1] = size while dec = indices.index{|x| x != 0} indices.fill indices[dec]-1, 0, dec + 1 yield copy.values_at(*indices) end end self end end end backports-3.3.5/lib/backports/1.9.2/array/repeated_permutation.rb000066400000000000000000000014101222557024500246020ustar00rootroot00000000000000unless Array.method_defined? :repeated_permutation require 'backports/tools' require 'backports/1.8.7/array/index' class Array # Note: Permutations are not yielded in the same order as MRI. # This is not a bug; the spec states that the order is implementation dependent!!! def repeated_permutation(num) return to_enum(:repeated_permutation, num) unless block_given? num = Backports.coerce_to_int(num) if num <= 0 yield [] if num == 0 else copy = dup indices = Array.new(num, 0) indices[-1] = size while dec = indices.index{|x| x != 0} indices.fill size-1, 0, dec indices[dec] -= 1 yield copy.values_at(*indices) end end self end end end backports-3.3.5/lib/backports/1.9.2/array/rotate.rb000066400000000000000000000005101222557024500216600ustar00rootroot00000000000000unless Array.method_defined? :rotate class Array def rotate(n=1) Array.new(self).rotate!(n) end end end unless Array.method_defined? :rotate! require 'backports/tools' class Array def rotate!(n=1) n = Backports.coerce_to_int(n) % (empty? ? 1 : size) concat(slice!(0, n)) end end end backports-3.3.5/lib/backports/1.9.2/array/select.rb000066400000000000000000000002541222557024500216460ustar00rootroot00000000000000unless Array.method_defined? :select! class Array def select! return to_enum(:select!) unless block_given? reject!{|elem| ! yield elem} end end end backports-3.3.5/lib/backports/1.9.2/array/sort_by.rb000066400000000000000000000003421222557024500220460ustar00rootroot00000000000000unless Array.method_defined? :sort_by! class Array def sort_by! return to_enum(:sort_by!) unless block_given? raise "can't modify frozen array" if frozen? replace sort_by{|e| yield e} end end end backports-3.3.5/lib/backports/1.9.2/array/uniq.rb000066400000000000000000000012431222557024500213420ustar00rootroot00000000000000unless [1,2].uniq{}.size == 1 require 'backports/tools' class Array def uniq_with_block return uniq_without_block unless block_given? h = {} each do |elem| key = yield(elem) h[key] = elem unless h.has_key?(key) end h.values end Backports.alias_method_chain self, :uniq, :block end end unless [1,2].uniq!{} require 'backports/tools' class Array def uniq_with_block! replace self if frozen? # force error return uniq_without_block! unless block_given? u = uniq{|e| yield e} replace u unless u.size == size end Backports.alias_method_chain self, :uniq!, :block end end backports-3.3.5/lib/backports/1.9.2/complex.rb000066400000000000000000000000721222557024500207160ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/complex/000077500000000000000000000000001222557024500203725ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/complex/to_r.rb000066400000000000000000000003541222557024500216640ustar00rootroot00000000000000if Object.const_defined? :Complex unless Complex.method_defined? :to_r class Complex def to_r raise RangeError, "Can't convert #{self} into Rational" unless imag.eql?(0) real.to_r end end end end backports-3.3.5/lib/backports/1.9.2/dir.rb000066400000000000000000000000721222557024500200250ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/dir/000077500000000000000000000000001222557024500175015ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/dir/home.rb000066400000000000000000000001411222557024500207520ustar00rootroot00000000000000unless Dir.respond_to? :home def Dir.home(user = "") File.expand_path "~#{user}" end end backports-3.3.5/lib/backports/1.9.2/enumerable.rb000066400000000000000000000000721222557024500213660ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/enumerable/000077500000000000000000000000001222557024500210425ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/enumerable/chunk.rb000066400000000000000000000024741222557024500225060ustar00rootroot00000000000000unless Enumerable.method_defined? :chunk require 'backports/1.9.1/enumerator/new' module Enumerable def chunk(initial_state = nil, &original_block) raise ArgumentError, "no block given" unless block_given? ::Enumerator.new do |yielder| previous = nil accumulate = [] block = initial_state.nil? ? original_block : Proc.new{|val| original_block.call(val, initial_state.clone)} each do |val| key = block.call(val) if key.nil? || (key.is_a?(Symbol) && key.to_s[0,1] == "_") yielder.yield [previous, accumulate] unless accumulate.empty? accumulate = [] previous = nil case key when nil, :_separator when :_alone yielder.yield [key, [val]] else raise RuntimeError, "symbol beginning with an underscore are reserved" end else if previous.nil? || previous == key accumulate << val else yielder.yield [previous, accumulate] unless accumulate.empty? accumulate = [val] end previous = key end end # what to do in case of a break? yielder.yield [previous, accumulate] unless accumulate.empty? end end end end backports-3.3.5/lib/backports/1.9.2/enumerable/collect_concat.rb000066400000000000000000000000561222557024500243440ustar00rootroot00000000000000require 'backports/1.9.2/enumerable/flat_map' backports-3.3.5/lib/backports/1.9.2/enumerable/each_entry.rb000066400000000000000000000004131222557024500235060ustar00rootroot00000000000000unless Enumerable.method_defined? :each_entry module Enumerable def each_entry(*pass) return to_enum(:each_entry, *pass) unless block_given? each(*pass) do |*args| yield args.size == 1 ? args[0] : args end self end end end backports-3.3.5/lib/backports/1.9.2/enumerable/flat_map.rb000066400000000000000000000004231222557024500231510ustar00rootroot00000000000000unless Enumerable.method_defined? :flat_map require 'backports/1.8.7/array/flatten' module Enumerable def flat_map(&block) return to_enum(:flat_map) unless block_given? map(&block).flatten(1) end alias_method :collect_concat, :flat_map end end backports-3.3.5/lib/backports/1.9.2/enumerable/slice_before.rb000066400000000000000000000016361222557024500240160ustar00rootroot00000000000000unless Enumerable.method_defined? :slice_before require 'backports/tools' require 'backports/1.9.1/enumerator/new' module Enumerable def slice_before(arg = Backports::Undefined, &block) if block_given? has_init = !(arg.equal? Backports::Undefined) else raise ArgumentError, "wrong number of arguments (0 for 1)" if arg.equal? Backports::Undefined block = Proc.new{|elem| arg === elem } end Enumerator.new do |yielder| init = arg.dup if has_init accumulator = nil each do |elem| start_new = has_init ? block.call(elem, init) : block.call(elem) if start_new yielder.yield accumulator if accumulator accumulator = [elem] else accumulator ||= [] accumulator << elem end end yielder.yield accumulator if accumulator end end end end backports-3.3.5/lib/backports/1.9.2/float.rb000066400000000000000000000000721222557024500203540ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/float/000077500000000000000000000000001222557024500200305ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/float/infinity.rb000066400000000000000000000001061222557024500222030ustar00rootroot00000000000000unless Float.const_defined? :INFINITY Float::INFINITY = 1.0/0.0 end backports-3.3.5/lib/backports/1.9.2/float/nan.rb000066400000000000000000000000741222557024500211320ustar00rootroot00000000000000unless Float.const_defined? :NAN Float::NAN = 0.0/0.0 end backports-3.3.5/lib/backports/1.9.2/hash.rb000066400000000000000000000000721222557024500201720ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/hash/000077500000000000000000000000001222557024500176465ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/hash/keep_if.rb000066400000000000000000000002701222557024500215740ustar00rootroot00000000000000unless Hash.method_defined? :keep_if class Hash def keep_if return to_enum(:keep_if) unless block_given? delete_if{|key, value| ! yield key, value} end end end backports-3.3.5/lib/backports/1.9.2/hash/select.rb000066400000000000000000000004221222557024500214500ustar00rootroot00000000000000unless Hash.method_defined? :select! class Hash def select! return to_enum(:select!) unless block_given? raise "can't modify frozen hash" if frozen? # reject! won't do it for empty hashes... reject!{|key, value| ! yield key, value} end end end backports-3.3.5/lib/backports/1.9.2/kernel.rb000066400000000000000000000000721222557024500205270ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.2/kernel/000077500000000000000000000000001222557024500202035ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/kernel/singleton_class.rb000066400000000000000000000002101222557024500237100ustar00rootroot00000000000000unless Kernel.method_defined? :singleton_class module Kernel def singleton_class class << self; self; end end end end backports-3.3.5/lib/backports/1.9.2/random.rb000066400000000000000000000000601222557024500205240ustar00rootroot00000000000000autoload :Random, "backports/extra/random/load" backports-3.3.5/lib/backports/1.9.2/stdlib.rb000066400000000000000000000000421222557024500205250ustar00rootroot00000000000000Backports::StdLib.extend_relative backports-3.3.5/lib/backports/1.9.2/stdlib/000077500000000000000000000000001222557024500202045ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/stdlib/matrix.rb000066400000000000000000001321571222557024500220460ustar00rootroot00000000000000# encoding: utf-8 # # = matrix.rb # # An implementation of Matrix and Vector classes. # # See classes Matrix and Vector for documentation. # # Current Maintainer:: Marc-André Lafortune # Original Author:: Keiju ISHITSUKA # Original Documentation:: Gavin Sinclair (sourced from Ruby in a Nutshell (Matsumoto, O'Reilly)) ## require "e2mmap.rb" module ExceptionForMatrix # :nodoc: def_e2message(TypeError, "wrong argument type %s (expected %s)") def_e2message(ArgumentError, "Wrong # of arguments(%d for %d)") def_exception("ErrOperationNotDefined", "Operation(%s) can\\'t be defined: %s op %s") unless const_defined?(:ErrOperationNotDefined) def_exception("ErrOperationNotImplemented", "Sorry, Operation(%s) not implemented: %s op %s") unless const_defined?(:ErrOperationNotImplemented) end # # The +Matrix+ class represents a mathematical matrix. It provides methods for creating # matrices, operating on them arithmetically and algebraically, # and determining their mathematical properties (trace, rank, inverse, determinant). # # == Method Catalogue # # To create a matrix: # * Matrix[*rows] # * Matrix.[](*rows) # * Matrix.rows(rows, copy = true) # * Matrix.columns(columns) # * Matrix.build(row_size, column_size, &block) # * Matrix.diagonal(*values) # * Matrix.scalar(n, value) # * Matrix.identity(n) # * Matrix.unit(n) # * Matrix.I(n) # * Matrix.zero(n) # * Matrix.row_vector(row) # * Matrix.column_vector(column) # # To access Matrix elements/columns/rows/submatrices/properties: # * #[](i, j) # * #row_size # * #column_size # * #row(i) # * #column(j) # * #collect # * #map # * #each # * #each_with_index # * #find_index # * #minor(*param) # # Properties of a matrix: # * #diagonal? # * #empty? # * #hermitian? # * #lower_triangular? # * #normal? # * #orthogonal? # * #permutation? # * #real? # * #regular? # * #singular? # * #square? # * #symmetric? # * #unitary? # * #upper_triangular? # * #zero? # # Matrix arithmetic: # * #*(m) # * #+(m) # * #-(m) # * #/(m) # * #inverse # * #inv # * #** # # Matrix functions: # * #determinant # * #det # * #rank # * #round # * #trace # * #tr # * #transpose # * #t # # Matrix decompositions: # * #eigen # * #eigensystem # * #lup # * #lup_decomposition # # Complex arithmetic: # * conj # * conjugate # * imag # * imaginary # * real # * rect # * rectangular # # Conversion to other data types: # * #coerce(other) # * #row_vectors # * #column_vectors # * #to_a # # String representations: # * #to_s # * #inspect # Backports.suppress_verbose_warnings do class Matrix include Enumerable include ExceptionForMatrix unless autoload?(:EigenvalueDecomposition) autoload :EigenvalueDecomposition, File.expand_path("../matrix/eigenvalue_decomposition", __FILE__) if 42.respond_to?(:conj) autoload :LUPDecomposition, File.expand_path("../matrix/lup_decomposition", __FILE__) end # instance creations private_class_method :new attr_reader :rows protected :rows # # Creates a matrix where each argument is a row. # Matrix[ [25, 93], [-1, 66] ] # => 25 93 # -1 66 # def Matrix.[](*rows) rows(rows, false) end # # Creates a matrix where +rows+ is an array of arrays, each of which is a row # of the matrix. If the optional argument +copy+ is false, use the given # arrays as the internal structure of the matrix without copying. # Matrix.rows([[25, 93], [-1, 66]]) # => 25 93 # -1 66 # def Matrix.rows(rows, copy = true) rows = convert_to_array(rows) rows.map! do |row| convert_to_array(row, copy) end size = (rows[0] || []).size rows.each do |row| Matrix.Raise ErrDimensionMismatch, "row size differs (#{row.size} should be #{size})" unless row.size == size end new rows, size end # # Creates a matrix using +columns+ as an array of column vectors. # Matrix.columns([[25, 93], [-1, 66]]) # => 25 -1 # 93 66 # def Matrix.columns(columns) rows(columns, false).transpose end # # Creates a matrix of size +row_size+ x +column_size+. # It fills the values by calling the given block, # passing the current row and column. # Returns an enumerator if no block is given. # # m = Matrix.build(2, 4) {|row, col| col - row } # => Matrix[[0, 1, 2, 3], [-1, 0, 1, 2]] # m = Matrix.build(3) { rand } # => a 3x3 matrix with random elements # def Matrix.build(row_size, column_size = row_size) row_size = CoercionHelper.coerce_to_int(row_size) column_size = CoercionHelper.coerce_to_int(column_size) raise ArgumentError if row_size < 0 || column_size < 0 return to_enum(:build, row_size, column_size) unless block_given? rows = Array.new(row_size) do |i| Array.new(column_size) do |j| yield i, j end end new rows, column_size end # # Creates a matrix where the diagonal elements are composed of +values+. # Matrix.diagonal(9, 5, -3) # => 9 0 0 # 0 5 0 # 0 0 -3 # def Matrix.diagonal(*values) size = values.size rows = Array.new(size) {|j| row = Array.new(size, 0) row[j] = values[j] row } new rows end # # Creates an +n+ by +n+ diagonal matrix where each diagonal element is # +value+. # Matrix.scalar(2, 5) # => 5 0 # 0 5 # def Matrix.scalar(n, value) diagonal(*Array.new(n, value)) end # # Creates an +n+ by +n+ identity matrix. # Matrix.identity(2) # => 1 0 # 0 1 # def Matrix.identity(n) scalar(n, 1) end class << Matrix alias unit identity alias I identity end # # Creates a zero matrix. # Matrix.zero(2) # => 0 0 # 0 0 # def Matrix.zero(row_size, column_size = row_size) rows = Array.new(row_size){Array.new(column_size, 0)} new rows, column_size end # # Creates a single-row matrix where the values of that row are as given in # +row+. # Matrix.row_vector([4,5,6]) # => 4 5 6 # def Matrix.row_vector(row) row = convert_to_array(row) new [row] end # # Creates a single-column matrix where the values of that column are as given # in +column+. # Matrix.column_vector([4,5,6]) # => 4 # 5 # 6 # def Matrix.column_vector(column) column = convert_to_array(column) new [column].transpose, 1 end # # Creates a empty matrix of +row_size+ x +column_size+. # At least one of +row_size+ or +column_size+ must be 0. # # m = Matrix.empty(2, 0) # m == Matrix[ [], [] ] # => true # n = Matrix.empty(0, 3) # n == Matrix.columns([ [], [], [] ]) # => true # m * n # => Matrix[[0, 0, 0], [0, 0, 0]] # def Matrix.empty(row_size = 0, column_size = 0) Matrix.Raise ArgumentError, "One size must be 0" if column_size != 0 && row_size != 0 Matrix.Raise ArgumentError, "Negative size" if column_size < 0 || row_size < 0 new([[]]*row_size, column_size) end # # Matrix.new is private; use Matrix.rows, columns, [], etc... to create. # def initialize(rows, column_size = rows[0].size) # No checking is done at this point. rows must be an Array of Arrays. # column_size must be the size of the first row, if there is one, # otherwise it *must* be specified and can be any integer >= 0 @rows = rows @column_size = column_size end def new_matrix(rows, column_size = rows[0].size) # :nodoc: self.class.send(:new, rows, column_size) # bypass privacy of Matrix.new end private :new_matrix # # Returns element (+i+,+j+) of the matrix. That is: row +i+, column +j+. # def [](i, j) @rows.fetch(i){return nil}[j] end alias element [] alias component [] def []=(i, j, v) @rows[i][j] = v end alias set_element []= alias set_component []= private :[]=, :set_element, :set_component # # Returns the number of rows. # def row_size @rows.size end # # Returns the number of columns. # attr_reader :column_size # # Returns row vector number +i+ of the matrix as a Vector (starting at 0 like # an array). When a block is given, the elements of that vector are iterated. # def row(i, &block) # :yield: e if block_given? @rows.fetch(i){return self}.each(&block) self else Vector.elements(@rows.fetch(i){return nil}) end end # # Returns column vector number +j+ of the matrix as a Vector (starting at 0 # like an array). When a block is given, the elements of that vector are # iterated. # def column(j) # :yield: e if block_given? return self if j >= column_size || j < -column_size row_size.times do |i| yield @rows[i][j] end self else return nil if j >= column_size || j < -column_size col = Array.new(row_size) {|i| @rows[i][j] } Vector.elements(col, false) end end # # Returns a matrix that is the result of iteration of the given block over all # elements of the matrix. # Matrix[ [1,2], [3,4] ].collect { |e| e**2 } # => 1 4 # 9 16 # def collect(&block) # :yield: e return to_enum(:collect) unless block_given? rows = @rows.collect{|row| row.collect(&block)} new_matrix rows, column_size end alias map collect # # Yields all elements of the matrix, starting with those of the first row, # or returns an Enumerator is no block given. # Elements can be restricted by passing an argument: # * :all (default): yields all elements # * :diagonal: yields only elements on the diagonal # * :off_diagonal: yields all elements except on the diagonal # * :lower: yields only elements on or below the diagonal # * :strict_lower: yields only elements below the diagonal # * :strict_upper: yields only elements above the diagonal # * :upper: yields only elements on or above the diagonal # # Matrix[ [1,2], [3,4] ].each { |e| puts e } # # => prints the numbers 1 to 4 # Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a # => [3] # def each(which = :all) # :yield: e return to_enum(:each, which) unless block_given? last = column_size - 1 case which when :all block = Proc.new @rows.each do |row| row.each(&block) end when :diagonal @rows.each_with_index do |row, row_index| yield row.fetch(row_index){return self} end when :off_diagonal @rows.each_with_index do |row, row_index| column_size.times do |col_index| yield row[col_index] unless row_index == col_index end end when :lower @rows.each_with_index do |row, row_index| 0.upto([row_index, last].min) do |col_index| yield row[col_index] end end when :strict_lower @rows.each_with_index do |row, row_index| [row_index, column_size].min.times do |col_index| yield row[col_index] end end when :strict_upper @rows.each_with_index do |row, row_index| (row_index+1).upto(last) do |col_index| yield row[col_index] end end when :upper @rows.each_with_index do |row, row_index| row_index.upto(last) do |col_index| yield row[col_index] end end else Matrix.Raise ArgumentError, "expected #{which.inspect} to be one of :all, :diagonal, :off_diagonal, :lower, :strict_lower, :strict_upper or :upper" end self end # # Same as #each, but the row index and column index in addition to the element # # Matrix[ [1,2], [3,4] ].each_with_index do |e, row, col| # puts "#{e} at #{row}, #{col}" # end # # => Prints: # # 1 at 0, 0 # # 2 at 0, 1 # # 3 at 1, 0 # # 4 at 1, 1 # def each_with_index(which = :all) # :yield: e, row, column return to_enum(:each_with_index, which) unless block_given? last = column_size - 1 case which when :all @rows.each_with_index do |row, row_index| row.each_with_index do |e, col_index| yield e, row_index, col_index end end when :diagonal @rows.each_with_index do |row, row_index| yield row.fetch(row_index){return self}, row_index, row_index end when :off_diagonal @rows.each_with_index do |row, row_index| column_size.times do |col_index| yield row[col_index], row_index, col_index unless row_index == col_index end end when :lower @rows.each_with_index do |row, row_index| 0.upto([row_index, last].min) do |col_index| yield row[col_index], row_index, col_index end end when :strict_lower @rows.each_with_index do |row, row_index| [row_index, column_size].min.times do |col_index| yield row[col_index], row_index, col_index end end when :strict_upper @rows.each_with_index do |row, row_index| (row_index+1).upto(last) do |col_index| yield row[col_index], row_index, col_index end end when :upper @rows.each_with_index do |row, row_index| row_index.upto(last) do |col_index| yield row[col_index], row_index, col_index end end else Matrix.Raise ArgumentError, "expected #{which.inspect} to be one of :all, :diagonal, :off_diagonal, :lower, :strict_lower, :strict_upper or :upper" end self end SELECTORS = {:all => true, :diagonal => true, :off_diagonal => true, :lower => true, :strict_lower => true, :strict_upper => true, :upper => true}.freeze unless const_defined?(:SELECTORS) # # :call-seq: # index(value, selector = :all) -> [row, column] # index(selector = :all){ block } -> [row, column] # index(selector = :all) -> an_enumerator # # The index method is specialized to return the index as [row, column] # It also accepts an optional +selector+ argument, see #each for details. # # Matrix[ [1,2], [3,4] ].index(&:even?) # => [0, 1] # Matrix[ [1,1], [1,1] ].index(1, :strict_lower) # => [1, 0] # def index(*args) raise ArgumentError, "wrong number of arguments(#{args.size} for 0-2)" if args.size > 2 which = (args.size == 2 || SELECTORS.include?(args.last)) ? args.pop : :all return to_enum(:find_index, which, *args) unless block_given? || args.size == 1 if args.size == 1 value = args.first each_with_index(which) do |e, row_index, col_index| return row_index, col_index if e == value end else each_with_index(which) do |e, row_index, col_index| return row_index, col_index if yield e end end nil end alias_method :find_index, :index # # Returns a section of the matrix. The parameters are either: # * start_row, nrows, start_col, ncols; OR # * row_range, col_range # # Matrix.diagonal(9, 5, -3).minor(0..1, 0..2) # => 9 0 0 # 0 5 0 # # Like Array#[], negative indices count backward from the end of the # row or column (-1 is the last element). Returns nil if the starting # row or column is greater than row_size or column_size respectively. # def minor(*param) case param.size when 2 row_range, col_range = param from_row = row_range.first from_row += row_size if from_row < 0 to_row = row_range.end to_row += row_size if to_row < 0 to_row += 1 unless row_range.exclude_end? size_row = to_row - from_row from_col = col_range.first from_col += column_size if from_col < 0 to_col = col_range.end to_col += column_size if to_col < 0 to_col += 1 unless col_range.exclude_end? size_col = to_col - from_col when 4 from_row, size_row, from_col, size_col = param return nil if size_row < 0 || size_col < 0 from_row += row_size if from_row < 0 from_col += column_size if from_col < 0 else Matrix.Raise ArgumentError, param.inspect end return nil if from_row > row_size || from_col > column_size || from_row < 0 || from_col < 0 rows = @rows[from_row, size_row].collect{|row| row[from_col, size_col] } new_matrix rows, [column_size - from_col, size_col].min end #-- # TESTING -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Returns +true+ is this is a diagonal matrix. # Raises an error if matrix is not square. # def diagonal? Matrix.Raise ErrDimensionMismatch unless square? each(:off_diagonal).all?(&:zero?) end # # Returns +true+ if this is an empty matrix, i.e. if the number of rows # or the number of columns is 0. # def empty? column_size == 0 || row_size == 0 end # # Returns +true+ is this is an hermitian matrix. # Raises an error if matrix is not square. # def hermitian? Matrix.Raise ErrDimensionMismatch unless square? each_with_index(:strict_upper).all? do |e, row, col| e == rows[col][row].conj end end if 42.respond_to?(:conj) # # Returns +true+ is this is a lower triangular matrix. # def lower_triangular? each(:strict_upper).all?(&:zero?) end # # Returns +true+ is this is a normal matrix. # Raises an error if matrix is not square. # def normal? Matrix.Raise ErrDimensionMismatch unless square? rows.each_with_index do |row_i, i| rows.each_with_index do |row_j, j| s = 0 rows.each_with_index do |row_k, k| s += row_i[k] * row_j[k].conj - row_k[i].conj * row_k[j] end return false unless s == 0 end end true end if 42.respond_to?(:conj) # # Returns +true+ is this is an orthogonal matrix # Raises an error if matrix is not square. # def orthogonal? Matrix.Raise ErrDimensionMismatch unless square? rows.each_with_index do |row, i| column_size.times do |j| s = 0 row_size.times do |k| s += row[k] * rows[k][j] end return false unless s == (i == j ? 1 : 0) end end true end # # Returns +true+ is this is a permutation matrix # Raises an error if matrix is not square. # def permutation? Matrix.Raise ErrDimensionMismatch unless square? cols = Array.new(column_size) rows.each_with_index do |row, i| found = false row.each_with_index do |e, j| if e == 1 return false if found || cols[j] found = cols[j] = true elsif e != 0 return false end end return false unless found end true end # # Returns +true+ if all entries of the matrix are real. # def real? all?(&:real?) end # # Returns +true+ if this is a regular (i.e. non-singular) matrix. # def regular? not singular? end # # Returns +true+ is this is a singular matrix. # def singular? determinant == 0 end # # Returns +true+ is this is a square matrix. # def square? column_size == row_size end # # Returns +true+ is this is a symmetric matrix. # Raises an error if matrix is not square. # def symmetric? Matrix.Raise ErrDimensionMismatch unless square? each_with_index(:strict_upper) do |e, row, col| return false if e != rows[col][row] end true end # # Returns +true+ is this is a unitary matrix # Raises an error if matrix is not square. # def unitary? Matrix.Raise ErrDimensionMismatch unless square? rows.each_with_index do |row, i| column_size.times do |j| s = 0 row_size.times do |k| s += row[k].conj * rows[k][j] end return false unless s == (i == j ? 1 : 0) end end true end if 42.respond_to?(:conj) # # Returns +true+ is this is an upper triangular matrix. # def upper_triangular? each(:strict_lower).all?(&:zero?) end # # Returns +true+ is this is a matrix with only zero elements # def zero? all?(&:zero?) end #-- # OBJECT METHODS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Returns +true+ if and only if the two matrices contain equal elements. # def ==(other) return false unless Matrix === other && column_size == other.column_size # necessary for empty matrices rows == other.rows end def eql?(other) return false unless Matrix === other && column_size == other.column_size # necessary for empty matrices rows.eql? other.rows end # # Returns a clone of the matrix, so that the contents of each do not reference # identical objects. # There should be no good reason to do this since Matrices are immutable. # def clone new_matrix @rows.map(&:dup), column_size end # # Returns a hash-code for the matrix. # def hash @rows.hash end #-- # ARITHMETIC -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Matrix multiplication. # Matrix[[2,4], [6,8]] * Matrix.identity(2) # => 2 4 # 6 8 # def *(m) # m is matrix or vector or number case(m) when Numeric rows = @rows.collect {|row| row.collect {|e| e * m } } return new_matrix(rows, column_size) when Vector m = self.class.column_vector(m) r = self * m return r.column(0) when Matrix Matrix.Raise ErrDimensionMismatch if column_size != m.row_size rows = Array.new(row_size) {|i| Array.new(m.column_size) {|j| (0 ... column_size).inject(0) do |vij, k| vij + self[i, k] * m[k, j] end } } return new_matrix(rows, m.column_size) else return apply_through_coercion(m, __method__) end end # # Matrix addition. # Matrix.scalar(2,5) + Matrix[[1,0], [-4,7]] # => 6 0 # -4 12 # def +(m) case m when Numeric Matrix.Raise ErrOperationNotDefined, "+", self.class, m.class when Vector m = self.class.column_vector(m) when Matrix else return apply_through_coercion(m, __method__) end Matrix.Raise ErrDimensionMismatch unless row_size == m.row_size and column_size == m.column_size rows = Array.new(row_size) {|i| Array.new(column_size) {|j| self[i, j] + m[i, j] } } new_matrix rows, column_size end # # Matrix subtraction. # Matrix[[1,5], [4,2]] - Matrix[[9,3], [-4,1]] # => -8 2 # 8 1 # def -(m) case m when Numeric Matrix.Raise ErrOperationNotDefined, "-", self.class, m.class when Vector m = self.class.column_vector(m) when Matrix else return apply_through_coercion(m, __method__) end Matrix.Raise ErrDimensionMismatch unless row_size == m.row_size and column_size == m.column_size rows = Array.new(row_size) {|i| Array.new(column_size) {|j| self[i, j] - m[i, j] } } new_matrix rows, column_size end # # Matrix division (multiplication by the inverse). # Matrix[[7,6], [3,9]] / Matrix[[2,9], [3,1]] # => -7 1 # -3 -6 # def /(other) case other when Numeric rows = @rows.collect {|row| row.collect {|e| e / other } } return new_matrix(rows, column_size) when Matrix return self * other.inverse else return apply_through_coercion(other, __method__) end end # # Returns the inverse of the matrix. # Matrix[[-1, -1], [0, -1]].inverse # => -1 1 # 0 -1 # def inverse Matrix.Raise ErrDimensionMismatch unless square? self.class.I(row_size).send(:inverse_from, self) end alias inv inverse def inverse_from(src) # :nodoc: last = row_size - 1 a = src.to_a 0.upto(last) do |k| i = k akk = a[k][k].abs (k+1).upto(last) do |j| v = a[j][k].abs if v > akk i = j akk = v end end Matrix.Raise ErrNotRegular if akk == 0 if i != k a[i], a[k] = a[k], a[i] @rows[i], @rows[k] = @rows[k], @rows[i] end akk = a[k][k] 0.upto(last) do |ii| next if ii == k q = a[ii][k].quo(akk) a[ii][k] = 0 (k + 1).upto(last) do |j| a[ii][j] -= a[k][j] * q end 0.upto(last) do |j| @rows[ii][j] -= @rows[k][j] * q end end (k+1).upto(last) do |j| a[k][j] = a[k][j].quo(akk) end 0.upto(last) do |j| @rows[k][j] = @rows[k][j].quo(akk) end end self end private :inverse_from # # Matrix exponentiation. # Equivalent to multiplying the matrix by itself N times. # Non integer exponents will be handled by diagonalizing the matrix. # # Matrix[[7,6], [3,9]] ** 2 # => 67 96 # 48 99 # def ** (other) case other when Integer x = self if other <= 0 x = self.inverse return self.class.identity(self.column_size) if other == 0 other = -other end z = nil loop do z = z ? z * x : x if other[0] == 1 return z if (other >>= 1).zero? x *= x end when Numeric v, d, v_inv = eigensystem v * self.class.diagonal(*d.each(:diagonal).map{|e| e ** other}) * v_inv else Matrix.Raise ErrOperationNotDefined, "**", self.class, other.class end end #-- # MATRIX FUNCTIONS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Returns the determinant of the matrix. # # Beware that using Float values can yield erroneous results # because of their lack of precision. # Consider using exact types like Rational or BigDecimal instead. # # Matrix[[7,6], [3,9]].determinant # => 45 # def determinant Matrix.Raise ErrDimensionMismatch unless square? m = @rows case row_size # Up to 4x4, give result using Laplacian expansion by minors. # This will typically be faster, as well as giving good results # in case of Floats when 0 +1 when 1 + m[0][0] when 2 + m[0][0] * m[1][1] - m[0][1] * m[1][0] when 3 m0, m1, m2 = m + m0[0] * m1[1] * m2[2] - m0[0] * m1[2] * m2[1] \ - m0[1] * m1[0] * m2[2] + m0[1] * m1[2] * m2[0] \ + m0[2] * m1[0] * m2[1] - m0[2] * m1[1] * m2[0] when 4 m0, m1, m2, m3 = m + m0[0] * m1[1] * m2[2] * m3[3] - m0[0] * m1[1] * m2[3] * m3[2] \ - m0[0] * m1[2] * m2[1] * m3[3] + m0[0] * m1[2] * m2[3] * m3[1] \ + m0[0] * m1[3] * m2[1] * m3[2] - m0[0] * m1[3] * m2[2] * m3[1] \ - m0[1] * m1[0] * m2[2] * m3[3] + m0[1] * m1[0] * m2[3] * m3[2] \ + m0[1] * m1[2] * m2[0] * m3[3] - m0[1] * m1[2] * m2[3] * m3[0] \ - m0[1] * m1[3] * m2[0] * m3[2] + m0[1] * m1[3] * m2[2] * m3[0] \ + m0[2] * m1[0] * m2[1] * m3[3] - m0[2] * m1[0] * m2[3] * m3[1] \ - m0[2] * m1[1] * m2[0] * m3[3] + m0[2] * m1[1] * m2[3] * m3[0] \ + m0[2] * m1[3] * m2[0] * m3[1] - m0[2] * m1[3] * m2[1] * m3[0] \ - m0[3] * m1[0] * m2[1] * m3[2] + m0[3] * m1[0] * m2[2] * m3[1] \ + m0[3] * m1[1] * m2[0] * m3[2] - m0[3] * m1[1] * m2[2] * m3[0] \ - m0[3] * m1[2] * m2[0] * m3[1] + m0[3] * m1[2] * m2[1] * m3[0] else # For bigger matrices, use an efficient and general algorithm. # Currently, we use the Gauss-Bareiss algorithm determinant_bareiss end end alias_method :det, :determinant # # Private. Use Matrix#determinant # # Returns the determinant of the matrix, using # Bareiss' multistep integer-preserving gaussian elimination. # It has the same computational cost order O(n^3) as standard Gaussian elimination. # Intermediate results are fraction free and of lower complexity. # A matrix of Integers will have thus intermediate results that are also Integers, # with smaller bignums (if any), while a matrix of Float will usually have # intermediate results with better precision. # def determinant_bareiss size = row_size last = size - 1 a = to_a no_pivot = Proc.new{ return 0 } sign = +1 pivot = 1 size.times do |k| previous_pivot = pivot if (pivot = a[k][k]) == 0 switch = (k+1 ... size).find(no_pivot) {|row| a[row][k] != 0 } a[switch], a[k] = a[k], a[switch] pivot = a[k][k] sign = -sign end (k+1).upto(last) do |i| ai = a[i] (k+1).upto(last) do |j| ai[j] = (pivot * ai[j] - ai[k] * a[k][j]) / previous_pivot end end end sign * pivot end private :determinant_bareiss # # deprecated; use Matrix#determinant # def determinant_e warn "#{caller(1)[0]}: warning: Matrix#determinant_e is deprecated; use #determinant" rank end alias det_e determinant_e # # Returns the rank of the matrix. # Beware that using Float values can yield erroneous results # because of their lack of precision. # Consider using exact types like Rational or BigDecimal instead. # # Matrix[[7,6], [3,9]].rank # => 2 # def rank # We currently use Bareiss' multistep integer-preserving gaussian elimination # (see comments on determinant) a = to_a last_column = column_size - 1 last_row = row_size - 1 pivot_row = 0 previous_pivot = 1 0.upto(last_column) do |k| switch_row = (pivot_row .. last_row).find {|row| a[row][k] != 0 } if switch_row a[switch_row], a[pivot_row] = a[pivot_row], a[switch_row] unless pivot_row == switch_row pivot = a[pivot_row][k] (pivot_row+1).upto(last_row) do |i| ai = a[i] (k+1).upto(last_column) do |j| ai[j] = (pivot * ai[j] - ai[k] * a[pivot_row][j]) / previous_pivot end end pivot_row += 1 previous_pivot = pivot end end pivot_row end # # deprecated; use Matrix#rank # def rank_e warn "#{caller(1)[0]}: warning: Matrix#rank_e is deprecated; use #rank" rank end # Returns a matrix with entries rounded to the given precision # (see Float#round) # def round(ndigits=0) map{|e| e.round(ndigits)} end # # Returns the trace (sum of diagonal elements) of the matrix. # Matrix[[7,6], [3,9]].trace # => 16 # def trace Matrix.Raise ErrDimensionMismatch unless square? (0...column_size).inject(0) do |tr, i| tr + @rows[i][i] end end alias tr trace # # Returns the transpose of the matrix. # Matrix[[1,2], [3,4], [5,6]] # => 1 2 # 3 4 # 5 6 # Matrix[[1,2], [3,4], [5,6]].transpose # => 1 3 5 # 2 4 6 # def transpose return self.class.empty(column_size, 0) if row_size.zero? new_matrix @rows.transpose, row_size end alias t transpose #-- # DECOMPOSITIONS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= #++ # # Returns the Eigensystem of the matrix; see +EigenvalueDecomposition+. # m = Matrix[[1, 2], [3, 4]] # v, d, v_inv = m.eigensystem # d.diagonal? # => true # v.inv == v_inv # => true # (v * d * v_inv).round(5) == m # => true # def eigensystem EigenvalueDecomposition.new(self) end alias eigen eigensystem # # Returns the LUP decomposition of the matrix; see +LUPDecomposition+. # a = Matrix[[1, 2], [3, 4]] # l, u, p = a.lup # l.lower_triangular? # => true # u.upper_triangular? # => true # p.permutation? # => true # l * u == a * p # => true # a.lup.solve([2, 5]) # => Vector[(1/1), (1/2)] # def lup LUPDecomposition.new(self) end alias lup_decomposition lup if 42.respond_to?(:conj) #-- # COMPLEX ARITHMETIC -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= #++ # # Returns the conjugate of the matrix. # Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]] # => 1+2i i 0 # 1 2 3 # Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].conjugate # => 1-2i -i 0 # 1 2 3 # def conjugate collect(&:conjugate) end alias conj conjugate # # Returns the imaginary part of the matrix. # Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]] # => 1+2i i 0 # 1 2 3 # Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].imaginary # => 2i i 0 # 0 0 0 # def imaginary collect(&:imaginary) end alias imag imaginary # # Returns the real part of the matrix. # Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]] # => 1+2i i 0 # 1 2 3 # Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]].real # => 1 0 0 # 1 2 3 # def real collect(&:real) end # # Returns an array containing matrices corresponding to the real and imaginary # parts of the matrix # # m.rect == [m.real, m.imag] # ==> true for all matrices m # def rect [real, imag] end alias rectangular rect end #-- # CONVERTING -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # The coerce method provides support for Ruby type coercion. # This coercion mechanism is used by Ruby to handle mixed-type # numeric operations: it is intended to find a compatible common # type between the two operands of the operator. # See also Numeric#coerce. # def coerce(other) case other when Numeric return Scalar.new(other), self else raise TypeError, "#{self.class} can't be coerced into #{other.class}" end end # # Returns an array of the row vectors of the matrix. See Vector. # def row_vectors Array.new(row_size) {|i| row(i) } end # # Returns an array of the column vectors of the matrix. See Vector. # def column_vectors Array.new(column_size) {|i| column(i) } end # # Returns an array of arrays that describe the rows of the matrix. # def to_a @rows.collect(&:dup) end def elements_to_f warn "#{caller(1)[0]}: warning: Matrix#elements_to_f is deprecated, use map(&:to_f)" map(&:to_f) end def elements_to_i warn "#{caller(1)[0]}: warning: Matrix#elements_to_i is deprecated, use map(&:to_i)" map(&:to_i) end def elements_to_r warn "#{caller(1)[0]}: warning: Matrix#elements_to_r is deprecated, use map(&:to_r)" map(&:to_r) end #-- # PRINTING -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Overrides Object#to_s # def to_s if empty? "#{self.class}.empty(#{row_size}, #{column_size})" else "#{self.class}[" + @rows.collect{|row| "[" + row.collect{|e| e.to_s}.join(", ") + "]" }.join(", ")+"]" end end # # Overrides Object#inspect # def inspect if empty? "#{self.class}.empty(#{row_size}, #{column_size})" else "#{self.class}#{@rows.inspect}" end end # Private helper modules module ConversionHelper # :nodoc: # # Converts the obj to an Array. If copy is set to true # a copy of obj will be made if necessary. # def convert_to_array(obj, copy = false) # :nodoc: case obj when Array copy ? obj.dup : obj when Vector obj.to_a else begin converted = obj.to_ary rescue Exception => e raise TypeError, "can't convert #{obj.class} into an Array (#{e.message})" end raise TypeError, "#{obj.class}#to_ary should return an Array" unless converted.is_a? Array converted end end private :convert_to_array end extend ConversionHelper module CoercionHelper # :nodoc: # # Applies the operator +oper+ with argument +obj+ # through coercion of +obj+ # def apply_through_coercion(obj, oper) coercion = obj.coerce(self) raise TypeError unless coercion.is_a?(Array) && coercion.length == 2 coercion[0].public_send(oper, coercion[1]) rescue raise TypeError, "#{obj.inspect} can't be coerced into #{self.class}" end private :apply_through_coercion # # Helper method to coerce a value into a specific class. # Raises a TypeError if the coercion fails or the returned value # is not of the right class. # (from Rubinius) # def self.coerce_to(obj, cls, meth) # :nodoc: return obj if obj.kind_of?(cls) begin ret = obj.__send__(meth) rescue Exception => e raise TypeError, "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed:\n" \ "(#{e.message})" end raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})" unless ret.kind_of? cls ret end def self.coerce_to_int(obj) coerce_to(obj, Integer, :to_int) end end include CoercionHelper # Private CLASS class Scalar < Numeric # :nodoc: include ExceptionForMatrix include CoercionHelper def initialize(value) @value = value end # ARITHMETIC def +(other) case other when Numeric Scalar.new(@value + other) when Vector, Matrix Scalar.Raise ErrOperationNotDefined, "+", @value.class, other.class else apply_through_coercion(other, __method__) end end def -(other) case other when Numeric Scalar.new(@value - other) when Vector, Matrix Scalar.Raise ErrOperationNotDefined, "-", @value.class, other.class else apply_through_coercion(other, __method__) end end def *(other) case other when Numeric Scalar.new(@value * other) when Vector, Matrix other.collect{|e| @value * e} else apply_through_coercion(other, __method__) end end def / (other) case other when Numeric Scalar.new(@value / other) when Vector Scalar.Raise ErrOperationNotDefined, "/", @value.class, other.class when Matrix self * other.inverse else apply_through_coercion(other, __method__) end end def ** (other) case other when Numeric Scalar.new(@value ** other) when Vector Scalar.Raise ErrOperationNotDefined, "**", @value.class, other.class when Matrix #other.powered_by(self) Scalar.Raise ErrOperationNotImplemented, "**", @value.class, other.class else apply_through_coercion(other, __method__) end end end end # # The +Vector+ class represents a mathematical vector, which is useful in its own right, and # also constitutes a row or column of a Matrix. # # == Method Catalogue # # To create a Vector: # * Vector.[](*array) # * Vector.elements(array, copy = true) # # To access elements: # * #[](i) # # To enumerate the elements: # * #each2(v) # * #collect2(v) # # Vector arithmetic: # * #*(x) "is matrix or number" # * #+(v) # * #-(v) # # Vector functions: # * #inner_product(v) # * #collect # * #magnitude # * #map # * #map2(v) # * #norm # * #normalize # * #r # * #size # # Conversion to other data types: # * #covector # * #to_a # * #coerce(other) # # String representations: # * #to_s # * #inspect # class Vector include ExceptionForMatrix include Enumerable include Matrix::CoercionHelper extend Matrix::ConversionHelper #INSTANCE CREATION private_class_method :new attr_reader :elements protected :elements # # Creates a Vector from a list of elements. # Vector[7, 4, ...] # def Vector.[](*array) new convert_to_array(array, false) end # # Creates a vector from an Array. The optional second argument specifies # whether the array itself or a copy is used internally. # def Vector.elements(array, copy = true) new convert_to_array(array, copy) end # # Vector.new is private; use Vector[] or Vector.elements to create. # def initialize(array) # No checking is done at this point. @elements = array end # ACCESSING # # Returns element number +i+ (starting at zero) of the vector. # def [](i) @elements[i] end alias element [] alias component [] def []=(i, v) @elements[i]= v end alias set_element []= alias set_component []= private :[]=, :set_element, :set_component # # Returns the number of elements in the vector. # def size @elements.size end #-- # ENUMERATIONS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Iterate over the elements of this vector # def each(&block) return to_enum(:each) unless block_given? @elements.each(&block) self end # # Iterate over the elements of this vector and +v+ in conjunction. # def each2(v) # :yield: e1, e2 raise TypeError, "Integer is not like Vector" if v.kind_of?(Integer) Vector.Raise ErrDimensionMismatch if size != v.size return to_enum(:each2, v) unless block_given? size.times do |i| yield @elements[i], v[i] end self end # # Collects (as in Enumerable#collect) over the elements of this vector and +v+ # in conjunction. # def collect2(v) # :yield: e1, e2 raise TypeError, "Integer is not like Vector" if v.kind_of?(Integer) Vector.Raise ErrDimensionMismatch if size != v.size return to_enum(:collect2, v) unless block_given? Array.new(size) do |i| yield @elements[i], v[i] end end #-- # COMPARING -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Returns +true+ iff the two vectors have the same elements in the same order. # def ==(other) return false unless Vector === other @elements == other.elements end def eql?(other) return false unless Vector === other @elements.eql? other.elements end # # Return a copy of the vector. # def clone self.class.elements(@elements) end # # Return a hash-code for the vector. # def hash @elements.hash end #-- # ARITHMETIC -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Multiplies the vector by +x+, where +x+ is a number or another vector. # def *(x) case x when Numeric els = @elements.collect{|e| e * x} self.class.elements(els, false) when Matrix Matrix.column_vector(self) * x when Vector Vector.Raise ErrOperationNotDefined, "*", self.class, x.class else apply_through_coercion(x, __method__) end end # # Vector addition. # def +(v) case v when Vector Vector.Raise ErrDimensionMismatch if size != v.size els = collect2(v) {|v1, v2| v1 + v2 } self.class.elements(els, false) when Matrix Matrix.column_vector(self) + v else apply_through_coercion(v, __method__) end end # # Vector subtraction. # def -(v) case v when Vector Vector.Raise ErrDimensionMismatch if size != v.size els = collect2(v) {|v1, v2| v1 - v2 } self.class.elements(els, false) when Matrix Matrix.column_vector(self) - v else apply_through_coercion(v, __method__) end end # # Vector division. # def /(x) case x when Numeric els = @elements.collect{|e| e / x} self.class.elements(els, false) when Matrix, Vector Vector.Raise ErrOperationNotDefined, "/", self.class, x.class else apply_through_coercion(x, __method__) end end #-- # VECTOR FUNCTIONS -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Returns the inner product of this vector with the other. # Vector[4,7].inner_product Vector[10,1] => 47 # def inner_product(v) Vector.Raise ErrDimensionMismatch if size != v.size p = 0 each2(v) {|v1, v2| p += v1 * v2 } p end # # Like Array#collect. # def collect(&block) # :yield: e return to_enum(:collect) unless block_given? els = @elements.collect(&block) self.class.elements(els, false) end alias map collect # # Returns the modulus (Pythagorean distance) of the vector. # Vector[5,8,2].r => 9.643650761 # def magnitude Math.sqrt(@elements.inject(0) {|v, e| v + e*e}) end alias r magnitude alias norm magnitude # # Like Vector#collect2, but returns a Vector instead of an Array. # def map2(v, &block) # :yield: e1, e2 return to_enum(:map2, v) unless block_given? els = collect2(v, &block) self.class.elements(els, false) end class ZeroVectorError < StandardError end # # Returns a new vector with the same direction but with norm 1. # v = Vector[5,8,2].normalize # # => Vector[0.5184758473652127, 0.8295613557843402, 0.20739033894608505] # v.norm => 1.0 # def normalize n = magnitude raise ZeroVectorError, "Zero vectors can not be normalized" if n == 0 self / n end #-- # CONVERTING #++ # # Creates a single-row matrix from this vector. # def covector Matrix.row_vector(self) end # # Returns the elements of the vector in an array. # def to_a @elements.dup end def elements_to_f warn "#{caller(1)[0]}: warning: Vector#elements_to_f is deprecated" map(&:to_f) end def elements_to_i warn "#{caller(1)[0]}: warning: Vector#elements_to_i is deprecated" map(&:to_i) end def elements_to_r warn "#{caller(1)[0]}: warning: Vector#elements_to_r is deprecated" map(&:to_r) end # # The coerce method provides support for Ruby type coercion. # This coercion mechanism is used by Ruby to handle mixed-type # numeric operations: it is intended to find a compatible common # type between the two operands of the operator. # See also Numeric#coerce. # def coerce(other) case other when Numeric return Matrix::Scalar.new(other), self else raise TypeError, "#{self.class} can't be coerced into #{other.class}" end end #-- # PRINTING -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- #++ # # Overrides Object#to_s # def to_s "Vector[" + @elements.join(", ") + "]" end # # Overrides Object#inspect # def inspect "Vector" + @elements.inspect end end end backports-3.3.5/lib/backports/1.9.2/stdlib/matrix/000077500000000000000000000000001222557024500215105ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.2/stdlib/matrix/eigenvalue_decomposition.rb000066400000000000000000000533641222557024500271300ustar00rootroot00000000000000class Matrix # Adapted from JAMA: http://math.nist.gov/javanumerics/jama/ # Eigenvalues and eigenvectors of a real matrix. # # Computes the eigenvalues and eigenvectors of a matrix A. # # If A is diagonalizable, this provides matrices V and D # such that A = V*D*V.inv, where D is the diagonal matrix with entries # equal to the eigenvalues and V is formed by the eigenvectors. # # If A is symmetric, then V is orthogonal and thus A = V*D*V.t class EigenvalueDecomposition # Constructs the eigenvalue decomposition for a square matrix +A+ # def initialize(a) # @d, @e: Arrays for internal storage of eigenvalues. # @v: Array for internal storage of eigenvectors. # @h: Array for internal storage of nonsymmetric Hessenberg form. raise TypeError, "Expected Matrix but got #{a.class}" unless a.is_a?(Matrix) @size = a.row_size @d = Array.new(@size, 0) @e = Array.new(@size, 0) if (@symmetric = a.symmetric?) @v = a.to_a tridiagonalize diagonalize else @v = Array.new(@size) { Array.new(@size, 0) } @h = a.to_a @ort = Array.new(@size, 0) reduce_to_hessenberg hessenberg_to_real_schur end end # Returns the eigenvector matrix +V+ # def eigenvector_matrix Matrix.send :new, build_eigenvectors.transpose end alias v eigenvector_matrix # Returns the inverse of the eigenvector matrix +V+ # def eigenvector_matrix_inv r = Matrix.send :new, build_eigenvectors r = r.transpose.inverse unless @symmetric r end alias v_inv eigenvector_matrix_inv # Returns the eigenvalues in an array # def eigenvalues values = @d.dup @e.each_with_index{|imag, i| values[i] = Complex(values[i], imag) unless imag == 0} values end # Returns an array of the eigenvectors # def eigenvectors build_eigenvectors.map{|ev| Vector.send :new, ev} end # Returns the block diagonal eigenvalue matrix +D+ # def eigenvalue_matrix Matrix.diagonal(*eigenvalues) end alias d eigenvalue_matrix # Returns [eigenvector_matrix, eigenvalue_matrix, eigenvector_matrix_inv] # def to_ary [v, d, v_inv] end alias_method :to_a, :to_ary private def build_eigenvectors # JAMA stores complex eigenvectors in a strange way # See http://cio.nist.gov/esd/emaildir/lists/jama/msg01021.html @e.each_with_index.map do |imag, i| if imag == 0 Array.new(@size){|j| @v[j][i]} elsif imag > 0 Array.new(@size){|j| Complex(@v[j][i], @v[j][i+1])} else Array.new(@size){|j| Complex(@v[j][i], -@v[j][i-1])} end end end # Complex scalar division. def cdiv(xr, xi, yr, yi) if (yr.abs > yi.abs) r = yi/yr d = yr + r*yi [(xr + r*xi)/d, (xi - r*xr)/d] else r = yr/yi d = yi + r*yr [(r*xr + xi)/d, (r*xi - xr)/d] end end # Symmetric Householder reduction to tridiagonal form. def tridiagonalize # This is derived from the Algol procedures tred2 by # Bowdler, Martin, Reinsch, and Wilkinson, Handbook for # Auto. Comp., Vol.ii-Linear Algebra, and the corresponding # Fortran subroutine in EISPACK. @size.times do |j| @d[j] = @v[@size-1][j] end # Householder reduction to tridiagonal form. (@size-1).downto(0+1) do |i| # Scale to avoid under/overflow. scale = 0.0 h = 0.0 i.times do |k| scale = scale + @d[k].abs end if (scale == 0.0) @e[i] = @d[i-1] i.times do |j| @d[j] = @v[i-1][j] @v[i][j] = 0.0 @v[j][i] = 0.0 end else # Generate Householder vector. i.times do |k| @d[k] /= scale h += @d[k] * @d[k] end f = @d[i-1] g = Math.sqrt(h) if (f > 0) g = -g end @e[i] = scale * g h -= f * g @d[i-1] = f - g i.times do |j| @e[j] = 0.0 end # Apply similarity transformation to remaining columns. i.times do |j| f = @d[j] @v[j][i] = f g = @e[j] + @v[j][j] * f (j+1).upto(i-1) do |k| g += @v[k][j] * @d[k] @e[k] += @v[k][j] * f end @e[j] = g end f = 0.0 i.times do |j| @e[j] /= h f += @e[j] * @d[j] end hh = f / (h + h) i.times do |j| @e[j] -= hh * @d[j] end i.times do |j| f = @d[j] g = @e[j] j.upto(i-1) do |k| @v[k][j] -= (f * @e[k] + g * @d[k]) end @d[j] = @v[i-1][j] @v[i][j] = 0.0 end end @d[i] = h end # Accumulate transformations. 0.upto(@size-1-1) do |i| @v[@size-1][i] = @v[i][i] @v[i][i] = 1.0 h = @d[i+1] if (h != 0.0) 0.upto(i) do |k| @d[k] = @v[k][i+1] / h end 0.upto(i) do |j| g = 0.0 0.upto(i) do |k| g += @v[k][i+1] * @v[k][j] end 0.upto(i) do |k| @v[k][j] -= g * @d[k] end end end 0.upto(i) do |k| @v[k][i+1] = 0.0 end end @size.times do |j| @d[j] = @v[@size-1][j] @v[@size-1][j] = 0.0 end @v[@size-1][@size-1] = 1.0 @e[0] = 0.0 end # Symmetric tridiagonal QL algorithm. def diagonalize # This is derived from the Algol procedures tql2, by # Bowdler, Martin, Reinsch, and Wilkinson, Handbook for # Auto. Comp., Vol.ii-Linear Algebra, and the corresponding # Fortran subroutine in EISPACK. 1.upto(@size-1) do |i| @e[i-1] = @e[i] end @e[@size-1] = 0.0 f = 0.0 tst1 = 0.0 eps = Float::EPSILON @size.times do |l| # Find small subdiagonal element tst1 = [tst1, @d[l].abs + @e[l].abs].max m = l while (m < @size) do if (@e[m].abs <= eps*tst1) break end m+=1 end # If m == l, @d[l] is an eigenvalue, # otherwise, iterate. if (m > l) iter = 0 begin iter = iter + 1 # (Could check iteration count here.) # Compute implicit shift g = @d[l] p = (@d[l+1] - g) / (2.0 * @e[l]) r = Math.hypot(p, 1.0) if (p < 0) r = -r end @d[l] = @e[l] / (p + r) @d[l+1] = @e[l] * (p + r) dl1 = @d[l+1] h = g - @d[l] (l+2).upto(@size-1) do |i| @d[i] -= h end f += h # Implicit QL transformation. p = @d[m] c = 1.0 c2 = c c3 = c el1 = @e[l+1] s = 0.0 s2 = 0.0 (m-1).downto(l) do |i| c3 = c2 c2 = c s2 = s g = c * @e[i] h = c * p r = Math.hypot(p, @e[i]) @e[i+1] = s * r s = @e[i] / r c = p / r p = c * @d[i] - s * g @d[i+1] = h + s * (c * g + s * @d[i]) # Accumulate transformation. @size.times do |k| h = @v[k][i+1] @v[k][i+1] = s * @v[k][i] + c * h @v[k][i] = c * @v[k][i] - s * h end end p = -s * s2 * c3 * el1 * @e[l] / dl1 @e[l] = s * p @d[l] = c * p # Check for convergence. end while (@e[l].abs > eps*tst1) end @d[l] = @d[l] + f @e[l] = 0.0 end # Sort eigenvalues and corresponding vectors. 0.upto(@size-2) do |i| k = i p = @d[i] (i+1).upto(@size-1) do |j| if (@d[j] < p) k = j p = @d[j] end end if (k != i) @d[k] = @d[i] @d[i] = p @size.times do |j| p = @v[j][i] @v[j][i] = @v[j][k] @v[j][k] = p end end end end # Nonsymmetric reduction to Hessenberg form. def reduce_to_hessenberg # This is derived from the Algol procedures orthes and ortran, # by Martin and Wilkinson, Handbook for Auto. Comp., # Vol.ii-Linear Algebra, and the corresponding # Fortran subroutines in EISPACK. low = 0 high = @size-1 (low+1).upto(high-1) do |m| # Scale column. scale = 0.0 m.upto(high) do |i| scale = scale + @h[i][m-1].abs end if (scale != 0.0) # Compute Householder transformation. h = 0.0 high.downto(m) do |i| @ort[i] = @h[i][m-1]/scale h += @ort[i] * @ort[i] end g = Math.sqrt(h) if (@ort[m] > 0) g = -g end h -= @ort[m] * g @ort[m] = @ort[m] - g # Apply Householder similarity transformation # @h = (I-u*u'/h)*@h*(I-u*u')/h) m.upto(@size-1) do |j| f = 0.0 high.downto(m) do |i| f += @ort[i]*@h[i][j] end f = f/h m.upto(high) do |i| @h[i][j] -= f*@ort[i] end end 0.upto(high) do |i| f = 0.0 high.downto(m) do |j| f += @ort[j]*@h[i][j] end f = f/h m.upto(high) do |j| @h[i][j] -= f*@ort[j] end end @ort[m] = scale*@ort[m] @h[m][m-1] = scale*g end end # Accumulate transformations (Algol's ortran). @size.times do |i| @size.times do |j| @v[i][j] = (i == j ? 1.0 : 0.0) end end (high-1).downto(low+1) do |m| if (@h[m][m-1] != 0.0) (m+1).upto(high) do |i| @ort[i] = @h[i][m-1] end m.upto(high) do |j| g = 0.0 m.upto(high) do |i| g += @ort[i] * @v[i][j] end # Double division avoids possible underflow g = (g / @ort[m]) / @h[m][m-1] m.upto(high) do |i| @v[i][j] += g * @ort[i] end end end end end # Nonsymmetric reduction from Hessenberg to real Schur form. def hessenberg_to_real_schur # This is derived from the Algol procedure hqr2, # by Martin and Wilkinson, Handbook for Auto. Comp., # Vol.ii-Linear Algebra, and the corresponding # Fortran subroutine in EISPACK. # Initialize nn = @size n = nn-1 low = 0 high = nn-1 eps = Float::EPSILON exshift = 0.0 p=q=r=s=z=0 # Store roots isolated by balanc and compute matrix norm norm = 0.0 nn.times do |i| if (i < low || i > high) @d[i] = @h[i][i] @e[i] = 0.0 end ([i-1, 0].max).upto(nn-1) do |j| norm = norm + @h[i][j].abs end end # Outer loop over eigenvalue index iter = 0 while (n >= low) do # Look for single small sub-diagonal element l = n while (l > low) do s = @h[l-1][l-1].abs + @h[l][l].abs if (s == 0.0) s = norm end if (@h[l][l-1].abs < eps * s) break end l-=1 end # Check for convergence # One root found if (l == n) @h[n][n] = @h[n][n] + exshift @d[n] = @h[n][n] @e[n] = 0.0 n-=1 iter = 0 # Two roots found elsif (l == n-1) w = @h[n][n-1] * @h[n-1][n] p = (@h[n-1][n-1] - @h[n][n]) / 2.0 q = p * p + w z = Math.sqrt(q.abs) @h[n][n] = @h[n][n] + exshift @h[n-1][n-1] = @h[n-1][n-1] + exshift x = @h[n][n] # Real pair if (q >= 0) if (p >= 0) z = p + z else z = p - z end @d[n-1] = x + z @d[n] = @d[n-1] if (z != 0.0) @d[n] = x - w / z end @e[n-1] = 0.0 @e[n] = 0.0 x = @h[n][n-1] s = x.abs + z.abs p = x / s q = z / s r = Math.sqrt(p * p+q * q) p /= r q /= r # Row modification (n-1).upto(nn-1) do |j| z = @h[n-1][j] @h[n-1][j] = q * z + p * @h[n][j] @h[n][j] = q * @h[n][j] - p * z end # Column modification 0.upto(n) do |i| z = @h[i][n-1] @h[i][n-1] = q * z + p * @h[i][n] @h[i][n] = q * @h[i][n] - p * z end # Accumulate transformations low.upto(high) do |i| z = @v[i][n-1] @v[i][n-1] = q * z + p * @v[i][n] @v[i][n] = q * @v[i][n] - p * z end # Complex pair else @d[n-1] = x + p @d[n] = x + p @e[n-1] = z @e[n] = -z end n -= 2 iter = 0 # No convergence yet else # Form shift x = @h[n][n] y = 0.0 w = 0.0 if (l < n) y = @h[n-1][n-1] w = @h[n][n-1] * @h[n-1][n] end # Wilkinson's original ad hoc shift if (iter == 10) exshift += x low.upto(n) do |i| @h[i][i] -= x end s = @h[n][n-1].abs + @h[n-1][n-2].abs x = y = 0.75 * s w = -0.4375 * s * s end # MATLAB's new ad hoc shift if (iter == 30) s = (y - x) / 2.0 s *= s + w if (s > 0) s = Math.sqrt(s) if (y < x) s = -s end s = x - w / ((y - x) / 2.0 + s) low.upto(n) do |i| @h[i][i] -= s end exshift += s x = y = w = 0.964 end end iter = iter + 1 # (Could check iteration count here.) # Look for two consecutive small sub-diagonal elements m = n-2 while (m >= l) do z = @h[m][m] r = x - z s = y - z p = (r * s - w) / @h[m+1][m] + @h[m][m+1] q = @h[m+1][m+1] - z - r - s r = @h[m+2][m+1] s = p.abs + q.abs + r.abs p /= s q /= s r /= s if (m == l) break end if (@h[m][m-1].abs * (q.abs + r.abs) < eps * (p.abs * (@h[m-1][m-1].abs + z.abs + @h[m+1][m+1].abs))) break end m-=1 end (m+2).upto(n) do |i| @h[i][i-2] = 0.0 if (i > m+2) @h[i][i-3] = 0.0 end end # Double QR step involving rows l:n and columns m:n m.upto(n-1) do |k| notlast = (k != n-1) if (k != m) p = @h[k][k-1] q = @h[k+1][k-1] r = (notlast ? @h[k+2][k-1] : 0.0) x = p.abs + q.abs + r.abs if (x != 0.0) p /= x q /= x r /= x end end if (x == 0.0) break end s = Math.sqrt(p * p + q * q + r * r) if (p < 0) s = -s end if (s != 0) if (k != m) @h[k][k-1] = -s * x elsif (l != m) @h[k][k-1] = -@h[k][k-1] end p += s x = p / s y = q / s z = r / s q /= p r /= p # Row modification k.upto(nn-1) do |j| p = @h[k][j] + q * @h[k+1][j] if (notlast) p += r * @h[k+2][j] @h[k+2][j] = @h[k+2][j] - p * z end @h[k][j] = @h[k][j] - p * x @h[k+1][j] = @h[k+1][j] - p * y end # Column modification 0.upto([n, k+3].min) do |i| p = x * @h[i][k] + y * @h[i][k+1] if (notlast) p += z * @h[i][k+2] @h[i][k+2] = @h[i][k+2] - p * r end @h[i][k] = @h[i][k] - p @h[i][k+1] = @h[i][k+1] - p * q end # Accumulate transformations low.upto(high) do |i| p = x * @v[i][k] + y * @v[i][k+1] if (notlast) p += z * @v[i][k+2] @v[i][k+2] = @v[i][k+2] - p * r end @v[i][k] = @v[i][k] - p @v[i][k+1] = @v[i][k+1] - p * q end end # (s != 0) end # k loop end # check convergence end # while (n >= low) # Backsubstitute to find vectors of upper triangular form if (norm == 0.0) return end (nn-1).downto(0) do |n| p = @d[n] q = @e[n] # Real vector if (q == 0) l = n @h[n][n] = 1.0 (n-1).downto(0) do |i| w = @h[i][i] - p r = 0.0 l.upto(n) do |j| r += @h[i][j] * @h[j][n] end if (@e[i] < 0.0) z = w s = r else l = i if (@e[i] == 0.0) if (w != 0.0) @h[i][n] = -r / w else @h[i][n] = -r / (eps * norm) end # Solve real equations else x = @h[i][i+1] y = @h[i+1][i] q = (@d[i] - p) * (@d[i] - p) + @e[i] * @e[i] t = (x * s - z * r) / q @h[i][n] = t if (x.abs > z.abs) @h[i+1][n] = (-r - w * t) / x else @h[i+1][n] = (-s - y * t) / z end end # Overflow control t = @h[i][n].abs if ((eps * t) * t > 1) i.upto(n) do |j| @h[j][n] = @h[j][n] / t end end end end # Complex vector elsif (q < 0) l = n-1 # Last vector component imaginary so matrix is triangular if (@h[n][n-1].abs > @h[n-1][n].abs) @h[n-1][n-1] = q / @h[n][n-1] @h[n-1][n] = -(@h[n][n] - p) / @h[n][n-1] else cdivr, cdivi = cdiv(0.0, -@h[n-1][n], @h[n-1][n-1]-p, q) @h[n-1][n-1] = cdivr @h[n-1][n] = cdivi end @h[n][n-1] = 0.0 @h[n][n] = 1.0 (n-2).downto(0) do |i| ra = 0.0 sa = 0.0 l.upto(n) do |j| ra = ra + @h[i][j] * @h[j][n-1] sa = sa + @h[i][j] * @h[j][n] end w = @h[i][i] - p if (@e[i] < 0.0) z = w r = ra s = sa else l = i if (@e[i] == 0) cdivr, cdivi = cdiv(-ra, -sa, w, q) @h[i][n-1] = cdivr @h[i][n] = cdivi else # Solve complex equations x = @h[i][i+1] y = @h[i+1][i] vr = (@d[i] - p) * (@d[i] - p) + @e[i] * @e[i] - q * q vi = (@d[i] - p) * 2.0 * q if (vr == 0.0 && vi == 0.0) vr = eps * norm * (w.abs + q.abs + x.abs + y.abs + z.abs) end cdivr, cdivi = cdiv(x*r-z*ra+q*sa, x*s-z*sa-q*ra, vr, vi) @h[i][n-1] = cdivr @h[i][n] = cdivi if (x.abs > (z.abs + q.abs)) @h[i+1][n-1] = (-ra - w * @h[i][n-1] + q * @h[i][n]) / x @h[i+1][n] = (-sa - w * @h[i][n] - q * @h[i][n-1]) / x else cdivr, cdivi = cdiv(-r-y*@h[i][n-1], -s-y*@h[i][n], z, q) @h[i+1][n-1] = cdivr @h[i+1][n] = cdivi end end # Overflow control t = [@h[i][n-1].abs, @h[i][n].abs].max if ((eps * t) * t > 1) i.upto(n) do |j| @h[j][n-1] = @h[j][n-1] / t @h[j][n] = @h[j][n] / t end end end end end end # Vectors of isolated roots nn.times do |i| if (i < low || i > high) i.upto(nn-1) do |j| @v[i][j] = @h[i][j] end end end # Back transformation to get eigenvectors of original matrix (nn-1).downto(low) do |j| low.upto(high) do |i| z = 0.0 low.upto([j, high].min) do |k| z += @v[i][k] * @h[k][j] end @v[i][j] = z end end end end end backports-3.3.5/lib/backports/1.9.2/stdlib/matrix/lup_decomposition.rb000066400000000000000000000124321222557024500255730ustar00rootroot00000000000000class Matrix # Adapted from JAMA: http://math.nist.gov/javanumerics/jama/ # # For an m-by-n matrix A with m >= n, the LU decomposition is an m-by-n # unit lower triangular matrix L, an n-by-n upper triangular matrix U, # and a m-by-m permutation matrix P so that L*U = P*A. # If m < n, then L is m-by-m and U is m-by-n. # # The LUP decomposition with pivoting always exists, even if the matrix is # singular, so the constructor will never fail. The primary use of the # LU decomposition is in the solution of square systems of simultaneous # linear equations. This will fail if singular? returns true. # class LUPDecomposition # Returns the lower triangular factor +L+ include Matrix::ConversionHelper def l Matrix.build(@row_size, @col_size) do |i, j| if (i > j) @lu[i][j] elsif (i == j) 1 else 0 end end end # Returns the upper triangular factor +U+ def u Matrix.build(@col_size, @col_size) do |i, j| if (i <= j) @lu[i][j] else 0 end end end # Returns the permutation matrix +P+ def p rows = Array.new(@row_size){Array.new(@col_size, 0)} @pivots.each_with_index{|p, i| rows[i][p] = 1} Matrix.send :new, rows, @col_size end # Returns +L+, +U+, +P+ in an array def to_ary [l, u, p] end alias_method :to_a, :to_ary # Returns the pivoting indices attr_reader :pivots # Returns +true+ if +U+, and hence +A+, is singular. def singular? () @col_size.times do |j| if (@lu[j][j] == 0) return true end end false end # Returns the determinant of +A+, calculated efficiently # from the factorization. def det if (@row_size != @col_size) Matrix.Raise Matrix::ErrDimensionMismatch unless square? end d = @pivot_sign @col_size.times do |j| d *= @lu[j][j] end d end alias_method :determinant, :det # Returns +m+ so that A*m = b, # or equivalently so that L*U*m = P*b # +b+ can be a Matrix or a Vector def solve b if (singular?) Matrix.Raise Matrix::ErrNotRegular, "Matrix is singular." end if b.is_a? Matrix if (b.row_size != @row_size) Matrix.Raise Matrix::ErrDimensionMismatch end # Copy right hand side with pivoting nx = b.column_size m = @pivots.map{|row| b.row(row).to_a} # Solve L*Y = P*b @col_size.times do |k| (k+1).upto(@col_size-1) do |i| nx.times do |j| m[i][j] -= m[k][j]*@lu[i][k] end end end # Solve U*m = Y (@col_size-1).downto(0) do |k| nx.times do |j| m[k][j] = m[k][j].quo(@lu[k][k]) end k.times do |i| nx.times do |j| m[i][j] -= m[k][j]*@lu[i][k] end end end Matrix.send :new, m, nx else # same algorithm, specialized for simpler case of a vector b = convert_to_array(b) if (b.size != @row_size) Matrix.Raise Matrix::ErrDimensionMismatch end # Copy right hand side with pivoting m = b.values_at(*@pivots) # Solve L*Y = P*b @col_size.times do |k| (k+1).upto(@col_size-1) do |i| m[i] -= m[k]*@lu[i][k] end end # Solve U*m = Y (@col_size-1).downto(0) do |k| m[k] = m[k].quo(@lu[k][k]) k.times do |i| m[i] -= m[k]*@lu[i][k] end end Vector.elements(m, false) end end def initialize a raise TypeError, "Expected Matrix but got #{a.class}" unless a.is_a?(Matrix) # Use a "left-looking", dot-product, Crout/Doolittle algorithm. @lu = a.to_a @row_size = a.row_size @col_size = a.column_size @pivots = Array.new(@row_size) @row_size.times do |i| @pivots[i] = i end @pivot_sign = 1 lu_col_j = Array.new(@row_size) # Outer loop. @col_size.times do |j| # Make a copy of the j-th column to localize references. @row_size.times do |i| lu_col_j[i] = @lu[i][j] end # Apply previous transformations. @row_size.times do |i| lu_row_i = @lu[i] # Most of the time is spent in the following dot product. kmax = [i, j].min s = 0 kmax.times do |k| s += lu_row_i[k]*lu_col_j[k] end lu_row_i[j] = lu_col_j[i] -= s end # Find pivot and exchange if necessary. p = j (j+1).upto(@row_size-1) do |i| if (lu_col_j[i].abs > lu_col_j[p].abs) p = i end end if (p != j) @col_size.times do |k| t = @lu[p][k]; @lu[p][k] = @lu[j][k]; @lu[j][k] = t end k = @pivots[p]; @pivots[p] = @pivots[j]; @pivots[j] = k @pivot_sign = -@pivot_sign end # Compute multipliers. if (j < @row_size && @lu[j][j] != 0) (j+1).upto(@row_size-1) do |i| @lu[i][j] = @lu[i][j].quo(@lu[j][j]) end end end end end end backports-3.3.5/lib/backports/1.9.2/stdlib/set.rb000066400000000000000000000005251222557024500213260ustar00rootroot00000000000000class Set def delete_if block_given? or return enum_for(__method__) to_a.each { |o| @hash.delete(o) if yield(o) } self end unless method_defined? :delete_if def keep_if block_given? or return enum_for(__method__) to_a.each { |o| @hash.delete(o) unless yield(o) } self end unless method_defined? :keep_if end backports-3.3.5/lib/backports/1.9.3.rb000066400000000000000000000001701222557024500172470ustar00rootroot00000000000000# require this file to load all the backports up to Ruby 1.9.3 require 'backports/1.9.2' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.3/000077500000000000000000000000001222557024500167245ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.3/file.rb000066400000000000000000000000721222557024500201670ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.3/file/000077500000000000000000000000001222557024500176435ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.3/file/null.rb000066400000000000000000000006121222557024500211410ustar00rootroot00000000000000unless File.const_defined? :NULL module File::Constants platform = RUBY_PLATFORM platform = RbConfig::CONFIG['host_os'] if platform == 'java' NULL = case platform when /mswin|mingw/i 'NUL' when /amiga/i 'NIL:' when /openvms/i 'NL:' else '/dev/null' end end end backports-3.3.5/lib/backports/1.9.3/io.rb000066400000000000000000000000721222557024500176570ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.3/io/000077500000000000000000000000001222557024500173335ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.3/io/advise.rb000066400000000000000000000011551222557024500211350ustar00rootroot00000000000000unless IO.method_defined? :advise require 'backports/tools' class IO def advise(advice, offset=0, len=0) raise RangeError if Backports.coerce_to_int(offset) >= 1<<31 raise RangeError if Backports.coerce_to_int(len) >= 1<<31 raise IOError if closed? case advice when :normal, :sequential, :random, :willneed, :dontneed, :noreuse return nil when Symbol raise NotImplementedError, "Unsupported advice #{advice}" else raise TypeError, "advice must be a Symbol" end end end end backports-3.3.5/lib/backports/1.9.3/io/binwrite.rb000066400000000000000000000003161222557024500215030ustar00rootroot00000000000000unless IO.respond_to? :binwrite require 'backports/tools' def IO.binwrite(name, string, offset = nil, options = Backports::Undefined) Backports.write(true, name, string, offset, options) end end backports-3.3.5/lib/backports/1.9.3/io/write.rb000066400000000000000000000003111222557024500210050ustar00rootroot00000000000000unless IO.respond_to? :write require 'backports/tools' def IO.write(name, string, offset = nil, options = Backports::Undefined) Backports.write(false, name, string, offset, options) end end backports-3.3.5/lib/backports/1.9.3/string.rb000066400000000000000000000000721222557024500205560ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/1.9.3/string/000077500000000000000000000000001222557024500202325ustar00rootroot00000000000000backports-3.3.5/lib/backports/1.9.3/string/byteslice.rb000066400000000000000000000022071222557024500225430ustar00rootroot00000000000000unless String.method_defined? :byteslice require 'backports/tools' class String def byteslice(start, len = Backports::Undefined) # Argument parsing & checking if Backports::Undefined == len if start.is_a?(Range) range = start start = Backports.coerce_to_int(range.begin) start += bytesize if start < 0 last = Backports.coerce_to_int(range.end) last += bytesize if last < 0 last += 1 unless range.exclude_end? len = last - start else start = Backports.coerce_to_int(start) start += bytesize if start < 0 len = 1 return if start >= bytesize end else start = Backports.coerce_to_int(start) start += bytesize if start < 0 len = Backports.coerce_to_int(len) return if len < 0 end return if start < 0 || start > bytesize len = 0 if len < 0 # Actual implementation: str = unpack("@#{start}a#{len}").first str = dup.replace(str) unless self.instance_of?(String) # Must return subclass str.force_encoding(encoding) end end end backports-3.3.5/lib/backports/1.9.3/string/prepend.rb000066400000000000000000000003031222557024500222100ustar00rootroot00000000000000unless String.method_defined? :prepend require 'backports/tools' class String def prepend(other_str) replace Backports.coerce_to_str(other_str) + self self end end end backports-3.3.5/lib/backports/1.9.rb000066400000000000000000000001261222557024500171070ustar00rootroot00000000000000# require this file to load all the backports of Ruby 1.9.x require 'backports/1.9.3' backports-3.3.5/lib/backports/2.0.0.rb000066400000000000000000000001661222557024500172410ustar00rootroot00000000000000# require this file to load all the backports up to Ruby 2.0.0 require 'backports/1.9' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/000077500000000000000000000000001222557024500167115ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/array.rb000066400000000000000000000000721222557024500203530ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/array/000077500000000000000000000000001222557024500200275ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/array/bsearch.rb000066400000000000000000000013741222557024500217700ustar00rootroot00000000000000unless Array.method_defined? :bsearch class Array def bsearch return to_enum(__method__) unless block_given? from = 0 to = size - 1 satisfied = nil while from <= to do midpoint = (from + to).div(2) result = yield(cur = self[midpoint]) case result when Numeric return cur if result == 0 result = result < 0 when true satisfied = cur when nil, false # nothing to do else raise TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)" end if result to = midpoint - 1 else from = midpoint + 1 end end satisfied end end end backports-3.3.5/lib/backports/2.0.0/enumerable.rb000066400000000000000000000000721222557024500213540ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/enumerable/000077500000000000000000000000001222557024500210305ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/enumerable/lazy.rb000066400000000000000000000167041222557024500223440ustar00rootroot00000000000000unless Enumerable.method_defined? :lazy require 'backports/tools' require 'backports/1.9.1/enumerator/new' module Enumerable def lazy klass = Enumerator::Lazy.send :class_variable_get, :@@lazy_with_no_block # Note: class_variable_get is private in 1.8 Enumerator::Lazy.new(klass.new(self, :each, [])) end end class Enumerator class Yielder # Current API for Lazy Enumerator does not provide an easy way # to handle internal state. We "cheat" and use yielder to hold it for us. # A new yielder is created when generating or after a `rewind`. # This way we avoid issues like http://bugs.ruby-lang.org/issues/7691 # or http://bugs.ruby-lang.org/issues/7696 attr_accessor :backports_memo end class Lazy < Enumerator @@done = :__backports_lazy_enumeration_done__ # used internally to bail out of an iteration @@lazy_with_no_block = Struct.new(:object, :method, :args) # used internally to create lazy without block def initialize(obj) if obj.is_a?(@@lazy_with_no_block) @inspect_info = obj return super(@receiver = obj.object, @method = obj.method || :each, * @args = obj.args) end raise ArgumentError, "must supply a block" unless block_given? @receiver = obj super() do |yielder, *args| catch @@done do obj.each(*args) do |*x| yield yielder, *x end end end end alias_method :force, :to_a def lazy self end def to_enum(method = :each, *args) Lazy.new(@@lazy_with_no_block.new(self, method, args)) end alias_method :enum_for, :to_enum def inspect suff = '' suff << ":#{@method}" unless @method.nil? || @method == :each suff << "(#{@args.inspect[1...-1]})" if @args && !@args.empty? "#<#{self.class}: #{@receiver.inspect}#{suff}>" end { :slice_before => //, :with_index => [], :cycle => [], :each_with_object => 42, :each_slice => 42, :each_entry => [], :each_cons => 42, }.each do |method, args| next unless Enumerator.method_defined? method unless [].lazy.send(method, *args).is_a?(Lazy) # Nothing to do if already backported, since it would use to_enum... module_eval <<-EOT, __FILE__, __LINE__ + 1 def #{method}(*args) # def cycle(*args) return to_enum(:#{method}, *args) unless block_given? # return to_enum(:cycle, *args) unless block_given? super # super end # end EOT end end def chunk(*) super.lazy end if Enumerable.method_defined?(:chunk) && ![].lazy.chunk{}.is_a?(Lazy) def map raise ArgumentError, "tried to call lazy map without a block" unless block_given? Lazy.new(self) do |yielder, *values| yielder << yield(*values) end.__set_inspect :map end alias_method :collect, :map def select raise ArgumentError, "tried to call lazy select without a block" unless block_given? Lazy.new(self) do |yielder, *values| values = values.first unless values.size > 1 yielder.yield values if yield values end.__set_inspect :select end alias_method :find_all, :select def reject raise ArgumentError, "tried to call lazy reject without a block" unless block_given? Lazy.new(self) do |yielder, *values| values = values.first unless values.size > 1 yielder.yield(values) unless yield values end.__set_inspect :reject end def grep(pattern) if block_given? # Split for performance Lazy.new(self) do |yielder, *values| values = values.first unless values.size > 1 yielder.yield(yield(values)) if pattern === values end else Lazy.new(self) do |yielder, *values| values = values.first unless values.size > 1 yielder.yield(values) if pattern === values end end.__set_inspect :grep, [pattern] end def drop(n) n = Backports::coerce_to_int(n) Lazy.new(self) do |yielder, *values| data = yielder.backports_memo ||= {:remain => n} if data[:remain] > 0 data[:remain] -= 1 else yielder.yield(*values) end end.__set_inspect :drop, [n] end def drop_while raise ArgumentError, "tried to call lazy drop_while without a block" unless block_given? Lazy.new(self) do |yielder, *values| data = yielder.backports_memo ||= {:dropping => true} yielder.yield(*values) unless data[:dropping] &&= yield(*values) end.__set_inspect :drop_while end def take(n) n = Backports::coerce_to_int(n) raise ArgumentError, 'attempt to take negative size' if n < 0 Lazy.new(n == 0 ? [] : self) do |yielder, *values| data = yielder.backports_memo ||= {:remain => n} yielder.yield(*values) throw @@done if (data[:remain] -= 1) == 0 end.__set_inspect :take, [n], self end def take_while raise ArgumentError, "tried to call lazy take_while without a block" unless block_given? Lazy.new(self) do |yielder, *values| throw @@done unless yield(*values) yielder.yield(*values) end.__set_inspect :take_while end def flat_map raise ArgumentError, "tried to call lazy flat_map without a block" unless block_given? Lazy.new(self) do |yielder, *values| result = yield(*values) ary = Backports.is_array?(result) if ary || (result.respond_to?(:each) && result.respond_to?(:force)) (ary || result).each{|x| yielder << x } else yielder << result end end.__set_inspect :flat_map end alias_method :collect_concat, :flat_map def zip(*args) return super if block_given? arys = args.map{ |arg| Backports.is_array?(arg) } if arys.all? # Handle trivial case of multiple array arguments separately # by avoiding Enumerator#next for efficiency & compatibility Lazy.new(self) do |yielder, *values| data = yielder.backports_memo ||= {:iter => 0} values = values.first unless values.size > 1 yielder << arys.map{|ary| ary[data[:iter]]}.unshift(values) data[:iter] += 1 end else args.each do |a| raise TypeError, "wrong argument type #{a.class} (must respond to :each)" unless a.respond_to? :each end Lazy.new(self) do |yielder, *values| enums = yielder.backports_memo ||= args.map(&:to_enum) values = values.first unless values.size > 1 others = enums.map do |arg| begin arg.next rescue StopIteration nil end end yielder << others.unshift(values) end end.__set_inspect :zip, args end protected def __set_inspect(method, args = nil, receiver = nil) @method = method @args = args @receiver = receiver if receiver self end end end end backports-3.3.5/lib/backports/2.0.0/enumerator.rb000066400000000000000000000000721222557024500214160ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/enumerator/000077500000000000000000000000001222557024500210725ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/enumerator/lazy.rb000066400000000000000000000000521222557024500223730ustar00rootroot00000000000000require 'backports/2.0.0/enumerable/lazy' backports-3.3.5/lib/backports/2.0.0/env.rb000066400000000000000000000000721222557024500200250ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/env/000077500000000000000000000000001222557024500175015ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/env/to_h.rb000066400000000000000000000001271222557024500207570ustar00rootroot00000000000000unless ENV.respond_to? :to_h class << ENV alias_method :to_h, :to_hash end end backports-3.3.5/lib/backports/2.0.0/hash.rb000066400000000000000000000000721222557024500201600ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/hash/000077500000000000000000000000001222557024500176345ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/hash/default_proc.rb000066400000000000000000000005641222557024500226350ustar00rootroot00000000000000if (({}.default_proc = nil) rescue true) require 'backports/tools' require 'backports/1.9.1/hash/default_proc' class Hash def default_proc_with_nil=(proc) if proc == nil self.default = nil self else self.default_proc_without_nil=(proc) end end Backports.alias_method_chain(self, :default_proc=, :nil) end end backports-3.3.5/lib/backports/2.0.0/hash/to_h.rb000066400000000000000000000002011222557024500211030ustar00rootroot00000000000000unless Hash.method_defined? :to_h class Hash def to_h self.class == Hash ? self : {}.replace(self) end end end backports-3.3.5/lib/backports/2.0.0/nil.rb000066400000000000000000000000721222557024500200170ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/nil/000077500000000000000000000000001222557024500174735ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/nil/to_h.rb000066400000000000000000000001371222557024500207520ustar00rootroot00000000000000unless NilClass.method_defined? :to_h class NilClass def to_h {} end end end backports-3.3.5/lib/backports/2.0.0/range.rb000066400000000000000000000000721222557024500203310ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/range/000077500000000000000000000000001222557024500200055ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/range/bsearch.rb000066400000000000000000000024651222557024500217500ustar00rootroot00000000000000unless Range.method_defined? :bsearch class Range def bsearch return to_enum(:bsearch) unless block_given? from = self.begin to = self.end unless from.is_a?(Numeric) && to.is_a?(Numeric) raise TypeError, "can't do binary search for #{from.class}" end midpoint = nil if from.is_a?(Integer) && to.is_a?(Integer) convert = Proc.new{ midpoint } else map = Proc.new do |pk, unpk, nb| result, = [nb.abs].pack(pk).unpack(unpk) nb < 0 ? -result : result end from = map['D', 'q', to.to_f] to = map['D', 'q', to.to_f] convert = Proc.new{ map['q', 'D', midpoint] } end to -= 1 if exclude_end? satisfied = nil while from <= to do midpoint = (from + to).div(2) result = yield(cur = convert.call) case result when Numeric return cur if result == 0 result = result < 0 when true satisfied = cur when nil, false # nothing to do else raise TypeError, "wrong argument type #{result.class} (must be numeric, true, false or nil)" end if result to = midpoint - 1 else from = midpoint + 1 end end satisfied end end end backports-3.3.5/lib/backports/2.0.0/stdlib.rb000066400000000000000000000000421222557024500205130ustar00rootroot00000000000000Backports::StdLib.extend_relative backports-3.3.5/lib/backports/2.0.0/stdlib/000077500000000000000000000000001222557024500201725ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/stdlib/abbrev.rb000066400000000000000000000000671222557024500217630ustar00rootroot00000000000000# For testing purposes only, see _backport_guards_test backports-3.3.5/lib/backports/2.0.0/stdlib/fake_stdlib_lib.rb000066400000000000000000000000671222557024500236170ustar00rootroot00000000000000# For testing purposes only, see _backport_guards_test backports-3.3.5/lib/backports/2.0.0/stdlib/ostruct.rb000066400000000000000000000011311222557024500222160ustar00rootroot00000000000000class OpenStruct def [](name) @table[name.to_sym] end unless method_defined? :[] def []=(name, value) modifiable[new_ostruct_member(name)] = value end unless method_defined? :[]= def eql?(other) return false unless other.kind_of?(OpenStruct) @table.eql?(other.table) end unless method_defined? :eql? def hash @table.hash end unless method_defined? :hash def each_pair return to_enum(:each_pair) unless block_given? @table.each_pair{|p| yield p} end unless method_defined? :each_pair def to_h @table.dup end unless method_defined? :to_h end backports-3.3.5/lib/backports/2.0.0/struct.rb000066400000000000000000000000721222557024500205610ustar00rootroot00000000000000require 'backports/tools' Backports.require_relative_dir backports-3.3.5/lib/backports/2.0.0/struct/000077500000000000000000000000001222557024500202355ustar00rootroot00000000000000backports-3.3.5/lib/backports/2.0.0/struct/to_h.rb000066400000000000000000000002401222557024500215070ustar00rootroot00000000000000unless Struct.method_defined? :to_h class Struct def to_h h = {} self.class.members.each{|m| h[m.to_sym] = self[m]} h end end end backports-3.3.5/lib/backports/2.0.rb000066400000000000000000000001261222557024500170770ustar00rootroot00000000000000# require this file to load all the backports of Ruby 2.0.x require 'backports/2.0.0' backports-3.3.5/lib/backports/basic_object.rb000066400000000000000000000037701222557024500212170ustar00rootroot00000000000000# Note: Must be required explicitely! # This is a best attempt to fake BasicObject in Ruby 1.8.x # What you do get: # * as few methods as the real BasicObject (at the moment the library is required...) # * BasicObject === # ==> returns true # What you don't get: # * BasicObject is not in the ancestor list of all classes and thus # * Comparisons between classes won't work, e.g. # Object < BasicObject # ==> returns true instead of false # * Instance methods added to Object or Kernel after you require 'backports/basic_object' # might also be available in instances of BasicObject and subclasses # (they will only be undefined whenever a subclass of BasicObject is created) # Because of all the fineprint, BasicObject must be required explicitely unless Object.const_defined? :BasicObject class BasicObject KEEP = %w[== equal? ! != instance_eval instance_exec __send__] KEEP.concat KEEP.map { |e| e.to_sym } # undefine almost all instance methods begin old_verbose, $VERBOSE = $VERBOSE, nil # silence the warning for undefining __id__ (instance_methods - KEEP).each do |method| undef_method method end ensure $VERBOSE = old_verbose end class << self def === (cmp) true end # Let's try to keep things clean, in case methods have been added to Object # either directly or through an included module. # We'll do this whenever a class is derived from BasicObject # Ideally, we'd do this by trapping Object.method_added # and M.method_added for any module M included in Object or a submodule # Seems really though to get right, but pull requests welcome ;-) def inherited(sub) BasicObject.class_eval do (instance_methods - KEEP).each do |method| if Object.method_defined?(method) && instance_method(method).owner == Object.instance_method(method).owner undef_method method end end end end end end end backports-3.3.5/lib/backports/extra/000077500000000000000000000000001222557024500173775ustar00rootroot00000000000000backports-3.3.5/lib/backports/extra/random/000077500000000000000000000000001222557024500206575ustar00rootroot00000000000000backports-3.3.5/lib/backports/extra/random/MT19937.rb000066400000000000000000000042511222557024500221430ustar00rootroot00000000000000class Random # An implementation of Mersenne Twister MT19937 in Ruby class MT19937 STATE_SIZE = 624 LAST_STATE = STATE_SIZE - 1 PAD_32_BITS = 0xffffffff # See seed= def initialize(seed) self.seed = seed end LAST_31_BITS = 0x7fffffff OFFSET = 397 # Generates a completely new state out of the previous one. def next_state STATE_SIZE.times do |i| mix = @state[i] & 0x80000000 | @state[i+1 - STATE_SIZE] & 0x7fffffff @state[i] = @state[i+OFFSET - STATE_SIZE] ^ (mix >> 1) @state[i] ^= 0x9908b0df if mix.odd? end @last_read = -1 end # Seed must be either an Integer (only the first 32 bits will be used) # or an Array of Integers (of which only the first 32 bits will be used) # # No conversion or type checking is done at this level def seed=(seed) case seed when Integer @state = Array.new(STATE_SIZE) @state[0] = seed & PAD_32_BITS (1..LAST_STATE).each do |i| @state[i] = (1812433253 * (@state[i-1] ^ @state[i-1]>>30) + i)& PAD_32_BITS end @last_read = LAST_STATE when Array self.seed = 19650218 i=1 j=0 [STATE_SIZE, seed.size].max.times do @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1664525) + j + seed[j] & PAD_32_BITS if (i+=1) >= STATE_SIZE @state[0] = @state[-1] i = 1 end j = 0 if (j+=1) >= seed.size end (STATE_SIZE-1).times do @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1566083941) - i & PAD_32_BITS if (i+=1) >= STATE_SIZE @state[0] = @state[-1] i = 1 end end @state[0] = 0x80000000 else raise ArgumentError, "Seed must be an Integer or an Array" end end # Returns a random Integer from the range 0 ... (1 << 32) def random_32_bits next_state if @last_read >= LAST_STATE @last_read += 1 y = @state[@last_read] # Tempering y ^= (y >> 11) y ^= (y << 7) & 0x9d2c5680 y ^= (y << 15) & 0xefc60000 y ^= (y >> 18) end end end backports-3.3.5/lib/backports/extra/random/bits_and_bytes.rb000066400000000000000000000042271222557024500242020ustar00rootroot00000000000000class Random # Supplement the MT19937 class with methods to do # conversions the same way as MRI. # No argument checking is done here either. class MT19937 FLOAT_FACTOR = 1.0/9007199254740992.0 # generates a random number on [0,1) with 53-bit resolution def random_float ((random_32_bits >> 5) * 67108864.0 + (random_32_bits >> 6)) * FLOAT_FACTOR; end # Returns an integer within 0...upto def random_integer(upto) n = upto - 1 nb_full_32 = 0 while n > PAD_32_BITS n >>= 32 nb_full_32 += 1 end mask = mask_32_bits(n) begin rand = random_32_bits & mask nb_full_32.times do rand <<= 32 rand |= random_32_bits end end until rand < upto rand end def random_bytes(nb) nb_32_bits = (nb + 3) / 4 random = nb_32_bits.times.map { random_32_bits } random.pack("L" * nb_32_bits)[0, nb] end def state_as_bignum b = 0 @state.each_with_index do |val, i| b |= val << (32 * i) end b end def left # It's actually the number of words left + 1, as per MRI... MT19937::STATE_SIZE - @last_read end def marshal_dump [state_as_bignum, left] end def marshal_load(ary) b, left = ary @last_read = MT19937::STATE_SIZE - left @state = Array.new(STATE_SIZE) STATE_SIZE.times do |i| @state[i] = b & PAD_32_BITS b >>= 32 end end # Convert an Integer seed of arbitrary size to either a single 32 bit integer, or an Array of 32 bit integers def self.convert_seed(seed) seed = seed.abs long_values = [] begin long_values << (seed & PAD_32_BITS) seed >>= 32 end until seed == 0 long_values.pop if long_values[-1] == 1 && long_values.size > 1 # Done to allow any kind of sequence of integers long_values.size > 1 ? long_values : long_values.first end def self.[](seed) new(convert_seed(seed)) end private MASK_BY = [1,2,4,8,16] def mask_32_bits(n) MASK_BY.each do |shift| n |= n >> shift end n end end end backports-3.3.5/lib/backports/extra/random/implementation.rb000066400000000000000000000046041222557024500242350ustar00rootroot00000000000000class Random # Implementation corresponding to the actual Random class of Ruby # The actual random generator (mersenne twister) is in MT19937. # Ruby specific conversions are handled in bits_and_bytes. # The high level stuff (argument checking) is done here. # module Implementation attr_reader :seed def initialize(seed = 0) super() srand(seed) end def srand(new_seed = 0) new_seed = Backports.coerce_to_int(new_seed) old, @seed = @seed, new_seed.nonzero? || Random.new_seed @mt = MT19937[ @seed ] old end def rand(limit = Backports::Undefined) case limit when Backports::Undefined @mt.random_float when Float limit * @mt.random_float unless limit <= 0 when Range _rand_range(limit) else limit = Backports.coerce_to_int(limit) @mt.random_integer(limit) unless limit <= 0 end || raise(ArgumentError, "invalid argument #{limit}") end def bytes(nb) nb = Backports.coerce_to_int(nb) raise ArgumentError, "negative size" if nb < 0 @mt.random_bytes(nb) end def ==(other) other.is_a?(Random) && seed == other.seed && left == other.send(:left) && state == other.send(:state) end def marshal_dump @mt.marshal_dump << @seed end def marshal_load(ary) @seed = ary.pop @mt = MT19937.allocate @mt.marshal_load(ary) end private def state @mt.state_as_bignum end def left @mt.left end def _rand_range(limit) range = limit.end - limit.begin if (!range.is_a?(Float)) && range.respond_to?(:to_int) && range = Backports.coerce_to_int(range) range += 1 unless limit.exclude_end? limit.begin + @mt.random_integer(range) unless range <= 0 elsif range = Backports.coerce_to(range, Float, :to_f) if range < 0 nil elsif limit.exclude_end? limit.begin + @mt.random_float * range unless range <= 0 else # cheat a bit... this will reduce the nb of random bits loop do r = @mt.random_float * range * 1.0001 break limit.begin + r unless r > range end end end end end def self.new_seed Kernel::srand # use the built-in seed generator Kernel::srand # return the generated seed end end backports-3.3.5/lib/backports/extra/random/load.rb000066400000000000000000000005061222557024500221240ustar00rootroot00000000000000require "backports/tools" require "backports/extra/random/MT19937" require "backports/extra/random/bits_and_bytes" require "backports/extra/random/implementation" class Random include Implementation class << self include Implementation end def inspect "#<#{self.class.name}:#{object_id}>" end srand end backports-3.3.5/lib/backports/force/000077500000000000000000000000001222557024500173525ustar00rootroot00000000000000backports-3.3.5/lib/backports/force/array_map.rb000066400000000000000000000000511222557024500216460ustar00rootroot00000000000000require 'backports/force/enumerable_map' backports-3.3.5/lib/backports/force/enumerable_map.rb000066400000000000000000000002001222557024500226430ustar00rootroot00000000000000Backports.make_block_optional Enumerable, :map, :test_on => 1..2 Backports.make_block_optional Array, :map, :test_on => [1, 2] backports-3.3.5/lib/backports/force/hash_select.rb000066400000000000000000000003771222557024500221700ustar00rootroot00000000000000class Hash if {}.select{} == [] def select_with_hash_return return to_enum(:select) unless block_given? Hash[select_without_hash_return{|k, v| yield [k, v]}] end Backports.alias_method_chain self, :select, :hash_return end end backports-3.3.5/lib/backports/force/string_length.rb000066400000000000000000000002641222557024500225500ustar00rootroot00000000000000# encoding: utf-8 class String if "é".length > 1 && "é".scan(/./).length == 1 def length unpack("U*").length end alias_method :size, :length end end backports-3.3.5/lib/backports/force/string_size.rb000066400000000000000000000000501222557024500222320ustar00rootroot00000000000000require 'backports/force/string_length' backports-3.3.5/lib/backports/rails.rb000066400000000000000000000001761222557024500177170ustar00rootroot00000000000000require "backports/tools" %w(array enumerable hash kernel module string).each do |lib| require "backports/rails/#{lib}" end backports-3.3.5/lib/backports/rails/000077500000000000000000000000001222557024500173665ustar00rootroot00000000000000backports-3.3.5/lib/backports/rails/array.rb000066400000000000000000000003621222557024500210320ustar00rootroot00000000000000class Array # See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Array/ExtractOptions.html] def extract_options! last.is_a?(::Hash) ? pop : {} end unless method_defined? :extract_options! end backports-3.3.5/lib/backports/rails/enumerable.rb000066400000000000000000000005601222557024500220330ustar00rootroot00000000000000module Enumerable # Standard in rails... See official documentation[http://api.rubyonrails.org/classes/Enumerable.html] # Modified from rails 2.3 to not rely on size def sum(identity = 0, &block) if block_given? map(&block).sum(identity) else inject { |sum, element| sum + element } || identity end end unless method_defined? :sum end backports-3.3.5/lib/backports/rails/hash.rb000066400000000000000000000027061222557024500206430ustar00rootroot00000000000000class Hash # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html] def reverse_merge(other_hash) other_hash.merge(self) end unless method_defined? :reverse_merge # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html] def reverse_merge!(other_hash) replace(reverse_merge(other_hash)) end unless method_defined? :reverse_merge! # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html] def symbolize_keys Hash[map{|key,value| [(key.to_sym rescue key) || key, value] }] end unless method_defined? :symbolize_keys # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html] def symbolize_keys! self.replace(self.symbolize_keys) end unless method_defined? :symbolize_keys! # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html] def stringify_keys Hash[map{|key,value| [key.to_s, value] }] end unless method_defined? :stringify_keys # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html] def stringify_keys! self.replace(self.stringify_keys) end unless method_defined? :stringify_keys! end backports-3.3.5/lib/backports/rails/kernel.rb000066400000000000000000000003551222557024500211760ustar00rootroot00000000000000class Object # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/Object.html] def try(method_id, *args, &block) send(method_id, *args, &block) unless self.nil? end unless method_defined? :try end backports-3.3.5/lib/backports/rails/module.rb000066400000000000000000000004651222557024500212050ustar00rootroot00000000000000class Module # Standard in rails... See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Module.html] def alias_method_chain(target, feature, &block) Backports.alias_method_chain(self, target, feature, &block) end unless method_defined? :alias_method_chain end backports-3.3.5/lib/backports/rails/string.rb000066400000000000000000000031311222557024500212170ustar00rootroot00000000000000class String # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html] def camelize(first_letter = :upper) if first_letter == :upper gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } else self[0..0].downcase + camelize[1..-1] end end unless method_defined? :camelize # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html] def constantize names = split('::') names.shift if names.empty? || names.first.empty? constant = Object names.each do |name| constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name) end constant end unless method_defined? :constantize # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html] def dasherize gsub(/_/, '-') end unless method_defined? :dasherize # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html] def demodulize gsub(/^.*::/, '') end unless method_defined? :demodulize # Standard in rails. See official documentation[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html] def underscore gsub(/::/, '/'). gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2'). gsub(/([a-z\d])([A-Z])/,'\1_\2'). tr("-", "_"). downcase end unless method_defined? :underscore end backports-3.3.5/lib/backports/tools.rb000066400000000000000000000275211222557024500177500ustar00rootroot00000000000000# Methods used internally by the backports. module Backports MOST_EXTREME_OBJECT_EVER = Object.new # :nodoc: class << MOST_EXTREME_OBJECT_EVER def < (whatever) true end def > (whatever) true end end def self.require_relative_dir dir = caller.first.split(/\.rb:\d/,2).first short_path = dir[/.*(backports\/.*)/, 1] << '/' Dir.entries(dir). map{|f| Regexp.last_match(1) if /^(.*)\.rb$/ =~ f}. compact. sort. each do |f| require short_path + f end end module StdLib class LoadedFeatures if RUBY_VERSION >= "1.9" # Full paths are recorded in $LOADED_FEATURES. @@our_loads = {} # Check loaded features for one that matches "#{any of the load path}/#{feature}" def include?(feature) return true if @@our_loads[feature] # Assume backported features are Ruby libraries (i.e. not C) @loaded ||= $LOADED_FEATURES.group_by{|p| File.basename(p, ".rb")} if fullpaths = @loaded[File.basename(feature, ".rb")] fullpaths.any?{|fullpath| base_dir, = fullpath.partition("/#{feature}") $LOAD_PATH.include?(base_dir) } end end def self.mark_as_loaded(feature) @@our_loads[feature] = true # Nothing to do, the full path will be OK end else # Requested features are recorded in $LOADED_FEATURES def include?(feature) # Assume backported features are Ruby libraries (i.e. not C) $LOADED_FEATURES.include?("#{File.basename(feature, '.rb')}.rb") end def self.mark_as_loaded(feature) $LOADED_FEATURES << "#{File.basename(feature, '.rb')}.rb" end end end class << self attr_accessor :extended_lib def extend_relative relative_dir="stdlib" loaded = Backports::StdLib::LoadedFeatures.new dir = File.expand_path(relative_dir, File.dirname(caller.first.split(/:\d/,2).first)) Dir.entries(dir). map{|f| Regexp.last_match(1) if /^(.*)\.rb$/ =~ f}. compact. each do |f| path = File.expand_path(f, dir) if loaded.include?(f) require path else @extended_lib[f] << path end end end end self.extended_lib ||= Hash.new{|h, k| h[k] = []} end # Metaprogramming utility to make block optional. # Tests first if block is already optional when given options def self.make_block_optional(mod, *methods) mod = class << mod; self; end unless mod.is_a? Module options = methods.last.is_a?(Hash) ? methods.pop : {} methods.each do |selector| unless mod.method_defined? selector warn "#{mod}##{selector} is not defined, so block can't be made optional" next end unless options[:force] # Check if needed test_on = options.fetch(:test_on) result = begin test_on.send(selector, *options.fetch(:arg, [])) rescue LocalJumpError false end next if result.class.name =~ /Enumerator$/ end require 'enumerator' arity = mod.instance_method(selector).arity last_arg = [] if arity < 0 last_arg = ["*rest"] arity = -1-arity end arg_sequence = ((0...arity).map{|i| "arg_#{i}"} + last_arg + ["&block"]).join(", ") alias_method_chain(mod, selector, :optional_block) do |aliased_target, punctuation| mod.module_eval <<-end_eval, __FILE__, __LINE__ + 1 def #{aliased_target}_with_optional_block#{punctuation}(#{arg_sequence}) return to_enum(:#{aliased_target}_without_optional_block#{punctuation}, #{arg_sequence}) unless block_given? #{aliased_target}_without_optional_block#{punctuation}(#{arg_sequence}) end end_eval end end end # Metaprogramming utility to convert the first file argument to path def self.convert_first_argument_to_path(klass, selector) mod = class << klass; self; end unless mod.method_defined? selector warn "#{mod}##{selector} is not defined, so argument can't converted to path" return end arity = mod.instance_method(selector).arity last_arg = [] if arity < 0 last_arg = ["*rest"] arity = -1-arity end arg_sequence = (["file"] + (1...arity).map{|i| "arg_#{i}"} + last_arg + ["&block"]).join(", ") alias_method_chain(mod, selector, :potential_path_argument) do |aliased_target, punctuation| mod.module_eval <<-end_eval, __FILE__, __LINE__ + 1 def #{aliased_target}_with_potential_path_argument#{punctuation}(#{arg_sequence}) file = Backports.convert_path(file) #{aliased_target}_without_potential_path_argument#{punctuation}(#{arg_sequence}) end end_eval end end # Metaprogramming utility to convert all file arguments to paths def self.convert_all_arguments_to_path(klass, selector, skip) mod = class << klass; self; end unless mod.method_defined? selector warn "#{mod}##{selector} is not defined, so arguments can't converted to path" return end first_args = (1..skip).map{|i| "arg_#{i}"}.join(",") + (skip > 0 ? "," : "") alias_method_chain(mod, selector, :potential_path_arguments) do |aliased_target, punctuation| mod.module_eval <<-end_eval, __FILE__, __LINE__ + 1 def #{aliased_target}_with_potential_path_arguments#{punctuation}(#{first_args}*files, &block) files = files.map{|f| Backports.convert_path(f) } #{aliased_target}_without_potential_path_arguments#{punctuation}(#{first_args}*files, &block) end end_eval end end def self.convert_path(path) try_convert(path, IO, :to_io) || begin path = path.to_path if path.respond_to?(:to_path) try_convert(path, String, :to_str) || path end end # Modified to avoid polluting Module if so desired # (from Rails) def self.alias_method_chain(mod, target, feature) mod.class_eval do # Strip out punctuation on predicates or bang methods since # e.g. target?_without_feature is not a valid method name. aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1 yield(aliased_target, punctuation) if block_given? with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}" alias_method without_method, target alias_method target, with_method case when public_method_defined?(without_method) public target when protected_method_defined?(without_method) protected target when private_method_defined?(without_method) private target end end end # Helper method to coerce a value into a specific class. # Raises a TypeError if the coercion fails or the returned value # is not of the right class. # (from Rubinius) def self.coerce_to(obj, cls, meth) return obj if obj.kind_of?(cls) begin ret = obj.__send__(meth) rescue Exception => e raise TypeError, "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed:\n" \ "(#{e.message})" end raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})" unless ret.kind_of? cls ret end def self.coerce_to_int(obj) coerce_to(obj, Integer, :to_int) end def self.coerce_to_ary(obj) coerce_to(obj, Array, :to_ary) end def self.coerce_to_str(obj) coerce_to(obj, String, :to_str) end def self.is_array?(obj) coerce_to(obj, Array, :to_ary) if obj.respond_to? :to_ary end def self.try_convert(obj, cls, meth) return obj if obj.kind_of?(cls) return nil unless obj.respond_to?(meth) ret = obj.__send__(meth) raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})" unless ret.nil? || ret.kind_of?(cls) ret end # Checks for a failed comparison (in which case it throws an ArgumentError) # Additionally, it maps any negative value to -1 and any positive value to +1 # (from Rubinius) def self.coerce_to_comparison(a, b, cmp = (a <=> b)) raise ArgumentError, "comparison of #{a} with #{b} failed" if cmp.nil? return 1 if cmp > 0 return -1 if cmp < 0 0 end # Used internally to make it easy to deal with optional arguments # (from Rubinius) Undefined = Object.new # Used internally. # Safe alias_method that will only alias if the source exists and destination doesn't def self.alias_method(mod, new_name, old_name) mod.instance_eval do alias_method new_name, old_name end if mod.method_defined?(old_name) && !mod.method_defined?(new_name) end # Used internally to combine {IO|File} options hash into mode (String or Integer) def self.combine_mode_and_option(mode = nil, options = Backports::Undefined) # Can't backport autoclose, {internal|external|}encoding mode, options = nil, mode if mode.respond_to?(:to_hash) and options == Backports::Undefined options = {} if options == nil || options == Backports::Undefined options = coerce_to(options, Hash, :to_hash) if mode && options[:mode] raise ArgumentError, "mode specified twice" end mode ||= options[:mode] || "r" mode = try_convert(mode, String, :to_str) || try_convert(mode, Integer, :to_int) || mode if options[:textmode] || options[:binmode] text = options[:textmode] || (mode.is_a?(String) && mode =~ /t/) bin = options[:binmode] || (mode.is_a?(String) ? mode =~ /b/ : mode & File::Constants::BINARY != 0) if text && bin raise ArgumentError, "both textmode and binmode specified" end case when !options[:binmode] when mode.is_a?(String) mode.insert(1, "b") else mode |= File::Constants::BINARY end end mode end # Used internally to combine {IO|File} options hash into mode (String or Integer) and perm def self.combine_mode_perm_and_option(mode = nil, perm = Backports::Undefined, options = Backports::Undefined) mode, options = nil, mode if mode.is_a?(Hash) and perm == Backports::Undefined perm, options = nil, perm if perm.is_a?(Hash) and options == Backports::Undefined perm = nil if perm == Backports::Undefined options = {} if options == Backports::Undefined if perm && options[:perm] raise ArgumentError, "perm specified twice" end [combine_mode_and_option(mode, options), perm || options[:perm]] end def self.write(binary, filename, string, offset, options) offset, options = nil, offset if Hash === offset and options == Backports::Undefined options = {} if options == Backports::Undefined File.open(filename, 'a+'){} if offset # insure existence options = {:mode => offset.nil? ? "w" : "r+"}.merge(options) args = options[:open_args] || [options] File.open(filename, *Backports.combine_mode_perm_and_option(*args)) do |f| f.binmode if binary && f.respond_to?(:binmode) f.seek(offset) unless offset.nil? f.write(string) end end def self.suppress_verbose_warnings before = $VERBOSE $VERBOSE = false if $VERBOSE # Set to false (default warning) but not nil (no warnings) yield ensure $VERBOSE = before end end module Kernel def require_with_backports(lib) begin return false unless require_without_backports(lib) paths = Backports::StdLib.extended_lib.fetch(lib, nil) rescue LoadError return false if Backports::StdLib::LoadedFeatures.new.include?(lib) raise unless paths = Backports::StdLib.extended_lib.fetch(lib, nil) Backports::StdLib::LoadedFeatures.mark_as_loaded(lib) end if paths paths.each do |path| require_without_backports(path) end end true end Backports.alias_method_chain self, :require, :backports end backports-3.3.5/lib/backports/version.rb000066400000000000000000000002151222557024500202640ustar00rootroot00000000000000module Backports VERSION = "3.3.5" unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis end backports-3.3.5/set_version/000077500000000000000000000000001222557024500160565ustar00rootroot00000000000000backports-3.3.5/set_version/1.8.7.rb000066400000000000000000000000751222557024500170600ustar00rootroot00000000000000require File.expand_path(File.dirname(__FILE__) + "/setter") backports-3.3.5/set_version/1.9.1.rb000066400000000000000000000000751222557024500170530ustar00rootroot00000000000000require File.expand_path(File.dirname(__FILE__) + "/setter") backports-3.3.5/set_version/1.9.2.rb000066400000000000000000000000751222557024500170540ustar00rootroot00000000000000require File.expand_path(File.dirname(__FILE__) + "/setter") backports-3.3.5/set_version/1.9.3.rb000066400000000000000000000000751222557024500170550ustar00rootroot00000000000000require File.expand_path(File.dirname(__FILE__) + "/setter") backports-3.3.5/set_version/2.0.0.rb000066400000000000000000000000751222557024500170420ustar00rootroot00000000000000require File.expand_path(File.dirname(__FILE__) + "/setter") backports-3.3.5/set_version/setter.rb000066400000000000000000000007571222557024500177220ustar00rootroot00000000000000module Backports TARGET_VERSION = caller.each{|c| break $1 if c =~ /set_version\/(\d\.\d\.\d)\.rb/} end unless Object.const_defined?(:Enumerator) || Backports::TARGET_VERSION < '1.9' require 'enumerator' # Needed for mspec: Enumerator = Enumerable::Enumerator end if RUBY_VERSION < Backports::TARGET_VERSION && Backports::TARGET_VERSION >= '1.9' require 'backports/1.9.2/float/infinity.rb' # Used in many specs... require 'backports/1.9.2/float/nan.rb' # Used in many specs... end backports-3.3.5/spec/000077500000000000000000000000001222557024500144505ustar00rootroot00000000000000backports-3.3.5/spec/rubyspec/000077500000000000000000000000001222557024500163045ustar00rootroot00000000000000backports-3.3.5/spec/tags/000077500000000000000000000000001222557024500154065ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/000077500000000000000000000000001222557024500160605ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/000077500000000000000000000000001222557024500170105ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/array/000077500000000000000000000000001222557024500201265ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/array/rotate_spec.rb000066400000000000000000000001761222557024500227670ustar00rootroot00000000000000fails:Array#rotate returns subclass instance for Array subclasses fails:Array#rotate! raises a RuntimeError on a frozen array backports-3.3.5/spec/tags/1.8.6/core/array/uniq_spec.rb000066400000000000000000000003631222557024500224430ustar00rootroot00000000000000fails:Array#uniq! raises a RuntimeError on a frozen array when the array is modified fails:Array#uniq! raises a RuntimeError on a frozen array when the array would not be modified fails:Array#uniq! doesn't yield to the block on a frozen array backports-3.3.5/spec/tags/1.8.6/core/complex/000077500000000000000000000000001222557024500204575ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/complex/to_r_spec.rb000066400000000000000000000005261222557024500227640ustar00rootroot00000000000000fails:Complex#to_r when the imaginary part is Fixnum 0 returns the result of sending #to_r to the real part fails:Complex#to_r when the imaginary part is Rational 0 returns the result of sending #to_r to the real part fails:Complex#to_r when the imaginary part responds to #== 0 with true returns the result of sending #to_r to the real part backports-3.3.5/spec/tags/1.8.6/core/enumerable/000077500000000000000000000000001222557024500211275ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/enumerable/each_entry_spec.rb000066400000000000000000000001221222557024500246020ustar00rootroot00000000000000fails:Enumerable#each_entry passes through the values yielded by #each_with_index backports-3.3.5/spec/tags/1.8.6/core/enumerator/000077500000000000000000000000001222557024500211715ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/enumerator/next_spec.rb000066400000000000000000000001041222557024500235010ustar00rootroot00000000000000fails:Enumerator#next is rewound after encountering a StopIteration backports-3.3.5/spec/tags/1.8.6/core/env/000077500000000000000000000000001222557024500176005ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/env/to_h_spec.rb000066400000000000000000000001521222557024500220660ustar00rootroot00000000000000fails:ENV.to_hash uses the locale encoding for keys fails:ENV.to_hash uses the locale encoding for values backports-3.3.5/spec/tags/1.8.6/core/file/000077500000000000000000000000001222557024500177275ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/file/join_spec.rb000066400000000000000000000002651222557024500222300ustar00rootroot00000000000000fails:File.join flattens nested arrays fails:File.join inserts the separator in between empty strings and arrays fails:File.join raises an ArgumentError if passed a recursive array backports-3.3.5/spec/tags/1.8.6/core/file/lchmod_spec.rb000066400000000000000000000001551222557024500225350ustar00rootroot00000000000000fails:File.lchmod returns false from #respond_to? fails:File.lchmod raises a NotImplementedError when called backports-3.3.5/spec/tags/1.8.6/core/file/new_spec.rb000066400000000000000000000002071222557024500220560ustar00rootroot00000000000000fails:File.new returns a new File when use File::APPEND mode fails:File.new returns a new File when use File::RDONLY|File::APPEND mode backports-3.3.5/spec/tags/1.8.6/core/file/open_spec.rb000066400000000000000000000012521222557024500222270ustar00rootroot00000000000000fails:File.open on a FIFO opens it as a normal file fails:File.open opens file when call with a block (basic case) fails:File.open opens a file with mode string and block fails:File.open opens a file with mode num and block fails:File.open opens the file when passed mode, num, permissions and block fails:File.open opens the file when call with fd fails:File.open opens a file with a file descriptor d and a block fails:File.open raises a SystemCallError if passed an invalid Integer type fails:File.open raises an IOError when read in a block opened with File::RDONLY|File::APPEND mode fails:File.open raises an IOError if the file exists when open with File::RDONLY|File::APPEND backports-3.3.5/spec/tags/1.8.6/core/file/to_path_spec.rb000066400000000000000000000000661222557024500227260ustar00rootroot00000000000000fails:File#to_path preserves the encoding of the path backports-3.3.5/spec/tags/1.8.6/core/fixnum/000077500000000000000000000000001222557024500203165ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/fixnum/fdiv_spec.rb000066400000000000000000000000601222557024500226010ustar00rootroot00000000000000fails:Fixnum#fdiv follows the coercion protocol backports-3.3.5/spec/tags/1.8.6/core/gc/000077500000000000000000000000001222557024500174015ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/gc/stress_spec.rb000066400000000000000000000001371222557024500222640ustar00rootroot00000000000000fails:GC.stress returns current status of GC stress mode fails:GC.stress= sets the stress mode backports-3.3.5/spec/tags/1.8.6/core/hash/000077500000000000000000000000001222557024500177335ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/hash/assoc_spec.rb000066400000000000000000000001241222557024500223770ustar00rootroot00000000000000fails:Hash#assoc only returns the first matching key-value pair for identity hashes backports-3.3.5/spec/tags/1.8.6/core/hash/default_proc_spec.rb000066400000000000000000000002211222557024500237340ustar00rootroot00000000000000fails:Hash#default_proc= raises an error if passed nil fails:Hash#default_proc= raises a TypeError if passed a lambda with an arity other than 2 backports-3.3.5/spec/tags/1.8.6/core/hash/eql_spec.rb000066400000000000000000000002661222557024500220570ustar00rootroot00000000000000fails:Hash#eql? computes equality for recursive hashes fails:Hash#eql? computes equality for complex recursive hashes fails:Hash#eql? computes equality for recursive hashes & arrays backports-3.3.5/spec/tags/1.8.6/core/hash/hash_spec.rb000066400000000000000000000003041222557024500222120ustar00rootroot00000000000000fails:Hash#hash generates a hash for recursive hash structures fails:Hash#hash returns the same hash for recursive hashes fails:Hash#hash returns the same hash for recursive hashes through arrays backports-3.3.5/spec/tags/1.8.6/core/hash/keep_if_spec.rb000066400000000000000000000001111222557024500226650ustar00rootroot00000000000000fails:Hash#keep_if raises an RuntimeError if called on a frozen instance backports-3.3.5/spec/tags/1.8.6/core/hash/select_spec.rb000066400000000000000000000001041222557024500225440ustar00rootroot00000000000000fails:Hash#select returns a Hash of entries for which block is true backports-3.3.5/spec/tags/1.8.6/core/integer/000077500000000000000000000000001222557024500204455ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/integer/round_spec.rb000066400000000000000000000001041222557024500231260ustar00rootroot00000000000000fails:Integer#round raises a RangeError when passed Float::INFINITY backports-3.3.5/spec/tags/1.8.6/core/io/000077500000000000000000000000001222557024500174175ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/io/binread_spec.rb000066400000000000000000000010111222557024500223530ustar00rootroot00000000000000fails:IO.binread reads the contents of a file fails:IO.binread reads the contents of a file up to a certain size when specified fails:IO.binread reads the contents of a file from an offset of a specific size when specified fails:IO.binread returns a String in ASCII-8BIT encoding fails:IO.binread returns a String in ASCII-8BIT encoding regardless of Encoding.default_internal fails:IO.binread raises an ArgumentError when not passed a valid length fails:IO.binread raises an Errno::EINVAL when not passed a valid offset backports-3.3.5/spec/tags/1.8.6/core/io/chars_spec.rb000066400000000000000000000000451222557024500220550ustar00rootroot00000000000000fails:IO#chars yields each character backports-3.3.5/spec/tags/1.8.6/core/io/each_char_spec.rb000066400000000000000000000000511222557024500226470ustar00rootroot00000000000000fails:IO#each_char yields each character backports-3.3.5/spec/tags/1.8.6/core/io/lines_spec.rb000066400000000000000000000000451222557024500220670ustar00rootroot00000000000000fails:IO#lines ignores a given block backports-3.3.5/spec/tags/1.8.6/core/io/open_spec.rb000066400000000000000000000033001222557024500217130ustar00rootroot00000000000000fails:IO.open uses the external encoding specified in the mode argument fails:IO.open uses the external and the internal encoding specified in the mode argument fails:IO.open uses the external encoding specified via the :external_encoding option fails:IO.open uses the internal encoding specified via the :internal_encoding option fails:IO.open uses the colon-separated encodings specified via the :encoding option fails:IO.open ingores the :encoding option when the :external_encoding option is present fails:IO.open ingores the :encoding option when the :internal_encoding option is present fails:IO.open uses the encoding specified via the :mode option hash fails:IO.open ignores the :internal_encoding option when the same as the external encoding fails:IO.open sets internal encoding to nil when passed '-' fails:IO.open sets binmode from mode string fails:IO.open does not set binmode without being asked fails:IO.open sets binmode from :binmode option fails:IO.open does not set binmode from false :binmode fails:IO.open raises an error if passed binary/text mode two ways fails:IO.open sets external encoding to binary with binmode in mode string fails:IO.open sets external encoding to binary with :binmode option fails:IO.open does not use binary encoding when mode encoding is specified fails:IO.open does not use binary encoding when :encoding option is specified fails:IO.open does not use binary encoding when :external_encoding option is specified fails:IO.open does not use binary encoding when :internal_encoding option is specified fails:IO.open coerces mode with #to_int fails:IO.open coerces options as second argument with #to_hash fails:IO.open raises ArgumentError if not passed a hash or nil for options backports-3.3.5/spec/tags/1.8.6/core/io/ungetbyte_spec.rb000066400000000000000000000003431222557024500227640ustar00rootroot00000000000000fails:IO#ungetbyte does nothing when passed nil fails:IO#ungetbyte puts back each byte in a String argument fails:IO#ungetbyte calls #to_str to convert the argument fails:IO#ungetbyte puts back one byte for an Integer argument backports-3.3.5/spec/tags/1.8.6/core/io/write_spec.rb000066400000000000000000000002451222557024500221110ustar00rootroot00000000000000fails:IO.write uses encoding from given options, if provided fails:IO.write uses an :open_args option fails:IO.write disregards other options if :open_args is given backports-3.3.5/spec/tags/1.8.6/core/kernel/000077500000000000000000000000001222557024500202705ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/kernel/__callee___spec.rb000066400000000000000000000005121222557024500236460ustar00rootroot00000000000000fails:Kernel.__callee__ returns the current method, even when aliased fails:Kernel.__callee__ returns the original name when aliased method fails:Kernel.__callee__ returns the caller from blocks too fails:Kernel.__callee__ returns nil when not called from a method fails:Kernel.__callee__ returns the caller when sent as a string backports-3.3.5/spec/tags/1.8.6/core/kernel/__method___spec.rb000066400000000000000000000001061222557024500237000ustar00rootroot00000000000000fails:Kernel.__method__ returns the original name when aliased method backports-3.3.5/spec/tags/1.8.6/core/kernel/define_singleton_method_spec.rb000066400000000000000000000004521222557024500265040ustar00rootroot00000000000000fails:Kernel#define_singleton_method when given an UnboundMethod defines any Child class method from any Parent's class methods fails:Kernel#define_singleton_method when given an UnboundMethod will raise when attempting to define an object's singleton method from another object's singleton method backports-3.3.5/spec/tags/1.8.6/core/kernel/public_method_spec.rb000066400000000000000000000002551222557024500244470ustar00rootroot00000000000000fails:Kernel#public_method returns a method object if we repond_to_missing? method fails:Kernel#public_method changes the method called for super on a target aliased method backports-3.3.5/spec/tags/1.8.6/core/math/000077500000000000000000000000001222557024500177415ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/math/log2_spec.rb000066400000000000000000000004151222557024500221430ustar00rootroot00000000000000fails:Math.log2 raises an Errno::EDOM if the argument is less than 0 fails:Math.log2 raises an TypeError if the argument cannot be coerced with Float() fails:Math.log2 raises an TypeError if passed a numerical argument as a string fails:Math.log2 returns NaN given NaN backports-3.3.5/spec/tags/1.8.6/core/math/log_spec.rb000066400000000000000000000002761222557024500220660ustar00rootroot00000000000000fails:Math.log raises a TypeError if the argument cannot be coerced with Float() fails:Math.log raises a TypeError for numerical values passed as string fails:Math.log returns NaN given NaN backports-3.3.5/spec/tags/1.8.6/core/module/000077500000000000000000000000001222557024500202755ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/module/class_exec_spec.rb000066400000000000000000000002071222557024500237440ustar00rootroot00000000000000fails:Module#class_exec defines method in the receiver's scope fails:Module#class_exec raises an LocalJumpError when no block is given backports-3.3.5/spec/tags/1.8.6/core/module/module_exec_spec.rb000066400000000000000000000002111222557024500241170ustar00rootroot00000000000000fails:Module#module_exec defines method in the receiver's scope fails:Module#module_exec raises an LocalJumpError when no block is given backports-3.3.5/spec/tags/1.8.6/core/numeric/000077500000000000000000000000001222557024500204525ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/numeric/step_spec.rb000066400000000000000000000022311222557024500227620ustar00rootroot00000000000000fails:Numeric#step Numeric#step with [stop, +step] when self, stop or step is a Float is careful about not yielding a value greater than limit fails:Numeric#step Numeric#step with [stop, -step] when self, stop or step is a Float is careful about not yielding a value smaller than limit fails:Numeric#step Numeric#step with [stop, +Infinity] yields once if self < stop fails:Numeric#step Numeric#step with [stop, +Infinity] yields once when stop is Infinity fails:Numeric#step Numeric#step with [stop, +Infinity] yields once when self equals stop fails:Numeric#step Numeric#step with [stop, +Infinity] yields once when self and stop are Infinity fails:Numeric#step Numeric#step with [stop, +Infinity] does not yield when self > stop fails:Numeric#step Numeric#step with [stop, -infinity] yields once if self > stop fails:Numeric#step Numeric#step with [stop, -infinity] yields once if stop is -Infinity fails:Numeric#step Numeric#step with [stop, -infinity] yields once when self equals stop fails:Numeric#step Numeric#step with [stop, -infinity] yields once when self and stop are Infinity fails:Numeric#step Numeric#step with [stop, -infinity] does not yield when self > stop backports-3.3.5/spec/tags/1.8.6/core/proc/000077500000000000000000000000001222557024500177535ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/proc/curry_spec.rb000066400000000000000000000004431222557024500224570ustar00rootroot00000000000000fails:Proc#curry produces Procs that raise ArgumentError for #binding fails:Proc#curry produces Procs that return [[:rest]] for #parameters fails:Proc#curry produces Procs that return nil for #source_location fails:Proc#curry produces Procs that can be passed as the block for instance_exec backports-3.3.5/spec/tags/1.8.6/core/range/000077500000000000000000000000001222557024500201045ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/range/step_spec.rb000066400000000000000000000025231222557024500224200ustar00rootroot00000000000000fails:Range#step with inclusive end and Integer values yields Float values incremented by a Float step fails:Range#step with inclusive end and Float values returns Float values of 'step * n + begin <= end' fails:Range#step with inclusive end and Integer, Float values yields Float values incremented by 1 and less than or equal to end when not passed a step fails:Range#step with inclusive end and Integer, Float values yields Float values incremented by an Integer step fails:Range#step with inclusive end and Integer, Float values yields Float values incremented by a Float step fails:Range#step with inclusive end and String values raises a TypeError when passed a Float step fails:Range#step with exclusive end and Integer values yields Float values incremented by a Float step fails:Range#step with exclusive end and Float values returns Float values of 'step * n + begin < end' fails:Range#step with exclusive end and Integer, Float values yields Float values incremented by 1 and less than end when not passed a step fails:Range#step with exclusive end and Integer, Float values yields Float values incremented by an Integer step fails:Range#step with exclusive end and Integer, Float values yields an Float and then Float values incremented by a Float step fails:Range#step with exclusive end and String values raises a TypeError when passed a Float step backports-3.3.5/spec/tags/1.8.6/core/string/000077500000000000000000000000001222557024500203165ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/string/getbyte_spec.rb000066400000000000000000000006431222557024500233230ustar00rootroot00000000000000fails:String#getbyte returns an Integer between 0 and 255 fails:String#getbyte regards a multi-byte character as having multiple bytes fails:String#getbyte mirrors the output of #bytes fails:String#getbyte interprets bytes relative to the String's encoding fails:String#getbyte raises an ArgumentError unless given one argument fails:String#getbyte raises a TypeError unless its argument can be coerced into an Integer backports-3.3.5/spec/tags/1.8.6/core/string/partition_spec.rb000066400000000000000000000001031222557024500236600ustar00rootroot00000000000000fails:String#partition with String sets global vars if regexp used backports-3.3.5/spec/tags/1.8.6/core/string/prepend_spec.rb000066400000000000000000000000771222557024500233160ustar00rootroot00000000000000fails:String#prepend raises a RuntimeError when self if frozen backports-3.3.5/spec/tags/1.8.6/core/string/rpartition_spec.rb000066400000000000000000000000571222557024500240520ustar00rootroot00000000000000fails:String#rpartition with String affects $~ backports-3.3.5/spec/tags/1.8.6/core/string/setbyte_spec.rb000066400000000000000000000005201222557024500233310ustar00rootroot00000000000000fails:String#setbyte allows changing bytes in multi-byte characters fails:String#setbyte can invalidate a String's encoding fails:String#setbyte sets a byte at an index greater than String size fails:String#setbyte raises a RuntimeError if self is frozen fails:String#setbyte raises a TypeError unless the second argument is an Integer backports-3.3.5/spec/tags/1.8.6/core/string/upto_spec.rb000066400000000000000000000001261222557024500226430ustar00rootroot00000000000000fails:String#upto raises a LocalJumpError if other is a string but no block was given backports-3.3.5/spec/tags/1.8.6/core/symbol/000077500000000000000000000000001222557024500203155ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.6/core/symbol/capitalize_spec.rb000066400000000000000000000003701222557024500240010ustar00rootroot00000000000000fails:Symbol#capitalize leaves the first character alone if it is not an alphabetical ASCII character fails:Symbol#capitalize leaves uppercase Unicode characters as they were fails:Symbol#capitalize leaves lowercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.6/core/symbol/comparison_spec.rb000066400000000000000000000001271222557024500240260ustar00rootroot00000000000000fails:Symbol#<=> with Symbol compares individual characters based on their ascii value backports-3.3.5/spec/tags/1.8.6/core/symbol/downcase_spec.rb000066400000000000000000000002161222557024500234560ustar00rootroot00000000000000fails:Symbol#downcase leaves lowercase Unicode characters as they were fails:Symbol#downcase leaves uppercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.6/core/symbol/element_reference_spec.rb000066400000000000000000000003151222557024500253220ustar00rootroot00000000000000fails:Symbol#[] with a Regex slice without a capture index sets $~ to the MatchData if there is a match fails:Symbol#[] with a Regex slice with a capture index sets $~ to the MatchData if there is a match backports-3.3.5/spec/tags/1.8.6/core/symbol/empty_spec.rb000066400000000000000000000000621222557024500230100ustar00rootroot00000000000000fails:Symbol#empty? returns true if self is empty backports-3.3.5/spec/tags/1.8.6/core/symbol/match_spec.rb000066400000000000000000000001551222557024500227510ustar00rootroot00000000000000fails:Symbol#=~ sets the last match pseudo-variables fails:Symbol#match sets the last match pseudo-variables backports-3.3.5/spec/tags/1.8.6/core/symbol/swapcase_spec.rb000066400000000000000000000002161222557024500234610ustar00rootroot00000000000000fails:Symbol#swapcase leaves uppercase Unicode characters as they were fails:Symbol#swapcase leaves lowercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.6/core/symbol/upcase_spec.rb000066400000000000000000000001051222557024500231300ustar00rootroot00000000000000fails:Symbol#upcase leaves lowercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.7/000077500000000000000000000000001222557024500160615ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/000077500000000000000000000000001222557024500170115ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/array/000077500000000000000000000000001222557024500201275ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/array/keep_if_spec.rb000066400000000000000000000002331222557024500230660ustar00rootroot00000000000000fails:Array#keep_if on frozen objects with truthy block raises a RuntimeError fails:Array#keep_if on frozen objects with falsy block raises a RuntimeError backports-3.3.5/spec/tags/1.8.7/core/array/rotate_spec.rb000066400000000000000000000001761222557024500227700ustar00rootroot00000000000000fails:Array#rotate returns subclass instance for Array subclasses fails:Array#rotate! raises a RuntimeError on a frozen array backports-3.3.5/spec/tags/1.8.7/core/array/select_spec.rb000066400000000000000000000002331222557024500227430ustar00rootroot00000000000000fails:Array#select! on frozen objects with truthy block raises a RuntimeError fails:Array#select! on frozen objects with falsy block raises a RuntimeError backports-3.3.5/spec/tags/1.8.7/core/array/uniq_spec.rb000066400000000000000000000003631222557024500224440ustar00rootroot00000000000000fails:Array#uniq! raises a RuntimeError on a frozen array when the array is modified fails:Array#uniq! raises a RuntimeError on a frozen array when the array would not be modified fails:Array#uniq! doesn't yield to the block on a frozen array backports-3.3.5/spec/tags/1.8.7/core/complex/000077500000000000000000000000001222557024500204605ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/complex/to_r_spec.rb000066400000000000000000000005261222557024500227650ustar00rootroot00000000000000fails:Complex#to_r when the imaginary part is Fixnum 0 returns the result of sending #to_r to the real part fails:Complex#to_r when the imaginary part is Rational 0 returns the result of sending #to_r to the real part fails:Complex#to_r when the imaginary part responds to #== 0 with true returns the result of sending #to_r to the real part backports-3.3.5/spec/tags/1.8.7/core/env/000077500000000000000000000000001222557024500176015ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/env/to_h_spec.rb000066400000000000000000000001521222557024500220670ustar00rootroot00000000000000fails:ENV.to_hash uses the locale encoding for keys fails:ENV.to_hash uses the locale encoding for values backports-3.3.5/spec/tags/1.8.7/core/file/000077500000000000000000000000001222557024500177305ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/file/lchmod_spec.rb000066400000000000000000000001551222557024500225360ustar00rootroot00000000000000fails:File.lchmod returns false from #respond_to? fails:File.lchmod raises a NotImplementedError when called backports-3.3.5/spec/tags/1.8.7/core/file/new_spec.rb000066400000000000000000000001331222557024500220550ustar00rootroot00000000000000fails:File.new raises an Errno::EBADF if the first parameter is an invalid file descriptor backports-3.3.5/spec/tags/1.8.7/core/file/open_spec.rb000066400000000000000000000000641222557024500222300ustar00rootroot00000000000000fails:File.open on a FIFO opens it as a normal file backports-3.3.5/spec/tags/1.8.7/core/file/readlink_spec.rb000066400000000000000000000013531222557024500230620ustar00rootroot00000000000000fails:File.readlink File.readlink with absolute paths return the name of the file referenced by the given link fails:File.readlink File.readlink with absolute paths returns the name of the file referenced by the given link when the file does not exist fails:File.readlink File.readlink with absolute paths raises an Errno::ENOENT if there is no such file fails:File.readlink File.readlink with absolute paths raises an Errno::EINVAL if called with a normal file fails:File.readlink File.readlink when changing the working directory returns the name of the file referenced by the given link fails:File.readlink File.readlink when changing the working directory returns the name of the file referenced by the given link when the file does not exist backports-3.3.5/spec/tags/1.8.7/core/file/to_path_spec.rb000066400000000000000000000000661222557024500227270ustar00rootroot00000000000000fails:File#to_path preserves the encoding of the path backports-3.3.5/spec/tags/1.8.7/core/hash/000077500000000000000000000000001222557024500177345ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/hash/assoc_spec.rb000066400000000000000000000001241222557024500224000ustar00rootroot00000000000000fails:Hash#assoc only returns the first matching key-value pair for identity hashes backports-3.3.5/spec/tags/1.8.7/core/hash/default_proc_spec.rb000066400000000000000000000002211222557024500237350ustar00rootroot00000000000000fails:Hash#default_proc= raises an error if passed nil fails:Hash#default_proc= raises a TypeError if passed a lambda with an arity other than 2 backports-3.3.5/spec/tags/1.8.7/core/hash/keep_if_spec.rb000066400000000000000000000001111222557024500226660ustar00rootroot00000000000000fails:Hash#keep_if raises an RuntimeError if called on a frozen instance backports-3.3.5/spec/tags/1.8.7/core/hash/rassoc_spec.rb000066400000000000000000000001011222557024500225550ustar00rootroot00000000000000fails:Hash#rassoc only returns the first matching key-value pair backports-3.3.5/spec/tags/1.8.7/core/hash/select_spec.rb000066400000000000000000000001041222557024500225450ustar00rootroot00000000000000fails:Hash#select returns a Hash of entries for which block is true backports-3.3.5/spec/tags/1.8.7/core/integer/000077500000000000000000000000001222557024500204465ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/integer/round_spec.rb000066400000000000000000000001041222557024500231270ustar00rootroot00000000000000fails:Integer#round raises a RangeError when passed Float::INFINITY backports-3.3.5/spec/tags/1.8.7/core/io/000077500000000000000000000000001222557024500174205ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/io/binread_spec.rb000066400000000000000000000010111222557024500223540ustar00rootroot00000000000000fails:IO.binread reads the contents of a file fails:IO.binread reads the contents of a file up to a certain size when specified fails:IO.binread reads the contents of a file from an offset of a specific size when specified fails:IO.binread returns a String in ASCII-8BIT encoding fails:IO.binread returns a String in ASCII-8BIT encoding regardless of Encoding.default_internal fails:IO.binread raises an ArgumentError when not passed a valid length fails:IO.binread raises an Errno::EINVAL when not passed a valid offset backports-3.3.5/spec/tags/1.8.7/core/io/open_spec.rb000066400000000000000000000033731222557024500217260ustar00rootroot00000000000000fails:IO.open uses the external encoding specified in the mode argument fails:IO.open uses the external and the internal encoding specified in the mode argument fails:IO.open uses the external encoding specified via the :external_encoding option fails:IO.open uses the internal encoding specified via the :internal_encoding option fails:IO.open uses the colon-separated encodings specified via the :encoding option fails:IO.open ingores the :encoding option when the :external_encoding option is present fails:IO.open ingores the :encoding option when the :internal_encoding option is present fails:IO.open uses the encoding specified via the :mode option hash fails:IO.open ignores the :internal_encoding option when the same as the external encoding fails:IO.open sets internal encoding to nil when passed '-' fails:IO.open raises an error if passed encodings two ways fails:IO.open sets binmode from mode string fails:IO.open does not set binmode without being asked fails:IO.open sets binmode from :binmode option fails:IO.open does not set binmode from false :binmode fails:IO.open sets external encoding to binary with binmode in mode string fails:IO.open does not use binary encoding when mode encoding is specified fails:IO.open does not use binary encoding when :encoding option is specified fails:IO.open does not use binary encoding when :external_encoding option is specified fails:IO.open does not use binary encoding when :internal_encoding option is specified fails:IO.open coerces mode with #to_int fails:IO.open coerces options as second argument with #to_hash fails:IO.open raises ArgumentError if not passed a hash or nil for options fails:IO.open sets external encoding to binary with :binmode option fails:IO.open raises an error if passed binary/text mode two ways backports-3.3.5/spec/tags/1.8.7/core/io/ungetbyte_spec.rb000066400000000000000000000003431222557024500227650ustar00rootroot00000000000000fails:IO#ungetbyte does nothing when passed nil fails:IO#ungetbyte puts back each byte in a String argument fails:IO#ungetbyte calls #to_str to convert the argument fails:IO#ungetbyte puts back one byte for an Integer argument backports-3.3.5/spec/tags/1.8.7/core/io/write_spec.rb000066400000000000000000000002451222557024500221120ustar00rootroot00000000000000fails:IO.write uses encoding from given options, if provided fails:IO.write uses an :open_args option fails:IO.write disregards other options if :open_args is given backports-3.3.5/spec/tags/1.8.7/core/kernel/000077500000000000000000000000001222557024500202715ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/kernel/__callee___spec.rb000066400000000000000000000005121222557024500236470ustar00rootroot00000000000000fails:Kernel.__callee__ returns the current method, even when aliased fails:Kernel.__callee__ returns the original name when aliased method fails:Kernel.__callee__ returns the caller from blocks too fails:Kernel.__callee__ returns nil when not called from a method fails:Kernel.__callee__ returns the caller when sent as a string backports-3.3.5/spec/tags/1.8.7/core/kernel/define_singleton_method_spec.rb000066400000000000000000000004521222557024500265050ustar00rootroot00000000000000fails:Kernel#define_singleton_method when given an UnboundMethod defines any Child class method from any Parent's class methods fails:Kernel#define_singleton_method when given an UnboundMethod will raise when attempting to define an object's singleton method from another object's singleton method backports-3.3.5/spec/tags/1.8.7/core/kernel/public_method_spec.rb000066400000000000000000000001231222557024500244420ustar00rootroot00000000000000fails:Kernel#public_method returns a method object if we repond_to_missing? method backports-3.3.5/spec/tags/1.8.7/core/math/000077500000000000000000000000001222557024500177425ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/math/log2_spec.rb000066400000000000000000000004151222557024500221440ustar00rootroot00000000000000fails:Math.log2 raises an Errno::EDOM if the argument is less than 0 fails:Math.log2 raises an TypeError if the argument cannot be coerced with Float() fails:Math.log2 raises an TypeError if passed a numerical argument as a string fails:Math.log2 returns NaN given NaN backports-3.3.5/spec/tags/1.8.7/core/math/log_spec.rb000066400000000000000000000002761222557024500220670ustar00rootroot00000000000000fails:Math.log raises a TypeError if the argument cannot be coerced with Float() fails:Math.log raises a TypeError for numerical values passed as string fails:Math.log returns NaN given NaN backports-3.3.5/spec/tags/1.8.7/core/proc/000077500000000000000000000000001222557024500177545ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/proc/curry_spec.rb000066400000000000000000000003211222557024500224530ustar00rootroot00000000000000fails:Proc#curry produces Procs that raise ArgumentError for #binding fails:Proc#curry produces Procs that return [[:rest]] for #parameters fails:Proc#curry produces Procs that return nil for #source_location backports-3.3.5/spec/tags/1.8.7/core/proc/yield_spec.rb000066400000000000000000000010001222557024500224100ustar00rootroot00000000000000fails:Proc#yield on a Proc created with Kernel#lambda or Kernel#proc ignores excess arguments when self is a proc fails:Proc#yield on a Proc created with Kernel#lambda or Kernel#proc substitutes nil for missing arguments when self is a proc fails:Proc#yield on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on excess arguments when self is a lambda fails:Proc#yield on a Proc created with Kernel#lambda or Kernel#proc raises an ArgumentError on missing arguments when self is a lambda backports-3.3.5/spec/tags/1.8.7/core/string/000077500000000000000000000000001222557024500203175ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/string/getbyte_spec.rb000066400000000000000000000005611222557024500233230ustar00rootroot00000000000000fails:String#getbyte returns an Integer between 0 and 255 fails:String#getbyte regards a multi-byte character as having multiple bytes fails:String#getbyte interprets bytes relative to the String's encoding fails:String#getbyte raises an ArgumentError unless given one argument fails:String#getbyte raises a TypeError unless its argument can be coerced into an Integer backports-3.3.5/spec/tags/1.8.7/core/string/prepend_spec.rb000066400000000000000000000000771222557024500233170ustar00rootroot00000000000000fails:String#prepend raises a RuntimeError when self if frozen backports-3.3.5/spec/tags/1.8.7/core/string/setbyte_spec.rb000066400000000000000000000005201222557024500233320ustar00rootroot00000000000000fails:String#setbyte allows changing bytes in multi-byte characters fails:String#setbyte can invalidate a String's encoding fails:String#setbyte sets a byte at an index greater than String size fails:String#setbyte raises a RuntimeError if self is frozen fails:String#setbyte raises a TypeError unless the second argument is an Integer backports-3.3.5/spec/tags/1.8.7/core/symbol/000077500000000000000000000000001222557024500203165ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.8.7/core/symbol/capitalize_spec.rb000066400000000000000000000003701222557024500240020ustar00rootroot00000000000000fails:Symbol#capitalize leaves the first character alone if it is not an alphabetical ASCII character fails:Symbol#capitalize leaves uppercase Unicode characters as they were fails:Symbol#capitalize leaves lowercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.7/core/symbol/comparison_spec.rb000066400000000000000000000001271222557024500240270ustar00rootroot00000000000000fails:Symbol#<=> with Symbol compares individual characters based on their ascii value backports-3.3.5/spec/tags/1.8.7/core/symbol/downcase_spec.rb000066400000000000000000000002161222557024500234570ustar00rootroot00000000000000fails:Symbol#downcase leaves lowercase Unicode characters as they were fails:Symbol#downcase leaves uppercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.7/core/symbol/element_reference_spec.rb000066400000000000000000000003151222557024500253230ustar00rootroot00000000000000fails:Symbol#[] with a Regex slice without a capture index sets $~ to the MatchData if there is a match fails:Symbol#[] with a Regex slice with a capture index sets $~ to the MatchData if there is a match backports-3.3.5/spec/tags/1.8.7/core/symbol/empty_spec.rb000066400000000000000000000000621222557024500230110ustar00rootroot00000000000000fails:Symbol#empty? returns true if self is empty backports-3.3.5/spec/tags/1.8.7/core/symbol/match_spec.rb000066400000000000000000000001551222557024500227520ustar00rootroot00000000000000fails:Symbol#=~ sets the last match pseudo-variables fails:Symbol#match sets the last match pseudo-variables backports-3.3.5/spec/tags/1.8.7/core/symbol/swapcase_spec.rb000066400000000000000000000002161222557024500234620ustar00rootroot00000000000000fails:Symbol#swapcase leaves uppercase Unicode characters as they were fails:Symbol#swapcase leaves lowercase Unicode characters as they were backports-3.3.5/spec/tags/1.8.7/core/symbol/upcase_spec.rb000066400000000000000000000001051222557024500231310ustar00rootroot00000000000000fails:Symbol#upcase leaves lowercase Unicode characters as they were backports-3.3.5/spec/tags/1.9.1/000077500000000000000000000000001222557024500160545ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.1/core/000077500000000000000000000000001222557024500170045ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.1/core/array/000077500000000000000000000000001222557024500201225ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.1/core/array/rotate_spec.rb000066400000000000000000000001021222557024500227500ustar00rootroot00000000000000fails:Array#rotate returns subclass instance for Array subclasses backports-3.3.5/spec/tags/1.9.1/core/env/000077500000000000000000000000001222557024500175745ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.1/core/env/to_h_spec.rb000066400000000000000000000001521222557024500220620ustar00rootroot00000000000000fails:ENV.to_hash uses the locale encoding for keys fails:ENV.to_hash uses the locale encoding for values backports-3.3.5/spec/tags/1.9.1/core/hash/000077500000000000000000000000001222557024500177275ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.1/core/hash/default_proc_spec.rb000066400000000000000000000001321222557024500237310ustar00rootroot00000000000000fails:Hash#default_proc= raises a TypeError if passed a lambda with an arity other than 2 backports-3.3.5/spec/tags/1.9.1/core/io/000077500000000000000000000000001222557024500174135ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.1/core/io/write_spec.rb000066400000000000000000000001461222557024500221050ustar00rootroot00000000000000fails:IO.write uses encoding from given options, if provided fails:IO.write uses an :open_args option backports-3.3.5/spec/tags/1.9.2/000077500000000000000000000000001222557024500160555ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.2/core/000077500000000000000000000000001222557024500170055ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.2/core/io/000077500000000000000000000000001222557024500174145ustar00rootroot00000000000000backports-3.3.5/spec/tags/1.9.2/core/io/write_spec.rb000066400000000000000000000001461222557024500221060ustar00rootroot00000000000000fails:IO.write uses encoding from given options, if provided fails:IO.write uses an :open_args option backports-3.3.5/test/000077500000000000000000000000001222557024500144755ustar00rootroot00000000000000backports-3.3.5/test/README000066400000000000000000000001141222557024500153510ustar00rootroot00000000000000`rake test` will run the tests in here. `rake spec` will run the rubyspecs. backports-3.3.5/test/_backport_guards_test.rb000066400000000000000000000106651222557024500214020ustar00rootroot00000000000000require 'stringio' if RUBY_VERSION < '1.9' require 'enumerator' require 'generator' # Must require first, because of warning in Ruby 1.8.7 with `ruby -w -r generator -e ""` end require './test/test_helper' $bogus = [] module Kernel def require_with_bogus_extension(lib) $bogus << lib require_without_bogus_extension(lib) end alias_method :require_without_bogus_extension, :require alias_method :require, :require_with_bogus_extension if defined? BasicObject and BasicObject.superclass BasicObject.send :undef_method, :require BasicObject.send :undef_method, :require_with_bogus_extension end end class AAA_TestBackportGuards < Test::Unit::TestCase def setup $VERBOSE = true @prev, $stderr = $stderr, StringIO.new end def teardown assert_equal '', $stderr.string $stderr = @prev end EXCLUDE = %w[require require_with_backports require_without_backports] # Overriden in all circumstances to load the std-lib EXCLUDE.map!(&:to_sym) if instance_methods.first.is_a?(Symbol) # For some very strange reason, Hash[kvp.flatten] doesn't always work in 1.8.6?? def hash(key_value_pairs) h = {} key_value_pairs.each{|k,v| h[k] = v} h end def class_signature(klass) hash( (klass.instance_methods - EXCLUDE).map{|m| [m, klass.instance_method(m)] } + (klass.methods - EXCLUDE).map{|m| [".#{m}", klass.method(m) ]} ) end CLASSES = [Array, Binding, Dir, Enumerable, Fixnum, Float, GC, Hash, Integer, IO, Kernel, Math, MatchData, Method, Module, Numeric, ObjectSpace, Proc, Process, Range, Regexp, String, Struct, Symbol] + [ENV, ARGF].map{|obj| class << obj; self; end } case RUBY_VERSION when '1.8.6' when '1.8.7' CLASSES << Enumerable::Enumerator else CLASSES << Enumerator end def digest hash( CLASSES.map { |klass| [klass, class_signature(klass)] } ) end def digest_delta(before, after) delta = {} before.each do |klass, methods| compare = after[klass] d = methods.map do |name, unbound| name unless unbound == compare[name] end + (compare.map(&:first) - methods.map(&:first)) d.compact! delta[klass] = d unless d.empty? end delta unless delta.empty? end # Order super important! def test__1_abbrev_can_be_required_before_backports assert require('abbrev') assert !$LOADED_FEATURES.include?('backports') end # Order super important! def test__2_backports_wont_override_unnecessarily before = digest latest = "2.0.0" unless RUBY_VERSION <= '1.8.6' require "backports/#{[RUBY_VERSION, latest].min}" after = digest assert_nil digest_delta(before, after) end unless RUBY_VERSION >= latest require "backports" after = digest assert !digest_delta(before, after).nil? end end def test_setlib_load_correctly_after_requiring_backports path = File.expand_path("../../lib/backports/1.9.2/stdlib/matrix.rb", __FILE__) assert_equal false, $LOADED_FEATURES.include?(path) assert_equal true, require('matrix') assert_equal true, $bogus.include?("matrix") assert_equal true, $LOADED_FEATURES.include?(path) assert_equal false, require('matrix') end def test_setlib_load_correctly_before_requiring_backports_test assert_equal true, $bogus.include?("abbrev") path = File.expand_path("../../lib/backports/2.0.0/stdlib/abbrev.rb", __FILE__) assert_equal true, $LOADED_FEATURES.include?(path) assert_equal false, require('abbrev') end def test_backports_does_not_interfere_for_libraries_without_backports_test assert_equal true, require('scanf') assert_equal false, require('scanf') end def test_load_correctly_new_libraries_test path = File.expand_path("../../lib/backports/2.0.0/stdlib/fake_stdlib_lib.rb", __FILE__) assert_equal false, $LOADED_FEATURES.include?(path) assert_equal true, require('fake_stdlib_lib') assert_equal true, $LOADED_FEATURES.include?(path) assert_equal false, require('fake_stdlib_lib') end def test_no_warnings require 'ostruct' require 'set' require 'backports/1.8.7/array/each' require 'backports/1.8.7/enumerator/next' assert_equal 1, [1,2,3].each.next # [Bug #70] end def test_rails require 'active_support/all' $stderr.string = '' # disregard warnings by Rails before = digest require "backports/rails" after = digest assert_nil digest_delta(before, after) end end backports-3.3.5/test/lazy_test.rb000066400000000000000000000366721222557024500170560ustar00rootroot00000000000000# This is copied & modified from MRI require './test/test_helper' class TestLazyEnumerator < Test::Unit::TestCase def setup require "backports/2.0.0/enumerable/lazy" require "backports/1.8.7/enumerable" require "backports/1.8.7/io/each" end class Step include Enumerable attr_reader :current, :args def initialize(enum) @enum = enum @current = nil @args = nil end def each(*args) @args = args @enum.each {|i| @current = i; yield i} end end def test_initialize assert_equal([1, 2, 3], [1, 2, 3].lazy.to_a) assert_equal([1, 2, 3], Enumerator::Lazy.new([1, 2, 3]){|y, v| y << v}.to_a) assert_raise(ArgumentError) { Enumerator::Lazy.new([1, 2, 3]) } end ### Backports: Disabled because of Enumerator#each not passing args in MRI < 2.0 # def test_each_args # a = Step.new(1..3) # assert_equal(1, a.lazy.each(4).first) # assert_equal([4], a.args) # end def test_each_line name = lineno = nil File.open(__FILE__) do |f| f.each("").map do |paragraph| paragraph[/\A\s*(.*)/, 1] end.find do |line| if name = line[/^class\s+(\S+)/, 1] lineno = f.lineno true end end end assert_equal(self.class.name, name) assert_operator(lineno, :>, 2) name = lineno = nil File.open(__FILE__) do |f| ### Backports: Modified to avoid bug of Enumerator#each not passing args in MRI < 2.0 f.each("").lazy.map do |paragraph| # paragraph[/\A\s*(.*)/, 1] end.find do |line| if name = line[/^class\s+(\S+)/, 1] lineno = f.lineno true end end end assert_equal(self.class.name, name) assert_equal(2, lineno) end def test_select a = Step.new(1..6) assert_equal(4, a.select {|x| x > 3}.first) assert_equal(6, a.current) assert_equal(4, a.lazy.select {|x| x > 3}.first) assert_equal(4, a.current) a = Step.new(['word', nil, 1]) assert_raise(TypeError) {a.select {|x| "x"+x}.first} assert_equal(nil, a.current) assert_equal("word", a.lazy.select {|x| "x"+x}.first) assert_equal("word", a.current) end def test_select_multiple_values e = Enumerator.new { |yielder| for i in 1..5 yielder.yield(i, i.to_s) end } ### Backport: non lazy version differs on JRuby and MRI assert_equal([[2, "2"], [4, "4"]], e.lazy.select {|x| x[0] % 2 == 0}.force) end def test_map a = Step.new(1..3) assert_equal(2, a.map {|x| x * 2}.first) assert_equal(3, a.current) assert_equal(2, a.lazy.map {|x| x * 2}.first) assert_equal(1, a.current) end def test_flat_map a = Step.new(1..3) assert_equal(2, a.flat_map {|x| [x * 2]}.first) assert_equal(3, a.current) assert_equal(2, a.lazy.flat_map {|x| [x * 2]}.first) assert_equal(1, a.current) end if [].respond_to?(:flat_map) def test_flat_map_nested a = Step.new(1..3) assert_equal([1, "a"], a.flat_map {|x| ("a".."c").map {|y| [x, y]}}.first) assert_equal(3, a.current) assert_equal([1, "a"], a.lazy.flat_map {|x| ("a".."c").lazy.map {|y| [x, y]}}.first) assert_equal(1, a.current) end if [].respond_to?(:flat_map) def test_flat_map_to_ary to_ary = Class.new { def initialize(value) @value = value end def to_ary [:to_ary, @value] end } assert_equal([:to_ary, 1, :to_ary, 2, :to_ary, 3], [1, 2, 3].flat_map {|x| to_ary.new(x)}) assert_equal([:to_ary, 1, :to_ary, 2, :to_ary, 3], [1, 2, 3].lazy.flat_map {|x| to_ary.new(x)}.force) end if [].respond_to?(:flat_map) def test_flat_map_non_array assert_equal(["1", "2", "3"], [1, 2, 3].flat_map {|x| x.to_s}) assert_equal(["1", "2", "3"], [1, 2, 3].lazy.flat_map {|x| x.to_s}.force) end if [].respond_to?(:flat_map) def test_flat_map_hash assert_equal([{?a=>97}, {?b=>98}, {?c=>99}], [?a, ?b, ?c].flat_map {|x| {x=>x.ord}}) assert_equal([{?a=>97}, {?b=>98}, {?c=>99}], [?a, ?b, ?c].lazy.flat_map {|x| {x=>x.ord}}.force) end if [].respond_to?(:flat_map) def test_reject a = Step.new(1..6) assert_equal(4, a.reject {|x| x < 4}.first) assert_equal(6, a.current) assert_equal(4, a.lazy.reject {|x| x < 4}.first) assert_equal(4, a.current) a = Step.new(['word', nil, 1]) assert_equal(nil, a.reject {|x| x}.first) assert_equal(1, a.current) assert_equal(nil, a.lazy.reject {|x| x}.first) assert_equal(nil, a.current) end def test_reject_multiple_values e = Enumerator.new { |yielder| for i in 1..5 yielder.yield(i, i.to_s) end } ### Backport: non lazy version differs on JRuby and MRI assert_equal([[2, "2"], [4, "4"]], e.lazy.reject {|x| x[0] % 2 != 0}.force) end def test_grep a = Step.new('a'..'f') assert_equal('c', a.grep(/c/).first) assert_equal('f', a.current) assert_equal('c', a.lazy.grep(/c/).first) assert_equal('c', a.current) assert_equal(%w[a e], a.grep(proc {|x| /[aeiou]/ =~ x})) assert_equal(%w[a e], a.lazy.grep(proc {|x| /[aeiou]/ =~ x}).to_a) end def test_grep_with_block a = Step.new('a'..'f') assert_equal('C', a.grep(/c/) {|i| i.upcase}.first) assert_equal('C', a.lazy.grep(/c/) {|i| i.upcase}.first) end def test_grep_multiple_values e = Enumerator.new { |yielder| 3.times { |i| yielder.yield(i, i.to_s) } } ### Backport: non lazy version differs on JRuby and MRI assert_equal([[2, "2"]], e.lazy.grep(proc {|x| x == [2, "2"]}).force) assert_equal(["22"], e.lazy.grep(proc {|x| x == [2, "2"]}, &:join).force) end def test_zip a = Step.new(1..3) assert_equal([1, "a"], a.zip("a".."c").first) assert_equal(3, a.current) assert_equal([1, "a"], a.lazy.zip("a".."c").first) assert_equal(1, a.current) end def test_zip_short_arg a = Step.new(1..5) assert_equal([5, nil], a.zip("a".."c").last) enum = [42].to_enum.next assert_equal([5, nil], a.lazy.zip("a".."d").force.last) ### Backport: modified to avoid fact that 1.8.x's Enumerator auto-rewind end def test_zip_without_arg a = Step.new(1..3) assert_equal([1], a.zip.first) assert_equal(3, a.current) avoid_bug_on_jruby = Enumerator.new{|y| y << [1]}.first ### Backport: see https://jira.codehaus.org/browse/JRUBY-7108 assert_equal(avoid_bug_on_jruby, a.lazy.zip.first) assert_equal(1, a.current) end def test_zip_bad_arg a = Step.new(1..3) assert_raise(TypeError){ a.lazy.zip(42) } end def test_zip_with_block # zip should be eager when a block is given a = Step.new(1..3) ary = [] assert_equal(nil, a.lazy.zip("a".."c") {|x, y| ary << [x, y]}) assert_equal(a.zip("a".."c"), ary) assert_equal(3, a.current) end def test_take a = Step.new(1..10) assert_equal(1, a.take(5).first) assert_equal(5, a.current) assert_equal(1, a.lazy.take(5).first) assert_equal(1, a.current) assert_equal((1..5).to_a, a.lazy.take(5).force) assert_equal(5, a.current) a = Step.new(1..10) assert_equal([], a.lazy.take(0).force) assert_equal(nil, a.current) end def test_take_recycle bug6428 = '[ruby-dev:45634]' a = Step.new(1..10) take5 = a.lazy.take(5) assert_equal((1..5).to_a, take5.force, bug6428) assert_equal((1..5).to_a, take5.force, bug6428) end def test_take_nested bug7696 = '[ruby-core:51470]' a = Step.new(1..10) take5 = a.lazy.take(5) assert_equal([*(1..5)]*5, take5.flat_map{take5}.force, bug7696) end def test_drop_while_nested bug7696 = '[ruby-core:51470]' a = Step.new(1..10) drop5 = a.lazy.drop_while{|x| x < 6} assert_equal([*(6..10)]*5, drop5.flat_map{drop5}.force, bug7696) end def test_drop_nested bug7696 = '[ruby-core:51470]' a = Step.new(1..10) drop5 = a.lazy.drop(5) assert_equal([*(6..10)]*5, drop5.flat_map{drop5}.force, bug7696) end def test_zip_nested bug7696 = '[ruby-core:51470]' enum = ('a'..'z').each enum.next zip = (1..3).lazy.zip(enum, enum) assert_equal([[1, 'a', 'a'], [2, 'b', 'b'], [3, 'c', 'c']]*3, zip.flat_map{zip}.force, bug7696) end def test_zip_lazy_on_args zip = Step.new(1..2).lazy.zip(42..Float::INFINITY) assert_equal [[1, 42], [2, 43]], zip.force end def test_zip_efficient_on_array_args ary = [42, :foo] [:to_enum, :enum_for, :lazy, :each].each do |forbid| ary.define_singleton_method(forbid){ fail "#{forbid} was called"} end zip = Step.new(1..2).lazy.zip(ary) assert_equal [[1, 42], [2, :foo]], zip.force end def test_take_rewound bug7696 = '[ruby-core:51470]' e=(1..42).lazy.take(2) assert_equal 1, e.next assert_equal 2, e.next e.rewind assert_equal 1, e.next assert_equal 2, e.next end def test_take_while a = Step.new(1..10) assert_equal(1, a.take_while {|i| i < 5}.first) assert_equal(5, a.current) assert_equal(1, a.lazy.take_while {|i| i < 5}.first) assert_equal(1, a.current) assert_equal((1..4).to_a, a.lazy.take_while {|i| i < 5}.to_a) end def test_drop a = Step.new(1..10) assert_equal(6, a.drop(5).first) assert_equal(10, a.current) assert_equal(6, a.lazy.drop(5).first) assert_equal(6, a.current) assert_equal((6..10).to_a, a.lazy.drop(5).to_a) end def test_drop_while a = Step.new(1..10) assert_equal(5, a.drop_while {|i| i < 5}.first) assert_equal(10, a.current) assert_equal(5, a.lazy.drop_while {|i| i < 5}.first) assert_equal(5, a.current) assert_equal((5..10).to_a, a.lazy.drop_while {|i| i < 5}.to_a) end def test_drop_and_take assert_equal([4, 5], (1..(1.0/0)).lazy.drop(3).take(2).to_a) # Backports: don't rely on INFINITY end def test_cycle a = Step.new(1..3) assert_equal("1", a.cycle(2).map{|x| x.to_s}.first) assert_equal(3, a.current) assert_equal("1", a.lazy.cycle(2).map{|x| x.to_s}.first) assert_equal(1, a.current) end def test_cycle_with_block # cycle should be eager when a block is given a = Step.new(1..3) ary = [] assert_equal(nil, a.lazy.cycle(2) {|i| ary << i}) assert_equal(a.cycle(2).to_a, ary) assert_equal(3, a.current) end def test_cycle_chain a = 1..3 assert_equal([1,2,3,1,2,3,1,2,3,1], a.lazy.cycle.take(10).force) assert_equal([2,2,2,2,2,2,2,2,2,2], a.lazy.cycle.select {|x| x == 2}.take(10).force) assert_equal([2,2,2,2,2,2,2,2,2,2], a.lazy.select {|x| x == 2}.cycle.take(10).force) end def test_force assert_equal([1, 2, 3], (1..Float::INFINITY).lazy.take(3).force) end def test_inspect return unless Enumerator.to_s == "Enumerator" assert_equal("#", (1..10).lazy.inspect) assert_equal('#>', "foo".each_char.lazy.inspect) assert_equal("#:map>", (1..10).lazy.map {}.inspect) assert_equal("#:take(0)>", (1..10).lazy.take(0).inspect) assert_equal("#:take(3)>", (1..10).lazy.take(3).inspect) assert_equal('#:grep(/b/)>', ("a".."c").lazy.grep(/b/).inspect) assert_equal("#:cycle(3)>", (1..10).lazy.cycle(3).inspect) assert_equal("#:cycle>", (1..10).lazy.cycle.inspect) assert_equal("#:cycle(3)>", (1..10).lazy.cycle(3).inspect) l = (1..10).lazy.map {}.flat_map {}.select {}.reject {}.grep(1).zip(?a..?c).take(10).take_while {}.drop(3).drop_while {}.cycle(3) ### Backport: Modified because I don't think the actual name we were called under in case of aliases is important enough to care assert_equal(<:map>:flat_map>:select>:reject>:grep(1)>:zip(\"a\"..\"c\")>:take(10)>:take_while>:drop(3)>:drop_while>:cycle(3)> EOS end if [].respond_to?(:flat_map) def test_lazy_to_enum lazy = [1, 2, 3].lazy def lazy.foo(*args) yield args yield args end enum = lazy.to_enum(:foo, :hello, :world) assert_equal Enumerator::Lazy, enum.class # assert_equal nil, enum.size ### Backport: see below assert_equal [[:hello, :world], [:hello, :world]], enum.to_a assert_equal [1, 2, 3], lazy.to_enum.to_a end ### Backport: way too much work to shim #size # def test_size # lazy = [1, 2, 3].lazy # assert_equal 3, lazy.size # assert_equal 42, Enumerator::Lazy.new([],->{42}){}.size # assert_equal 42, Enumerator::Lazy.new([],42){}.size # assert_equal 42, Enumerator::Lazy.new([],42){}.lazy.size # assert_equal 42, lazy.to_enum{ 42 }.size # [:map, :collect].each do |m| # assert_equal 3, lazy.send(m){}.size # end # assert_equal 3, lazy.zip([4]).size # [:flat_map, :collect_concat, :select, :find_all, :reject, :take_while, :drop_while].each do |m| # assert_equal nil, lazy.send(m){}.size # end # assert_equal nil, lazy.grep(//).size # assert_equal 2, lazy.take(2).size # assert_equal 3, lazy.take(4).size # assert_equal 4, loop.lazy.take(4).size # assert_equal nil, lazy.select{}.take(4).size # assert_equal 1, lazy.drop(2).size # assert_equal 0, lazy.drop(4).size # assert_equal Float::INFINITY, loop.lazy.drop(4).size # assert_equal nil, lazy.select{}.drop(4).size # assert_equal 0, lazy.cycle(0).size # assert_equal 6, lazy.cycle(2).size # assert_equal 3 << 80, 4.times.inject(lazy){|enum| enum.cycle(1 << 20)}.size # assert_equal Float::INFINITY, lazy.cycle.size # assert_equal Float::INFINITY, loop.lazy.cycle(4).size # assert_equal Float::INFINITY, loop.lazy.cycle.size # assert_equal nil, lazy.select{}.cycle(4).size # assert_equal nil, lazy.select{}.cycle.size # end # def test_map_zip # bug7507 = '[ruby-core:50545]' # assert_ruby_status(["-e", "GC.stress = true", "-e", "(1..10).lazy.map{}.zip(){}"], bug7507) # assert_ruby_status(["-e", "GC.stress = true", "-e", "(1..10).lazy.map{}.zip().to_a"], bug7507) # end def test_require_block [:select, :reject, :drop_while, :take_while, :map, :flat_map].each do |method| assert_raise(ArgumentError){ [].lazy.send(method) } end end def test_laziness_conservation bug7507 = '[ruby-core:51510]' { :slice_before => //, :with_index => [], :cycle => [], :each_with_object => 42, :each_slice => 42, :each_entry => [], :each_cons => 42, }.each do |method, arg| assert_equal Enumerator::Lazy, [].lazy.send(method, *arg).class, method if [].respond_to?(method) end assert_equal Enumerator::Lazy, [].lazy.chunk{}.class, bug7507 end ### Backport: assert_warning not defined, we're ok anyways # def test_no_warnings # le = (1..3).lazy # assert_warning("") {le.zip([4,5,6]).force} # assert_warning("") {le.zip(4..6).force} # assert_warning("") {le.take(1).force} # assert_warning("") {le.drop(1).force} # assert_warning("") {le.drop_while{false}.force} # end end backports-3.3.5/test/socket_interaction_test.rb000066400000000000000000000003221222557024500217450ustar00rootroot00000000000000require './test/test_helper' class TestSocketInteraction < Test::Unit::TestCase def test_interaction # Issue #67 require 'backports' require 'socket' assert_equal nil, UDPSocket.open{} end end backports-3.3.5/test/test_helper.rb000066400000000000000000000000241222557024500173340ustar00rootroot00000000000000require 'test/unit'