tiny_tds 1.0.4 → 2.1.5

data/ext/tiny_tds/extconf.rb

@@ -3,327 +3,71 @@ ENV['RC_ARCHS'] = '' if RUBY_PLATFORM =~ /darwin/
 # :stopdoc:
 
 require 'mkmf'
-require 'fileutils'
-
-# The gem version constraint in the gemspec is not respected at install time.
-# Keep this version in sync with the one in the gemspec !
-gem 'mini_portile2', '~> 2.0'
-require 'mini_portile2'
+require 'rbconfig'
 require_relative './extconsts'
 
-OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE
-
 # Shamelessly copied from nokogiri
 #
 
 def do_help
   print <<HELP
 usage: ruby #{$0} [options]
-
-    --enable-system-freetds / --disable-system-freetds
-    --enable-system-iconv   / --disable-system-iconv
-    --enable-system-openssl / --disable-system-openssl
-      Force use of system or builtin freetds/iconv/openssl library.
-      Default is to prefer system libraries and fallback to builtin.
-
     --with-freetds-dir=DIR
       Use the freetds library placed under DIR.
-
-    --enable-lookup
-      Search for freetds through all paths in the PATH environment variable.
-
-    --disable-openssl
-      Disable OpenSSL for freetds build. No effect on system-freetds.
-
-    --enable-gnutls
-      Use GnuTLS instead of OpenSSL for freetds build.
-
-    --enable-cross-build
-      Do cross-build.
 HELP
   exit! 0
 end
 
 do_help if arg_config('--help')
 
