duct_tape 0.0.4

data/lib/ext/pathname.rb

@@ -0,0 +1,114 @@
+require 'pathname'
+
+class Pathname
+  # Cross-platform way of finding an executable in the $PATH.
+  #
+  #   Pathname.which('ruby') #=> /usr/bin/ruby
+  def self.which(cmd)
+    paths = ENV['PATH'].split(File::PATH_SEPARATOR).uniq
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    names = exts.map { |ext| "#{cmd}#{ext}" }
+    return do_search(paths, *names) { |f| f.executable? }
+  end
+
+  def self.library(lib)
+    paths = [
+      '/usr/local/lib64',
+      '/usr/local/lib',
+      '/usr/local/libdata',
+      '/opt/local/lib',
+      '/usr/lib64',
+      '/usr/lib',
+      '/usr/X11/lib',
+      '/usr/share',
+    ].uniq
+    names = [lib, "#{lib}.so", "lib#{lib}", "lib#{lib}.so"]
+
+    if detect_os[:platform] == "windows"
+      names = [
+        lib, "#{lib}.dll", "#{lib}.dll.a",
+        "lib#{lib}", "lib#{lib}.dll", "lib#{lib}.dll.a"
+      ]
+      paths = [
+        calling_method_dirname,
+        Dir.pwd,
+        File.join(ENV["SystemRoot"], "system"),
+        File.join(ENV["SystemRoot"], "system32"),
+        ENV["SystemRoot"],
+      ].compact.uniq
+      paths |= ENV['PATH'].split(File::PATH_SEPARATOR).uniq
+    end
+
+    return do_search(paths, *names) { |f| f.readable? && f.file? }
+  end
+
+  def self.header(hdr)
+    paths = [
+      "/usr/local/include",
+      "/opt/include",
+      "/usr/include",
+      RbConfig::CONFIG["includedir"],
+      RbConfig::CONFIG["oldincludedir"],
+    ].compact.uniq
+    names = [hdr, hdr + ".h", hdr + ".hpp"]
+    return do_search(paths, *names) { |f| f.readable? && f.file? }
+  end
+
+  def self.join(*paths)
+    new(File.join(*paths))
+  end
+
+  def to_file(*args, &block)
+    File.open(to_s, *args, &block)
+  end
+
+  def to_dir(*args, &block)
+    Dir.new(to_s, *args, &block)
+  end
+
+=begin
+  def to_object(*args, &block)
+    if socket?
+      if defined?(::UNIXSocket)
+        ::UNIXSocket.new(path)
+      else
+        :socket
+      end
+    elsif symlink?
+      link = Pathname.new(File.readlink(name))
+      link = Pathname.join(File.dirname(to_s), link) if link !~ /\A#{SEPARATOR}/
+#      {:symlink => classify_file(link)}
+      link.to_object(*args, &block)
+    elsif directory?
+      (readable?) ? Dir.new(to_s, *args, &block) : :unreadable_directory
+    elsif file?
+      (readable?) ? File.open(to_s, *args, &block) : :unreadable_file
+    elsif blockdev?
+      :block_device
+    elsif chardev?
+      :char_device
+    end
+  rescue Errno::ECONNREFUSED
+    :unreadable_socket
+  rescue Errno::EPROTOTYPE
+    :socket
+  rescue Errno::EACCES
+    :unreadable_item
+  end
+=end
+  alias_method :exists?, :exist?
+
+  private
+
+  def self.do_search(paths, *try_names, &block)
+    try_names.flatten!
+    paths.each do |path|
+      pn = Pathname.new(path)
+      try_names.each do |name|
+        file = pn + name
+        return file if yield(file)
+      end
+    end
+    nil
+  end
+end

data/lib/ext/range.rb

@@ -0,0 +1,7 @@
+class Range
+  # Converts to an array, then chunks into segments of maximum length
+  # (1..10).chunk(3) #=> [[1,2,3], [4,5,6], [7,8,9], [10]]
+  def chunk(max_length)
+    each_slice(max_length).to_a
+  end
+end

data/lib/ext/regexp.rb

