sqlite3-ruby 1.3.2 → 1.3.3.beta.1

data/tasks/faq.rake

@@ -1,9 +0,0 @@
-# Generate FAQ
-desc "Generate the FAQ document"
-task :faq => ['faq/faq.html']
-
-file 'faq/faq.html' => ['faq/faq.rb', 'faq/faq.yml'] do
-  cd 'faq' do
-    ruby "faq.rb > faq.html"
-  end
-end

data/tasks/gem.rake

@@ -1,31 +0,0 @@
-begin
-  require 'hoe'
-rescue LoadError
-  # try with rubygems?
-  require 'rubygems'
-  require 'hoe'
-end
-
-Hoe.plugin :debugging, :doofus, :git
-
-HOE = Hoe.spec 'sqlite3-ruby' do
-  developer           'Jamis Buck', 'jamis@37signals.com'
-  developer           'Luis Lavena', 'luislavena@gmail.com'
-  developer           'Aaron Patterson', 'aaron@tenderlovemaking.com'
-
-  self.readme_file   = 'README.rdoc'
-  self.history_file  = 'CHANGELOG.rdoc'
-  self.extra_rdoc_files  = FileList['*.rdoc', 'ext/**/*.c']
-
-  spec_extras[:required_ruby_version]     = Gem::Requirement.new('>= 1.8.7')
-  spec_extras[:required_rubygems_version] = '>= 1.3.5'
-  spec_extras[:extensions]                = ["ext/sqlite3/extconf.rb"]
-
-  extra_dev_deps << ['rake-compiler', "~> 0.7.0"]
-
-  clean_globs.push('**/test.db')
-end
-
-Hoe.add_include_dirs '.'
-
-# vim: syntax=ruby

data/tasks/native.rake

@@ -1,61 +0,0 @@
-# use rake-compiler for building the extension
-require 'rake/extensiontask'
-
-# NOTE: version used by cross compilation of Windows native extension
-# It do not affect compilation under other operating systems
-# The version indicated is the minimum DLL suggested for correct functionality
-BINARY_VERSION = '3.7.3'
-URL_VERSION = BINARY_VERSION.gsub('.', '_')
-
-# build sqlite3_native C extension
-Rake::ExtensionTask.new('sqlite3_native', HOE.spec) do |ext|
-  # where to locate the extension
-  ext.ext_dir = 'ext/sqlite3'
-
-  # where native extension will be copied (matches makefile)
-  ext.lib_dir = "lib/sqlite3"
-
-  # reference to the sqlite3 library
-  sqlite3_lib = File.expand_path(File.join(File.dirname(__FILE__), '..', 'vendor', 'sqlite3'))
-
-  # clean binary folders always
-  CLEAN.include("#{ext.lib_dir}/?.?")
-
-  # automatically add build options to avoid need of manual input
-  if RUBY_PLATFORM =~ /mswin|mingw/ then
-    # define target for extension (supporting fat binaries)
-    RUBY_VERSION =~ /(\d+\.\d+)/
-    ext.lib_dir = "lib/sqlite3/#{$1}"
-    ext.config_options << "--with-sqlite3-dir=#{sqlite3_lib}"
-  else
-    ext.cross_compile = true
-    ext.cross_platform = ['i386-mswin32-60', 'i386-mingw32']
-    ext.cross_config_options << "--with-sqlite3-dir=#{sqlite3_lib}"
-    ext.cross_compiling do |gemspec|
-      gemspec.post_install_message = <<-POST_INSTALL_MESSAGE
-
-=============================================================================
-
-  You've installed the binary version of #{gemspec.name}.
-  It was built using SQLite3 version #{BINARY_VERSION}.
-  It's recommended to use the exact same version to avoid potential issues.
-
-  At the time of building this gem, the necessary DLL files where available
-  in the following download:
-
-  http://www.sqlite.org/sqlitedll-#{URL_VERSION}.zip
-
-  You can put the sqlite3.dll available in this package in your Ruby bin
-  directory, for example C:\\Ruby\\bin
-
-=============================================================================
-
-      POST_INSTALL_MESSAGE
-    end
-  end
-end
-
-# ensure things are compiled prior testing
-task :test => [:compile]
-
-# vim: syntax=ruby

data/tasks/vendor_sqlite3.rake