-FREETDSDIR = ENV['FREETDS_DIR']
-
-if FREETDSDIR.nil? || FREETDSDIR.empty?
-  LIBDIR     = RbConfig::CONFIG['libdir']
-  INCLUDEDIR = RbConfig::CONFIG['includedir']
-else
-  puts "Will use #{FREETDSDIR}"
-  LIBDIR = "#{FREETDSDIR}/lib"
-  INCLUDEDIR = "#{FREETDSDIR}/include"
-end
-
-$CFLAGS  << " #{ENV["CFLAGS"]}"
-$LDFLAGS << " #{ENV["LDFLAGS"]}"
-$LIBS    << " #{ENV["LIBS"]}"
-
-SEARCHABLE_PATHS = begin
-  eop_regexp = /#{File::SEPARATOR}bin$/
-  paths = ENV['PATH']
-  paths = paths.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
-  paths = paths.split(File::PATH_SEPARATOR)
-  bin_paths = paths.select{ |p| p =~ eop_regexp }
-  bin_paths.map{ |p| p.sub(eop_regexp,'') }.compact.reject{ |p| p.empty? }.uniq
-end
-
-def searchable_paths_with_directories(*directories)
-  SEARCHABLE_PATHS.map do |path|
-    directories.map do |paths|
-      dir = File.join path, *paths
-      File.directory?(dir) ? dir : nil
-    end.flatten.compact
-  end.flatten.compact
-end
-
-class BuildRecipe < MiniPortile
-  def initialize(name, version, files)
-    super(name, version)
-    self.files = files
-    self.target = File.expand_path('../../../ports', __FILE__)
-    self.host = consolidated_host(RbConfig::CONFIG["host"])
-    self.patch_files = Dir[File.join(self.target, "patches", self.name, self.version, "*.diff")].sort
-  end
-
-  def consolidated_host(name)
-     # Host name and prefix of build tools are different on Windows 32 bit.
-    name.gsub('i686-pc-mingw32', 'i686-w64-mingw32')
-  end
-
-  def configure_defaults
-    [
-      "--host=#{host}",    # build for specific target (host)
-      "--disable-static",
-      "--enable-shared",
-    ]
-  end
-
-  # Use the same path for all recipes, so that only one include/lib path is required.
-  def port_path
-    "#{target}/#{host}"
-  end
-
-  # We use the same port_path for all recipes. That breaks the standard installed? method.
-  def installed?
-    false
-  end
-
-  # When using rake-compiler-dock on Windows, the underlying Virtualbox shared
-  # folders don't support symlinks, but libiconv expects it for a build on
-  # Linux. We work around this limitation by using the temp dir for cooking.
-  def chdir_for_build
-    build_dir = ENV['RCD_HOST_RUBY_PLATFORM'].to_s =~ /mingw|mswin|cygwin/ ? '/tmp' : '.'
-    Dir.chdir(build_dir) do
-      yield
-    end
-  end
-
-  def cook_and_activate
-    checkpoint = File.join(self.target, "#{self.name}-#{self.version}-#{self.host}.installed")
-    unless File.exist?(checkpoint)
-      chdir_for_build do
-        self.cook
-      end
-      FileUtils.touch checkpoint
-    end
-    self.activate
-    self
-  end
-end
-
-def define_libssl_recipe(host)
-  BuildRecipe.new("openssl", OPENSSL_VERSION, [OPENSSL_SOURCE_URI]).tap do |recipe|
-    class << recipe
-      def extract_file(file, target)
-        filename = File.basename(file)
-        FileUtils.mkdir_p target
-
-        message "Extracting #{filename} into #{target}... "
-        result = `#{tar_exe} #{tar_compression_switch(filename)}xf "#{file}" -C "#{target}" 2>&1`
-        if $?.success?
-          output "OK"
-        else
-          # tar on windows returns error exit code, because it can not extract symlinks
-          output "ERROR (ignored)"
-        end
-      end
-
-      def configure
-        config = if host=~/mingw/
-          host=~/x86_64/ ? 'mingw64' : 'mingw'
-        end
-        args = [ "CFLAGS=-DDSO_WIN32",
-            "./Configure",
-            "no-shared",
-            configure_prefix,
-            config,
-          ]
-        args.unshift("CROSS_COMPILE=#{host}-") if enable_config("cross-build")
-
-        execute "configure", "sh -c \"#{args.join(" ")}\""
-      end
-
-      def compile
-        super
-        # OpenSSL DLLs are called "libeay32.dll" and "ssleay32.dll" per default,
-        # regardless to the version. This is best suited to meet the Windows DLL hell.
-        # To avoid any conflicts we do a static build and build DLLs afterwards,
-        # with our own naming scheme.
-        execute "mkdef-libeay32", "(perl util/mkdef.pl 32 libeay >libeay32.def)"
-        execute "mkdef-ssleay32", "(perl util/mkdef.pl 32 ssleay >ssleay32.def)"
-        dllwrap = consolidated_host(RbConfig::CONFIG["DLLWRAP"])
-        execute "dllwrap-libeay32", "#{dllwrap} --dllname libeay32-#{version}-#{host}.dll --output-lib libcrypto.dll.a --def libeay32.def libcrypto.a -lwsock32 -lgdi32 -lcrypt32"
-        execute "dllwrap-ssleay32", "#{dllwrap} --dllname ssleay32-#{version}-#{host}.dll --output-lib libssl.dll.a --def ssleay32.def libssl.a libcrypto.dll.a"
-      end
-
-      def install
-        super
-        FileUtils.cp "#{work_path}/libeay32-#{version}-#{host}.dll", "#{path}/bin/"
-        FileUtils.cp "#{work_path}/ssleay32-#{version}-#{host}.dll", "#{path}/bin/"
-        FileUtils.cp "#{work_path}/libcrypto.dll.a", "#{path}/lib/"
-        FileUtils.cp "#{work_path}/libssl.dll.a", "#{path}/lib/"
-      end
-    end
-  end
+# Make sure to check the ports path for the configured host
+host = RbConfig::CONFIG['host']
+project_dir = File.expand_path("../../..", __FILE__)
+freetds_ports_dir = File.join(project_dir, 'ports', host, 'freetds', FREETDS_VERSION)
+freetds_ports_dir = File.expand_path(freetds_ports_dir)
+
+# Add all the special path searching from the original tiny_tds build
+# order is important here! First in, first searched.
+DIRS = %w(
+  /opt/local
+  /usr/local
+)
+
+# Add the ports directory if it exists for local developer builds
+DIRS.unshift(freetds_ports_dir) if File.directory?(freetds_ports_dir)
+
+# Grab freetds environment variable for use by people on services like
+# Heroku who they can't easily use bundler config to set directories
+DIRS.unshift(ENV['FREETDS_DIR']) if ENV.has_key?('FREETDS_DIR')
+
+# Add the search paths for freetds configured above
+ldirs = DIRS.flat_map do |path|
+  ldir = "#{path}/lib"
+  [ldir, "#{ldir}/freetds"]
 end
 
