nullifyable 0.1.0

data/vendor/bundle/gems/sqlite3-1.3.13/test/test_result_set.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+module SQLite3
+  class TestResultSet < SQLite3::TestCase
+    def test_each_hash
+      db = SQLite3::Database.new ':memory:'
+      db.execute "create table foo ( a integer primary key, b text )"
+      list = ('a'..'z').to_a
+      list.each do |t|
+        db.execute "insert into foo (b) values (\"#{t}\")"
+      end
+
+      rs = db.prepare('select * from foo').execute
+      rs.each_hash do |hash|
+        assert_equal list[hash['a'] - 1], hash['b']
+      end
+    end
+
+    def test_next_hash
+      db = SQLite3::Database.new ':memory:'
+      db.execute "create table foo ( a integer primary key, b text )"
+      list = ('a'..'z').to_a
+      list.each do |t|
+        db.execute "insert into foo (b) values (\"#{t}\")"
+      end
+
+      rs = db.prepare('select * from foo').execute
+      rows = []
+      while row = rs.next_hash
+        rows << row
+      end
+      rows.each do |hash|
+        assert_equal list[hash['a'] - 1], hash['b']
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sqlite3-1.3.13/test/test_sqlite3.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+module SQLite3
+  class TestSQLite3 < SQLite3::TestCase
+    def test_libversion
+      assert_not_nil SQLite3.libversion
+    end
+
+    def test_threadsafe
+      assert_not_nil SQLite3.threadsafe
+    end
+
+    def test_threadsafe?
+      if SQLite3.threadsafe > 0
+        assert SQLite3.threadsafe?
+      else
+        refute SQLite3.threadsafe?
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sqlite3-1.3.13/test/test_statement.rb