@@ -0,0 +1,12 @@
+class Regexp
+  def invert
+    if @inverse
+      %r{#{@inverse}}
+    else
+      ret = %r{\A(?:(?!#{source}).)+\z}
+      ret.instance_exec(source) { |src| @inverse = src }
+      ret
+    end
+  end
+  alias_method :inverse, :invert
+end

data/lib/ext/string.rb

@@ -0,0 +1,54 @@
+class String
+  def uncolorize
+    self.gsub(/\e\[0[;0-9]*m/, "")
+  end
+
+  def colorized?
+    self =~ /\e\[0[;0-9]*m/ && true || false
+  end
+
+  def word_wrap(width=(tty_width || 80).to_i)
+    ret = dup
+    ret.word_wrap!(width)
+    ret
+  end
+
+  def word_wrap!(width=(tty_width || 80).to_i)
+    self.gsub!(/(.{1,#{width}})( +|$\n?)|(.{1,#{width}})/, "\\1\\3\n")
+  end
+
+  def chunk(max_length)
+    type_assert(max_length, Integer)
+    chars.each_slice(max_length).to_a.map! { |ary| ary.join("") }
+  end
+
+  def %(arg)
+    if ::RUBY_VERSION <= "1.8.7" && arg.is_a?(Hash)
+      return gsub(/%\{(\w+)\}/) do |s|
+        if arg.has_key?($1.to_sym)
+          arg[$1.to_sym]
+        else
+          raise KeyError.new("key{#{$1}} not found")
+        end
+      end
+    elsif arg.is_a?(Array)
+      return Kernel.sprintf(self, *arg)
+    else
+      return Kernel.sprintf(self, arg)
+    end
+  end
+
+  # Transform self to a Date
+  def to_date
+    Date.parse(self)
+  end
+
+  # Transform self to a Time
+  def to_time
+    Time.parse(self)
+  end
+
+  def to_const
+    split("::").inject(::Object) { |k,c| k.const_get(c) }
+  end
+end

data/lib/ext/symbol.rb

@@ -0,0 +1,8 @@
+class Symbol
+  unless method_defined?(:<=>)
+    def <=>(other)
+      return nil unless other.is_a?(Symbol)
+      to_s <=> other.to_s
+    end
+  end
+end

data/lib/ext/time.rb

@@ -0,0 +1,32 @@
+class Time
+  def self.duration(num, usecs=false)
+    type_assert(num, Numeric)
+    secs  = num.to_i
+    mins  = secs / 60
+    hours = mins / 60
+    days  = hours / 24
+
+    secs  = num if usecs
+
+    day_str = (days == 1 ? "day" : "days")
+    hour_str = (hours % 24 == 1 ? "hour" : "hours")
+    min_str = (mins % 60 == 1 ? "minute" : "minutes")
+    sec_str = (secs % 60 == 1 ? "second" : "seconds")
+
+    str_ary = []
+    str_ary << "#{days} #{day_str}" if days > 0
+    str_ary << "#{hours % 24} #{hour_str}" if hours > 0
+    str_ary << "#{mins % 60} #{min_str}" if mins > 0
+    str_ary << "#{secs % 60} #{sec_str}" if secs > 0
+    if str_ary.size > 2
+      [str_ary[0..-2].join(", "), str_ary[-1]].join(", and ")
+    else
+      str_ary.join(" and ")
+    end
+  end
+
+  # Transform a Time to a DateTime
+  def to_datetime
+    DateTime.parse(self.to_s)
+  end
+end

data/lib/ext/uri.rb

@@ -0,0 +1,16 @@
+require 'pathname'
+require 'uri'
+
+class URI::Generic
+  def relative_path?
+    relative? && !path.empty? && Pathname.new(path).relative?
+  end
+
+  def absolute_path?
+    relative? && Pathname.new(path).absolute?
+  end
+
+  def relative_scheme?
+    scheme.nil? && (!host.nil? || !path.empty?)
+  end
+end

data/spec/algorithms/containers/heap_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper.rb")
+
+#
+# Containers::Heap#to_a
+#
+describe Containers::Heap, "#to_a" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::Heap#each
+#
+describe Containers::Heap, "#each" do
+  it "remains unchanged" do
+    # TODO
+  end
+end

data/spec/algorithms/containers/priority_queue_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper.rb")
+
+#
+# Containers::PriorityQueue#to_a
+#
+describe Containers::PriorityQueue, "#to_a" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::PriorityQueue#each
+#
+describe Containers::PriorityQueue, "#each" do
+  it "remains unchanged" do
+    # TODO
+  end
+end

data/spec/duct_tape/autoassociative_array_spec.rb

@@ -0,0 +1,139 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper.rb")
+
+#
+# Containers::AutoassociativeArray#initialize
+#
+describe Containers::AutoassociativeArray, "#initialize" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#insert
+#
+describe Containers::AutoassociativeArray, "#insert" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#<<
+#
+describe Containers::AutoassociativeArray, "#<<" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#partial_match
+#
+describe Containers::AutoassociativeArray, "#partial_match" do
+  it "remains unchanged" do
+    # TODO
+  end
+
+  it "returns the matches with the most query matches" do
+    aa = Containers::AutoassociativeArray.new
+    aa << [1,2,3] << [2,3,4] << [3,4,5]
+    aa.partial_match(1,4,5).should eq([3,4,5])
+  end
+
+  it "returns all of the matches with the most query matches" do
+    aa = Containers::AutoassociativeArray.new
+    aa << [1,2,3] << [2,3,4] << [3,4,5]
+    aa.partial_match(1,5).should eq([[1,2,3], [3,4,5]])
+    aa.partial_match(1,3,5).should eq([[1,2,3], [3,4,5]])
+    aa.partial_match(2,4).should eq([2,3,4])
+  end
+
+  it "returns the matches with the most query matches with the most matches" do
+    aa = Containers::AutoassociativeArray.new
+    aa << [1,2,3] << [2,3,4] << [3,4,5]
+    aa.partial_match(1,4).should eq([[2,3,4], [3,4,5]])
+    aa.partial_match(2,5).should eq([[1,2,3], [2,3,4]])
+  end
+end
+
+#
+# Containers::AutoassociativeArray#[]
+#
+describe Containers::AutoassociativeArray, "#[]" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#by_column
+#
+describe Containers::AutoassociativeArray, "#by_column" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#empty?
+#
+describe Containers::AutoassociativeArray, "#empty?" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#length
+#
+describe Containers::AutoassociativeArray, "#length" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#size
+#
+describe Containers::AutoassociativeArray, "#size" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#clear
+#
+describe Containers::AutoassociativeArray, "#clear" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#inspect
+#
+describe Containers::AutoassociativeArray, "#inspect" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#to_s
+#
+describe Containers::AutoassociativeArray, "#to_s" do
+  it "remains unchanged" do
+    # TODO
+  end
+end
+
+#
+# Containers::AutoassociativeArray#dup
+#
+describe Containers::AutoassociativeArray, "#dup" do
+  it "remains unchanged" do
+    # TODO
+  end
+end