@@ -1,104 +0,0 @@
-require 'rake/clean'
-require 'rake/extensioncompiler'
-
-# download sqlite3 library and headers
-
-# only on Windows or cross platform compilation
-def dlltool(dllname, deffile, libfile)
-  # define if we are using GCC or not
-  if Rake::ExtensionCompiler.mingw_gcc_executable then
-    dir = File.dirname(Rake::ExtensionCompiler.mingw_gcc_executable)
-    tool = case RUBY_PLATFORM
-      when /mingw/
-        File.join(dir, 'dlltool.exe')
-      when /linux|darwin/
-        File.join(dir, "#{Rake::ExtensionCompiler.mingw_host}-dlltool")
-    end
-    return "#{tool} --dllname #{dllname} --def #{deffile} --output-lib #{libfile}"
-  else
-    if RUBY_PLATFORM =~ /mswin/ then
-      tool = 'lib.exe'
-    else
-      fail "Unsupported platform for cross-compilation (please, contribute some patches)."
-    end
-    return "#{tool} /DEF:#{deffile} /OUT:#{libfile}"
-  end
-end
-
-# required folder structure for --with-sqlite3-dir (include + lib)
-directory "vendor/sqlite3/lib"
-directory "vendor/sqlite3/include"
-
-# download amalgamation version (for include files)
-file "vendor/sqlite-amalgamation-#{URL_VERSION}.zip" => ['vendor'] do |t|
-  url = "http://www.sqlite.org/#{File.basename(t.name)}"
-  when_writing "downloading #{t.name}" do
-    cd File.dirname(t.name) do
-      system "wget -c #{url} || curl -C - -O #{url}"
-    end
-  end
-end
-
-# download dll binaries
-file "vendor/sqlitedll-#{URL_VERSION}.zip" => ['vendor'] do |t|
-  url = "http://www.sqlite.org/#{File.basename(t.name)}"
-  when_writing "downloading #{t.name}" do
-    cd File.dirname(t.name) do
-      system "wget -c #{url} || curl -C - -O #{url}"
-    end
-  end
-end
-
-# extract header files into include folder
-file "vendor/sqlite3/include/sqlite3.h" => ['vendor/sqlite3/include', "vendor/sqlite-amalgamation-#{URL_VERSION}.zip"] do |t|
-  full_file = File.expand_path(t.prerequisites.last)
-  when_writing "creating #{t.name}" do
-    cd File.dirname(t.name) do
-      sh "unzip #{full_file}"
-      # update file timestamp to avoid Rake perform this extraction again.
-      touch File.basename(t.name)
-    end
-  end
-end
-
-# extract dll files into lib folder
-file "vendor/sqlite3/lib/sqlite3.dll" => ['vendor/sqlite3/lib', "vendor/sqlitedll-#{URL_VERSION}.zip"] do |t|
-  full_file = File.expand_path(t.prerequisites.last)
-  when_writing "creating #{t.name}" do
-    cd File.dirname(t.name) do
-      sh "unzip #{full_file}"
-      # update file timestamp to avoid Rake perform this extraction again.
-      touch File.basename(t.name)
-    end
-  end
-end
-
-# generate import library from definition and dll file
-file "vendor/sqlite3/lib/sqlite3.lib" => ["vendor/sqlite3/lib/sqlite3.dll"] do |t|
-  libfile = t.name
-  dllname = libfile.ext('dll')
-  deffile = libfile.ext('def')
-
-  when_writing "creating #{t.name}" do
-    sh dlltool(dllname, deffile, libfile)
-  end
-end
-
-# clean and clobber actions
-# All the uncompressed files must be removed at clean
-CLEAN.include('vendor/sqlite3')
-
-# clobber vendored packages
-CLOBBER.include('vendor')
-
-# vendor:sqlite3
-task 'vendor:sqlite3' => ["vendor/sqlite3/lib/sqlite3.lib", "vendor/sqlite3/include/sqlite3.h"]
-
-# hook into cross compilation vendored sqlite3 dependency
-if RUBY_PLATFORM =~ /mingw|mswin/ then
-  Rake::Task['compile'].prerequisites.unshift 'vendor:sqlite3'
-else
-  if Rake::Task.task_defined?(:cross)
-    Rake::Task['cross'].prerequisites.unshift 'vendor:sqlite3'
-  end
-end

data/test/helper.rb

@@ -1,3 +0,0 @@
-require 'sqlite3'
-require 'test/unit'
-require 'iconv'

data/test/test_backup.rb