-def define_libiconv_recipe(host)
-  BuildRecipe.new("libiconv", ICONV_VERSION, [ICONV_SOURCE_URI]).tap do |recipe|
-    # always produce position independent code
-    recipe.configure_options << "CFLAGS=-fPIC"
-  end
+idirs = DIRS.flat_map do |path|
+  idir = "#{path}/include"
+  [idir, "#{idir}/freetds"]
 end
 
-def define_freetds_recipe(host, libiconv, libssl, gnutls)
-  BuildRecipe.new("freetds", FREETDS_VERSION, [FREETDS_SOURCE_URI]).tap do |recipe|
-    with_tdsver = FREETDS_VERSION =~ /0\.91/ ? "--with-tdsver=7.1" : "--with-tdsver=7.3"
-    for_windows = recipe.host =~ /mswin|mingw/i
-    recipe.configure_options << '--with-pic'
-    recipe.configure_options << "--with-libiconv-prefix=#{libiconv.path}" if libiconv
-    if true == libssl
-      recipe.configure_options << "--with-openssl"
-    elsif libssl
-      recipe.configure_options << "--with-openssl=#{libssl.path}"
-    end
-    recipe.configure_options << "--with-gnutls" if gnutls
-    recipe.configure_options << '--sysconfdir=C:\Sites' if for_windows
-    recipe.configure_options << '--enable-sspi' if for_windows
-    recipe.configure_options << "--disable-odbc"
-    recipe.configure_options << with_tdsver
-    if libiconv
-      # For some reason freetds doesn't honor --with-libiconv-prefix
-      # so we have do add it by hand:
-      recipe.configure_options << "CFLAGS=-I#{libiconv.path}/include"
-      recipe.configure_options << "LDFLAGS=-L#{libiconv.path}/lib -liconv"
-    end
-
-    class << recipe
-
-      def install
-        super_value = super
-        # Install binstub target binaries.
-        if super_value
-          bin_path = File.expand_path File.join(path, 'bin')
-          exe_path = File.expand_path File.join(target, '..', 'exe')
-          return unless File.directory?(bin_path)
-          ['tsql', 'defncopy'].each do |bin|
-            ['.exe', ''].each do |ext|
-              exe = File.join bin_path, "#{bin}#{ext}"
-              next unless File.exists?(exe)
-              next unless File.executable?(exe)
-              FileUtils.cp exe, exe_path
-            end
-          end
-        end
-        super_value
-      end
-
-    end
-
-  end
+puts "looking for freetds headers in the following directories:\n#{idirs.map{|a| " - #{a}\n"}.join}"
+puts "looking for freetds library in the following directories:\n#{ldirs.map{|a| " - #{a}\n"}.join}"
+dir_config('freetds', idirs, ldirs)
+
+have_dependencies = [
+  find_header('sybfront.h'),
+  find_header('sybdb.h'),
+  find_library('sybdb', 'tdsdbopen'),
+  find_library('sybdb', 'dbanydatecrack')
+].inject(true) do |memo, current|
+  memo && current
 end
 