@@ -0,0 +1,260 @@
+require 'helper'
+
+module SQLite3
+  class TestStatement < SQLite3::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @stmt = SQLite3::Statement.new(@db, "select 'foo'")
+    end
+
+    def test_double_close_does_not_segv
+      @db.execute 'CREATE TABLE "things" ("number" float NOT NULL)'
+
+      stmt = @db.prepare 'INSERT INTO things (number) VALUES (?)'
+      assert_raises(SQLite3::ConstraintException) { stmt.execute(nil) }
+
+      stmt.close
+
+      assert_raises(SQLite3::Exception) { stmt.close }
+    end
+
+    def test_raises_type_error
+      assert_raises(TypeError) do
+        SQLite3::Statement.new( @db, nil )
+      end
+    end
+
+    def test_insert_duplicate_records
+      @db.execute 'CREATE TABLE "things" ("name" varchar(20) CONSTRAINT "index_things_on_name" UNIQUE)'
+      stmt = @db.prepare("INSERT INTO things(name) VALUES(?)")
+      stmt.execute('ruby')
+
+      exception = assert_raises(SQLite3::ConstraintException) { stmt.execute('ruby') }
+      # SQLite 3.8.2 returns new error message:
+      #   UNIQUE constraint failed: *table_name*.*column_name*
+      # Older versions of SQLite return:
+      #   column *column_name* is not unique
+      assert_match(/(column(s)? .* (is|are) not unique|UNIQUE constraint failed: .*)/, exception.message)
+    end
+
+    ###
+    # This method may not exist depending on how sqlite3 was compiled
+    def test_database_name
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      stmt = @db.prepare('select text from foo')
+      if stmt.respond_to?(:database_name)
+        assert_equal 'main', stmt.database_name(0)
+      end
+    end
+
+    def test_prepare_blob
+      @db.execute('create table foo(text BLOB)')
+      stmt = @db.prepare('insert into foo(text) values (?)')
+      stmt.bind_param(1, SQLite3::Blob.new('hello'))
+      stmt.step
+      stmt.close
+    end
+
+    def test_select_blob
+      @db.execute('create table foo(text BLOB)')
+      @db.execute('insert into foo(text) values (?)',SQLite3::Blob.new('hello'))
+      assert_equal 'hello', @db.execute('select * from foo').first.first
+    end
+
+    def test_new
+      assert @stmt
+    end
+
+    def test_new_closed_handle
+      @db = SQLite3::Database.new(':memory:')
+      @db.close
+      assert_raises(ArgumentError) do
+        SQLite3::Statement.new(@db, 'select "foo"')
+      end
+    end
+
+    def test_new_with_remainder
+      stmt = SQLite3::Statement.new(@db, "select 'foo';bar")
+      assert_equal 'bar', stmt.remainder
+    end
+
+    def test_empty_remainder
+      assert_equal '', @stmt.remainder
+    end
+
+    def test_close
+      @stmt.close
+      assert @stmt.closed?
+    end
+
+    def test_double_close
+      @stmt.close
+      assert_raises(SQLite3::Exception) do
+        @stmt.close
+      end
+    end
+
+    def test_bind_param_string
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, "hello")
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_bind_param_int
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 10)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [10], result
+    end
+
+    def test_bind_nil
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, nil)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [nil], result
+    end
+
+    def test_bind_blobs
+    end
+
+    def test_bind_64
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2 ** 31)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2 ** 31], result
+    end
+
+    def test_bind_double
+      stmt = SQLite3::Statement.new(@db, "select ?")
+      stmt.bind_param(1, 2.2)
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal [2.2], result
+    end
+
+    def test_named_bind
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(':foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_no_colon
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param('foo', 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_symbol
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      stmt.bind_param(:foo, 'hello')
+      result = nil
+      stmt.each { |x| result = x }
+      assert_equal ['hello'], result
+    end
+
+    def test_named_bind_not_found
+      stmt = SQLite3::Statement.new(@db, "select :foo")
+      assert_raises(SQLite3::Exception) do
+        stmt.bind_param('bar', 'hello')
+      end
+    end
+
+    def test_each
+      r = nil
+      @stmt.each do |row|
+        r = row
+      end
+      assert_equal(['foo'], r)
+    end
+
+    def test_reset!
+      r = []
+      @stmt.each { |row| r << row }
+      @stmt.reset!
+      @stmt.each { |row| r << row }
+      assert_equal [['foo'], ['foo']], r
+    end
+
+    def test_step
+      r = @stmt.step
+      assert_equal ['foo'], r
+    end
+
+    def test_tainted
+      r = @stmt.step
+      assert r.first.tainted?
+    end
+
+    def test_step_twice
+      assert_not_nil @stmt.step
+      assert !@stmt.done?
+      assert_nil @stmt.step
+      assert @stmt.done?
+
+      @stmt.reset!
+      assert !@stmt.done?
+    end
+
+    def test_step_never_moves_past_done
+      10.times { @stmt.step }
+      @stmt.done?
+    end
+
+    def test_column_count
+      assert_equal 1, @stmt.column_count
+    end
+
+    def test_column_name
+      assert_equal "'foo'", @stmt.column_name(0)
+      assert_equal nil, @stmt.column_name(10)
+    end
+
+    def test_bind_parameter_count
+      stmt = SQLite3::Statement.new(@db, "select ?, ?, ?")
+      assert_equal 3, stmt.bind_parameter_count
+    end
+
+    def test_execute_with_varargs
+      stmt = @db.prepare('select ?, ?')
+      assert_equal [[nil, nil]], stmt.execute(nil, nil).to_a
+    end
+
+    def test_execute_with_hash
+      stmt = @db.prepare('select :n, :h')
+      assert_equal [[10, nil]], stmt.execute('n' => 10, 'h' => nil).to_a
+    end
+
+    def test_with_error
+      @db.execute('CREATE TABLE "employees" ("name" varchar(20) NOT NULL CONSTRAINT "index_employees_on_name" UNIQUE)')
+      stmt = @db.prepare("INSERT INTO Employees(name) VALUES(?)")
+      stmt.execute('employee-1')
+      stmt.execute('employee-1') rescue SQLite3::ConstraintException
+      stmt.reset!
+      assert stmt.execute('employee-2')
+    end
+
+    def test_clear_bindings
+      stmt = @db.prepare('select ?, ?')
+      stmt.bind_param 1, "foo"
+      stmt.bind_param 2, "bar"
+
+      # We can't fetch bound parameters back out of sqlite3, so just call
+      # the clear_bindings! method and assert that nil is returned
+      stmt.clear_bindings!
+
+      while x = stmt.step
+        assert_equal [nil, nil], x
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sqlite3-1.3.13/test/test_statement_execute.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module SQLite3
+  class TestStatementExecute < SQLite3::TestCase
+    def setup
+      @db   = SQLite3::Database.new(':memory:')
+      @db.execute_batch(
+        "CREATE TABLE items (id integer PRIMARY KEY, number integer)")
+    end
+
+    def test_execute_insert
+      ps = @db.prepare("INSERT INTO items (number) VALUES (:n)")
+      ps.execute('n'=>10)
+      assert_equal 1, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+
+    def test_execute_update
+      @db.execute("INSERT INTO items (number) VALUES (?)", [10])
+
+      ps = @db.prepare("UPDATE items SET number = :new WHERE number = :old")
+      ps.execute('old'=>10, 'new'=>20)
+      assert_equal 20, @db.get_first_value("SELECT number FROM items")
+      ps.close
+    end
+
+    def test_execute_delete
+      @db.execute("INSERT INTO items (number) VALUES (?)", [20])
+      ps = @db.prepare("DELETE FROM items WHERE number = :n")
+      ps.execute('n' => 20)
+      assert_equal 0, @db.get_first_value("SELECT count(*) FROM items")
+      ps.close
+    end
+  end
+end

data/vendor/bundle/gems/thread_safe-0.3.6/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format progress

data/vendor/bundle/gems/thread_safe-0.3.6/.travis.yml

@@ -0,0 +1,46 @@
+dist: trusty
+sudo: required
+language: ruby
+rvm:
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - 2.1.9
+  - 2.0.0
+  - 1.9.3
+  - ruby-head
+  - jruby-9.1.5.0
+  - jruby-1.7.26
+  - jruby-head
+  - rubinius-3
+  - rubinius-2
+jdk:
+  - openjdk7
+  - oraclejdk8
+matrix:
+  exclude:
+    - rvm: 2.4.0
+      jdk: oraclejdk8
+    - rvm: 2.3.3
+      jdk: oraclejdk8
+    - rvm: 2.2.6
+      jdk: oraclejdk8
+    - rvm: 2.1.9
+      jdk: oraclejdk8
+    - rvm: 2.0.0
+      jdk: oraclejdk8
+    - rvm: 1.9.3
+      jdk: oraclejdk8
+    - rvm: ruby-head
+      jdk: oraclejdk8
+    - rvm: rubinius-3
+      jdk: oraclejdk8
+    - rvm: rubinius-2
+      jdk: oraclejdk8
+  allow_failures:
+    - rvm: 1.9.3
+    - rvm: ruby-head
+    - rvm: jruby-1.7.26
+    - rvm: jruby-head
+    - rvm: rubinius-2
+script: "bundle exec rake test"

data/vendor/bundle/gems/thread_safe-0.3.6/.yardopts

@@ -0,0 +1,13 @@
+--protected
+--no-private
+--embed-mixins
+--output-dir ./yardoc
+--markup markdown
+--title=Concurrent Ruby
+--template default
+--template-path ./yard-template
+
+./lib/**/*.rb
+-
+README.md
+LICENSE

data/vendor/bundle/gems/thread_safe-0.3.6/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.2.0'
+  gem 'simplecov', '~> 0.9.2', :require => false
+  if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0.0')
+    gem 'term-ansicolor', '~> 1.3.2', :require => false
+    gem 'tins', '~> 1.6.0', :require => false
+  end
+  gem 'coveralls', '~> 0.7.11', :require => false
+end
+
+group :documentation do
+  gem 'countloc', '~> 0.4.0', :platforms => :mri, :require => false
+  gem 'yard', '~> 0.8.7.6', :require => false
+  gem 'inch', '~> 0.5.10', :platforms => :mri, :require => false
+  gem 'redcarpet', '~> 3.2.2', platforms: :mri # understands github markdown
+end

data/vendor/bundle/gems/thread_safe-0.3.6/LICENSE

@@ -0,0 +1,144 @@
+Apache License
+
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as 
+defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that 
+is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that 
+control, are controlled by, or are under common control with that entity. For the purposes 
+of this definition, "control" means (i) the power, direct or indirect, to cause the 
+direction or management of such entity, whether by contract or otherwise, or (ii) ownership 
+of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of 
+such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by 
+this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not 
+limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of 
+a Source form, including but not limited to compiled object code, generated documentation, 
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available 
+under the License, as indicated by a copyright notice that is included in or attached to the 
+work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on 
+(or derived from) the Work and for which the editorial revisions, annotations, elaborations, 
+or other modifications represent, as a whole, an original work of authorship. For the 
+purposes of this License, Derivative Works shall not include works that remain separable 
+from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works 
+thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work 
+and any modifications or additions to that Work or Derivative Works thereof, that is 
+intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by 
+an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the 
+purposes of this definition, "submitted" means any form of electronic, verbal, or written 
+communication sent to the Licensor or its representatives, including but not limited to 
+communication on electronic mailing lists, source code control systems, and issue tracking 
+systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and 
+improving the Work, but excluding communication that is conspicuously marked or otherwise 
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a 
+Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each 
+Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
+royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, 
+publicly display, publicly perform, sublicense, and distribute the Work and such Derivative 
+Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each 
+Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, 
+royalty-free, irrevocable (except as stated in this section) patent license to make, have 
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license 
+applies only to those patent claims licensable by such Contributor that are necessarily 
+infringed by their Contribution(s) alone or by combination of their Contribution(s) with the 
+Work to which such Contribution(s) was submitted. If You institute patent litigation against 
+any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or 
+a Contribution incorporated within the Work constitutes direct or contributory patent 
+infringement, then any patent licenses granted to You under this License for that Work shall 
+terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works 
+thereof in any medium, with or without modifications, and in Source or Object form, provided 
+that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; 
+and
+
+You must cause any modified files to carry prominent notices stating that You changed the 
+files; and
+
+You must retain, in the Source form of any Derivative Works that You distribute, all 
+copyright, patent, trademark, and attribution notices from the Source form of the Work, 
+excluding those notices that do not pertain to any part of the Derivative Works; and
+
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative 
+Works that You distribute must include a readable copy of the attribution notices contained 
+within such NOTICE file, excluding those notices that do not pertain to any part of the 
+Derivative Works, in at least one of the following places: within a NOTICE text file 
+distributed as part of the Derivative Works; within the Source form or documentation, if 
+provided along with the Derivative Works; or, within a display generated by the Derivative 
+Works, if and wherever such third-party notices normally appear. The contents of the NOTICE 
+file are for informational purposes only and do not modify the License. You may add Your own 
+attribution notices within Derivative Works that You distribute, alongside or as an addendum 
+to the NOTICE text from the Work, provided that such additional attribution notices cannot 
+be construed as modifying the License. You may add Your own copyright statement to Your 
+modifications and may provide additional or different license terms and conditions for use, 
+reproduction, or distribution of Your modifications, or for any such Derivative Works as a 
+whole, provided Your use, reproduction, and distribution of the Work otherwise complies with 
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution 
+intentionally submitted for inclusion in the Work by You to the Licensor shall be under the 
+terms and conditions of this License, without any additional terms or conditions. 
+Notwithstanding the above, nothing herein shall supersede or modify the terms of any 
+separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, 
+service marks, or product names of the Licensor, except as required for reasonable and 
+customary use in describing the origin of the Work and reproducing the content of the NOTICE 
+file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, 
+Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" 
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, 
+without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, 
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for 
+determining the appropriateness of using or redistributing the Work and assume any risks 
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort 
+(including negligence), contract, or otherwise, unless required by applicable law (such as 
+deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be 
+liable to You for damages, including any direct, indirect, special, incidental, or 
+consequential damages of any character arising as a result of this License or out of the use 
+or inability to use the Work (including but not limited to damages for loss of goodwill, 
+work stoppage, computer failure or malfunction, or any and all other commercial damages or 
+losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative 
+Works thereof, You may choose to offer, and charge a fee for, acceptance of support, 
+warranty, indemnity, or other liability obligations and/or rights consistent with this 
+License. However, in accepting such obligations, You may act only on Your own behalf and on 
+Your sole responsibility, not on behalf of any other Contributor, and only if You agree to 
+indemnify, defend, and hold each Contributor harmless for any liability incurred by, or 
+claims asserted against, such Contributor by reason of your accepting any such warranty or 
+additional liability.
+
+END OF TERMS AND CONDITIONS