@@ -1,33 +0,0 @@
-require File.expand_path('helper', File.dirname(__FILE__))
-
-module SQLite3
-  class TestBackup < Test::Unit::TestCase
-    def setup
-      @sdb = SQLite3::Database.new(':memory:')
-      @ddb = SQLite3::Database.new(':memory:')
-      @sdb.execute('CREATE TABLE foo (idx, val);');
-      @data = ('A'..'Z').map{|x|x * 40}
-      @data.each_with_index do |v, i|
-        @sdb.execute('INSERT INTO foo (idx, val) VALUES (?, ?);', [i, v])
-      end
-    end
-
-    def test_backup_step
-      b = SQLite3::Backup.new(@ddb, 'main', @sdb, 'main')
-      while b.step(1) == SQLite3::Constants::ErrorCode::OK
-        assert_not_equal(0, b.remaining)
-      end
-      assert_equal(0, b.remaining)
-      b.finish
-      assert_equal(@data.length, @ddb.execute('SELECT * FROM foo;').length)
-    end
-
-    def test_backup_all
-      b = SQLite3::Backup.new(@ddb, 'main', @sdb, 'main')
-      assert_equal(SQLite3::Constants::ErrorCode::DONE, b.step(-1))
-      assert_equal(0, b.remaining)
-      b.finish
-      assert_equal(@data.length, @ddb.execute('SELECT * FROM foo;').length)
-    end
-  end
-end

data/test/test_collation.rb

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'helper'
-
-module SQLite3
-  class TestCollation < Test::Unit::TestCase
-    class Comparator
-      attr_reader :calls
-      def initialize
-        @calls = []
-      end
-
-      def compare left, right
-        @calls << [left, right]
-        left <=> right
-      end
-    end
-
-    def setup
-      @db = SQLite3::Database.new(':memory:')
-      @create = "create table ex(id int, data string)"
-      @db.execute(@create);
-      [ [1, 'hello'], [2, 'world'] ].each do |vals|
-        @db.execute('insert into ex (id, data) VALUES (?, ?)', vals)
-      end
-    end
-
-    def test_custom_collation
-      comparator = Comparator.new
-
-      @db.collation 'foo', comparator
-
-      assert_equal comparator, @db.collations['foo']
-      @db.execute('select data from ex order by 1 collate foo')
-      assert_equal 1, comparator.calls.length
-    end
-
-    def test_remove_collation
-      comparator = Comparator.new
-
-      @db.collation 'foo', comparator
-      @db.collation 'foo', nil
-
-      assert_nil @db.collations['foo']
-      assert_raises(SQLite3::SQLException) do
-        @db.execute('select data from ex order by 1 collate foo')
-      end
-    end
-
-    if RUBY_VERSION >= '1.9.1'
-      def test_encoding
-        comparator = Comparator.new
-        @db.collation 'foo', comparator
-        @db.execute('select data from ex order by 1 collate foo')
-
-        a, b = *comparator.calls.first
-
-        assert_equal Encoding.find('UTF-8'), a.encoding
-        assert_equal Encoding.find('UTF-8'), b.encoding
-      end
-
-      def test_encoding_default_internal
-        warn_before = $-w
-        $-w = false
-        before_enc = Encoding.default_internal
-
-        Encoding.default_internal = 'EUC-JP'
-        comparator = Comparator.new
-        @db.collation 'foo', comparator
-        @db.execute('select data from ex order by 1 collate foo')
-
-        a, b = *comparator.calls.first
-
-        assert_equal Encoding.find('EUC-JP'), a.encoding
-        assert_equal Encoding.find('EUC-JP'), b.encoding
-      ensure
-        Encoding.default_internal = before_enc
-        $-w = warn_before
-      end
-    end
-  end
-end

data/test/test_database.rb