-if RbConfig::CONFIG['target_os'] =~ /mswin32|mingw32/
-  lib_prefix = 'lib' unless RbConfig::CONFIG['target_os'] =~ /mingw32/
-  # There's no default include/lib dir on Windows. Let's just add the Ruby ones
-  # and resort on the search path specified by INCLUDE and LIB environment
-  # variables
-  HEADER_DIRS = [INCLUDEDIR]
-  LIB_DIRS = [LIBDIR]
-else
-  lib_prefix = ''
-  HEADER_DIRS = [
-    # First search /opt/local for macports
-    '/opt/local/include',
-    # Then search /usr/local for people that installed from source
-    '/usr/local/include',
-    # Check the ruby install locations
-    INCLUDEDIR,
-    # Finally fall back to /usr
-    '/usr/include'
-  ].reject{ |dir| !File.directory?(dir) }
-  LIB_DIRS = [
-    # First search /opt/local for macports
-    '/opt/local/lib',
-    # Then search /usr/local for people that installed from source
-    '/usr/local/lib',
-    # Check the ruby install locations
-    LIBDIR,
-    # Finally fall back to /usr
-    '/usr/lib',
-  ].reject{ |dir| !File.directory?(dir) }
+unless have_dependencies
+  abort 'Failed! Do you have FreeTDS 0.95.80 or higher installed?'
 end
 
-FREETDS_HEADER_DIRS = (searchable_paths_with_directories(['include'],['include','freetds']) + HEADER_DIRS).uniq
-FREETDS_LIB_DIRS = (searchable_paths_with_directories(['lib'],['lib','freetds']) + LIB_DIRS).uniq
-
-# lookup over searchable paths is great for native compilation, however, when
-# cross compiling we need to specify our own paths.
-if enable_config("lookup", true)
-  dir_config('freetds', FREETDS_HEADER_DIRS, FREETDS_LIB_DIRS)
-else
-  dir_config('freetds')
-
-  # remove LDFLAGS
-  $LDFLAGS = ENV.fetch("LDFLAGS", "")
-end
-
-def asplode(lib)
-  msg = "-----\n"
-  msg << "#{lib} is missing.\n"
-  msg << "Do you have FreeTDS 0.95.80 or higher installed?\n" if lib == 'freetds'
-  msg << "-----"
-  abort(msg)
-end
-
-def freetds_usable?(lib_prefix)
-  have_header('sybfront.h') && have_header('sybdb.h') &&
-    find_library("#{lib_prefix}sybdb", 'tdsdbopen') &&
-    find_library("#{lib_prefix}sybdb", 'dbanydatecrack')
-end
-
-# We use freetds, when available already, and fallback to compilation of ports
-system_freetds = enable_config('system-freetds', ENV['TINYTDS_SKIP_PORTS'] || freetds_usable?(lib_prefix))
-
-# We expect to have iconv and OpenSSL available on non-Windows systems
-host = RbConfig::CONFIG["host"]
-system_iconv = enable_config('system-iconv', host =~ /mingw|mswin/ ? false : true)
-system_openssl = enable_config('system-openssl', host =~ /mingw|mswin/ ? false : true )
-enable_gnutls = enable_config('gnutls', false )
-enable_openssl = enable_config('openssl', !enable_gnutls )
-
-unless system_freetds
-  libssl = define_libssl_recipe(host).cook_and_activate unless system_openssl
-  libiconv = define_libiconv_recipe(host).cook_and_activate unless system_iconv
-  freetds = define_freetds_recipe(host, libiconv, libssl || enable_openssl, enable_gnutls).cook_and_activate
-  dir_config('freetds', freetds.path + "/include", freetds.path + "/lib")
-end
-
-asplode 'freetds'  unless freetds_usable?(lib_prefix)
-
 create_makefile('tiny_tds/tiny_tds')
 
 # :startdoc:

