sqlite3-ruby 1.3.0.beta.2-x86-mswin32-60

data/tasks/faq.rake

@@ -0,0 +1,9 @@
+# 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

@@ -0,0 +1,31 @@
+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.6')
+  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

@@ -0,0 +1,31 @@
+# use rake-compiler for building the extension
+require 'rake/extensiontask'
+
+# 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'))
+
+  # 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}"
+  end
+end
+
+# ensure things are compiled prior testing
+task :test => [:compile]
+
+# vim: syntax=ruby

data/tasks/vendor_sqlite3.rake

@@ -0,0 +1,107 @@
+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
+
+SQLITE_VERSION = '3.6.22'
+url_version = SQLITE_VERSION.gsub('.', '_')
+
+# 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

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

data/test/test_database.rb

@@ -0,0 +1,291 @@
+require 'helper'
+require 'iconv'
+
+module SQLite3
+  class TestDatabase < Test::Unit::TestCase
+    def setup
+      @db = SQLite3::Database.new(':memory:')
+    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