@@ -1,312 +0,0 @@
-require 'helper'
-require 'iconv'
-
-module SQLite3
-  class TestDatabase < Test::Unit::TestCase
-    def setup
-      @db = SQLite3::Database.new(':memory:')
-    end
-
-    def test_get_first_row
-      assert_equal [1], @db.get_first_row('SELECT 1')
-    end
-
-    def test_get_first_row_with_type_translation_and_hash_results
-      @db.results_as_hash = true
-      assert_equal({0=>1, "1"=>1}, @db.get_first_row('SELECT 1'))
-    end
-
-    def test_execute_with_type_translation_and_hash
-      @db.results_as_hash = true
-      rows = []
-      @db.execute('SELECT 1') { |row| rows << row }
-
-      assert_equal({0=>1, "1"=>1}, rows.first)
-    end
-
-    def test_encoding
-      assert @db.encoding, 'database has encoding'
-    end
-
-    def test_changes
-      @db.execute("CREATE TABLE items (id integer PRIMARY KEY AUTOINCREMENT, number integer)")
-      assert_equal 0, @db.changes
-      @db.execute("INSERT INTO items (number) VALUES (10)")
-      assert_equal 1, @db.changes
-      @db.execute_batch(
-        "UPDATE items SET number = (number + :nn) WHERE (number = :n)",
-        {"nn" => 20, "n" => 10})
-      assert_equal 1, @db.changes
-      assert_equal [[30]], @db.execute("select number from items")
-    end
-
-    def test_new
-      db = SQLite3::Database.new(':memory:')
-      assert db
-    end
-
-    def test_new_yields_self
-      thing = nil
-      SQLite3::Database.new(':memory:') do |db|
-        thing = db
-      end
-      assert_instance_of(SQLite3::Database, thing)
-    end
-
-    def test_new_with_options
-      db = SQLite3::Database.new(Iconv.conv('UTF-16LE', 'UTF-8', ':memory:'),
-                                 :utf16 => true)
-      assert db
-    end
-
-    def test_close
-      db = SQLite3::Database.new(':memory:')
-      db.close
-      assert db.closed?
-    end
-
-    def test_block_closes_self
-      thing = nil
-      SQLite3::Database.new(':memory:') do |db|
-        thing = db
-        assert !thing.closed?
-      end
-      assert thing.closed?
-    end
-
-    def test_prepare
-      db = SQLite3::Database.new(':memory:')
-      stmt = db.prepare('select "hello world"')
-      assert_instance_of(SQLite3::Statement, stmt)
-    end
-
-    def test_total_changes
-      db = SQLite3::Database.new(':memory:')
-      db.execute("create table foo ( a integer primary key, b text )")
-      db.execute("insert into foo (b) values ('hello')")
-      assert_equal 1, db.total_changes
-    end
-
-    def test_execute_returns_list_of_hash
-      db = SQLite3::Database.new(':memory:', :results_as_hash => true)
-      db.execute("create table foo ( a integer primary key, b text )")
-      db.execute("insert into foo (b) values ('hello')")
-      rows = db.execute("select * from foo")
-      assert_equal [{0=>1, "a"=>1, "b"=>"hello", 1=>"hello"}], rows
-    end
-
-    def test_execute_yields_hash
-      db = SQLite3::Database.new(':memory:', :results_as_hash => true)
-      db.execute("create table foo ( a integer primary key, b text )")
-      db.execute("insert into foo (b) values ('hello')")
-      db.execute("select * from foo") do |row|
-        assert_equal({0=>1, "a"=>1, "b"=>"hello", 1=>"hello"}, row)
-      end
-    end
-
-    def test_table_info
-      db = SQLite3::Database.new(':memory:', :results_as_hash => true)
-      db.execute("create table foo ( a integer primary key, b text )")
-      info = [{
-        "name"       => "a",
-        "pk"         => 1,
-        "notnull"    => 0,
-        "type"       => "integer",
-        "dflt_value" => nil,
-        "cid"        => 0
-      },
-      {
-        "name"       => "b",
-        "pk"         => 0,
-        "notnull"    => 0,
-        "type"       => "text",
-        "dflt_value" => nil,
-        "cid"        => 1
-      }]
-      assert_equal info, db.table_info('foo')
-    end
-
-    def test_total_changes_closed
-      db = SQLite3::Database.new(':memory:')
-      db.close
-      assert_raise(SQLite3::Exception) do
-        db.total_changes
-      end
-    end
-
-    def test_trace_requires_opendb
-      @db.close
-      assert_raise(SQLite3::Exception) do
-        @db.trace { |x| }
-      end
-    end
-
-    def test_trace_with_block
-      result = nil
-      @db.trace { |sql| result = sql }
-      @db.execute "select 'foo'"
-      assert_equal "select 'foo'", result
-    end
-
-    def test_trace_with_object
-      obj = Class.new {
-        attr_accessor :result
-        def call sql; @result = sql end
-      }.new
-
-      @db.trace(obj)
-      @db.execute "select 'foo'"
-      assert_equal "select 'foo'", obj.result
-    end
-
-    def test_trace_takes_nil
-      @db.trace(nil)
-      @db.execute "select 'foo'"
-    end
-
-    def test_last_insert_row_id_closed
-      @db.close
-      assert_raise(SQLite3::Exception) do
-        @db.last_insert_row_id
-      end
-    end
-
-    def test_define_function
-      called_with = nil
-      @db.define_function("hello") do |value|
-        called_with = value
-      end
-      @db.execute("select hello(10)")
-      assert_equal 10, called_with
-    end
-
-    def test_call_func_arg_type
-      called_with = nil
-      @db.define_function("hello") do |b, c, d|
-        called_with = [b, c, d]
-        nil
-      end
-      @db.execute("select hello(2.2, 'foo', NULL)")
-      assert_equal [2.2, 'foo', nil], called_with
-    end
-
-    def test_define_varargs
-      called_with = nil
-      @db.define_function("hello") do |*args|
-        called_with = args
-        nil
-      end
-      @db.execute("select hello(2.2, 'foo', NULL)")
-      assert_equal [2.2, 'foo', nil], called_with
-    end
-
-    def test_function_return
-      @db.define_function("hello") { |a| 10 }
-      assert_equal [10], @db.execute("select hello('world')").first
-    end
-
-    def test_function_return_types
-      [10, 2.2, nil, "foo"].each do |thing|
-        @db.define_function("hello") { |a| thing }
-        assert_equal [thing], @db.execute("select hello('world')").first
-      end
-    end
-
-    def test_define_function_closed
-      @db.close
-      assert_raise(SQLite3::Exception) do
-        @db.define_function('foo') {  }
-      end
-    end
-
-    def test_inerrupt_closed
-      @db.close
-      assert_raise(SQLite3::Exception) do
-        @db.interrupt
-      end
-    end
-
-    def test_define_aggregate
-      @db.execute "create table foo ( a integer primary key, b text )"
-      @db.execute "insert into foo ( b ) values ( 'foo' )"
-      @db.execute "insert into foo ( b ) values ( 'bar' )"
-      @db.execute "insert into foo ( b ) values ( 'baz' )"
-
-      acc = Class.new {
-        attr_reader :sum
-        alias :finalize :sum
-        def initialize
-          @sum = 0
-        end
-
-        def step a
-          @sum += a
-        end
-      }.new
-
-      @db.define_aggregator("accumulate", acc)
-      value = @db.get_first_value( "select accumulate(a) from foo" )
-      assert_equal 6, value
-    end
-
-    def test_authorizer_ok
-      @db.authorizer = Class.new {
-        def call action, a, b, c, d; true end
-      }.new
-      @db.prepare("select 'fooooo'")
-
-      @db.authorizer = Class.new {
-        def call action, a, b, c, d; 0 end
-      }.new
-      @db.prepare("select 'fooooo'")
-    end
-
-    def test_authorizer_ignore
-      @db.authorizer = Class.new {
-        def call action, a, b, c, d; nil end
-      }.new
-      stmt = @db.prepare("select 'fooooo'")
-      assert_equal nil, stmt.step
-    end
-
-    def test_authorizer_fail
-      @db.authorizer = Class.new {
-        def call action, a, b, c, d; false end
-      }.new
-      assert_raises(SQLite3::AuthorizationException) do
-        @db.prepare("select 'fooooo'")
-      end
-    end
-
-    def test_remove_auth
-      @db.authorizer = Class.new {
-        def call action, a, b, c, d; false end
-      }.new
-      assert_raises(SQLite3::AuthorizationException) do
-        @db.prepare("select 'fooooo'")
-      end
-
-      @db.authorizer = nil
-      @db.prepare("select 'fooooo'")
-    end
-
-    def test_close_with_open_statements
-      stmt = @db.prepare("select 'foo'")
-      assert_raises(SQLite3::BusyException) do
-        @db.close
-      end
-    end
-
-    def test_execute_with_empty_bind_params
-      assert_equal [['foo']], @db.execute("select 'foo'", [])
-    end
-
-    def test_query_with_named_bind_params
-      assert_equal [['foo']], @db.query("select :n", {'n' => 'foo'}).to_a
-    end
-
-    def test_execute_with_named_bind_params
-      assert_equal [['foo']], @db.execute("select :n", {'n' => 'foo'})
-    end
-  end
-end