data/ext/tiny_tds/extconsts.rb

@@ -1,15 +1,15 @@
 
-ICONV_VERSION = ENV['TINYTDS_ICONV_VERSION'] || "1.14"
+ICONV_VERSION = ENV['TINYTDS_ICONV_VERSION'] || "1.15"
 ICONV_SOURCE_URI = "http://ftp.gnu.org/pub/gnu/libiconv/libiconv-#{ICONV_VERSION}.tar.gz"
 
-OPENSSL_VERSION = ENV['TINYTDS_OPENSSL_VERSION'] || '1.0.2g'
+OPENSSL_VERSION = ENV['TINYTDS_OPENSSL_VERSION'] || '1.1.1d'
 OPENSSL_SOURCE_URI = "https://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz"
 
-FREETDS_VERSION = ENV['TINYTDS_FREETDS_VERSION'] || "1.00"
+FREETDS_VERSION = ENV['TINYTDS_FREETDS_VERSION'] || "1.1.24"
 FREETDS_VERSION_INFO = Hash.new { |h,k|
-  h[k] = {files: "ftp://ftp.freetds.org/pub/freetds/stable/freetds-#{k}.tar.bz2"}
+  h[k] = {files: "http://www.freetds.org/files/stable/freetds-#{k}.tar.bz2"}
 }
-FREETDS_VERSION_INFO['1.00'] = {files: 'ftp://ftp.freetds.org/pub/freetds/stable/freetds-1.00.tar.bz2'}
-FREETDS_VERSION_INFO['0.99'] = {files: 'ftp://ftp.freetds.org/pub/freetds/current/freetds-dev.0.99.678.tar.gz'}
-FREETDS_VERSION_INFO['0.95'] = {files: 'ftp://ftp.freetds.org/pub/freetds/stable/freetds-0.95.92.tar.gz'}
+FREETDS_VERSION_INFO['1.00'] = {files: 'http://www.freetds.org/files/stable/freetds-1.00.tar.bz2'}
+FREETDS_VERSION_INFO['0.99'] = {files: 'http://www.freetds.org/files/current/freetds-dev.0.99.678.tar.gz'}
+FREETDS_VERSION_INFO['0.95'] = {files: 'http://www.freetds.org/files/stable/freetds-0.95.92.tar.gz'}
 FREETDS_SOURCE_URI = FREETDS_VERSION_INFO[FREETDS_VERSION][:files]

data/ext/tiny_tds/result.c

@@ -6,10 +6,10 @@
 
 VALUE cTinyTdsResult;
 extern VALUE mTinyTds, cTinyTdsClient, cTinyTdsError;
-VALUE cBigDecimal, cDate;
+VALUE cKernel, cDate;
 VALUE opt_decimal_zero, opt_float_zero, opt_one, opt_zero, opt_four, opt_19hdr, opt_onek, opt_tenk, opt_onemil, opt_onebil;
 static ID intern_new, intern_utc, intern_local, intern_localtime, intern_merge,
-          intern_civil, intern_new_offset, intern_plus, intern_divide;
+          intern_civil, intern_new_offset, intern_plus, intern_divide, intern_bigd;
 static ID sym_symbolize_keys, sym_as, sym_array, sym_cache_rows, sym_first, sym_timezone, sym_local, sym_utc, sym_empty_sets;
 
 
@@ -86,25 +86,40 @@ static void dbcancel_ubf(DBPROCESS *client) {
 static void nogvl_setup(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   userdata->nonblocking = 1;
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors = malloc(ERRORS_STACK_INIT_SIZE * sizeof(tinytds_errordata));
+  userdata->nonblocking_errors_size = ERRORS_STACK_INIT_SIZE;
 }
 
 static void nogvl_cleanup(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   userdata->nonblocking = 0;
+  userdata->timing_out = 0;
   /*
   Now that the blocking operation is done, we can finally throw any
   exceptions based on errors from SQL Server.
   */
-  if (userdata->nonblocking_error.is_set) {
-    userdata->nonblocking_error.is_set = 0;
-    rb_tinytds_raise_error(client,
-      userdata->nonblocking_error.cancel,
-      userdata->nonblocking_error.error,
-      userdata->nonblocking_error.source,
-      userdata->nonblocking_error.severity,
-      userdata->nonblocking_error.dberr,
-      userdata->nonblocking_error.oserr);
+  short int i;
+  for (i = 0; i < userdata->nonblocking_errors_length; i++) {
+    tinytds_errordata error = userdata->nonblocking_errors[i];
+
+    // lookahead to drain any info messages ahead of raising error
+    if (!error.is_message) {
+      short int j;
+      for (j = i; j < userdata->nonblocking_errors_length; j++) {
+        tinytds_errordata msg_error = userdata->nonblocking_errors[j];
+        if (msg_error.is_message) {
+          rb_tinytds_raise_error(client, msg_error);
+        }
+      }
+    }
+
+    rb_tinytds_raise_error(client, error);
   }
+
+  free(userdata->nonblocking_errors);
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static RETCODE nogvl_dbsqlok(DBPROCESS *client) {
@@ -227,7 +242,7 @@ static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_
           int data_slength = (int)data_info->precision + (int)data_info->scale + 1;
           char converted_decimal[data_slength];
           dbconvert(rwrap->client, coltype, data, data_len, SYBVARCHAR, (BYTE *)converted_decimal, -1);
-          val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new2((char *)converted_decimal));
+          val = rb_funcall(cKernel, intern_bigd, 1, rb_str_new2((char *)converted_decimal));
           break;
         }
         case SYBFLT8: {
@@ -245,7 +260,7 @@ static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_
           char converted_money[25];
           long long money_value = ((long long)money->mnyhigh << 32) | money->mnylow;
           sprintf(converted_money, "%" LONG_LONG_FORMAT, money_value);
-          val = rb_funcall(cBigDecimal, intern_new, 2, rb_str_new2(converted_money), opt_four);
+          val = rb_funcall(cKernel, intern_bigd, 2, rb_str_new2(converted_money), opt_four);
           val = rb_funcall(val, intern_divide, 1, opt_tenk);
           break;
         }
@@ -253,7 +268,7 @@ static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_
           DBMONEY4 *money = (DBMONEY4 *)data;
           char converted_money[20];
           sprintf(converted_money, "%f", money->mny4 / 10000.0);
-          val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new2(converted_money));
+          val = rb_funcall(cKernel, intern_bigd, 1, rb_str_new2(converted_money));
           break;
         }
         case SYBBINARY:
@@ -325,6 +340,15 @@ static VALUE rb_tinytds_result_fetch_row(VALUE self, ID timezone, int symbolize_
         case SYBTEXT:
           val = ENCODED_STR_NEW(data, data_len);
           break;
+        case 98: { // SYBVARIANT
+          if (data_len == 4) {
+            val = INT2NUM(*(DBINT *)data);
+            break;
+          } else {
+            val = ENCODED_STR_NEW(data, data_len);
+            break;
+          }
+        }
         default:
           val = ENCODED_STR_NEW(data, data_len);
           break;
@@ -556,7 +580,7 @@ static VALUE rb_tinytds_result_insert(VALUE self) {
 
 void init_tinytds_result() {
   /* Data Classes */
-  cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+  cKernel = rb_const_get(rb_cObject, rb_intern("Kernel"));
   cDate = rb_const_get(rb_cObject, rb_intern("Date"));
   /* Define TinyTds::Result */
   cTinyTdsResult = rb_define_class_under(mTinyTds, "Result", rb_cObject);
@@ -578,6 +602,7 @@ void init_tinytds_result() {
   intern_new_offset = rb_intern("new_offset");
   intern_plus = rb_intern("+");
   intern_divide = rb_intern("/");
+  intern_bigd = rb_intern("BigDecimal");
   /* Symbol Helpers */
   sym_symbolize_keys = ID2SYM(rb_intern("symbolize_keys"));
   sym_as = ID2SYM(rb_intern("as"));

data/lib/tiny_tds/bin.rb

@@ -1,72 +1,91 @@
 require_relative './version'
+require_relative './gem'
 require 'shellwords'
 
 module TinyTds
   class Bin
 
-    ROOT  = File.expand_path '../../..', __FILE__
-    PATHS = ENV['PATH'].split File::PATH_SEPARATOR
-    EXTS  = (ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']) | ['.exe']
-
     attr_reader :name
 
     class << self
-
       def exe(name, *args)
         bin = new(name)
-        puts bin.info
+        puts bin.info unless args.any? { |x| x == '-q' }
         bin.run(*args)
       end
-
     end
 
     def initialize(name)
+      @root = Gem.root_path
+      @exts = (ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']) | ['.exe']
+
       @name = name
       @binstub = find_bin
       @exefile = find_exe
     end
 
     def run(*args)
-      return nil unless path
-      Kernel.system Shellwords.join(args.unshift(path))
-      $?.to_i
+      with_ports_paths do
+        return nil unless path
+        Kernel.system Shellwords.join(args.unshift(path))
+        $CHILD_STATUS.to_i
+      end
     end
 
     def path
-      return @path if defined?(@path)
-      @path = @exefile && File.exists?(@exefile) ? @exefile : which
+      @path ||= @exefile && File.exist?(@exefile) ? @exefile : which
     end
 
     def info
       "[TinyTds][v#{TinyTds::VERSION}][#{name}]: #{path}"
     end
 
-
     private
 
+    def search_paths
+      ENV['PATH'].split File::PATH_SEPARATOR
+    end
+
+    def with_ports_paths
+      old_path = ENV['PATH']
+
+      begin
+        ENV['PATH'] = [
+          Gem.ports_bin_paths,
+          old_path
+        ].flatten.join File::PATH_SEPARATOR
+
+        yield if block_given?
+      ensure
+        ENV['PATH'] = old_path
+      end
+    end
+
     def find_bin
-      File.join ROOT, 'bin', name
+      File.join @root, 'bin', name
     end
 
     def find_exe
-      EXTS.each do |ext|
-        f = File.join ROOT, 'exe', "#{name}#{ext}"
-        return f if File.exists?(f)
+      Gem.ports_bin_paths.each do |bin|
+        @exts.each do |ext|
+          f = File.join bin, "#{name}#{ext}"
+          return f if File.exist?(f)
+        end
       end
       nil
     end
 
     def which
-      PATHS.each do |path|
-        EXTS.each do |ext|
-          exe = File.expand_path File.join(path, "#{name}#{ext}"), ROOT
+      search_paths.each do |path|
+        @exts.each do |ext|
+          exe = File.expand_path File.join(path, "#{name}#{ext}"), @root
           next if exe == @binstub
-          next if !File.executable?(exe)
-          next if !binary?(exe)
+          next unless File.executable?(exe)
+          next unless binary?(exe)
           return exe
         end
       end
-      return nil
+      nil
     end
 
     # Implementation directly copied from ptools.
@@ -77,10 +96,9 @@ module TinyTds
       bytes = File.stat(file).blksize
       return false unless bytes
       bytes = 4096 if bytes > 4096
-      s = (File.read(file, bytes) || "")
-      s = s.encode('US-ASCII', :undef => :replace).split(//)
-      ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
+      s = (File.read(file, bytes) || '')
+      s = s.encode('US-ASCII', undef: :replace).split(//)
+      ((s.size - s.grep(' '..'~').size) / s.size.to_f) > 0.30
     end
-
   end
 end